Reference documentation for deal.II version GIT relicensing-218-g1f873f3929 2024-03-28 15:00:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
block_vector.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 1999 - 2023 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_block_vector_h
16#define dealii_block_vector_h
17
18
19#include <deal.II/base/config.h>
20
22
27
28#include <cstdio>
29#include <vector>
30
32
33
34// Forward declaration
35#ifndef DOXYGEN
36# ifdef DEAL_II_WITH_TRILINOS
37namespace TrilinosWrappers
38{
39 namespace MPI
40 {
41 class BlockVector;
42 }
43} // namespace TrilinosWrappers
44# endif
45#endif
46
47
69template <typename Number>
70class BlockVector : public BlockVectorBase<Vector<Number>>
71{
72public:
77
82
88 using pointer = typename BaseClass::pointer;
93 using iterator = typename BaseClass::iterator;
95
106 explicit BlockVector(const unsigned int n_blocks = 0,
107 const size_type block_size = 0);
108
114
115
120 BlockVector(BlockVector<Number> && /*v*/) noexcept = default;
121
128 template <typename OtherNumber>
129 explicit BlockVector(const BlockVector<OtherNumber> &v);
130
131#ifdef DEAL_II_WITH_TRILINOS
137
138#endif
143 BlockVector(const std::vector<size_type> &block_sizes);
144
150
160 template <typename InputIterator>
161 BlockVector(const std::vector<size_type> &block_sizes,
162 const InputIterator first,
163 const InputIterator end);
164
168 ~BlockVector() override = default;
169
180 void
182
189 bool
191
198
205
211 operator=(BlockVector<Number> && /*v*/) = default; // NOLINT
212
217 template <class Number2>
220
226
227#ifdef DEAL_II_WITH_TRILINOS
234#endif
235
248 void
249 reinit(const unsigned int n_blocks,
250 const size_type block_size = 0,
251 const bool omit_zeroing_entries = false);
252
269 void
270 reinit(const std::vector<size_type> &block_sizes,
271 const bool omit_zeroing_entries = false);
272
282 void
284 const bool omit_zeroing_entries = false);
285
299 template <typename Number2>
300 void
302 const bool omit_zeroing_entries = false);
303
308 template <class BlockVector2>
309 void
310 scale(const BlockVector2 &v);
311
323 void
325
329 void
330 print(std::ostream &out,
331 const unsigned int precision = 3,
332 const bool scientific = true,
333 const bool across = true) const;
334
340 void
341 block_write(std::ostream &out) const;
342
354 void
355 block_read(std::istream &in);
356
367};
368
371#ifndef DOXYGEN
372/*----------------------- Inline functions ----------------------------------*/
373
374
375
376template <typename Number>
377template <typename InputIterator>
378BlockVector<Number>::BlockVector(const std::vector<size_type> &block_sizes,
379 const InputIterator first,
380 const InputIterator end)
381{
382 // first set sizes of blocks, but
383 // don't initialize them as we will
384 // copy elements soon
385 (void)end;
386 reinit(block_sizes, true);
387 InputIterator start = first;
388 for (size_type b = 0; b < block_sizes.size(); ++b)
389 {
390 InputIterator end = start;
391 std::advance(end, static_cast<signed int>(block_sizes[b]));
392 std::copy(start, end, this->block(b).begin());
393 start = end;
394 };
395 Assert(start == end, ExcIteratorRangeDoesNotMatchVectorSize());
396}
397
398
399
400template <typename Number>
401inline BlockVector<Number> &
402BlockVector<Number>::operator=(const value_type s)
403{
405
406 BaseClass::operator=(s);
407 return *this;
408}
409
410
411
412template <typename Number>
413inline BlockVector<Number> &
415{
416 reinit(v, true);
417 BaseClass::operator=(v);
418 return *this;
419}
420
421
422
423template <typename Number>
424inline BlockVector<Number> &
426{
427 BaseClass::operator=(v);
428 return *this;
429}
430
431
432
433template <typename Number>
434template <typename Number2>
435inline BlockVector<Number> &
437{
438 reinit(v, true);
439 BaseClass::operator=(v);
440 return *this;
441}
442
443template <typename Number>
444inline void
446{
447 for (size_type i = 0; i < this->n_blocks(); ++i)
448 this->components[i].compress(operation);
449}
450
451
452
453template <typename Number>
454inline bool
456{
457 return false;
458}
459
460
461
462template <typename Number>
463template <class BlockVector2>
464void
465BlockVector<Number>::scale(const BlockVector2 &v)
466{
467 BaseClass::scale(v);
468}
469
470#endif // DOXYGEN
471
472
480template <typename Number>
481inline void
486
487
488namespace internal
489{
490 namespace LinearOperatorImplementation
491 {
492 template <typename>
493 class ReinitHelper;
494
499 template <typename number>
501 {
502 public:
503 template <typename Matrix>
504 static void
505 reinit_range_vector(const Matrix &matrix,
507 bool omit_zeroing_entries)
508 {
509 v.reinit(matrix.get_row_indices(), omit_zeroing_entries);
510 }
511
512 template <typename Matrix>
513 static void
514 reinit_domain_vector(const Matrix &matrix,
516 bool omit_zeroing_entries)
517 {
518 v.reinit(matrix.get_column_indices(), omit_zeroing_entries);
519 }
520 };
521
522 } // namespace LinearOperatorImplementation
523} /* namespace internal */
524
525
529template <typename Number>
530struct is_serial_vector<BlockVector<Number>> : std::true_type
531{};
532
534
535#endif
::internal::BlockVectorIterators::Iterator< BlockVectorBase, false > iterator
typename BlockType::const_reference const_reference
typename BlockType::value_type value_type
::internal::BlockVectorIterators::Iterator< BlockVectorBase, true > const_iterator
typename BlockType::reference reference
typename BlockType::real_type real_type
BlockVector(const std::vector< size_type > &block_sizes)
typename BaseClass::const_reference const_reference
void reinit(const BlockIndices &block_indices, const bool omit_zeroing_entries=false)
void swap(BlockVector< Number > &v)
typename BaseClass::reference reference
void print(std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const
void compress(VectorOperation::values operation=VectorOperation::unknown)
bool has_ghost_elements() const
BlockVector(const TrilinosWrappers::MPI::BlockVector &v)
BlockVector< Number > & operator=(const TrilinosWrappers::MPI::BlockVector &V)
BlockVector< Number > & operator=(const BlockVector< Number2 > &V)
BlockVector(const BlockIndices &block_indices)
BlockVector< Number > & operator=(BlockVector< Number > &&)=default
typename BaseClass::value_type value_type
typename BaseClass::const_pointer const_pointer
BlockVector(const BlockVector< Number > &V)
void block_write(std::ostream &out) const
typename BaseClass::pointer pointer
~BlockVector() override=default
typename BaseClass::BlockType BlockType
BlockVector(const unsigned int n_blocks=0, const size_type block_size=0)
void scale(const BlockVector2 &v)
BlockVector(BlockVector< Number > &&) noexcept=default
void reinit(const std::vector< size_type > &block_sizes, const bool omit_zeroing_entries=false)
typename BaseClass::iterator iterator
void block_read(std::istream &in)
BlockVector & operator=(const value_type s)
typename BaseClass::size_type size_type
BlockVector< Number > & operator=(const Vector< Number > &V)
BlockVector< Number > & operator=(const BlockVector< Number > &v)
BlockVector(const std::vector< size_type > &block_sizes, const InputIterator first, const InputIterator end)
void reinit(const unsigned int n_blocks, const size_type block_size=0, const bool omit_zeroing_entries=false)
void swap(BlockVector< Number > &u, BlockVector< Number > &v)
typename BaseClass::const_iterator const_iterator
void reinit(const BlockVector< Number2 > &V, const bool omit_zeroing_entries=false)
typename BaseClass::real_type real_type
static void reinit_range_vector(const Matrix &matrix, BlockVector< number > &v, bool omit_zeroing_entries)
static void reinit_domain_vector(const Matrix &matrix, BlockVector< number > &v, bool omit_zeroing_entries)
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:502
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:503
Point< 2 > first
Definition grid_out.cc:4613
#define DeclException0(Exception0)
Definition exceptions.h:471
#define Assert(cond, exc)
#define AssertIsFinite(number)
static ::ExceptionBase & ExcIteratorRangeDoesNotMatchVectorSize()
std::enable_if_t< IsBlockVector< VectorType >::value, unsigned int > n_blocks(const VectorType &vector)
Definition operators.h:49
std::string compress(const std::string &input)
Definition utilities.cc:389
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)