block_vector.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_block_vector_h
#define dealii_block_vector_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
 
#include <deal.II/lac/block_indices.h>
#include <deal.II/lac/block_vector_base.h>
#include <deal.II/lac/vector_operation.h>
#include <deal.II/lac/vector_type_traits.h>
 
#include <cstdio>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
// Forward declaration
#ifndef DOXYGEN
#  ifdef DEAL_II_WITH_TRILINOS
namespace TrilinosWrappers
{
  namespace MPI
  {
    class BlockVector;
  }
} // namespace TrilinosWrappers
#  endif
#endif
 
 
template <typename Number>
class BlockVector : public BlockVectorBase<Vector<Number>>
{
public:
  using BaseClass = BlockVectorBase<Vector<Number>>;
 
  using BlockType = typename BaseClass::BlockType;
 
  using value_type      = typename BaseClass::value_type;
  using real_type       = typename BaseClass::real_type;
  using pointer         = typename BaseClass::pointer;
  using const_pointer   = typename BaseClass::const_pointer;
  using reference       = typename BaseClass::reference;
  using const_reference = typename BaseClass::const_reference;
  using size_type       = typename BaseClass::size_type;
  using iterator        = typename BaseClass::iterator;
  using const_iterator  = typename BaseClass::const_iterator;
 
  explicit BlockVector(const unsigned int n_blocks   = 0,
                       const size_type    block_size = 0);
 
  BlockVector(const BlockVector<Number> &V);
 
 
  BlockVector(BlockVector<Number> && /*v*/) noexcept = default;
 
  template <typename OtherNumber>
  explicit BlockVector(const BlockVector<OtherNumber> &v);
 
#ifdef DEAL_II_WITH_TRILINOS
  BlockVector(const TrilinosWrappers::MPI::BlockVector &v);
 
#endif
  BlockVector(const std::vector<size_type> &block_sizes);
 
  BlockVector(const BlockIndices &block_indices);
 
  template <typename InputIterator>
  BlockVector(const std::vector<size_type> &block_sizes,
              const InputIterator           first,
              const InputIterator           end);
 
  ~BlockVector() override = default;
 
  void
  compress(::VectorOperation::values operation =
             ::VectorOperation::unknown);
 
  bool
  has_ghost_elements() const;
 
  BlockVector &
  operator=(const value_type s);
 
  BlockVector<Number> &
  operator=(const BlockVector<Number> &v);
 
  BlockVector<Number> &
  operator=(BlockVector<Number> && /*v*/) = default; // NOLINT
 
  template <class Number2>
  BlockVector<Number> &
  operator=(const BlockVector<Number2> &V);
 
  BlockVector<Number> &
  operator=(const Vector<Number> &V);
 
#ifdef DEAL_II_WITH_TRILINOS
  BlockVector<Number> &
  operator=(const TrilinosWrappers::MPI::BlockVector &V);
#endif
 
  void
  reinit(const unsigned int n_blocks,
         const size_type    block_size           = 0,
         const bool         omit_zeroing_entries = false);
 
  void
  reinit(const std::vector<size_type> &block_sizes,
         const bool                    omit_zeroing_entries = false);
 
  void
  reinit(const BlockIndices &block_indices,
         const bool          omit_zeroing_entries = false);
 
  template <typename Number2>
  void
  reinit(const BlockVector<Number2> &V,
         const bool                  omit_zeroing_entries = false);
 
  template <class BlockVector2>
  void
  scale(const BlockVector2 &v);
 
  void
  swap(BlockVector<Number> &v);
 
  void
  print(std::ostream &     out,
        const unsigned int precision  = 3,
        const bool         scientific = true,
        const bool         across     = true) const;
 
  void
  block_write(std::ostream &out) const;
 
  void
  block_read(std::istream &in);
 
  DeclException0(ExcIteratorRangeDoesNotMatchVectorSize);
};
 
#ifndef DOXYGEN
/*----------------------- Inline functions ----------------------------------*/
 
 
 
template <typename Number>
template <typename InputIterator>
BlockVector<Number>::BlockVector(const std::vector<size_type> &block_sizes,
                                 const InputIterator           first,
                                 const InputIterator           end)
{
  // first set sizes of blocks, but
  // don't initialize them as we will
  // copy elements soon
  (void)end;
  reinit(block_sizes, true);
  InputIterator start = first;
  for (size_type b = 0; b < block_sizes.size(); ++b)
    {
      InputIterator end = start;
      std::advance(end, static_cast<signed int>(block_sizes[b]));
      std::copy(start, end, this->block(b).begin());
      start = end;
    };
  Assert(start == end, ExcIteratorRangeDoesNotMatchVectorSize());
}
 
 
 
template <typename Number>
inline BlockVector<Number> &
BlockVector<Number>::operator=(const value_type s)
{
  AssertIsFinite(s);
 
  BaseClass::operator=(s);
  return *this;
}
 
 
 
template <typename Number>
inline BlockVector<Number> &
BlockVector<Number>::operator=(const BlockVector<Number> &v)
{
  reinit(v, true);
  BaseClass::operator=(v);
  return *this;
}
 
 
 
template <typename Number>
inline BlockVector<Number> &
BlockVector<Number>::operator=(const Vector<Number> &v)
{
  BaseClass::operator=(v);
  return *this;
}
 
 
 
template <typename Number>
template <typename Number2>
inline BlockVector<Number> &
BlockVector<Number>::operator=(const BlockVector<Number2> &v)
{
  reinit(v, true);
  BaseClass::operator=(v);
  return *this;
}
 
template <typename Number>
inline void
BlockVector<Number>::compress(::VectorOperation::values operation)
{
  for (size_type i = 0; i < this->n_blocks(); ++i)
    this->components[i].compress(operation);
}
 
 
 
template <typename Number>
inline bool
BlockVector<Number>::has_ghost_elements() const
{
  return false;
}
 
 
 
template <typename Number>
template <class BlockVector2>
void
BlockVector<Number>::scale(const BlockVector2 &v)
{
  BaseClass::scale(v);
}
 
#endif // DOXYGEN
 
 
template <typename Number>
inline void
swap(BlockVector<Number> &u, BlockVector<Number> &v)
{
  u.swap(v);
}
 
 
namespace internal
{
  namespace LinearOperatorImplementation
  {
    template <typename>
    class ReinitHelper;
 
    template <typename number>
    class ReinitHelper<BlockVector<number>>
    {
    public:
      template <typename Matrix>
      static void
      reinit_range_vector(const Matrix &       matrix,
                          BlockVector<number> &v,
                          bool                 omit_zeroing_entries)
      {
        v.reinit(matrix.get_row_indices(), omit_zeroing_entries);
      }
 
      template <typename Matrix>
      static void
      reinit_domain_vector(const Matrix &       matrix,
                           BlockVector<number> &v,
                           bool                 omit_zeroing_entries)
      {
        v.reinit(matrix.get_column_indices(), omit_zeroing_entries);
      }
    };
 
  } // namespace LinearOperatorImplementation
} /* namespace internal */
 
 
template <typename Number>
struct is_serial_vector<BlockVector<Number>> : std::true_type
{};
 
DEAL_II_NAMESPACE_CLOSE
 
#endif