block_vector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2018 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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


#ifdef DEAL_II_WITH_TRILINOS
namespace TrilinosWrappers
{
  namespace MPI
  {
    class BlockVector;
  }
}
#endif


template <typename Number>
class BlockVector : public BlockVectorBase<Vector<Number> >
{
public:
  typedef BlockVectorBase<Vector<Number> > BaseClass;

  typedef typename BaseClass::BlockType  BlockType;

  typedef typename BaseClass::value_type      value_type;
  typedef typename BaseClass::real_type       real_type;
  typedef typename BaseClass::pointer         pointer;
  typedef typename BaseClass::const_pointer   const_pointer;
  typedef typename BaseClass::reference       reference;
  typedef typename BaseClass::const_reference const_reference;
  typedef typename BaseClass::size_type       size_type;
  typedef typename BaseClass::iterator        iterator;
  typedef typename BaseClass::const_iterator  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 () = default;

  void compress (::VectorOperation::values operation
                 =::VectorOperation::unknown);

  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>
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 LinearOperator */
} /* namespace internal */


template <typename Number>
struct is_serial_vector< BlockVector< Number > > : std::true_type
{
};

DEAL_II_NAMESPACE_CLOSE

#endif