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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#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;
  }
} // namespace PETScWrappers
#endif

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

namespace LinearAlgebra
{
  namespace distributed
  {
    template <typename Number>
    class BlockVector : public BlockVectorBase<Vector<Number>>,
                        public VectorSpaceVector<Number>
    {
    public:
      static constexpr unsigned int communication_block_size = 20;

      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 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