la_parallel_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_la_parallel_block_vector_h
#define dealii_la_parallel_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/la_parallel_vector.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_PETSC
namespace PETScWrappers
{
  namespace MPI
  {
    class BlockVector;
  }
}
#endif

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

namespace LinearAlgebra
{
  namespace distributed
  {

    template <typename Number>
    class BlockVector : public BlockVectorBase<Vector<Number> >,
      public VectorSpaceVector<Number>
    {
      static constexpr unsigned int communication_block_size = 20;
    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 size_type num_blocks = 0,
                            const size_type block_size = 0);

      BlockVector (const BlockVector<Number> &V);

      template <typename OtherNumber>
      explicit
      BlockVector (const BlockVector<OtherNumber> &v);

      BlockVector (const std::vector<size_type> &block_sizes);

      BlockVector (const std::vector<IndexSet> &local_ranges,
                   const std::vector<IndexSet> &ghost_indices,
                   const MPI_Comm  communicator);

      BlockVector (const std::vector<IndexSet> &local_ranges,
                   const MPI_Comm  communicator);

      virtual BlockVector &operator = (const value_type s) override;

      BlockVector &
      operator= (const BlockVector &V);

      template <class Number2>
      BlockVector &
      operator= (const BlockVector<Number2> &V);

      BlockVector &
      operator= (const Vector<Number> &V);

#ifdef DEAL_II_WITH_PETSC

      BlockVector<Number> &
      operator = (const PETScWrappers::MPI::BlockVector &petsc_vec);
#endif

#ifdef DEAL_II_WITH_TRILINOS

      BlockVector<Number> &
      operator = (const TrilinosWrappers::MPI::BlockVector &trilinos_vec);
#endif

      void reinit (const size_type num_blocks,
                   const size_type block_size = 0,
                   const bool omit_zeroing_entries = false);

      void reinit (const std::vector<size_type> &N,
                   const bool                    omit_zeroing_entries=false);

      template <typename Number2>
      void reinit (const BlockVector<Number2> &V,
                   const bool                 omit_zeroing_entries=false);

      virtual void compress (::VectorOperation::values operation) override;

      void update_ghost_values () const;

      void zero_out_ghosts () const;

      bool has_ghost_elements() const;

      template <typename OtherNumber>
      void add (const std::vector<size_type>        &indices,
                const ::Vector<OtherNumber> &values);

      void sadd (const Number               s,
                 const BlockVector<Number> &V);

      DEAL_II_DEPRECATED
      void equ (const Number a, const BlockVector<Number> &u,
                const Number b, const BlockVector<Number> &v);

      DEAL_II_DEPRECATED
      void sadd (const Number               s,
                 const Number               a,
                 const BlockVector<Number> &V,
                 const Number               b,
                 const BlockVector<Number> &W);

      virtual bool all_zero () const override;

      virtual Number mean_value () const override;

      real_type lp_norm (const real_type p) const;

      void swap (BlockVector<Number> &v);


      virtual void reinit(const VectorSpaceVector<Number> &V,
                          const bool omit_zeroing_entries = false) override;

      virtual BlockVector<Number> &operator*= (const Number factor) override;

      virtual BlockVector<Number> &operator/= (const Number factor) override;

      virtual BlockVector<Number> &operator+= (const VectorSpaceVector<Number> &V) override;

      virtual BlockVector<Number> &operator-= (const VectorSpaceVector<Number> &V) override;

      virtual void import(const LinearAlgebra::ReadWriteVector<Number> &V,
                          VectorOperation::values operation,
                          std::shared_ptr<const CommunicationPatternBase> communication_pattern =
                            std::shared_ptr<const CommunicationPatternBase> ()) override;

      virtual Number operator* (const VectorSpaceVector<Number> &V) const override;

      template <typename FullMatrixType>
      void multivector_inner_product(FullMatrixType &matrix,
                                     const BlockVector<Number> &V,
                                     const bool symmetric = false) const;

      template <typename FullMatrixType>
      Number multivector_inner_product_with_metric(const FullMatrixType &matrix,
                                                   const BlockVector<Number> &V,
                                                   const bool symmetric = false) const;

      template <typename FullMatrixType>
      void mmult(BlockVector<Number> &V,
                 const FullMatrixType &matrix,
                 const Number s = Number(0.),
                 const Number b = Number(1.)) const;

      virtual void add(const Number a) override;

      virtual void add(const Number a, const VectorSpaceVector<Number> &V) override;

      virtual void add(const Number a, const VectorSpaceVector<Number> &V,
                       const Number b, const VectorSpaceVector<Number> &W) override;

      virtual void add (const std::vector<size_type> &indices,
                        const std::vector<Number>    &values);

      virtual void sadd(const Number s, const Number a,
                        const VectorSpaceVector<Number> &V) override;

      virtual void scale(const VectorSpaceVector<Number> &scaling_factors) override;

      virtual void equ(const Number a, const VectorSpaceVector<Number> &V) override;

      virtual real_type l1_norm() const override;

      virtual real_type l2_norm() const override;

      real_type norm_sqr() const;

      virtual real_type linfty_norm() const override;

      virtual Number add_and_dot(const Number a,
                                 const VectorSpaceVector<Number> &V,
                                 const VectorSpaceVector<Number> &W) override;

      virtual size_type size() const override;

      virtual ::IndexSet locally_owned_elements() const override;

      virtual void print(std::ostream &out,
                         const unsigned int precision=3,
                         const bool scientific=true,
                         const bool across=true) const override;

      virtual std::size_t memory_consumption() const override;

      DeclException0(ExcVectorTypeNotCompatible);

      DeclException0 (ExcIteratorRangeDoesNotMatchVectorSize);
    };

  } // end of namespace distributed

} // end of namespace LinearAlgebra


template <typename Number>
inline
void swap (LinearAlgebra::distributed::BlockVector<Number> &u,
           LinearAlgebra::distributed::BlockVector<Number> &v)
{
  u.swap (v);
}


template <typename Number>
struct is_serial_vector< LinearAlgebra::distributed::BlockVector< Number > > : std::false_type
{
};


DEAL_II_NAMESPACE_CLOSE

#ifdef DEAL_II_MSVC
#include <deal.II/lac/la_parallel_block_vector.templates.h>
#endif

#endif