Reference documentation for deal.II version 9.4.0
Collaboration diagram for TrilinosWrappers:

## Namespaces

namespace  TrilinosWrappers

namespace  TrilinosWrappers::MPI

namespace  TrilinosWrappers::internal

namespace  TrilinosWrappers::internal::BlockLinearOperatorImplementation

namespace  internal

namespace  internal::LinearOperatorImplementation

## Functions

TrilinosWrappers::BlockSparsityPattern::BlockSparsityPattern ()=default

TrilinosWrappers::BlockSparsityPattern::BlockSparsityPattern (const size_type n_rows, const size_type n_columns)

TrilinosWrappers::BlockSparsityPattern::BlockSparsityPattern (const std::vector< size_type > &row_block_sizes, const std::vector< size_type > &col_block_sizes)

TrilinosWrappers::BlockSparsityPattern::BlockSparsityPattern (const std::vector< IndexSet > &parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD)

TrilinosWrappers::BlockSparsityPattern::BlockSparsityPattern (const std::vector< IndexSet > &row_parallel_partitioning, const std::vector< IndexSet > &column_parallel_partitioning, const std::vector< IndexSet > &writeable_rows, const MPI_Comm &communicator=MPI_COMM_WORLD)

void TrilinosWrappers::BlockSparsityPattern::reinit (const std::vector< size_type > &row_block_sizes, const std::vector< size_type > &col_block_sizes)

void TrilinosWrappers::BlockSparsityPattern::reinit (const std::vector< IndexSet > &parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD)

void TrilinosWrappers::BlockSparsityPattern::reinit (const std::vector< IndexSet > &row_parallel_partitioning, const std::vector< IndexSet > &column_parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD)

void TrilinosWrappers::BlockSparsityPattern::reinit (const std::vector< IndexSet > &row_parallel_partitioning, const std::vector< IndexSet > &column_parallel_partitioning, const std::vector< IndexSet > &writeable_rows, const MPI_Comm &communicator=MPI_COMM_WORLD)

TrilinosWrappers::BlockSparseMatrix::BlockSparseMatrix ()=default

TrilinosWrappers::BlockSparseMatrix::~BlockSparseMatrix () override

BlockSparseMatrixTrilinosWrappers::BlockSparseMatrix::operator= (const BlockSparseMatrix &)=default

BlockSparseMatrixTrilinosWrappers::BlockSparseMatrix::operator= (const double d)

void TrilinosWrappers::BlockSparseMatrix::reinit (const size_type n_block_rows, const size_type n_block_columns)

template<typename BlockSparsityPatternType >
void TrilinosWrappers::BlockSparseMatrix::reinit (const std::vector< IndexSet > &input_maps, const BlockSparsityPatternType &block_sparsity_pattern, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool exchange_data=false)

template<typename BlockSparsityPatternType >
void TrilinosWrappers::BlockSparseMatrix::reinit (const BlockSparsityPatternType &block_sparsity_pattern)

void TrilinosWrappers::BlockSparseMatrix::reinit (const std::vector< IndexSet > &parallel_partitioning, const ::BlockSparseMatrix< double > &dealii_block_sparse_matrix, const MPI_Comm &communicator=MPI_COMM_WORLD, const double drop_tolerance=1e-13)

void TrilinosWrappers::BlockSparseMatrix::reinit (const ::BlockSparseMatrix< double > &deal_ii_sparse_matrix, const double drop_tolerance=1e-13)

bool TrilinosWrappers::BlockSparseMatrix::is_compressed () const

void TrilinosWrappers::BlockSparseMatrix::collect_sizes ()

std::uint64_t TrilinosWrappers::BlockSparseMatrix::n_nonzero_elements () const

MPI_Comm TrilinosWrappers::BlockSparseMatrix::get_mpi_communicator () const

std::vector< IndexSetTrilinosWrappers::BlockSparseMatrix::locally_owned_domain_indices () const

std::vector< IndexSetTrilinosWrappers::BlockSparseMatrix::locally_owned_range_indices () const

template<typename VectorType1 , typename VectorType2 >
void TrilinosWrappers::BlockSparseMatrix::vmult (VectorType1 &dst, const VectorType2 &src) const

template<typename VectorType1 , typename VectorType2 >
void TrilinosWrappers::BlockSparseMatrix::Tvmult (VectorType1 &dst, const VectorType2 &src) const

TrilinosScalar TrilinosWrappers::BlockSparseMatrix::residual (MPI::BlockVector &dst, const MPI::BlockVector &x, const MPI::BlockVector &b) const

TrilinosScalar TrilinosWrappers::BlockSparseMatrix::residual (MPI::BlockVector &dst, const MPI::Vector &x, const MPI::BlockVector &b) const

TrilinosScalar TrilinosWrappers::BlockSparseMatrix::residual (MPI::Vector &dst, const MPI::BlockVector &x, const MPI::Vector &b) const

TrilinosScalar TrilinosWrappers::BlockSparseMatrix::residual (MPI::Vector &dst, const MPI::Vector &x, const MPI::Vector &b) const

template<typename VectorType1 , typename VectorType2 >
void TrilinosWrappers::BlockSparseMatrix::vmult (VectorType1 &dst, const VectorType2 &src, const bool transpose, const std::integral_constant< bool, true >, const std::integral_constant< bool, true >) const

template<typename VectorType1 , typename VectorType2 >
void TrilinosWrappers::BlockSparseMatrix::vmult (VectorType1 &dst, const VectorType2 &src, const bool transpose, const std::integral_constant< bool, false >, const std::integral_constant< bool, true >) const

template<typename VectorType1 , typename VectorType2 >
void TrilinosWrappers::BlockSparseMatrix::vmult (VectorType1 &dst, const VectorType2 &src, const bool transpose, const std::integral_constant< bool, true >, const std::integral_constant< bool, false >) const

template<typename VectorType1 , typename VectorType2 >
void TrilinosWrappers::BlockSparseMatrix::vmult (VectorType1 &dst, const VectorType2 &src, const bool transpose, const std::integral_constant< bool, false >, const std::integral_constant< bool, false >) const

template<typename... Args>

TrilinosWrappers::MPI::BlockVector::BlockVector ()=default

TrilinosWrappers::MPI::BlockVector::BlockVector (const std::vector< IndexSet > &parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD)

TrilinosWrappers::MPI::BlockVector::BlockVector (const std::vector< IndexSet > &parallel_partitioning, const std::vector< IndexSet > &ghost_values, const MPI_Comm &communicator, const bool vector_writable=false)

TrilinosWrappers::MPI::BlockVector::BlockVector (const BlockVector &v)

TrilinosWrappers::MPI::BlockVector::BlockVector (BlockVector &&v) noexcept

TrilinosWrappers::MPI::BlockVector::BlockVector (const size_type num_blocks)

TrilinosWrappers::MPI::BlockVector::~BlockVector () override=default

BlockVectorTrilinosWrappers::MPI::BlockVector::operator= (const value_type s)

BlockVectorTrilinosWrappers::MPI::BlockVector::operator= (const BlockVector &v)

BlockVectorTrilinosWrappers::MPI::BlockVector::operator= (BlockVector &&v) noexcept

template<typename Number >
BlockVectorTrilinosWrappers::MPI::BlockVector::operator= (const ::BlockVector< Number > &v)

void TrilinosWrappers::MPI::BlockVector::reinit (const std::vector< IndexSet > &parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool omit_zeroing_entries=false)

void TrilinosWrappers::MPI::BlockVector::reinit (const std::vector< IndexSet > &partitioning, const std::vector< IndexSet > &ghost_values, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool vector_writable=false)

void TrilinosWrappers::MPI::BlockVector::reinit (const BlockVector &V, const bool omit_zeroing_entries=false)

void TrilinosWrappers::MPI::BlockVector::reinit (const size_type num_blocks)

void TrilinosWrappers::MPI::BlockVector::import_nonlocal_data_for_fe (const TrilinosWrappers::BlockSparseMatrix &m, const BlockVector &v)

bool TrilinosWrappers::MPI::BlockVector::has_ghost_elements () const

void TrilinosWrappers::MPI::BlockVector::swap (BlockVector &v)

void TrilinosWrappers::MPI::BlockVector::print (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const

void TrilinosWrappers::MPI::swap (BlockVector &u, BlockVector &v)

template<typename Matrix >
static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::BlockVector >::reinit_range_vector (const Matrix &matrix, TrilinosWrappers::MPI::BlockVector &v, bool omit_zeroing_entries)

template<typename Matrix >
static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::BlockVector >::reinit_domain_vector (const Matrix &matrix, TrilinosWrappers::MPI::BlockVector &v, bool omit_zeroing_entries)

TrilinosWrappers::PreconditionBase::PreconditionBase ()

TrilinosWrappers::PreconditionBase::PreconditionBase (const PreconditionBase &)

TrilinosWrappers::PreconditionBase::~PreconditionBase () override=default

void TrilinosWrappers::PreconditionBase::clear ()

MPI_Comm TrilinosWrappers::PreconditionBase::get_mpi_communicator () const

void TrilinosWrappers::PreconditionBase::transpose ()

virtual void TrilinosWrappers::PreconditionBase::vmult (MPI::Vector &dst, const MPI::Vector &src) const

virtual void TrilinosWrappers::PreconditionBase::Tvmult (MPI::Vector &dst, const MPI::Vector &src) const

virtual void TrilinosWrappers::PreconditionBase::vmult (::Vector< double > &dst, const ::Vector< double > &src) const

virtual void TrilinosWrappers::PreconditionBase::Tvmult (::Vector< double > &dst, const ::Vector< double > &src) const

virtual void TrilinosWrappers::PreconditionBase::vmult (::LinearAlgebra::distributed::Vector< double > &dst, const ::LinearAlgebra::distributed::Vector< double > &src) const

virtual void TrilinosWrappers::PreconditionBase::Tvmult (::LinearAlgebra::distributed::Vector< double > &dst, const ::LinearAlgebra::distributed::Vector< double > &src) const

TrilinosWrappers::PreconditionSSOR::AdditionalData::AdditionalData (const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)

TrilinosWrappers::PreconditionSOR::AdditionalData::AdditionalData (const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)

TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::AdditionalData (const unsigned int block_size=1, const std::string &block_creation_type="linear", const double omega=1, const double min_diagonal=0, const unsigned int n_sweeps=1)

TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::AdditionalData (const unsigned int block_size=1, const std::string &block_creation_type="linear", const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)

TrilinosWrappers::PreconditionBlockSOR::AdditionalData::AdditionalData (const unsigned int block_size=1, const std::string &block_creation_type="linear", const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)

TrilinosWrappers::PreconditionIC::AdditionalData::AdditionalData (const unsigned int ic_fill=0, const double ic_atol=0., const double ic_rtol=1., const unsigned int overlap=0)

TrilinosWrappers::PreconditionILU::AdditionalData::AdditionalData (const unsigned int ilu_fill=0, const double ilu_atol=0., const double ilu_rtol=1., const unsigned int overlap=0)

TrilinosWrappers::PreconditionILUT::AdditionalData::AdditionalData (const double ilut_drop=0., const unsigned int ilut_fill=0, const double ilut_atol=0., const double ilut_rtol=1., const unsigned int overlap=0)

TrilinosWrappers::PreconditionChebyshev::AdditionalData::AdditionalData (const unsigned int degree=1, const double max_eigenvalue=10., const double eigenvalue_ratio=30., const double min_eigenvalue=1., const double min_diagonal=1e-12, const bool nonzero_starting=false)

TrilinosWrappers::PreconditionAMG::AdditionalData::AdditionalData (const bool elliptic=true, const bool higher_order_elements=false, const unsigned int n_cycles=1, const bool w_cycle=false, const double aggregation_threshold=1e-4, const std::vector< std::vector< bool > > &constant_modes=std::vector< std::vector< bool > >(0), const unsigned int smoother_sweeps=2, const unsigned int smoother_overlap=0, const bool output_details=false, const char *smoother_type="Chebyshev", const char *coarse_type="Amesos-KLU")

void TrilinosWrappers::PreconditionAMG::AdditionalData::set_parameters (Teuchos::ParameterList &parameter_list, std::unique_ptr< Epetra_MultiVector > &distributed_constant_modes, const Epetra_RowMatrix &matrix) const

void TrilinosWrappers::PreconditionAMG::AdditionalData::set_parameters (Teuchos::ParameterList &parameter_list, std::unique_ptr< Epetra_MultiVector > &distributed_constant_modes, const SparseMatrix &matrix) const

void TrilinosWrappers::PreconditionAMG::AdditionalData::set_operator_null_space (Teuchos::ParameterList &parameter_list, std::unique_ptr< Epetra_MultiVector > &distributed_constant_modes, const Epetra_RowMatrix &matrix) const

void TrilinosWrappers::PreconditionAMG::AdditionalData::set_operator_null_space (Teuchos::ParameterList &parameter_list, std::unique_ptr< Epetra_MultiVector > &distributed_constant_modes, const SparseMatrix &matrix) const

TrilinosWrappers::PreconditionAMG::~PreconditionAMG () override

void TrilinosWrappers::PreconditionAMG::initialize (const SparseMatrix &matrix, const Teuchos::ParameterList &ml_parameters)

void TrilinosWrappers::PreconditionAMG::initialize (const Epetra_RowMatrix &matrix, const Teuchos::ParameterList &ml_parameters)

template<typename number >

void TrilinosWrappers::PreconditionAMG::reinit ()

void TrilinosWrappers::PreconditionAMG::clear ()

size_type TrilinosWrappers::PreconditionAMG::memory_consumption () const

TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::AdditionalData (const bool elliptic=true, const unsigned int n_cycles=1, const bool w_cycle=false, const double aggregation_threshold=1e-4, const std::vector< std::vector< bool > > &constant_modes=std::vector< std::vector< bool > >(0), const unsigned int smoother_sweeps=2, const unsigned int smoother_overlap=0, const bool output_details=false, const char *smoother_type="Chebyshev", const char *coarse_type="Amesos-KLU")

TrilinosWrappers::PreconditionAMGMueLu::PreconditionAMGMueLu ()

virtual TrilinosWrappers::PreconditionAMGMueLu::~PreconditionAMGMueLu () override=default

void TrilinosWrappers::PreconditionAMGMueLu::initialize (const SparseMatrix &matrix, Teuchos::ParameterList &muelu_parameters)

void TrilinosWrappers::PreconditionAMGMueLu::initialize (const Epetra_CrsMatrix &matrix, Teuchos::ParameterList &muelu_parameters)

template<typename number >

void TrilinosWrappers::PreconditionAMGMueLu::clear ()

size_type TrilinosWrappers::PreconditionAMGMueLu::memory_consumption () const

void TrilinosWrappers::PreconditionIdentity::vmult (MPI::Vector &dst, const MPI::Vector &src) const override

void TrilinosWrappers::PreconditionIdentity::Tvmult (MPI::Vector &dst, const MPI::Vector &src) const override

void TrilinosWrappers::PreconditionIdentity::vmult (::Vector< double > &dst, const ::Vector< double > &src) const override

void TrilinosWrappers::PreconditionIdentity::Tvmult (::Vector< double > &dst, const ::Vector< double > &src) const override

void TrilinosWrappers::PreconditionIdentity::vmult (LinearAlgebra::distributed::Vector< double > &dst, const ::LinearAlgebra::distributed::Vector< double > &src) const override

void TrilinosWrappers::PreconditionIdentity::Tvmult (LinearAlgebra::distributed::Vector< double > &dst, const ::LinearAlgebra::distributed::Vector< double > &src) const override

int TrilinosWrappers::gid (const Epetra_BlockMap &map, int i)

void TrilinosWrappers::MPI::swap (Vector &u, Vector &v)

template<typename Matrix >
static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::Vector >::reinit_range_vector (const Matrix &matrix, TrilinosWrappers::MPI::Vector &v, bool omit_zeroing_entries)

template<typename Matrix >
static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::Vector >::reinit_domain_vector (const Matrix &matrix, TrilinosWrappers::MPI::Vector &v, bool omit_zeroing_entries)

void swap (BlockVector &u, BlockVector &v)

void swap (Vector &u, Vector &v)

## Partitioners

class TrilinosWrappers::PreconditionBase::SolverBase

Teuchos::RCP< Epetra_OperatorTrilinosWrappers::PreconditionBase::preconditioner

Epetra_MpiComm TrilinosWrappers::PreconditionBase::communicator

std::shared_ptr< Epetra_Map > TrilinosWrappers::PreconditionBase::vector_distributor

IndexSet TrilinosWrappers::PreconditionBase::locally_owned_domain_indices () const

IndexSet TrilinosWrappers::PreconditionBase::locally_owned_range_indices () const

static ::ExceptionBaseTrilinosWrappers::PreconditionBase::ExcNonMatchingMaps (std::string arg1)

## 4: Mixed stuff

class TrilinosWrappers::MPI::Vector::internal::VectorReference

Epetra_CombineMode TrilinosWrappers::MPI::Vector::last_action

bool TrilinosWrappers::MPI::Vector::compressed

bool TrilinosWrappers::MPI::Vector::has_ghosts

std::unique_ptr< Epetra_FEVector > TrilinosWrappers::MPI::Vector::vector

std::unique_ptr< Epetra_MultiVector > TrilinosWrappers::MPI::Vector::nonlocal_vector

IndexSet TrilinosWrappers::MPI::Vector::owned_elements

const Epetra_MultiVector & TrilinosWrappers::MPI::Vector::trilinos_vector () const

Epetra_FEVector & TrilinosWrappers::MPI::Vector::trilinos_vector ()

const Epetra_BlockMap & TrilinosWrappers::MPI::Vector::trilinos_partitioner () const

void TrilinosWrappers::MPI::Vector::print (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const

void TrilinosWrappers::MPI::Vector::swap (Vector &v)

std::size_t TrilinosWrappers::MPI::Vector::memory_consumption () const

const MPI_CommTrilinosWrappers::MPI::Vector::get_mpi_communicator () const

static ::ExceptionBaseTrilinosWrappers::MPI::Vector::ExcDifferentParallelPartitioning ()

static ::ExceptionBaseTrilinosWrappers::MPI::Vector::ExcTrilinosError (int arg1)

static ::ExceptionBaseTrilinosWrappers::MPI::Vector::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4)

## Creation of a LinearOperator

template<typename Range , typename Domain = Range, typename Matrix >
LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayloadTrilinosWrappers::linear_operator (const TrilinosWrappers::SparseMatrix &operator_exemplar, const Matrix &matrix)

template<typename Range , typename Domain = Range>
LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayloadTrilinosWrappers::linear_operator (const TrilinosWrappers::SparseMatrix &matrix)

template<typename Range , typename Domain , typename Matrix >
LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayloadTrilinosWrappers::linear_operator (const LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > &operator_exemplar, const Matrix &matrix)

template<typename Range , typename Domain = Range, typename Matrix >
LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayloadlinear_operator (const TrilinosWrappers::SparseMatrix &operator_exemplar, const Matrix &matrix)

template<typename Range , typename Domain = Range>
LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayloadlinear_operator (const TrilinosWrappers::SparseMatrix &matrix)

template<typename Range , typename Domain , typename Matrix >
LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayloadlinear_operator (const LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > &operator_exemplar, const Matrix &matrix)

## Creation of a BlockLinearOperator

template<typename Range , typename Domain = Range>

template<std::size_t m, std::size_t n, typename Range , typename Domain = Range>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_operator (const std::array< std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, n >, m > &ops)

template<typename Range , typename Domain = Range>

template<std::size_t m, typename Range , typename Domain = Range>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_diagonal_operator (const std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, m > &ops)

template<typename Range , typename Domain = Range>

template<std::size_t m, std::size_t n, typename Range , typename Domain = Range>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_operator (const std::array< std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, n >, m > &ops)

template<typename Range , typename Domain = Range>

template<std::size_t m, typename Range , typename Domain = Range>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_diagonal_operator (const std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, m > &ops)

Epetra_OperatorTrilinosWrappers::PreconditionBase::trilinos_operator () const

## 1: Basic Object-handling

TrilinosWrappers::MPI::Vector::Vector ()

TrilinosWrappers::MPI::Vector::Vector (const Vector &v)

TrilinosWrappers::MPI::Vector::Vector (const IndexSet &parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD)

TrilinosWrappers::MPI::Vector::Vector (const IndexSet &local, const IndexSet &ghost, const MPI_Comm &communicator=MPI_COMM_WORLD)

TrilinosWrappers::MPI::Vector::Vector (const IndexSet &parallel_partitioning, const Vector &v, const MPI_Comm &communicator=MPI_COMM_WORLD)

template<typename Number >
TrilinosWrappers::MPI::Vector::Vector (const IndexSet &parallel_partitioning, const ::Vector< Number > &v, const MPI_Comm &communicator=MPI_COMM_WORLD)

TrilinosWrappers::MPI::Vector::Vector (Vector &&v) noexcept

TrilinosWrappers::MPI::Vector::~Vector () override=default

void TrilinosWrappers::MPI::Vector::clear ()

void TrilinosWrappers::MPI::Vector::reinit (const Vector &v, const bool omit_zeroing_entries=false, const bool allow_different_maps=false)

void TrilinosWrappers::MPI::Vector::reinit (const IndexSet &parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool omit_zeroing_entries=false)

void TrilinosWrappers::MPI::Vector::reinit (const IndexSet &locally_owned_entries, const IndexSet &ghost_entries, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool vector_writable=false)

void TrilinosWrappers::MPI::Vector::reinit (const BlockVector &v, const bool import_data=false)

void TrilinosWrappers::MPI::Vector::compress (::VectorOperation::values operation)

VectorTrilinosWrappers::MPI::Vector::operator= (const TrilinosScalar s)

VectorTrilinosWrappers::MPI::Vector::operator= (const Vector &v)

VectorTrilinosWrappers::MPI::Vector::operator= (Vector &&v) noexcept

template<typename Number >
VectorTrilinosWrappers::MPI::Vector::operator= (const ::Vector< Number > &v)

void TrilinosWrappers::MPI::Vector::import_nonlocal_data_for_fe (const ::TrilinosWrappers::SparseMatrix &matrix, const Vector &vector)

void TrilinosWrappers::MPI::Vector::import (const LinearAlgebra::ReadWriteVector< double > &rwv, const VectorOperation::values operation)

bool TrilinosWrappers::MPI::Vector::operator== (const Vector &v) const

bool TrilinosWrappers::MPI::Vector::operator!= (const Vector &v) const

size_type TrilinosWrappers::MPI::Vector::size () const

size_type TrilinosWrappers::MPI::Vector::local_size () const

size_type TrilinosWrappers::MPI::Vector::locally_owned_size () const

std::pair< size_type, size_typeTrilinosWrappers::MPI::Vector::local_range () const

bool TrilinosWrappers::MPI::Vector::in_local_range (const size_type index) const

IndexSet TrilinosWrappers::MPI::Vector::locally_owned_elements () const

bool TrilinosWrappers::MPI::Vector::has_ghost_elements () const

void TrilinosWrappers::MPI::Vector::update_ghost_values () const

TrilinosScalar TrilinosWrappers::MPI::Vector::operator* (const Vector &vec) const

real_type TrilinosWrappers::MPI::Vector::norm_sqr () const

TrilinosScalar TrilinosWrappers::MPI::Vector::mean_value () const

TrilinosScalar TrilinosWrappers::MPI::Vector::min () const

TrilinosScalar TrilinosWrappers::MPI::Vector::max () const

real_type TrilinosWrappers::MPI::Vector::l1_norm () const

real_type TrilinosWrappers::MPI::Vector::l2_norm () const

real_type TrilinosWrappers::MPI::Vector::lp_norm (const TrilinosScalar p) const

real_type TrilinosWrappers::MPI::Vector::linfty_norm () const

TrilinosScalar TrilinosWrappers::MPI::Vector::add_and_dot (const TrilinosScalar a, const Vector &V, const Vector &W)

bool TrilinosWrappers::MPI::Vector::all_zero () const

bool TrilinosWrappers::MPI::Vector::is_non_negative () const

## 2: Data-Access

reference TrilinosWrappers::MPI::Vector::operator() (const size_type index)

TrilinosScalar TrilinosWrappers::MPI::Vector::operator() (const size_type index) const

reference TrilinosWrappers::MPI::Vector::operator[] (const size_type index)

TrilinosScalar TrilinosWrappers::MPI::Vector::operator[] (const size_type index) const

void TrilinosWrappers::MPI::Vector::extract_subvector_to (const std::vector< size_type > &indices, std::vector< TrilinosScalar > &values) const

template<typename ForwardIterator , typename OutputIterator >
void TrilinosWrappers::MPI::Vector::extract_subvector_to (ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin) const

iterator TrilinosWrappers::MPI::Vector::begin ()

const_iterator TrilinosWrappers::MPI::Vector::begin () const

iterator TrilinosWrappers::MPI::Vector::end ()

const_iterator TrilinosWrappers::MPI::Vector::end () const

## 3: Modification of vectors

void TrilinosWrappers::MPI::Vector::set (const std::vector< size_type > &indices, const std::vector< TrilinosScalar > &values)

void TrilinosWrappers::MPI::Vector::set (const std::vector< size_type > &indices, const ::Vector< TrilinosScalar > &values)

void TrilinosWrappers::MPI::Vector::set (const size_type n_elements, const size_type *indices, const TrilinosScalar *values)

void TrilinosWrappers::MPI::Vector::add (const std::vector< size_type > &indices, const std::vector< TrilinosScalar > &values)

void TrilinosWrappers::MPI::Vector::add (const std::vector< size_type > &indices, const ::Vector< TrilinosScalar > &values)

void TrilinosWrappers::MPI::Vector::add (const size_type n_elements, const size_type *indices, const TrilinosScalar *values)

VectorTrilinosWrappers::MPI::Vector::operator*= (const TrilinosScalar factor)

VectorTrilinosWrappers::MPI::Vector::operator/= (const TrilinosScalar factor)

VectorTrilinosWrappers::MPI::Vector::operator+= (const Vector &V)

VectorTrilinosWrappers::MPI::Vector::operator-= (const Vector &V)

void TrilinosWrappers::MPI::Vector::add (const Vector &V, const bool allow_different_maps=false)

void TrilinosWrappers::MPI::Vector::add (const TrilinosScalar a, const Vector &V)

void TrilinosWrappers::MPI::Vector::add (const TrilinosScalar a, const Vector &V, const TrilinosScalar b, const Vector &W)

void TrilinosWrappers::MPI::Vector::sadd (const TrilinosScalar s, const Vector &V)

void TrilinosWrappers::MPI::Vector::sadd (const TrilinosScalar s, const TrilinosScalar a, const Vector &V)

void TrilinosWrappers::MPI::Vector::scale (const Vector &scaling_factors)

void TrilinosWrappers::MPI::Vector::equ (const TrilinosScalar a, const Vector &V)

## Detailed Description

The classes in this module are wrappers around functionality provided by the Trilinos library. They provide a modern object-oriented interface that is compatible with the interfaces of the other linear algebra classes in deal.II. All classes and functions in this group reside in a namespace TrilinosWrappers.

These classes are only available if a Trilinos installation was detected during configuration of deal.II. Refer to the README file for more details about this.

## ◆ BaseClass [1/2]

Definition at line 77 of file trilinos_block_sparse_matrix.h.

## ◆ BlockType [1/3]

Typedef the type of the underlying matrix.

Definition at line 82 of file trilinos_block_sparse_matrix.h.

## ◆ value_type [1/3]

Import the alias from the base class.

Definition at line 87 of file trilinos_block_sparse_matrix.h.

## ◆ pointer [1/2]

Definition at line 88 of file trilinos_block_sparse_matrix.h.

## ◆ const_pointer [1/2]

Definition at line 89 of file trilinos_block_sparse_matrix.h.

## ◆ reference [1/3]

Definition at line 90 of file trilinos_block_sparse_matrix.h.

## ◆ const_reference [1/3]

Definition at line 91 of file trilinos_block_sparse_matrix.h.

## ◆ size_type [1/4]

Definition at line 92 of file trilinos_block_sparse_matrix.h.

## ◆ iterator [1/3]

Definition at line 93 of file trilinos_block_sparse_matrix.h.

## ◆ const_iterator [1/3]

Definition at line 94 of file trilinos_block_sparse_matrix.h.

## ◆ BlockType [2/3]

Type of payload held by each subblock

Definition at line 588 of file trilinos_block_sparse_matrix.h.

## ◆ BaseClass [2/2]

Definition at line 80 of file trilinos_parallel_block_vector.h.

## ◆ BlockType [3/3]

Typedef the type of the underlying vector.

Definition at line 85 of file trilinos_parallel_block_vector.h.

## ◆ value_type [2/3]

Import the alias from the base class.

Definition at line 90 of file trilinos_parallel_block_vector.h.

## ◆ pointer [2/2]

Definition at line 91 of file trilinos_parallel_block_vector.h.

## ◆ const_pointer [2/2]

Definition at line 92 of file trilinos_parallel_block_vector.h.

## ◆ reference [2/3]

Definition at line 93 of file trilinos_parallel_block_vector.h.

## ◆ const_reference [2/3]

Definition at line 94 of file trilinos_parallel_block_vector.h.

## ◆ size_type [2/4]

Definition at line 95 of file trilinos_parallel_block_vector.h.

## ◆ iterator [2/3]

Definition at line 96 of file trilinos_parallel_block_vector.h.

## ◆ const_iterator [2/3]

Definition at line 97 of file trilinos_parallel_block_vector.h.

## ◆ size_type [3/4]

Declare the type for container size.

Definition at line 82 of file trilinos_precondition.h.

## ◆ value_type [3/3]

Declare some of the standard types used in all containers. These types parallel those in the C standard libraries vector<...> class.

Definition at line 406 of file trilinos_vector.h.

## ◆ real_type

Definition at line 407 of file trilinos_vector.h.

## ◆ size_type [4/4]

Definition at line 408 of file trilinos_vector.h.

## ◆ iterator [3/3]

Definition at line 409 of file trilinos_vector.h.

## ◆ const_iterator [3/3]

 using TrilinosWrappers::MPI::Vector::const_iterator = const value_type *

Definition at line 410 of file trilinos_vector.h.

## ◆ reference [3/3]

 using TrilinosWrappers::MPI::Vector::reference = internal::VectorReference

Definition at line 411 of file trilinos_vector.h.

## ◆ const_reference [3/3]

 using TrilinosWrappers::MPI::Vector::const_reference = const internal::VectorReference

Definition at line 412 of file trilinos_vector.h.

## ◆ BlockSparsityPattern() [1/5]

 TrilinosWrappers::BlockSparsityPattern::BlockSparsityPattern ( )
default

Initialize the matrix empty, that is with no memory allocated. This is useful if you want such objects as member variables in other classes. You can make the structure usable by calling the reinit() function.

## ◆ BlockSparsityPattern() [2/5]

 BlockSparsityPattern::BlockSparsityPattern ( const size_type n_rows, const size_type n_columns )

Initialize the matrix with the given number of block rows and columns. The blocks themselves are still empty, and you have to call collect_sizes() after you assign them sizes.

Definition at line 560 of file block_sparsity_pattern.cc.

## ◆ BlockSparsityPattern() [3/5]

 BlockSparsityPattern::BlockSparsityPattern ( const std::vector< size_type > & row_block_sizes, const std::vector< size_type > & col_block_sizes )

Initialize the pattern with two BlockIndices for the block structures of matrix rows and columns. This function is equivalent to calling the previous constructor with the length of the two index vector and then entering the index values.

Definition at line 567 of file block_sparsity_pattern.cc.

## ◆ BlockSparsityPattern() [4/5]

 BlockSparsityPattern::BlockSparsityPattern ( const std::vector< IndexSet > & parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD )

Initialize the pattern with an array of index sets that specifies both rows and columns of the matrix (so the final matrix will be a square matrix), where the size() of the IndexSets specifies the size of the blocks and the values in each IndexSet denotes the rows that are going to be saved in each block.

Definition at line 581 of file block_sparsity_pattern.cc.

## ◆ BlockSparsityPattern() [5/5]

 BlockSparsityPattern::BlockSparsityPattern ( const std::vector< IndexSet > & row_parallel_partitioning, const std::vector< IndexSet > & column_parallel_partitioning, const std::vector< IndexSet > & writeable_rows, const MPI_Comm & communicator = MPI_COMM_WORLD )

Initialize the pattern with two arrays of index sets that specify rows and columns of the matrix, where the size() of the IndexSets specifies the size of the blocks and the values in each IndexSet denotes the rows that are going to be saved in each block. The additional index set writable_rows is used to set all rows that we allow to write locally. This constructor is used to create matrices that allow several threads to write simultaneously into the matrix (to different rows, of course), see the method TrilinosWrappers::SparsityPattern::reinit method with three index set arguments for more details.

Definition at line 597 of file block_sparsity_pattern.cc.

## ◆ reinit() [1/18]

 void BlockSparsityPattern::reinit ( const std::vector< size_type > & row_block_sizes, const std::vector< size_type > & col_block_sizes )

Resize the matrix to a tensor product of matrices with dimensions defined by the arguments.

The matrix will have as many block rows and columns as there are entries in the two arguments. The block at position (i,j) will have the dimensions row_block_sizes[i] times col_block_sizes[j].

Definition at line 618 of file block_sparsity_pattern.cc.

## ◆ reinit() [2/18]

 void BlockSparsityPattern::reinit ( const std::vector< IndexSet > & parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD )

Resize the matrix to a square tensor product of matrices. See the constructor that takes a vector of IndexSets for details.

Definition at line 632 of file block_sparsity_pattern.cc.

## ◆ reinit() [3/18]

 void BlockSparsityPattern::reinit ( const std::vector< IndexSet > & row_parallel_partitioning, const std::vector< IndexSet > & column_parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD )

Resize the matrix to a rectangular block matrices. This method allows rows and columns to be different, both in the outer block structure and within the blocks.

Definition at line 649 of file block_sparsity_pattern.cc.

## ◆ reinit() [4/18]

 void BlockSparsityPattern::reinit ( const std::vector< IndexSet > & row_parallel_partitioning, const std::vector< IndexSet > & column_parallel_partitioning, const std::vector< IndexSet > & writeable_rows, const MPI_Comm & communicator = MPI_COMM_WORLD )

Resize the matrix to a rectangular block matrices that furthermore explicitly specify the writable rows in each of the blocks. This method is used to create matrices that allow several threads to write simultaneously into the matrix (to different rows, of course), see the method TrilinosWrappers::SparsityPattern::reinit method with three index set arguments for more details.

Definition at line 667 of file block_sparsity_pattern.cc.

## ◆ BlockSparseMatrix()

 TrilinosWrappers::BlockSparseMatrix::BlockSparseMatrix ( )
default

Constructor; initializes the matrix to be empty, without any structure, i.e. the matrix is not usable at all. This constructor is therefore only useful for matrices which are members of a class. All other matrices should be created at a point in the data flow where all necessary information is available.

You have to initialize the matrix before usage with reinit(BlockSparsityPattern). The number of blocks per row and column are then determined by that function.

## ◆ ~BlockSparseMatrix()

 BlockSparseMatrix< number >::~BlockSparseMatrix ( )
override

Destructor.

Definition at line 27 of file trilinos_block_sparse_matrix.cc.

## ◆ operator=() [1/10]

 BlockSparseMatrix & TrilinosWrappers::BlockSparseMatrix::operator= ( const BlockSparseMatrix & )
default

Pseudo copy operator only copying empty objects. The sizes of the block matrices need to be the same.

## ◆ operator=() [2/10]

 BlockSparseMatrix & BlockSparseMatrix< number >::operator= ( const double d )
inline

This operator assigns a scalar to a matrix. Since this does usually not make much sense (should we set all matrix entries to this value? Only the nonzero entries of the sparsity pattern?), this operation is only allowed if the actual value to be assigned is zero. This operator only exists to allow for the obvious notation matrix=0, which sets all elements of the matrix to zero, but keep the sparsity pattern previously used.

Definition at line 411 of file trilinos_block_sparse_matrix.h.

## ◆ reinit() [5/18]

 void TrilinosWrappers::BlockSparseMatrix::reinit ( const size_type n_block_rows, const size_type n_block_columns )

Resize the matrix, by setting the number of block rows and columns. This deletes all blocks and replaces them with uninitialized ones, i.e. ones for which also the sizes are not yet set. You have to do that by calling the reinit functions of the blocks themselves. Do not forget to call collect_sizes() after that on this object.

The reason that you have to set sizes of the blocks yourself is that the sizes may be varying, the maximum number of elements per row may be varying, etc. It is simpler not to reproduce the interface of the SparsityPattern class here but rather let the user call whatever function they desire.

## ◆ reinit() [6/18]

template<typename BlockSparsityPatternType >
 void BlockSparseMatrix< BlockSparsityPatternType >::reinit ( const std::vector< IndexSet > & input_maps, const BlockSparsityPatternType & block_sparsity_pattern, const MPI_Comm & communicator = MPI_COMM_WORLD, const bool exchange_data = false )

Resize the matrix, by using an array of index sets to determine the parallel distribution of the individual matrices. This function assumes that a quadratic block matrix is generated.

Definition at line 73 of file trilinos_block_sparse_matrix.cc.

## ◆ reinit() [7/18]

template<typename BlockSparsityPatternType >
 void BlockSparseMatrix< BlockSparsityPatternType >::reinit ( const BlockSparsityPatternType & block_sparsity_pattern )

Resize the matrix and initialize it by the given sparsity pattern. Since no distribution map is given, the result is a block matrix for which all elements are stored locally.

Definition at line 127 of file trilinos_block_sparse_matrix.cc.

## ◆ reinit() [8/18]

 void BlockSparseMatrix< number >::reinit ( const std::vector< IndexSet > & parallel_partitioning, const ::BlockSparseMatrix< double > & dealii_block_sparse_matrix, const MPI_Comm & communicator = MPI_COMM_WORLD, const double drop_tolerance = 1e-13 )

This function initializes the Trilinos matrix using the deal.II sparse matrix and the entries stored therein. It uses a threshold to copy only elements whose modulus is larger than the threshold (so zeros in the deal.II matrix can be filtered away).

Definition at line 164 of file trilinos_block_sparse_matrix.cc.

## ◆ reinit() [9/18]

 void BlockSparseMatrix< number >::reinit ( const ::BlockSparseMatrix< double > & deal_ii_sparse_matrix, const double drop_tolerance = 1e-13 )

This function initializes the Trilinos matrix using the deal.II sparse matrix and the entries stored therein. It uses a threshold to copy only elements whose modulus is larger than the threshold (so zeros in the deal.II matrix can be filtered away). Since no Epetra_Map is given, all the elements will be locally stored.

Definition at line 201 of file trilinos_block_sparse_matrix.cc.

## ◆ is_compressed()

 bool BlockSparseMatrix< number >::is_compressed ( ) const
inline

Return the state of the matrix, i.e., whether compress() needs to be called after an operation requiring data exchange. Does only return non-true values when used in debug mode, since it is quite expensive to keep track of all operations that lead to the need for compress().

Definition at line 425 of file trilinos_block_sparse_matrix.h.

## ◆ collect_sizes()

 void BlockSparseMatrix< number >::collect_sizes ( )

This function collects the sizes of the sub-objects and stores them in internal arrays, in order to be able to relay global indices into the matrix to indices into the subobjects. You must call this function each time after you have changed the size of the sub-objects. Note that this is a collective operation, i.e., it needs to be called on all MPI processes. This command internally calls the method compress(), so you don't need to call that function in case you use collect_sizes().

Definition at line 227 of file trilinos_block_sparse_matrix.cc.

## ◆ n_nonzero_elements()

 std::uint64_t BlockSparseMatrix< number >::n_nonzero_elements ( ) const

Return the total number of nonzero elements of this matrix (summed over all MPI processes).

Definition at line 236 of file trilinos_block_sparse_matrix.cc.

## ◆ get_mpi_communicator() [1/3]

 MPI_Comm BlockSparseMatrix< number >::get_mpi_communicator ( ) const

Return the MPI communicator object in use with this matrix.

Definition at line 309 of file trilinos_block_sparse_matrix.cc.

## ◆ locally_owned_domain_indices() [1/2]

 std::vector< IndexSet > BlockSparseMatrix< number >::locally_owned_domain_indices ( ) const
inline

Return the partitioning of the domain space for the individual blocks of this matrix, i.e., the partitioning of the block vectors this matrix has to be multiplied with.

Definition at line 532 of file trilinos_block_sparse_matrix.h.

## ◆ locally_owned_range_indices() [1/2]

 std::vector< IndexSet > BlockSparseMatrix< number >::locally_owned_range_indices ( ) const
inline

Return the partitioning of the range space for the individual blocks of this matrix, i.e., the partitioning of the block vectors that result from matrix-vector products.

Definition at line 548 of file trilinos_block_sparse_matrix.h.

## ◆ vmult() [1/11]

template<typename VectorType1 , typename VectorType2 >
 void BlockSparseMatrix< VectorType1, VectorType2 >::vmult ( VectorType1 & dst, const VectorType2 & src ) const
inline

Matrix-vector multiplication: let $$dst = M*src$$ with $$M$$ being this matrix. The vector types can be block vectors or non-block vectors (only if the matrix has only one row or column, respectively), and need to define TrilinosWrappers::SparseMatrix::vmult.

Definition at line 443 of file trilinos_block_sparse_matrix.h.

## ◆ Tvmult() [1/7]

template<typename VectorType1 , typename VectorType2 >
 void BlockSparseMatrix< VectorType1, VectorType2 >::Tvmult ( VectorType1 & dst, const VectorType2 & src ) const
inline

Matrix-vector multiplication: let $$dst = M^T*src$$ with $$M$$ being this matrix. This function does the same as vmult() but takes the transposed matrix.

Definition at line 456 of file trilinos_block_sparse_matrix.h.

## ◆ residual() [1/4]

 TrilinosScalar BlockSparseMatrix< number >::residual ( MPI::BlockVector & dst, const MPI::BlockVector & x, const MPI::BlockVector & b ) const

Compute the residual of an equation Mx=b, where the residual is defined to be r=b-Mx. Write the residual into dst. The l2 norm of the residual vector is returned.

Source x and destination dst must not be the same vector.

Note that both vectors have to be distributed vectors generated using the same Map as was used for the matrix.

This function only applicable if the matrix only has one block row.

Definition at line 249 of file trilinos_block_sparse_matrix.cc.

## ◆ residual() [2/4]

 TrilinosScalar BlockSparseMatrix< number >::residual ( MPI::BlockVector & dst, const MPI::Vector & x, const MPI::BlockVector & b ) const

Compute the residual of an equation Mx=b, where the residual is defined to be r=b-Mx. Write the residual into dst. The l2 norm of the residual vector is returned.

This function is only applicable if the matrix only has one block row.

Definition at line 267 of file trilinos_block_sparse_matrix.cc.

## ◆ residual() [3/4]

 TrilinosScalar BlockSparseMatrix< number >::residual ( MPI::Vector & dst, const MPI::BlockVector & x, const MPI::Vector & b ) const

Compute the residual of an equation Mx=b, where the residual is defined to be r=b-Mx. Write the residual into dst. The l2 norm of the residual vector is returned.

This function is only applicable if the matrix only has one block column.

Definition at line 281 of file trilinos_block_sparse_matrix.cc.

## ◆ residual() [4/4]

 TrilinosScalar BlockSparseMatrix< number >::residual ( MPI::Vector & dst, const MPI::Vector & x, const MPI::Vector & b ) const

Compute the residual of an equation Mx=b, where the residual is defined to be r=b-Mx. Write the residual into dst. The l2 norm of the residual vector is returned.

This function is only applicable if the matrix only has one block.

Definition at line 295 of file trilinos_block_sparse_matrix.cc.

## ◆ vmult() [2/11]

template<typename VectorType1 , typename VectorType2 >
 void BlockSparseMatrix< VectorType1, VectorType2 >::vmult ( VectorType1 & dst, const VectorType2 & src, const bool transpose, const std::integral_constant< bool, true > , const std::integral_constant< bool, true > ) const
inlineprivate

Internal version of (T)vmult with two block vectors

Definition at line 469 of file trilinos_block_sparse_matrix.h.

## ◆ vmult() [3/11]

template<typename VectorType1 , typename VectorType2 >
 void BlockSparseMatrix< VectorType1, VectorType2 >::vmult ( VectorType1 & dst, const VectorType2 & src, const bool transpose, const std::integral_constant< bool, false > , const std::integral_constant< bool, true > ) const
inlineprivate

Internal version of (T)vmult where the source vector is a block vector but the destination vector is a non-block vector

Definition at line 485 of file trilinos_block_sparse_matrix.h.

## ◆ vmult() [4/11]

template<typename VectorType1 , typename VectorType2 >
 void BlockSparseMatrix< VectorType1, VectorType2 >::vmult ( VectorType1 & dst, const VectorType2 & src, const bool transpose, const std::integral_constant< bool, true > , const std::integral_constant< bool, false > ) const
inlineprivate

Internal version of (T)vmult where the source vector is a non-block vector but the destination vector is a block vector

Definition at line 501 of file trilinos_block_sparse_matrix.h.

## ◆ vmult() [5/11]

template<typename VectorType1 , typename VectorType2 >
 void BlockSparseMatrix< VectorType1, VectorType2 >::vmult ( VectorType1 & dst, const VectorType2 & src, const bool transpose, const std::integral_constant< bool, false > , const std::integral_constant< bool, false > ) const
inlineprivate

Internal version of (T)vmult where both source vector and the destination vector are non-block vectors (only defined if the matrix consists of only one block)

Definition at line 517 of file trilinos_block_sparse_matrix.h.

template<typename... Args>
inline

Default constructor

This simply checks that the payload for each block has been chosen correctly (i.e. is of type TrilinosPayload). Apart from this, this class does not do anything in particular and needs no special configuration, we have only one generic constructor that can be called under any conditions.

Definition at line 600 of file trilinos_block_sparse_matrix.h.

## ◆ linear_operator() [1/6]

template<typename Range , typename Domain = Range, typename Matrix >
 LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > TrilinosWrappers::linear_operator ( const TrilinosWrappers::SparseMatrix & operator_exemplar, const Matrix & matrix )
inline

A function that encapsulates generic matrix objects, based on an operator_exemplar, that act on a compatible Vector type into a LinearOperator.

This function is the equivalent of the linear_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 76 of file trilinos_linear_operator.h.

## ◆ linear_operator() [2/6]

template<typename Range , typename Domain = Range>
 LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > TrilinosWrappers::linear_operator ( const TrilinosWrappers::SparseMatrix & matrix )
inline

A function that encapsulates generic matrix objects that act on a compatible Vector type into a LinearOperator.

This function is the equivalent of the linear_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 106 of file trilinos_linear_operator.h.

## ◆ linear_operator() [3/6]

template<typename Range , typename Domain , typename Matrix >
 LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > TrilinosWrappers::linear_operator ( const LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > & operator_exemplar, const Matrix & matrix )
inline

A function that encapsulates generic matrix objects, based on an operator_exemplar, that act on a compatible Vector type into a LinearOperator.

This function is the equivalent of the linear_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 135 of file trilinos_linear_operator.h.

## ◆ block_operator() [1/4]

template<typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_operator ( const TrilinosWrappers::BlockSparseMatrix & block_matrix )
inline

A function that encapsulates a block_matrix into a BlockLinearOperator.

This function is the equivalent of the block_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 178 of file trilinos_linear_operator.h.

## ◆ block_operator() [2/4]

template<std::size_t m, std::size_t n, typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_operator ( const std::array< std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, n >, m > & ops )
inline

A variant of above function that builds up a block diagonal linear operator from an array ops of diagonal elements (off-diagonal blocks are assumed to be 0).

This function is the equivalent of the block_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 214 of file trilinos_linear_operator.h.

## ◆ block_diagonal_operator() [1/4]

template<typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_diagonal_operator ( const TrilinosWrappers::BlockSparseMatrix & block_matrix )
inline

This function extracts the diagonal blocks of block_matrix (either a block matrix type or a BlockLinearOperator) and creates a BlockLinearOperator with the diagonal. Off-diagonal elements are initialized as null_operator (with correct reinit_range_vector and reinit_domain_vector methods).

This function is the equivalent of the block_diagonal_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 255 of file trilinos_linear_operator.h.

## ◆ block_diagonal_operator() [2/4]

template<std::size_t m, typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_diagonal_operator ( const std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, m > & ops )
inline

A variant of above function that builds up a block diagonal linear operator from an array ops of diagonal elements (off-diagonal blocks are assumed to be 0).

This function is the equivalent of the block_diagonal_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 290 of file trilinos_linear_operator.h.

## ◆ BlockVector() [1/6]

 TrilinosWrappers::MPI::BlockVector::BlockVector ( )
default

Default constructor. Generate an empty vector without any blocks.

## ◆ BlockVector() [2/6]

 BlockVector< Number >::BlockVector ( const std::vector< IndexSet > & parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD )
inlineexplicit

Constructor. Generate a block vector with as many blocks as there are entries in partitioning. Each IndexSet together with the MPI communicator contains the layout of the distribution of data among the MPI processes.

Definition at line 317 of file trilinos_parallel_block_vector.h.

## ◆ BlockVector() [3/6]

 BlockVector< Number >::BlockVector ( const std::vector< IndexSet > & parallel_partitioning, const std::vector< IndexSet > & ghost_values, const MPI_Comm & communicator, const bool vector_writable = false )
inline

Creates a BlockVector with ghost elements. See the respective reinit() method for more details. ghost_values may contain any elements in parallel_partitioning, they will be ignored.

Definition at line 326 of file trilinos_parallel_block_vector.h.

## ◆ BlockVector() [4/6]

 BlockVector< Number >::BlockVector ( const BlockVector & v )
inline

Copy-Constructor. Set all the properties of the parallel vector to those of the given argument and copy the elements.

Definition at line 347 of file trilinos_parallel_block_vector.h.

## ◆ BlockVector() [5/6]

 BlockVector< Number >::BlockVector ( BlockVector && v )
inlinenoexcept

Move constructor. Creates a new vector by stealing the internal data of the vector v.

Definition at line 359 of file trilinos_parallel_block_vector.h.

## ◆ BlockVector() [6/6]

 BlockVector< Number >::BlockVector ( const size_type num_blocks )
inlineexplicit

Creates a block vector consisting of num_blocks components, but there is no content in the individual components and the user has to fill appropriate data using a reinit of the blocks.

Definition at line 340 of file trilinos_parallel_block_vector.h.

## ◆ ~BlockVector()

 TrilinosWrappers::MPI::BlockVector::~BlockVector ( )
overridedefault

Destructor. Clears memory

## ◆ operator=() [3/10]

 BlockVector & BlockVector< Number >::operator= ( const value_type s )

Copy operator: fill all components of the vector that are locally stored with the given scalar value.

Definition at line 31 of file trilinos_block_vector.cc.

## ◆ operator=() [4/10]

 BlockVector & BlockVector< Number >::operator= ( const BlockVector & v )

Copy operator for arguments of the same type.

Definition at line 40 of file trilinos_block_vector.cc.

## ◆ operator=() [5/10]

 BlockVector & BlockVector< Number >::operator= ( BlockVector && v )
noexcept

Move the given vector. This operator replaces the present vector with v by efficiently swapping the internal data structures.

Definition at line 61 of file trilinos_block_vector.cc.

## ◆ operator=() [6/10]

template<typename Number >
 BlockVector & BlockVector< Number >::operator= ( const ::BlockVector< Number > & v )

Another copy function. This one takes a deal.II block vector and copies it into a TrilinosWrappers block vector. Note that the number of blocks has to be the same in the vector as in the input vector. Use the reinit() command for resizing the BlockVector or for changing the internal structure of the block components.

Since Trilinos only works on doubles, this function is limited to accept only one possible number type in the deal.II vector.

Definition at line 370 of file trilinos_parallel_block_vector.h.

## ◆ reinit() [10/18]

 void BlockVector< Number >::reinit ( const std::vector< IndexSet > & parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD, const bool omit_zeroing_entries = false )

Reinitialize the BlockVector to contain as many blocks as there are index sets given in the input argument, according to the parallel distribution of the individual components described in the maps.

If omit_zeroing_entries==false, the vector is filled with zeros.

Definition at line 70 of file trilinos_block_vector.cc.

## ◆ reinit() [11/18]

 void BlockVector< Number >::reinit ( const std::vector< IndexSet > & partitioning, const std::vector< IndexSet > & ghost_values, const MPI_Comm & communicator = MPI_COMM_WORLD, const bool vector_writable = false )

Reinit functionality. This function destroys the old vector content and generates a new one based on the input partitioning. In addition to just specifying one index set as in all the other methods above, this method allows to supply an additional set of ghost entries. There are two different versions of a vector that can be created. If the flag vector_writable is set to false, the vector only allows read access to the joint set of parallel_partitioning and ghost_entries. The effect of the reinit method is then equivalent to calling the other reinit method with an index set containing both the locally owned entries and the ghost entries.

If the flag vector_writable is set to true, this creates an alternative storage scheme for ghost elements that allows multiple threads to write into the vector (for the other reinit methods, only one thread is allowed to write into the ghost entries at a time).

Definition at line 97 of file trilinos_block_vector.cc.

## ◆ reinit() [12/18]

 void BlockVector< Number >::reinit ( const BlockVector & V, const bool omit_zeroing_entries = false )

Change the dimension to that of the vector V. The same applies as for the other reinit() function.

The elements of V are not copied, i.e. this function is the same as calling reinit (V.size(), omit_zeroing_entries).

Note that you must call this (or the other reinit() functions) function, rather than calling the reinit() functions of an individual block, to allow the block vector to update its caches of vector sizes. If you call reinit() on one of the blocks, then subsequent actions on this object may yield unpredictable results since they may be routed to the wrong block.

Definition at line 126 of file trilinos_block_vector.cc.

## ◆ reinit() [13/18]

 void BlockVector< Number >::reinit ( const size_type num_blocks )

Change the number of blocks to num_blocks. The individual blocks will get initialized with zero size, so it is assumed that the user resizes the individual blocks by herself in an appropriate way, and calls collect_sizes afterwards.

Definition at line 141 of file trilinos_block_vector.cc.

## ◆ import_nonlocal_data_for_fe() [1/2]

 void BlockVector< Number >::import_nonlocal_data_for_fe ( const TrilinosWrappers::BlockSparseMatrix & m, const BlockVector & v )

This reinit function is meant to be used for parallel calculations where some non-local data has to be used. The typical situation where one needs this function is the call of the FEValues<dim>::get_function_values function (or of some derivatives) in parallel. Since it is usually faster to retrieve the data in advance, this function can be called before the assembly forks out to the different processors. What this function does is the following: It takes the information in the columns of the given matrix and looks which data couples between the different processors. That data is then queried from the input vector. Note that you should not write to the resulting vector any more, since the some data can be stored several times on different processors, leading to unpredictable results. In particular, such a vector cannot be used for matrix- vector products as for example done during the solution of linear systems.

Definition at line 157 of file trilinos_block_vector.cc.

## ◆ has_ghost_elements() [1/2]

 bool BlockVector< Number >::has_ghost_elements ( ) const
inline

Return if this Vector contains ghost elements.

vectors with ghost elements

Definition at line 391 of file trilinos_parallel_block_vector.h.

## ◆ swap() [1/6]

 void BlockVector< Number >::swap ( BlockVector & v )
inline

Swap the contents of this vector and the other vector v. One could do this operation with a temporary variable and copying over the data elements, but this function is significantly more efficient since it only swaps the pointers to the data of the two vectors and therefore does not need to allocate temporary storage and move data around.

Limitation: right now this function only works if both vectors have the same number of blocks. If needed, the numbers of blocks should be exchanged, too.

This function is analogous to the swap() function of all C++ standard containers. Also, there is a global function swap(u,v) that simply calls u.swap(v), again in analogy to standard functions.

Definition at line 404 of file trilinos_parallel_block_vector.h.

## ◆ print() [1/2]

 void BlockVector< Number >::print ( std::ostream & out, const unsigned int precision = 3, const bool scientific = true, const bool across = true ) const

Print to a stream.

Definition at line 181 of file trilinos_block_vector.cc.

## ◆ swap() [2/6]

 void swap ( BlockVector & u, BlockVector & v )
inline

Global function which overloads the default implementation of the C++ standard library which uses a temporary object. The function simply exchanges the data of the two vectors.

Definition at line 421 of file trilinos_parallel_block_vector.h.

## ◆ reinit_range_vector() [1/2]

template<typename Matrix >
 static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::BlockVector >::reinit_range_vector ( const Matrix & matrix, TrilinosWrappers::MPI::BlockVector & v, bool omit_zeroing_entries )
inlinestatic

Definition at line 450 of file trilinos_parallel_block_vector.h.

## ◆ reinit_domain_vector() [1/2]

template<typename Matrix >
 static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::BlockVector >::reinit_domain_vector ( const Matrix & matrix, TrilinosWrappers::MPI::BlockVector & v, bool omit_zeroing_entries )
inlinestatic

Definition at line 461 of file trilinos_parallel_block_vector.h.

## ◆ PreconditionBase() [1/2]

 TrilinosWrappers::PreconditionBase::PreconditionBase ( )

Constructor. Does not do anything. The initialize function of the derived classes will have to create the preconditioner from a given sparse matrix.

Definition at line 34 of file trilinos_precondition.cc.

## ◆ PreconditionBase() [2/2]

 TrilinosWrappers::PreconditionBase::PreconditionBase ( const PreconditionBase & base )

Copy constructor.

Definition at line 40 of file trilinos_precondition.cc.

## ◆ ~PreconditionBase()

 TrilinosWrappers::PreconditionBase::~PreconditionBase ( )
overridedefault

Destructor.

## ◆ clear() [1/4]

 void TrilinosWrappers::PreconditionBase::clear ( )

Destroys the preconditioner, leaving an object like just after having called the constructor.

Definition at line 50 of file trilinos_precondition.cc.

## ◆ get_mpi_communicator() [2/3]

 MPI_Comm TrilinosWrappers::PreconditionBase::get_mpi_communicator ( ) const

Return the MPI communicator object in use with this matrix.

Definition at line 59 of file trilinos_precondition.cc.

## ◆ transpose()

 void TrilinosWrappers::PreconditionBase::transpose ( )

Sets an internal flag so that all operations performed by the matrix, i.e., multiplications, are done in transposed order. However, this does not reshape the matrix to transposed form directly, so care should be taken when using this flag.

Note
Calling this function any even number of times in succession will return the object to its original state.

## ◆ vmult() [6/11]

 virtual void TrilinosWrappers::PreconditionBase::vmult ( MPI::Vector & dst, const MPI::Vector & src ) const
virtual

Apply the preconditioner.

Reimplemented in TrilinosWrappers::PreconditionIdentity.

## ◆ Tvmult() [2/7]

 virtual void TrilinosWrappers::PreconditionBase::Tvmult ( MPI::Vector & dst, const MPI::Vector & src ) const
virtual

Apply the transpose preconditioner.

Reimplemented in TrilinosWrappers::PreconditionIdentity.

## ◆ vmult() [7/11]

 virtual void TrilinosWrappers::PreconditionBase::vmult ( ::Vector< double > & dst, const ::Vector< double > & src ) const
virtual

Apply the preconditioner on deal.II data structures instead of the ones provided in the Trilinos wrapper class.

Reimplemented in TrilinosWrappers::PreconditionIdentity.

## ◆ Tvmult() [3/7]

 virtual void TrilinosWrappers::PreconditionBase::Tvmult ( ::Vector< double > & dst, const ::Vector< double > & src ) const
virtual

Apply the transpose preconditioner on deal.II data structures instead of the ones provided in the Trilinos wrapper class.

Reimplemented in TrilinosWrappers::PreconditionIdentity.

## ◆ vmult() [8/11]

 virtual void TrilinosWrappers::PreconditionBase::vmult ( ::LinearAlgebra::distributed::Vector< double > & dst, const ::LinearAlgebra::distributed::Vector< double > & src ) const
virtual

Apply the preconditioner on deal.II parallel data structures instead of the ones provided in the Trilinos wrapper class.

Reimplemented in TrilinosWrappers::PreconditionIdentity.

## ◆ Tvmult() [4/7]

 virtual void TrilinosWrappers::PreconditionBase::Tvmult ( ::LinearAlgebra::distributed::Vector< double > & dst, const ::LinearAlgebra::distributed::Vector< double > & src ) const
virtual

Apply the transpose preconditioner on deal.II parallel data structures instead of the ones provided in the Trilinos wrapper class.

Reimplemented in TrilinosWrappers::PreconditionIdentity.

## ◆ trilinos_operator()

 Epetra_Operator & TrilinosWrappers::PreconditionBase::trilinos_operator ( ) const

Calling this function from an uninitialized object will cause an exception.

Definition at line 66 of file trilinos_precondition.cc.

## ◆ locally_owned_domain_indices() [2/2]

 IndexSet TrilinosWrappers::PreconditionBase::locally_owned_domain_indices ( ) const

Return the partitioning of the domain space of this matrix, i.e., the partitioning of the vectors this matrix has to be multiplied with.

Definition at line 75 of file trilinos_precondition.cc.

## ◆ locally_owned_range_indices() [2/2]

 IndexSet TrilinosWrappers::PreconditionBase::locally_owned_range_indices ( ) const

Return the partitioning of the range space of this matrix, i.e., the partitioning of the vectors that are result from matrix-vector products.

Definition at line 82 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionJacobi::AdditionalData::AdditionalData ( const double omega = 1, const double min_diagonal = 0, const unsigned int n_sweeps = 1 )

Constructor. By default, set the damping parameter to one, and do not modify the diagonal.

Definition at line 89 of file trilinos_precondition.cc.

## ◆ initialize() [1/22]

Take the sparse matrix the preconditioner object should be built of, and additional flags (damping parameter, etc.) if there are any.

Definition at line 101 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionSSOR::AdditionalData::AdditionalData ( const double omega = 1, const double min_diagonal = 0, const unsigned int overlap = 0, const unsigned int n_sweeps = 1 )

Constructor. By default, set the damping parameter to one, we do not modify the diagonal, and there is no overlap (i.e. in parallel, we run a BlockJacobi preconditioner, where each block is inverted approximately by an SSOR).

Definition at line 141 of file trilinos_precondition.cc.

## ◆ initialize() [2/22]

Take the sparse matrix the preconditioner object should be built of, and additional flags (damping parameter, overlap in parallel computations, etc.) if there are any.

Definition at line 154 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionSOR::AdditionalData::AdditionalData ( const double omega = 1, const double min_diagonal = 0, const unsigned int overlap = 0, const unsigned int n_sweeps = 1 )

Constructor. By default, set the damping parameter to one, we do not modify the diagonal, and there is no overlap (i.e. in parallel, we run a BlockJacobi preconditioner, where each block is inverted approximately by an SOR.

Definition at line 194 of file trilinos_precondition.cc.

## ◆ initialize() [3/22]

Take the sparse matrix the preconditioner object should be built of, and additional flags (damping parameter, overlap in parallel computations etc.) if there are any.

Definition at line 207 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::AdditionalData ( const unsigned int block_size = 1, const std::string & block_creation_type = "linear", const double omega = 1, const double min_diagonal = 0, const unsigned int n_sweeps = 1 )

Constructor. By default, use a block size of 1, use linear subdivision of the rows, set the damping parameter to one, and do not modify the diagonal.

Definition at line 247 of file trilinos_precondition.cc.

## ◆ initialize() [4/22]

 void PreconditionBlockJacobi< MatrixType, inverse_type >::initialize ( const SparseMatrix & matrix, const AdditionalData & additional_data = AdditionalData() )

Take the sparse matrix the preconditioner object should be built of, and additional flags (damping parameter, etc.) if there are any.

Definition at line 263 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::AdditionalData ( const unsigned int block_size = 1, const std::string & block_creation_type = "linear", const double omega = 1, const double min_diagonal = 0, const unsigned int overlap = 0, const unsigned int n_sweeps = 1 )

Constructor. By default, use a block size of 1, use linear subdivision of the rows, set the damping parameter to one, we do not modify the diagonal, and there is no overlap (i.e. in parallel, we run a BlockJacobi preconditioner, where each block is inverted approximately by a block SOR).

Definition at line 314 of file trilinos_precondition.cc.

## ◆ initialize() [5/22]

 void PreconditionBlockSSOR< MatrixType, inverse_type >::initialize ( const SparseMatrix & matrix, const AdditionalData & additional_data = AdditionalData() )

Take the sparse matrix the preconditioner object should be built of, and additional flags (damping parameter, overlap in parallel computations, etc.) if there are any.

Definition at line 332 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionBlockSOR::AdditionalData::AdditionalData ( const unsigned int block_size = 1, const std::string & block_creation_type = "linear", const double omega = 1, const double min_diagonal = 0, const unsigned int overlap = 0, const unsigned int n_sweeps = 1 )

Constructor. By default, use a block size of 1, use linear subdivision of the rows, set the damping parameter to one, we do not modify the diagonal, and there is no overlap (i.e. in parallel, we run a BlockJacobi preconditioner, where each block is inverted approximately by a block SOR).

Definition at line 383 of file trilinos_precondition.cc.

## ◆ initialize() [6/22]

 void PreconditionBlockSOR< MatrixType, inverse_type >::initialize ( const SparseMatrix & matrix, const AdditionalData & additional_data = AdditionalData() )

Take the sparse matrix the preconditioner object should be built of, and additional flags (damping parameter, overlap in parallel computations etc.) if there are any.

Definition at line 401 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionIC::AdditionalData::AdditionalData ( const unsigned int ic_fill = 0, const double ic_atol = 0., const double ic_rtol = 1., const unsigned int overlap = 0 )

Constructor. By default, set the drop tolerance to 0, the level of extra fill-ins is set to be zero (just use the matrix structure, do not generate any additional fill-in), the tolerance level are 0 and 1, respectively, and the overlap in case of a parallel execution is zero. This overlap in a block-application of the IC in the parallel case makes the preconditioner a so-called additive Schwarz preconditioner.

Definition at line 452 of file trilinos_precondition.cc.

## ◆ initialize() [7/22]

Initialize function. Takes the matrix the preconditioner should be computed of, and additional flags if there are any.

Definition at line 465 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionILU::AdditionalData::AdditionalData ( const unsigned int ilu_fill = 0, const double ilu_atol = 0., const double ilu_rtol = 1., const unsigned int overlap = 0 )

Constructor with default values for all parameters.

Definition at line 502 of file trilinos_precondition.cc.

## ◆ initialize() [8/22]

Initialize function. Takes the matrix which is used to form the preconditioner, and additional flags if there are any.

Definition at line 515 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionILUT::AdditionalData::AdditionalData ( const double ilut_drop = 0., const unsigned int ilut_fill = 0, const double ilut_atol = 0., const double ilut_rtol = 1., const unsigned int overlap = 0 )

Constructor. By default, no element will be dropped, the level of extra fill-ins is set to be zero (just use the matrix structure, do not generate any additional fill-in except the one that results from non-dropping large elements), the tolerance level are 0 and 1, respectively, and the overlap in case of a parallel execution is zero. This overlap in a block-application of the ILU in the parallel case makes the preconditioner a so-called additive Schwarz preconditioner.

Definition at line 553 of file trilinos_precondition.cc.

## ◆ initialize() [9/22]

Initialize function. Takes the matrix which is used to form the preconditioner, and additional flags if there are any.

Definition at line 568 of file trilinos_precondition.cc.

Constructor.

Definition at line 607 of file trilinos_precondition.cc.

## ◆ initialize() [10/22]

Initialize function. Takes the matrix which is used to form the preconditioner, and additional flags if there are any.

Definition at line 615 of file trilinos_precondition.cc.

 PreconditionChebyshev< MatrixType, VectorType, PreconditionerType >::AdditionalData::AdditionalData ( const unsigned int degree = 1, const double max_eigenvalue = 10., const double eigenvalue_ratio = 30., const double min_eigenvalue = 1., const double min_diagonal = 1e-12, const bool nonzero_starting = false )

Constructor.

Definition at line 649 of file trilinos_precondition.cc.

## ◆ initialize() [11/22]

 void PreconditionChebyshev< MatrixType, VectorType, PreconditionerType >::initialize ( const SparseMatrix & matrix, const AdditionalData & additional_data = AdditionalData() )

Initialize function. Takes the matrix which is used to form the preconditioner, and additional flags if there are any.

Definition at line 667 of file trilinos_precondition.cc.

 TrilinosWrappers::PreconditionAMG::AdditionalData::AdditionalData ( const bool elliptic = true, const bool higher_order_elements = false, const unsigned int n_cycles = 1, const bool w_cycle = false, const double aggregation_threshold = 1e-4, const std::vector< std::vector< bool > > & constant_modes = std::vector>(0), const unsigned int smoother_sweeps = 2, const unsigned int smoother_overlap = 0, const bool output_details = false, const char * smoother_type = "Chebyshev", const char * coarse_type = "Amesos-KLU" )

Constructor. By default, we pretend to work on elliptic problems with linear finite elements on a scalar equation.

Making use of the DoFTools::extract_constant_modes() function, the constant_modes vector can be initialized for a given field in the following manner:

...
DoFHandler<...> dof_handler;
FEValuesExtractors::Type... field_extractor;
...
dof_handler,
data.constant_modes );
void extract_constant_modes(const DoFHandler< dim, spacedim > &dof_handler, const ComponentMask &component_mask, std::vector< std::vector< bool > > &constant_modes)
Definition: dof_tools.cc:1255

Definition at line 39 of file trilinos_precondition_ml.cc.

## ◆ set_parameters() [1/2]

 void TrilinosWrappers::PreconditionAMG::AdditionalData::set_parameters ( Teuchos::ParameterList & parameter_list, std::unique_ptr< Epetra_MultiVector > & distributed_constant_modes, const Epetra_RowMatrix & matrix ) const

Fill in a parameter_list that can be used to initialize the AMG preconditioner.

The matrix is used in conjunction with the constant_modes to configure the null space settings for the preconditioner. The distributed_constant_modes are initialized by this function, and must remain in scope until PreconditionAMG::initialize() has been called.

Note
The set parameters reflect the current settings in this object, with various options being set both directly though the state of the member variables (e.g. the "smoother: type") as well as indirectly (e.g. the "aggregation: type"). If you wish to have fine-grained control over the configuration of the AMG preconditioner, then you can create the parameter list using this function (which conveniently sets the null space of the operator), change the relevant settings, and use the amended parameters list as an argument to PreconditionAMG::initialize(), instead of the AdditionalData object itself.

See the documentation for the Trilinos ML package for details on what options are available for modification.

Note
Any user-defined parameters that are not in conflict with those set by this data structure will be retained.

Definition at line 67 of file trilinos_precondition_ml.cc.

## ◆ set_parameters() [2/2]

 void TrilinosWrappers::PreconditionAMG::AdditionalData::set_parameters ( Teuchos::ParameterList & parameter_list, std::unique_ptr< Epetra_MultiVector > & distributed_constant_modes, const SparseMatrix & matrix ) const

Fill in a parameter list that can be used to initialize the AMG preconditioner.

Note
Any user-defined parameters that are not in conflict with those set by this data structure will be retained.

Definition at line 188 of file trilinos_precondition_ml.cc.

## ◆ set_operator_null_space() [1/2]

 void TrilinosWrappers::PreconditionAMG::AdditionalData::set_operator_null_space ( Teuchos::ParameterList & parameter_list, std::unique_ptr< Epetra_MultiVector > & distributed_constant_modes, const Epetra_RowMatrix & matrix ) const

Configure the null space setting in the parameter_list for the input matrix based on the state of the constant_modes variable.

Definition at line 127 of file trilinos_precondition_ml.cc.

## ◆ set_operator_null_space() [2/2]

 void TrilinosWrappers::PreconditionAMG::AdditionalData::set_operator_null_space ( Teuchos::ParameterList & parameter_list, std::unique_ptr< Epetra_MultiVector > & distributed_constant_modes, const SparseMatrix & matrix ) const

Configure the null space setting in the parameter_list for the input matrix based on the state of the constant_modes variable.

Definition at line 201 of file trilinos_precondition_ml.cc.

## ◆ ~PreconditionAMG()

 TrilinosWrappers::PreconditionAMG::~PreconditionAMG ( )
override

Destructor.

Definition at line 213 of file trilinos_precondition_ml.cc.

## ◆ initialize() [12/22]

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. The function uses the matrix format specified in TrilinosWrappers::SparseMatrix.

Definition at line 222 of file trilinos_precondition_ml.cc.

## ◆ initialize() [13/22]

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. As opposed to the other initialize function above, this function uses an abstract interface to an object of type Epetra_RowMatrix which allows a user to pass quite general objects to the ML preconditioner.

This initialization routine is useful in cases where the operator to be preconditioned is not a TrilinosWrappers::SparseMatrix object but still allows getting a copy of the entries in each of the locally owned matrix rows (method ExtractMyRowCopy) and implements a matrix-vector product (methods Multiply or Apply). An example are operators which provide faster matrix-vector multiplications than possible with matrix entries (matrix-free methods). These implementations can be beneficially combined with Chebyshev smoothers that only perform matrix-vector products. The interface class Epetra_RowMatrix is very flexible to enable this kind of implementation.

Definition at line 231 of file trilinos_precondition_ml.cc.

## ◆ initialize() [14/22]

 void TrilinosWrappers::PreconditionAMG::initialize ( const SparseMatrix & matrix, const Teuchos::ParameterList & ml_parameters )

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. The function uses the matrix format specified in TrilinosWrappers::SparseMatrix.

This function is similar to the one above, but allows the user to set all the options of the Trilinos ML preconditioner. In order to find out about all the options for ML, we refer to the ML documentation page. In particular, users need to follow the ML instructions in case a vector-valued problem ought to be solved.

Definition at line 257 of file trilinos_precondition_ml.cc.

## ◆ initialize() [15/22]

 void TrilinosWrappers::PreconditionAMG::initialize ( const Epetra_RowMatrix & matrix, const Teuchos::ParameterList & ml_parameters )

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. As opposed to the other initialize function above, this function uses an abstract interface to an object of type Epetra_RowMatrix which allows a user to pass quite general objects to the ML preconditioner.

Definition at line 266 of file trilinos_precondition_ml.cc.

## ◆ initialize() [16/22]

template<typename number >
 void TrilinosWrappers::PreconditionAMG::initialize ( const ::SparseMatrix< number > & deal_ii_sparse_matrix, const AdditionalData & additional_data = AdditionalData(), const double drop_tolerance = 1e-13, const ::SparsityPattern * use_this_sparsity = nullptr )

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. This function takes a deal.II matrix and copies the content into a Trilinos matrix, so the function can be considered rather inefficient.

Definition at line 277 of file trilinos_precondition_ml.cc.

## ◆ reinit() [14/18]

 void TrilinosWrappers::PreconditionAMG::reinit ( )

This function can be used for a faster recalculation of the preconditioner construction when the matrix entries underlying the preconditioner have changed, but the matrix sparsity pattern has remained the same. What this function does is taking the already generated coarsening structure, computing the AMG prolongation and restriction according to a smoothed aggregation strategy and then building the whole multilevel hierarchy. This function can be considerably faster than the initialize function, since the coarsening pattern is usually the most difficult thing to do when setting up the AMG ML preconditioner.

Definition at line 311 of file trilinos_precondition_ml.cc.

## ◆ clear() [2/4]

 void TrilinosWrappers::PreconditionAMG::clear ( )

Destroys the preconditioner, leaving an object like just after having called the constructor.

Definition at line 321 of file trilinos_precondition_ml.cc.

## ◆ memory_consumption() [1/3]

 PreconditionAMG::size_type TrilinosWrappers::PreconditionAMG::memory_consumption ( ) const

Prints an estimate of the memory consumption of this class.

Definition at line 330 of file trilinos_precondition_ml.cc.

 TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::AdditionalData ( const bool elliptic = true, const unsigned int n_cycles = 1, const bool w_cycle = false, const double aggregation_threshold = 1e-4, const std::vector< std::vector< bool > > & constant_modes = std::vector>(0), const unsigned int smoother_sweeps = 2, const unsigned int smoother_overlap = 0, const bool output_details = false, const char * smoother_type = "Chebyshev", const char * coarse_type = "Amesos-KLU" )

Constructor. By default, we pretend to work on elliptic problems with linear finite elements on a scalar equation.

Definition at line 31 of file trilinos_precondition_muelu.cc.

## ◆ PreconditionAMGMueLu()

 TrilinosWrappers::PreconditionAMGMueLu::PreconditionAMGMueLu ( )

Constructor.

Definition at line 56 of file trilinos_precondition_muelu.cc.

## ◆ ~PreconditionAMGMueLu()

 virtual TrilinosWrappers::PreconditionAMGMueLu::~PreconditionAMGMueLu ( )
overridevirtualdefault

Destructor.

## ◆ initialize() [17/22]

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. The function uses the matrix format specified in TrilinosWrappers::SparseMatrix.

Definition at line 73 of file trilinos_precondition_muelu.cc.

## ◆ initialize() [18/22]

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. As opposed to the other initialize function above, this function uses an object of type Epetra_CrsMatrixCrs.

Definition at line 82 of file trilinos_precondition_muelu.cc.

## ◆ initialize() [19/22]

 void TrilinosWrappers::PreconditionAMGMueLu::initialize ( const SparseMatrix & matrix, Teuchos::ParameterList & muelu_parameters )

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. The function uses the matrix format specified in TrilinosWrappers::SparseMatrix.

This function is similar to the one above, but allows the user to set most of the options of the Trilinos ML preconditioner. In order to find out about all the options for ML, we refer to the ML documentation page. Not all ML options have a corresponding MueLu option.

Definition at line 186 of file trilinos_precondition_muelu.cc.

## ◆ initialize() [20/22]

 void TrilinosWrappers::PreconditionAMGMueLu::initialize ( const Epetra_CrsMatrix & matrix, Teuchos::ParameterList & muelu_parameters )

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. As opposed to the other initialize function above, this function uses an object of type Epetra_CrsMatrix.

Definition at line 195 of file trilinos_precondition_muelu.cc.

## ◆ initialize() [21/22]

template<typename number >
 void TrilinosWrappers::PreconditionAMGMueLu::initialize ( const ::SparseMatrix< number > & deal_ii_sparse_matrix, const AdditionalData & additional_data = AdditionalData(), const double drop_tolerance = 1e-13, const ::SparsityPattern * use_this_sparsity = nullptr )

Let Trilinos compute a multilevel hierarchy for the solution of a linear system with the given matrix. This function takes a deal.II matrix and copies the content into a Trilinos matrix, so the function can be considered rather inefficient.

Definition at line 208 of file trilinos_precondition_muelu.cc.

## ◆ clear() [3/4]

 void TrilinosWrappers::PreconditionAMGMueLu::clear ( )

Destroys the preconditioner, leaving an object like just after having called the constructor.

Definition at line 242 of file trilinos_precondition_muelu.cc.

## ◆ memory_consumption() [2/3]

 PreconditionAMGMueLu::size_type TrilinosWrappers::PreconditionAMGMueLu::memory_consumption ( ) const

Prints an estimate of the memory consumption of this class.

Definition at line 251 of file trilinos_precondition_muelu.cc.

## ◆ initialize() [22/22]

The matrix argument is ignored and here just for compatibility with more complex preconditioners.

Note
This function must be called when this preconditioner is to be wrapped in a LinearOperator without an exemplar materix.

Definition at line 710 of file trilinos_precondition.cc.

## ◆ vmult() [9/11]

 void PreconditionIdentity::vmult ( MPI::Vector & dst, const MPI::Vector & src ) const
overridevirtual

Apply the preconditioner, i.e., dst = src.

Reimplemented from TrilinosWrappers::PreconditionBase.

Definition at line 754 of file trilinos_precondition.cc.

## ◆ Tvmult() [5/7]

 void PreconditionIdentity::Tvmult ( MPI::Vector & dst, const MPI::Vector & src ) const
overridevirtual

Apply the transport conditioner, i.e., dst = src.

Reimplemented from TrilinosWrappers::PreconditionBase.

Definition at line 760 of file trilinos_precondition.cc.

## ◆ vmult() [10/11]

 void PreconditionIdentity::vmult ( ::Vector< double > & dst, const ::Vector< double > & src ) const
overridevirtual

Apply the preconditioner on deal.II data structures instead of the ones provided in the Trilinos wrapper class, i.e., dst = src.

Reimplemented from TrilinosWrappers::PreconditionBase.

Definition at line 766 of file trilinos_precondition.cc.

## ◆ Tvmult() [6/7]

 void PreconditionIdentity::Tvmult ( ::Vector< double > & dst, const ::Vector< double > & src ) const
overridevirtual

Apply the transpose preconditioner on deal.II data structures instead of the ones provided in the Trilinos wrapper class, i.e. dst = src.

Reimplemented from TrilinosWrappers::PreconditionBase.

Definition at line 773 of file trilinos_precondition.cc.

## ◆ vmult() [11/11]

 void TrilinosWrappers::PreconditionIdentity::vmult ( LinearAlgebra::distributed::Vector< double > & dst, const ::LinearAlgebra::distributed::Vector< double > & src ) const
override

Apply the preconditioner on deal.II parallel data structures instead of the ones provided in the Trilinos wrapper class, i.e., dst = src.

## ◆ Tvmult() [7/7]

 void TrilinosWrappers::PreconditionIdentity::Tvmult ( LinearAlgebra::distributed::Vector< double > & dst, const ::LinearAlgebra::distributed::Vector< double > & src ) const
override

Apply the transpose preconditioner on deal.II parallel data structures instead of the ones provided in the Trilinos wrapper class, i.e., dst = src.

## ◆ gid()

 int TrilinosWrappers::gid ( const Epetra_BlockMap & map, int i )
inline

Definition at line 200 of file trilinos_vector.h.

## ◆ Vector() [1/7]

 Vector< Number >::Vector ( )

Default constructor that generates an empty (zero size) vector. The function reinit() will have to give the vector the correct size and distribution among processes in case of an MPI run.

Definition at line 70 of file trilinos_vector.cc.

## ◆ Vector() [2/7]

 Vector< Number >::Vector ( const Vector & v )

Copy constructor using the given vector.

Definition at line 90 of file trilinos_vector.cc.

## ◆ Vector() [3/7]

 Vector< Number >::Vector ( const IndexSet & parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD )
explicit

This constructor takes an IndexSet that defines how to distribute the individual components among the MPI processors. Since it also includes information about the size of the vector, this is all we need to generate a parallel vector.

Depending on whether the parallel_partitioning argument uniquely subdivides elements among processors or not, the resulting vector may or may not have ghost elements. See the general documentation of this class for more information.

In case the provided IndexSet forms an overlapping partitioning, it is not clear which elements are owned by which process and locally_owned_elements() will return an IndexSet of size zero.

vectors with ghost elements

Definition at line 81 of file trilinos_vector.cc.

## ◆ Vector() [4/7]

 Vector< Number >::Vector ( const IndexSet & local, const IndexSet & ghost, const MPI_Comm & communicator = MPI_COMM_WORLD )

Creates a ghosted parallel vector.

Depending on whether the ghost argument uniquely subdivides elements among processors or not, the resulting vector may or may not have ghost elements. See the general documentation of this class for more information.

vectors with ghost elements

Definition at line 128 of file trilinos_vector.cc.

## ◆ Vector() [5/7]

 Vector< Number >::Vector ( const IndexSet & parallel_partitioning, const Vector & v, const MPI_Comm & communicator = MPI_COMM_WORLD )

Copy constructor from the TrilinosWrappers vector class. Since a vector of this class does not necessarily need to be distributed among processes, the user needs to supply us with an IndexSet and an MPI communicator that set the partitioning details.

Depending on whether the parallel_partitioning argument uniquely subdivides elements among processors or not, the resulting vector may or may not have ghost elements. See the general documentation of this class for more information.

vectors with ghost elements

Definition at line 109 of file trilinos_vector.cc.

## ◆ Vector() [6/7]

template<typename Number >
 TrilinosWrappers::MPI::Vector::Vector ( const IndexSet & parallel_partitioning, const ::Vector< Number > & v, const MPI_Comm & communicator = MPI_COMM_WORLD )

Copy-constructor from deal.II vectors. Sets the dimension to that of the given vector, and copies all the elements.

Depending on whether the parallel_partitioning argument uniquely subdivides elements among processors or not, the resulting vector may or may not have ghost elements. See the general documentation of this class for more information.

vectors with ghost elements

## ◆ Vector() [7/7]

 Vector< Number >::Vector ( Vector && v )
noexcept

Move constructor. Creates a new vector by stealing the internal data of the vector v.

Definition at line 100 of file trilinos_vector.cc.

## ◆ ~Vector()

 TrilinosWrappers::MPI::Vector::~Vector ( )
overridedefault

Destructor.

## ◆ clear() [4/4]

 void Vector< Number >::clear ( )

Release all memory and return to a state just like after having called the default constructor.

Definition at line 139 of file trilinos_vector.cc.

## ◆ reinit() [15/18]

 void Vector< Number >::reinit ( const Vector & v, const bool omit_zeroing_entries = false, const bool allow_different_maps = false )

Reinit functionality. This function sets the calling vector to the dimension and the parallel distribution of the input vector, but does not copy the elements in v. If omit_zeroing_entries is not true, the elements in the vector are initialized with zero. If it is set to true, the vector entries are in an unspecified state and the user has to set all elements. In the current implementation, this method does not touch the vector entries in case the vector layout is unchanged from before, otherwise entries are set to zero. Note that this behavior might change between releases without notification.

This function has a third argument, allow_different_maps, that allows for an exchange of data between two equal-sized vectors (but being distributed differently among the processors). A trivial application of this function is to generate a replication of a whole vector on each machine, when the calling vector is built with a map consisting of all indices on each process, and v is a distributed vector. In this case, the variable omit_zeroing_entries needs to be set to false, since it does not make sense to exchange data between differently parallelized vectors without touching the elements.

Definition at line 194 of file trilinos_vector.cc.

## ◆ reinit() [16/18]

 void Vector< Number >::reinit ( const IndexSet & parallel_partitioning, const MPI_Comm & communicator = MPI_COMM_WORLD, const bool omit_zeroing_entries = false )

Reinit functionality. This function destroys the old vector content and generates a new one based on the input partitioning. The flag omit_zeroing_entries determines whether the vector should be filled with zero (false). If the flag is set to true, the vector entries are in an unspecified state and the user has to set all elements. In the current implementation, this method still sets the entries to zero, but this might change between releases without notification.

Depending on whether the parallel_partitioning argument uniquely subdivides elements among processors or not, the resulting vector may or may not have ghost elements. See the general documentation of this class for more information.

In case parallel_partitioning is overlapping, it is not clear which process should own which elements. Hence, locally_owned_elements() returns an empty IndexSet in this case.

vectors with ghost elements

Definition at line 153 of file trilinos_vector.cc.

## ◆ reinit() [17/18]

 void Vector< Number >::reinit ( const IndexSet & locally_owned_entries, const IndexSet & ghost_entries, const MPI_Comm & communicator = MPI_COMM_WORLD, const bool vector_writable = false )

Reinit functionality. This function destroys the old vector content and generates a new one based on the input partitioning. In addition to just specifying one index set as in all the other methods above, this method allows to supply an additional set of ghost entries. There are two different versions of a vector that can be created. If the flag vector_writable is set to false, the vector only allows read access to the joint set of parallel_partitioning and ghost_entries. The effect of the reinit method is then equivalent to calling the other reinit method with an index set containing both the locally owned entries and the ghost entries.

If the flag vector_writable is set to true, this creates an alternative storage scheme for ghost elements that allows multiple threads to write into the vector (for the other reinit methods, only one thread is allowed to write into the ghost entries at a time).

Depending on whether the ghost_entries argument uniquely subdivides elements among processors or not, the resulting vector may or may not have ghost elements. See the general documentation of this class for more information.

vectors with ghost elements

Definition at line 352 of file trilinos_vector.cc.

## ◆ reinit() [18/18]

 void Vector< Number >::reinit ( const BlockVector & v, const bool import_data = false )

Create vector by merging components from a block vector.

Definition at line 275 of file trilinos_vector.cc.

## ◆ compress()

 void Vector< Number >::compress ( ::VectorOperation::values operation )

Compress the underlying representation of the Trilinos object, i.e. flush the buffers of the vector object if it has any. This function is necessary after writing into a vector element-by-element and before anything else can be done on it.

The (defaulted) argument can be used to specify the compress mode (Add or Insert) in case the vector has not been written to since the last time this function was called. The argument is ignored if the vector has been added or written to since the last time compress() was called.

Definition at line 570 of file trilinos_vector.cc.

## ◆ operator=() [7/10]

 Vector & TrilinosWrappers::MPI::Vector::operator= ( const TrilinosScalar s )

Set all components of the vector to the given number s. Simply pass this down to the base class, but we still need to declare this function to make the example given in the discussion about making the constructor explicit work. the constructor explicit work.

Since the semantics of assigning a scalar to a vector are not immediately clear, this operator can only be used if you want to set the entire vector to zero. This allows the intuitive notation v=0.

## ◆ operator=() [8/10]

 Vector & Vector< Number >::operator= ( const Vector & v )

Copy the given vector. Resize the present vector if necessary. In this case, also the Epetra_Map that designs the parallel partitioning is taken from the input vector.

Definition at line 410 of file trilinos_vector.cc.

## ◆ operator=() [9/10]

 Vector & Vector< Number >::operator= ( Vector && v )
noexcept

Move the given vector. This operator replaces the present vector with v by efficiently swapping the internal data structures.

Definition at line 486 of file trilinos_vector.cc.

## ◆ operator=() [10/10]

template<typename Number >
 Vector & TrilinosWrappers::MPI::Vector::operator= ( const ::Vector< Number > & v )

Another copy function. This one takes a deal.II vector and copies it into a TrilinosWrapper vector. Note that since we do not provide any Epetra_map that tells about the partitioning of the vector among the MPI processes, the size of the TrilinosWrapper vector has to be the same as the size of the input vector.

## ◆ import_nonlocal_data_for_fe() [2/2]

 void Vector< Number >::import_nonlocal_data_for_fe ( const ::TrilinosWrappers::SparseMatrix & matrix, const Vector & vector )

This reinit function is meant to be used for parallel calculations where some non-local data has to be used. The typical situation where one needs this function is the call of the FEValues<dim>::get_function_values function (or of some derivatives) in parallel. Since it is usually faster to retrieve the data in advance, this function can be called before the assembly forks out to the different processors. What this function does is the following: It takes the information in the columns of the given matrix and looks which data couples between the different processors. That data is then queried from the input vector. Note that you should not write to the resulting vector any more, since the some data can be stored several times on different processors, leading to unpredictable results. In particular, such a vector cannot be used for matrix- vector products as for example done during the solution of linear systems.

Definition at line 515 of file trilinos_vector.cc.

## ◆ import()

 void Vector< Number >::import ( const LinearAlgebra::ReadWriteVector< double > & rwv, const VectorOperation::values operation )

Imports all the elements present in the vector's IndexSet from the input vector rwv. VectorOperation::values operation is used to decide if the elements in rwv should be added to the current vector or replace the current elements.

Definition at line 539 of file trilinos_vector.cc.

## ◆ operator==()

 bool Vector< Number >::operator== ( const Vector & v ) const

Test for equality. This function assumes that the present vector and the one to compare with have the same size already, since comparing vectors of different sizes makes not much sense anyway.

Definition at line 702 of file trilinos_vector.cc.

## ◆ operator!=()

 bool Vector< Number >::operator!= ( const Vector & v ) const

Test for inequality. This function assumes that the present vector and the one to compare with have the same size already, since comparing vectors of different sizes makes not much sense anyway.

Definition at line 719 of file trilinos_vector.cc.

## ◆ size()

 size_type TrilinosWrappers::MPI::Vector::size ( ) const

Return the global dimension of the vector.

## ◆ local_size()

 size_type TrilinosWrappers::MPI::Vector::local_size ( ) const

Return the local dimension of the vector, i.e. the number of elements stored on the present MPI process. For sequential vectors, this number is the same as size(), but for parallel vectors it may be smaller.

To figure out which elements exactly are stored locally, use local_range().

If the vector contains ghost elements, they are included in this number.

Deprecated:
This function is deprecated.

## ◆ locally_owned_size()

 size_type TrilinosWrappers::MPI::Vector::locally_owned_size ( ) const

Return the local size of the vector, i.e., the number of indices owned locally.

## ◆ local_range()

 std::pair< size_type, size_type > TrilinosWrappers::MPI::Vector::local_range ( ) const

Return a pair of indices indicating which elements of this vector are stored locally. The first number is the index of the first element stored, the second the index of the one past the last one that is stored locally. If this is a sequential vector, then the result will be the pair (0,N), otherwise it will be a pair (i,i+n), where n=local_size() and i is the first element of the vector stored on this processor, corresponding to the half open interval $$[i,i+n)$$

Note
The description above is true most of the time, but not always. In particular, Trilinos vectors need not store contiguous ranges of elements such as $$[i,i+n)$$. Rather, it can store vectors where the elements are distributed in an arbitrary way across all processors and each processor simply stores a particular subset, not necessarily contiguous. In this case, this function clearly makes no sense since it could, at best, return a range that includes all elements that are stored locally. Thus, the function only succeeds if the locally stored range is indeed contiguous. It will trigger an assertion if the local portion of the vector is not contiguous.

## ◆ in_local_range()

 bool TrilinosWrappers::MPI::Vector::in_local_range ( const size_type index ) const

Return whether index is in the local range or not, see also local_range().

Note
The same limitation for the applicability of this function applies as listed in the documentation of local_range().

## ◆ locally_owned_elements()

 IndexSet TrilinosWrappers::MPI::Vector::locally_owned_elements ( ) const

Return an index set that describes which elements of this vector are owned by the current processor. Note that this index set does not include elements this vector may store locally as ghost elements but that are in fact owned by another processor. As a consequence, the index sets returned on different processors if this is a distributed vector will form disjoint sets that add up to the complete index set. Obviously, if a vector is created on only one processor, then the result would satisfy

vec.locally_owned_elements() == complete_index_set (vec.size())
IndexSet complete_index_set(const IndexSet::size_type N)
Definition: index_set.h:1014

## ◆ has_ghost_elements() [2/2]

 bool TrilinosWrappers::MPI::Vector::has_ghost_elements ( ) const

Return if the vector contains ghost elements. This answer is true if there are ghost elements on at least one process.

vectors with ghost elements

## ◆ update_ghost_values()

 void TrilinosWrappers::MPI::Vector::update_ghost_values ( ) const

This function only exists for compatibility with the LinearAlgebra::distributed::Vector class and does nothing: this class implements ghost value updates in a different way that is a better fit with the underlying Trilinos vector object.

## ◆ operator*()

 TrilinosScalar TrilinosWrappers::MPI::Vector::operator* ( const Vector & vec ) const

Return the scalar (inner) product of two vectors. The vectors must have the same size.

## ◆ norm_sqr()

 real_type TrilinosWrappers::MPI::Vector::norm_sqr ( ) const

Return the square of the $$l_2$$-norm.

## ◆ mean_value()

 TrilinosScalar TrilinosWrappers::MPI::Vector::mean_value ( ) const

Mean value of the elements of this vector.

## ◆ min()

 TrilinosScalar TrilinosWrappers::MPI::Vector::min ( ) const

Compute the minimal value of the elements of this vector.

## ◆ max()

 TrilinosScalar TrilinosWrappers::MPI::Vector::max ( ) const

Compute the maximal value of the elements of this vector.

## ◆ l1_norm()

 real_type TrilinosWrappers::MPI::Vector::l1_norm ( ) const

$$l_1$$-norm of the vector. The sum of the absolute values.

## ◆ l2_norm()

 real_type TrilinosWrappers::MPI::Vector::l2_norm ( ) const

$$l_2$$-norm of the vector. The square root of the sum of the squares of the elements.

## ◆ lp_norm()

 real_type TrilinosWrappers::MPI::Vector::lp_norm ( const TrilinosScalar p ) const

$$l_p$$-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.

## ◆ linfty_norm()

 real_type TrilinosWrappers::MPI::Vector::linfty_norm ( ) const

Maximum absolute value of the elements.

 TrilinosScalar TrilinosWrappers::MPI::Vector::add_and_dot ( const TrilinosScalar a, const Vector & V, const Vector & W )

Performs a combined operation of a vector addition and a subsequent inner product, returning the value of the inner product. In other words, the result of this function is the same as if the user called

return_value = *this * W;
void add(const std::vector< size_type > &indices, const std::vector< TrilinosScalar > &values)
static const char V

The reason this function exists is for compatibility with deal.II's own vector classes which can implement this functionality with less memory transfer. However, for Trilinos vectors such a combined operation is not natively supported and thus the cost is completely equivalent as calling the two methods separately.

For complex-valued vectors, the scalar product in the second step is implemented as $$\left<v,w\right>=\sum_i v_i \bar{w_i}$$.

## ◆ all_zero()

 bool Vector< Number >::all_zero ( ) const

Return whether the vector contains only elements with value zero. This is a collective operation. This function is expensive, because potentially all elements have to be checked.

Definition at line 729 of file trilinos_vector.cc.

## ◆ is_non_negative()

 bool Vector< Number >::is_non_negative ( ) const

Return true if the vector has no negative entries, i.e. all entries are zero or positive. This function is used, for example, to check whether refinement indicators are really all positive (or zero).

Definition at line 758 of file trilinos_vector.cc.

## ◆ operator()() [1/2]

 reference TrilinosWrappers::MPI::Vector::operator() ( const size_type index )

When using a vector distributed with MPI, this operation only makes sense for elements that are actually present on the calling processor. Otherwise, an exception is thrown.

## ◆ operator()() [2/2]

 TrilinosScalar Vector< Number >::operator() ( const size_type index ) const

When using a vector distributed with MPI, this operation only makes sense for elements that are actually present on the calling processor. Otherwise, an exception is thrown.

Definition at line 641 of file trilinos_vector.cc.

## ◆ operator[]() [1/2]

 reference TrilinosWrappers::MPI::Vector::operator[] ( const size_type index )

Exactly the same as operator().

## ◆ operator[]() [2/2]

 TrilinosScalar TrilinosWrappers::MPI::Vector::operator[] ( const size_type index ) const

Exactly the same as operator().

## ◆ extract_subvector_to() [1/2]

 void TrilinosWrappers::MPI::Vector::extract_subvector_to ( const std::vector< size_type > & indices, std::vector< TrilinosScalar > & values ) const

Instead of getting individual elements of a vector via operator(), this function allows getting a whole set of elements at once. The indices of the elements to be read are stated in the first argument, the corresponding values are returned in the second.

If the current vector is called v, then this function is the equivalent to the code

for (unsigned int i=0; i<indices.size(); ++i)
values[i] = v[indices[i]];
Precondition
The sizes of the indices and values arrays must be identical.

## ◆ extract_subvector_to() [2/2]

template<typename ForwardIterator , typename OutputIterator >
 void TrilinosWrappers::MPI::Vector::extract_subvector_to ( ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin ) const

Instead of getting individual elements of a vector via operator(), this function allows getting a whole set of elements at once. In contrast to the previous function, this function obtains the indices of the elements by dereferencing all elements of the iterator range provided by the first two arguments, and puts the vector values into memory locations obtained by dereferencing a range of iterators starting at the location pointed to by the third argument.

If the current vector is called v, then this function is the equivalent to the code

ForwardIterator indices_p = indices_begin;
OutputIterator values_p = values_begin;
while (indices_p != indices_end)
{
*values_p = v[*indices_p];
++indices_p;
++values_p;
}
Precondition
It must be possible to write into as many memory locations starting at values_begin as there are iterators between indices_begin and indices_end.

## ◆ begin() [1/2]

 iterator TrilinosWrappers::MPI::Vector::begin ( )

Make the Vector class a bit like the vector<> class of the C++ standard library by returning iterators to the start and end of the locally owned elements of this vector. The ordering of local elements corresponds to the one given by the global indices in case the vector is constructed from an IndexSet or other methods in deal.II (note that an Epetra_Map can contain elements in arbitrary orders, though).

It holds that end() - begin() == local_size().

## ◆ begin() [2/2]

 const_iterator TrilinosWrappers::MPI::Vector::begin ( ) const

Return constant iterator to the start of the locally owned elements of the vector.

## ◆ end() [1/2]

 iterator TrilinosWrappers::MPI::Vector::end ( )

Return an iterator pointing to the element past the end of the array of locally owned entries.

## ◆ end() [2/2]

 const_iterator TrilinosWrappers::MPI::Vector::end ( ) const

Return a constant iterator pointing to the element past the end of the array of the locally owned entries.

## ◆ set() [1/3]

 void TrilinosWrappers::MPI::Vector::set ( const std::vector< size_type > & indices, const std::vector< TrilinosScalar > & values )

A collective set operation: instead of setting individual elements of a vector, this function allows to set a whole set of elements at once. The indices of the elements to be set are stated in the first argument, the corresponding values in the second.

## ◆ set() [2/3]

 void TrilinosWrappers::MPI::Vector::set ( const std::vector< size_type > & indices, const ::Vector< TrilinosScalar > & values )

This is a second collective set operation. As a difference, this function takes a deal.II vector of values.

## ◆ set() [3/3]

 void TrilinosWrappers::MPI::Vector::set ( const size_type n_elements, const size_type * indices, const TrilinosScalar * values )

This collective set operation is of lower level and can handle anything else — the only thing you have to provide is an address where all the indices are stored and the number of elements to be set.

 void TrilinosWrappers::MPI::Vector::add ( const std::vector< size_type > & indices, const std::vector< TrilinosScalar > & values )

A collective add operation: This function adds a whole set of values stored in values to the vector components specified by indices.

 void TrilinosWrappers::MPI::Vector::add ( const std::vector< size_type > & indices, const ::Vector< TrilinosScalar > & values )

This is a second collective add operation. As a difference, this function takes a deal.II vector of values.

 void TrilinosWrappers::MPI::Vector::add ( const size_type n_elements, const size_type * indices, const TrilinosScalar * values )

Take an address where n_elements are stored contiguously and add them into the vector. Handles all cases which are not covered by the other two add() functions above.

## ◆ operator*=()

 Vector & TrilinosWrappers::MPI::Vector::operator*= ( const TrilinosScalar factor )

Multiply the entire vector by a fixed factor.

## ◆ operator/=()

 Vector & TrilinosWrappers::MPI::Vector::operator/= ( const TrilinosScalar factor )

Divide the entire vector by a fixed factor.

## ◆ operator+=()

 Vector & TrilinosWrappers::MPI::Vector::operator+= ( const Vector & V )

Add the given vector to the present one.

## ◆ operator-=()

 Vector & TrilinosWrappers::MPI::Vector::operator-= ( const Vector & V )

Subtract the given vector from the present one.

 void TrilinosWrappers::MPI::Vector::add ( const TrilinosScalar s )

Addition of s to all components. Note that s is a scalar and not a vector.

 void Vector< Number >::add ( const Vector & V, const bool allow_different_maps = false )

Simple vector addition, equal to the operator+=.

Though, if the second argument allow_different_maps is set, then it is possible to add data from a vector that uses a different map, i.e., a vector whose elements are split across processors differently. This may include vectors with ghost elements, for example. In general, however, adding vectors with a different element-to- processor map requires communicating data among processors and, consequently, is a slower operation than when using vectors using the same map.

Definition at line 667 of file trilinos_vector.cc.

 void TrilinosWrappers::MPI::Vector::add ( const TrilinosScalar a, const Vector & V )

Simple addition of a multiple of a vector, i.e. *this += a*V.

 void TrilinosWrappers::MPI::Vector::add ( const TrilinosScalar a, const Vector & V, const TrilinosScalar b, const Vector & W )

Multiple addition of scaled vectors, i.e. *this += a*V + b*W.

 void TrilinosWrappers::MPI::Vector::sadd ( const TrilinosScalar s, const Vector & V )

Scaling and simple vector addition, i.e. this = s(*this) + V.

 void TrilinosWrappers::MPI::Vector::sadd ( const TrilinosScalar s, const TrilinosScalar a, const Vector & V )

Scaling and simple addition, i.e. this = s(*this) + a*V.

## ◆ scale()

 void TrilinosWrappers::MPI::Vector::scale ( const Vector & scaling_factors )

Scale each element of this vector by the corresponding element in the argument. This function is mostly meant to simulate multiplication (and immediate re-assignment) by a diagonal scaling matrix.

## ◆ equ()

 void TrilinosWrappers::MPI::Vector::equ ( const TrilinosScalar a, const Vector & V )

Assignment *this = a*V.

## ◆ trilinos_vector() [1/2]

 const Epetra_MultiVector & TrilinosWrappers::MPI::Vector::trilinos_vector ( ) const

Return a const reference to the underlying Trilinos Epetra_MultiVector class.

## ◆ trilinos_vector() [2/2]

 Epetra_FEVector & TrilinosWrappers::MPI::Vector::trilinos_vector ( )

Return a (modifiable) reference to the underlying Trilinos Epetra_FEVector class.

## ◆ trilinos_partitioner()

 const Epetra_BlockMap & TrilinosWrappers::MPI::Vector::trilinos_partitioner ( ) const

Return a const reference to the underlying Trilinos Epetra_BlockMap that sets the parallel partitioning of the vector.

## ◆ print() [2/2]

 void Vector< Number >::print ( std::ostream & out, const unsigned int precision = 3, const bool scientific = true, const bool across = true ) const

Print to a stream. precision denotes the desired precision with which values shall be printed, scientific whether scientific notation shall be used. If across is true then the vector is printed in a line, while if false then the elements are printed on a separate line each.

Definition at line 785 of file trilinos_vector.cc.

## ◆ swap() [3/6]

 void Vector< Number >::swap ( Vector & v )

Swap the contents of this vector and the other vector v. One could do this operation with a temporary variable and copying over the data elements, but this function is significantly more efficient since it only swaps the pointers to the data of the two vectors and therefore does not need to allocate temporary storage and move data around. Note that the vectors need to be of the same size and base on the same map.

This function is analogous to the swap function of all C++ standard containers. Also, there is a global function swap(u,v) that simply calls u.swap(v), again in analogy to standard functions.

Definition at line 833 of file trilinos_vector.cc.

## ◆ memory_consumption() [3/3]

 std::size_t Vector< Number >::memory_consumption ( ) const

Estimate for the memory consumption in bytes.

Definition at line 846 of file trilinos_vector.cc.

## ◆ get_mpi_communicator() [3/3]

 const MPI_Comm & TrilinosWrappers::MPI::Vector::get_mpi_communicator ( ) const

Return a reference to the MPI communicator object in use with this object.

## ◆ swap() [4/6]

 void swap ( Vector & u, Vector & v )
inline

Global function swap which overloads the default implementation of the C++ standard library which uses a temporary object. The function simply exchanges the data of the two vectors.

Definition at line 1364 of file trilinos_vector.h.

## ◆ reinit_range_vector() [2/2]

template<typename Matrix >
 static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::Vector >::reinit_range_vector ( const Matrix & matrix, TrilinosWrappers::MPI::Vector & v, bool omit_zeroing_entries )
inlinestatic

Definition at line 2232 of file trilinos_vector.h.

## ◆ reinit_domain_vector() [2/2]

template<typename Matrix >
 static void internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::Vector >::reinit_domain_vector ( const Matrix & matrix, TrilinosWrappers::MPI::Vector & v, bool omit_zeroing_entries )
inlinestatic

Definition at line 2243 of file trilinos_vector.h.

## ◆ linear_operator() [4/6]

template<typename Range , typename Domain = Range, typename Matrix >
 LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > linear_operator ( const TrilinosWrappers::SparseMatrix & operator_exemplar, const Matrix & matrix )
related

A function that encapsulates generic matrix objects, based on an operator_exemplar, that act on a compatible Vector type into a LinearOperator.

This function is the equivalent of the linear_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 76 of file trilinos_linear_operator.h.

## ◆ linear_operator() [5/6]

template<typename Range , typename Domain = Range>
 LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > linear_operator ( const TrilinosWrappers::SparseMatrix & matrix )
related

A function that encapsulates generic matrix objects that act on a compatible Vector type into a LinearOperator.

This function is the equivalent of the linear_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 106 of file trilinos_linear_operator.h.

## ◆ linear_operator() [6/6]

template<typename Range , typename Domain , typename Matrix >
 LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > linear_operator ( const LinearOperator< Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > & operator_exemplar, const Matrix & matrix )
related

A function that encapsulates generic matrix objects, based on an operator_exemplar, that act on a compatible Vector type into a LinearOperator.

This function is the equivalent of the linear_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 135 of file trilinos_linear_operator.h.

## ◆ block_operator() [3/4]

template<typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_operator ( const TrilinosWrappers::BlockSparseMatrix & block_matrix )
related

A function that encapsulates a block_matrix into a BlockLinearOperator.

This function is the equivalent of the block_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 178 of file trilinos_linear_operator.h.

## ◆ block_operator() [4/4]

template<std::size_t m, std::size_t n, typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_operator ( const std::array< std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, n >, m > & ops )
related

A variant of above function that builds up a block diagonal linear operator from an array ops of diagonal elements (off-diagonal blocks are assumed to be 0).

This function is the equivalent of the block_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 214 of file trilinos_linear_operator.h.

## ◆ block_diagonal_operator() [3/4]

template<typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_diagonal_operator ( const TrilinosWrappers::BlockSparseMatrix & block_matrix )
related

This function extracts the diagonal blocks of block_matrix (either a block matrix type or a BlockLinearOperator) and creates a BlockLinearOperator with the diagonal. Off-diagonal elements are initialized as null_operator (with correct reinit_range_vector and reinit_domain_vector methods).

This function is the equivalent of the block_diagonal_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 255 of file trilinos_linear_operator.h.

## ◆ block_diagonal_operator() [4/4]

template<std::size_t m, typename Range , typename Domain = Range>
 BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_diagonal_operator ( const std::array< LinearOperator< typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload >, m > & ops )
related

A variant of above function that builds up a block diagonal linear operator from an array ops of diagonal elements (off-diagonal blocks are assumed to be 0).

This function is the equivalent of the block_diagonal_operator, but ensures full compatibility with Trilinos operations by preselecting the appropriate template parameters.

Definition at line 290 of file trilinos_linear_operator.h.

## ◆ swap() [5/6]

 void swap ( BlockVector & u, BlockVector & v )
related

Global function which overloads the default implementation of the C++ standard library which uses a temporary object. The function simply exchanges the data of the two vectors.

Definition at line 421 of file trilinos_parallel_block_vector.h.

## ◆ swap() [6/6]

 void swap ( Vector & u, Vector & v )
related

Global function swap which overloads the default implementation of the C++ standard library which uses a temporary object. The function simply exchanges the data of the two vectors.

Definition at line 1364 of file trilinos_vector.h.

## ◆ ExcNonMatchingMaps()

 static ::ExceptionBase & TrilinosWrappers::PreconditionBase::ExcNonMatchingMaps ( std::string arg1 )
static

Exception.

Note
The message that will be printed by this exception reads:
<< "The sparse matrix the preconditioner is based on " << "uses a map that is not compatible to the one in vector " << arg1 << ". Check preconditioner and matrix setup."

## ◆ ExcDifferentParallelPartitioning()

 static ::ExceptionBase & TrilinosWrappers::MPI::Vector::ExcDifferentParallelPartitioning ( )
static

Exception

## ◆ ExcTrilinosError()

 static ::ExceptionBase & TrilinosWrappers::MPI::Vector::ExcTrilinosError ( int arg1 )
static

Exception

Note
The message that will be printed by this exception reads:
<< "An error with error number " << arg1 << " occurred while calling a Trilinos function"

## ◆ ExcAccessToNonLocalElement()

 static ::ExceptionBase & TrilinosWrappers::MPI::Vector::ExcAccessToNonLocalElement ( size_type arg1, size_type arg2, size_type arg3, size_type arg4 )
static

Exception

Note
The message that will be printed by this exception reads:
<< "You are trying to access element " << arg1 << " of a distributed vector, but this element is not stored " << "on the current processor. Note: There are " << arg2 << " elements stored " << "on the current processor from within the range [" << arg3 << ',' << arg4 << "] but Trilinos vectors need not store contiguous " << "ranges on each processor, and not every element in " << "this range may in fact be stored locally." << "\n\n" << "A common source for this kind of problem is that you " << "are passing a 'fully distributed' vector into a function " << "that needs read access to vector elements that correspond " << "to degrees of freedom on ghost cells (or at least to " << "'locally active' degrees of freedom that are not also " << "'locally owned'). You need to pass a vector that has these " << "elements as ghost entries."

## ◆ preconditioner

 Teuchos::RCP TrilinosWrappers::PreconditionBase::preconditioner
protected

This is a pointer to the preconditioner object that is used when applying the preconditioner.

Definition at line 232 of file trilinos_precondition.h.

## ◆ communicator

 Epetra_MpiComm TrilinosWrappers::PreconditionBase::communicator
protected

Internal communication pattern in case the matrix needs to be copied from deal.II format.

Definition at line 238 of file trilinos_precondition.h.

## ◆ vector_distributor

 std::shared_ptr TrilinosWrappers::PreconditionBase::vector_distributor
protected

Internal Trilinos map in case the matrix needs to be copied from deal.II format.

Definition at line 244 of file trilinos_precondition.h.

## ◆ omega [1/6]

This specifies the relaxation parameter in the Jacobi preconditioner.

Definition at line 290 of file trilinos_precondition.h.

## ◆ min_diagonal [1/7]

This specifies the minimum value the diagonal elements should have. This might be necessary when the Jacobi preconditioner is used on matrices with zero diagonal elements. In that case, a straight- forward application would not be possible since we would divide by zero.

Definition at line 299 of file trilinos_precondition.h.

## ◆ n_sweeps [1/6]

Sets how many times the given operation should be applied during the vmult() operation.

Definition at line 305 of file trilinos_precondition.h.

## ◆ omega [2/6]

This specifies the (over-) relaxation parameter in the SSOR preconditioner.

Definition at line 377 of file trilinos_precondition.h.

## ◆ min_diagonal [2/7]

This specifies the minimum value the diagonal elements should have. This might be necessary when the SSOR preconditioner is used on matrices with zero diagonal elements. In that case, a straight- forward application would not be possible since we divide by the diagonal element.

Definition at line 386 of file trilinos_precondition.h.

## ◆ overlap [1/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 392 of file trilinos_precondition.h.

## ◆ n_sweeps [2/6]

Sets how many times the given operation should be applied during the vmult() operation.

Definition at line 398 of file trilinos_precondition.h.

## ◆ omega [3/6]

This specifies the (over-) relaxation parameter in the SOR preconditioner.

Definition at line 471 of file trilinos_precondition.h.

## ◆ min_diagonal [3/7]

This specifies the minimum value the diagonal elements should have. This might be necessary when the SOR preconditioner is used on matrices with zero diagonal elements. In that case, a straight- forward application would not be possible since we divide by the diagonal element.

Definition at line 480 of file trilinos_precondition.h.

## ◆ overlap [2/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 486 of file trilinos_precondition.h.

## ◆ n_sweeps [3/6]

Sets how many times the given operation should be applied during the vmult() operation.

Definition at line 492 of file trilinos_precondition.h.

## ◆ block_size [1/3]

This specifies the size of blocks.

Definition at line 557 of file trilinos_precondition.h.

## ◆ block_creation_type [1/3]

Strategy for creation of blocks passed on to Ifpack block relaxation (variable 'partitioner: type') with this string as the given value. Available types in Ifpack include "linear" (i.e., divide the local range of the matrix in slices of the block size), "greedy" "metis". For a full list, see the documentation of Ifpack.

Definition at line 566 of file trilinos_precondition.h.

## ◆ omega [4/6]

This specifies the (over-) relaxation parameter in the Jacobi preconditioner.

Definition at line 572 of file trilinos_precondition.h.

## ◆ min_diagonal [4/7]

This specifies the minimum value the diagonal elements should have. This might be necessary when the block Jacobi preconditioner is used on matrices with zero diagonal elements. In that case, a straight- forward application would not be possible since we divide by the diagonal element.

Definition at line 581 of file trilinos_precondition.h.

## ◆ n_sweeps [4/6]

Sets how many times the given operation should be applied during the vmult() operation.

Definition at line 587 of file trilinos_precondition.h.

## ◆ block_size [2/3]

This specifies the size of blocks.

Definition at line 661 of file trilinos_precondition.h.

## ◆ block_creation_type [2/3]

Strategy for creation of blocks passed on to Ifpack block relaxation (variable 'partitioner: type') with this string as the given value. Available types in Ifpack include "linear" (i.e., divide the local range of the matrix in slices of the block size), "greedy" "metis". For a full list, see the documentation of Ifpack.

Definition at line 670 of file trilinos_precondition.h.

## ◆ omega [5/6]

This specifies the (over-) relaxation parameter in the SOR preconditioner.

Definition at line 676 of file trilinos_precondition.h.

## ◆ min_diagonal [5/7]

This specifies the minimum value the diagonal elements should have. This might be necessary when the SSOR preconditioner is used on matrices with zero diagonal elements. In that case, a straight- forward application would not be possible since we divide by the diagonal element.

Definition at line 685 of file trilinos_precondition.h.

## ◆ overlap [3/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 691 of file trilinos_precondition.h.

## ◆ n_sweeps [5/6]

Sets how many times the given operation should be applied during the vmult() operation.

Definition at line 697 of file trilinos_precondition.h.

## ◆ block_size [3/3]

This specifies the size of blocks.

Definition at line 772 of file trilinos_precondition.h.

## ◆ block_creation_type [3/3]

Strategy for creation of blocks passed on to Ifpack block relaxation (variable 'partitioner: type') with this string as the given value. Available types in Ifpack include "linear" (i.e., divide the local range of the matrix in slices of the block size), "greedy" "metis". For a full list, see the documentation of Ifpack.

Definition at line 781 of file trilinos_precondition.h.

## ◆ omega [6/6]

This specifies the (over-) relaxation parameter in the SOR preconditioner.

Definition at line 787 of file trilinos_precondition.h.

## ◆ min_diagonal [6/7]

This specifies the minimum value the diagonal elements should have. This might be necessary when the SOR preconditioner is used on matrices with zero diagonal elements. In that case, a straight- forward application would not be possible since we divide by the diagonal element.

Definition at line 796 of file trilinos_precondition.h.

## ◆ overlap [4/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 802 of file trilinos_precondition.h.

## ◆ n_sweeps [6/6]

Sets how many times the given operation should be applied during the vmult() operation.

Definition at line 808 of file trilinos_precondition.h.

## ◆ ic_fill

This specifies the amount of additional fill-in elements besides the sparse matrix structure. When ic_fill is large, this means that many fill-ins will be added, so that the IC preconditioner comes closer to a direct sparse Cholesky decomposition. Note, however, that this will drastically increase the memory requirement, especially when the preconditioner is used in 3D.

Definition at line 900 of file trilinos_precondition.h.

## ◆ ic_atol

This specifies the amount of an absolute perturbation that will be added to the diagonal of the matrix, which sometimes can help to get better preconditioners.

Definition at line 907 of file trilinos_precondition.h.

## ◆ ic_rtol

This specifies the factor by which the diagonal of the matrix will be scaled, which sometimes can help to get better preconditioners.

Definition at line 913 of file trilinos_precondition.h.

## ◆ overlap [5/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 919 of file trilinos_precondition.h.

## ◆ ilu_fill

Additional fill-in, see class documentation above.

Definition at line 1014 of file trilinos_precondition.h.

## ◆ ilu_atol

The amount of perturbation to add to diagonal entries. See the class documentation above for details.

Definition at line 1020 of file trilinos_precondition.h.

## ◆ ilu_rtol

Scaling actor for diagonal entries. See the class documentation above for details.

Definition at line 1026 of file trilinos_precondition.h.

## ◆ overlap [6/8]

Overlap between processors. See the class documentation for details.

Definition at line 1031 of file trilinos_precondition.h.

## ◆ ilut_drop

This specifies the relative size of elements which should be dropped when forming an incomplete LU decomposition with threshold.

Definition at line 1121 of file trilinos_precondition.h.

## ◆ ilut_fill

This specifies the amount of additional fill-in elements besides the sparse matrix structure. When ilu_fill is large, this means that many fill-ins will be added, so that the ILU preconditioner comes closer to a (direct) sparse LU decomposition. Note, however, that this will drastically increase the memory requirement, especially when the preconditioner is used in 3D.

Definition at line 1131 of file trilinos_precondition.h.

## ◆ ilut_atol

This specifies the amount of an absolute perturbation that will be added to the diagonal of the matrix, which sometimes can help to get better preconditioners.

Definition at line 1138 of file trilinos_precondition.h.

## ◆ ilut_rtol

This specifies the factor by which the diagonal of the matrix will be scaled, which sometimes can help to get better preconditioners.

Definition at line 1144 of file trilinos_precondition.h.

## ◆ overlap [7/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 1150 of file trilinos_precondition.h.

## ◆ overlap [8/8]

This determines how large the overlap of the local matrix portions on each processor in a parallel application should be.

Definition at line 1200 of file trilinos_precondition.h.

## ◆ degree

This determines the degree of the Chebyshev polynomial. The degree of the polynomial gives the number of matrix-vector products to be performed for one application of the vmult() operation.

Definition at line 1246 of file trilinos_precondition.h.

## ◆ max_eigenvalue

This sets the maximum eigenvalue of the matrix, which needs to be set properly for appropriate performance of the Chebyshev preconditioner.

Definition at line 1252 of file trilinos_precondition.h.

## ◆ eigenvalue_ratio

This sets the ratio between the maximum and the minimum eigenvalue.

Definition at line 1257 of file trilinos_precondition.h.

## ◆ min_eigenvalue

This sets the minimum eigenvalue, which is an optional parameter only used internally for checking whether we use an identity matrix.

Definition at line 1263 of file trilinos_precondition.h.

## ◆ min_diagonal [7/7]

This sets a threshold below which the diagonal element will not be inverted in the Chebyshev algorithm.

Definition at line 1269 of file trilinos_precondition.h.

## ◆ nonzero_starting

When this flag is set to true, it enables the method vmult(dst, src) to use non-zero data in the vector dst, appending to it the Chebyshev corrections. This can be useful in some situations (e.g. when used for high-frequency error smoothing), but not the way the solver classes expect a preconditioner to work (where one ignores the content in dst for the preconditioner application). The user should really know what they are doing when touching this flag.

Definition at line 1281 of file trilinos_precondition.h.

## ◆ elliptic [1/2]

Determines whether the AMG preconditioner should be optimized for elliptic problems (ML option smoothed aggregation SA, using a Chebyshev smoother) or for non-elliptic problems (ML option non- symmetric smoothed aggregation NSSA, smoother is SSOR with underrelaxation).

Definition at line 1461 of file trilinos_precondition.h.

## ◆ higher_order_elements

Determines whether the matrix that the preconditioner is built upon is generated from linear or higher-order elements.

Definition at line 1467 of file trilinos_precondition.h.

## ◆ n_cycles [1/2]

Defines how many multigrid cycles should be performed by the preconditioner.

Definition at line 1473 of file trilinos_precondition.h.

## ◆ w_cycle [1/2]

Defines whether a w-cycle should be used instead of the standard setting of a v-cycle.

Definition at line 1479 of file trilinos_precondition.h.

## ◆ aggregation_threshold [1/2]

This threshold tells the AMG setup how the coarsening should be performed. In the AMG used by ML, all points that strongly couple with the tentative coarse-level point form one aggregate. The term strong coupling is controlled by the variable aggregation_threshold, meaning that all elements that are not smaller than aggregation_threshold times the diagonal element do couple strongly.

Definition at line 1490 of file trilinos_precondition.h.

## ◆ constant_modes [1/2]

Specifies the constant modes (near null space) of the matrix. This parameter tells AMG whether we work on a scalar equation (where the near null space only consists of ones, and default value is OK) or on a vector-valued equation. For vector-valued problem with n_components components, the provided constant_modes should fulfill the following requirements:

• constant_modes.size() == n_components
• constant_modes[*].size() needs to be equal to either the total number of degrees of freedom associated with the linear system (constant_modes[*].size() == n_dofs), or the number of locally owned degrees of freedom (constant_modes[*].size() == n_locally_owned_dofs). In parallel computations, the latter is the more appropriate choice since one does not want to store vectors of global size on individual processes.
• constant_modes[ic][id] == true if DoF id is a degree of freedom that is part of vector component ic.

We obtain the constant_modes fulfilling the above requirements with the function DoFTools::extract_constant_modes.

Definition at line 1516 of file trilinos_precondition.h.

## ◆ smoother_sweeps [1/2]

Determines how many sweeps of the smoother should be performed. When the flag elliptic is set to true, i.e., for elliptic or almost elliptic problems, the polynomial degree of the Chebyshev smoother is set to smoother_sweeps. The term sweeps refers to the number of matrix-vector products performed in the Chebyshev case. In the non-elliptic case, smoother_sweeps sets the number of SSOR relaxation sweeps for post-smoothing to be performed.

Definition at line 1528 of file trilinos_precondition.h.

## ◆ smoother_overlap [1/2]

Determines the overlap in the SSOR/Chebyshev error smoother when run in parallel.

Definition at line 1534 of file trilinos_precondition.h.

## ◆ output_details [1/2]

If this flag is set to true, then internal information from the ML preconditioner is printed to screen. This can be useful when debugging the preconditioner.

Definition at line 1541 of file trilinos_precondition.h.

## ◆ smoother_type [1/2]

Determines which smoother to use for the AMG cycle. Possibilities for smoother_type are the following:

• "Aztec"
• "IFPACK"
• "Jacobi"
• "ML symmetric Gauss-Seidel"
• "symmetric Gauss-Seidel"
• "ML Gauss-Seidel"
• "Gauss-Seidel"
• "block Gauss-Seidel"
• "symmetric block Gauss-Seidel"
• "Chebyshev"
• "MLS"
• "Hiptmair"
• "Amesos-KLU"
• "Amesos-Superlu"
• "Amesos-UMFPACK"
• "Amesos-Superludist"
• "Amesos-MUMPS"
• "user-defined"
• "SuperLU"
• "IFPACK-Chebyshev"
• "self"
• "do-nothing"
• "IC"
• "ICT"
• "ILU"
• "ILUT"
• "Block Chebyshev"
• "IFPACK-Block Chebyshev"

Definition at line 1577 of file trilinos_precondition.h.

## ◆ coarse_type [1/2]

Determines which solver to use on the coarsest level. The same settings as for the smoother type are possible.

Definition at line 1583 of file trilinos_precondition.h.

## ◆ trilinos_matrix [1/2]

 std::shared_ptr TrilinosWrappers::PreconditionAMG::trilinos_matrix
private

A copy of the deal.II matrix into Trilinos format.

Definition at line 1697 of file trilinos_precondition.h.

## ◆ elliptic [2/2]

Determines whether the AMG preconditioner should be optimized for elliptic problems (MueLu option smoothed aggregation SA, using a Chebyshev smoother) or for non-elliptic problems (MueLu option non- symmetric smoothed aggregation NSSA, smoother is SSOR with underrelaxation).

Definition at line 1755 of file trilinos_precondition.h.

## ◆ n_cycles [2/2]

Defines how many multigrid cycles should be performed by the preconditioner.

Definition at line 1761 of file trilinos_precondition.h.

## ◆ w_cycle [2/2]

Defines whether a w-cycle should be used instead of the standard setting of a v-cycle.

Definition at line 1767 of file trilinos_precondition.h.

## ◆ aggregation_threshold [2/2]

This threshold tells the AMG setup how the coarsening should be performed. In the AMG used by MueLu, all points that strongly couple with the tentative coarse-level point form one aggregate. The term strong coupling is controlled by the variable aggregation_threshold, meaning that all elements that are not smaller than aggregation_threshold times the diagonal element do couple strongly.

Definition at line 1778 of file trilinos_precondition.h.

## ◆ constant_modes [2/2]

Specifies the constant modes (near null space) of the matrix. This parameter tells AMG whether we work on a scalar equation (where the near null space only consists of ones) or on a vector-valued equation.

Definition at line 1786 of file trilinos_precondition.h.

## ◆ smoother_sweeps [2/2]

Determines how many sweeps of the smoother should be performed. When the flag elliptic is set to true, i.e., for elliptic or almost elliptic problems, the polynomial degree of the Chebyshev smoother is set to smoother_sweeps. The term sweeps refers to the number of matrix-vector products performed in the Chebyshev case. In the non-elliptic case, smoother_sweeps sets the number of SSOR relaxation sweeps for post-smoothing to be performed.

Definition at line 1798 of file trilinos_precondition.h.

## ◆ smoother_overlap [2/2]

Determines the overlap in the SSOR/Chebyshev error smoother when run in parallel.

Definition at line 1804 of file trilinos_precondition.h.

## ◆ output_details [2/2]

If this flag is set to true, then internal information from the ML preconditioner is printed to screen. This can be useful when debugging the preconditioner.

Definition at line 1811 of file trilinos_precondition.h.

## ◆ smoother_type [2/2]

Determines which smoother to use for the AMG cycle. Possibilities for smoother_type are the following:

• "Aztec"
• "IFPACK"
• "Jacobi"
• "ML symmetric Gauss-Seidel"
• "symmetric Gauss-Seidel"
• "ML Gauss-Seidel"
• "Gauss-Seidel"
• "block Gauss-Seidel"
• "symmetric block Gauss-Seidel"
• "Chebyshev"
• "MLS"
• "Hiptmair"
• "Amesos-KLU"
• "Amesos-Superlu"
• "Amesos-UMFPACK"
• "Amesos-Superludist"
• "Amesos-MUMPS"
• "user-defined"
• "SuperLU"
• "IFPACK-Chebyshev"
• "self"
• "do-nothing"
• "IC"
• "ICT"
• "ILU"
• "ILUT"
• "Block Chebyshev"
• "IFPACK-Block Chebyshev"

Definition at line 1847 of file trilinos_precondition.h.

## ◆ coarse_type [2/2]

Determines which solver to use on the coarsest level. The same settings as for the smoother type are possible.

Definition at line 1853 of file trilinos_precondition.h.

## ◆ trilinos_matrix [2/2]

 std::shared_ptr TrilinosWrappers::PreconditionAMGMueLu::trilinos_matrix
private

A copy of the deal.II matrix into Trilinos format.

Definition at line 1941 of file trilinos_precondition.h.

## ◆ last_action

 Epetra_CombineMode TrilinosWrappers::MPI::Vector::last_action
private

Trilinos doesn't allow to mix additions to matrix entries and overwriting them (to make synchronization of parallel computations simpler). The way we do it is to, for each access operation, store whether it is an insertion or an addition. If the previous one was of different type, then we first have to flush the Trilinos buffers; otherwise, we can simply go on. Luckily, Trilinos has an object for this which does already all the parallel communications in such a case, so we simply use their model, which stores whether the last operation was an addition or an insertion.

Definition at line 1314 of file trilinos_vector.h.

## ◆ compressed

 bool TrilinosWrappers::MPI::Vector::compressed
private

A boolean variable to hold information on whether the vector is compressed or not.

Definition at line 1320 of file trilinos_vector.h.

## ◆ has_ghosts

 bool TrilinosWrappers::MPI::Vector::has_ghosts
private

Whether this vector has ghost elements. This is true on all processors even if only one of them has any ghost elements.

Definition at line 1326 of file trilinos_vector.h.

## ◆ vector

 std::unique_ptr TrilinosWrappers::MPI::Vector::vector
private

Pointer to the actual Epetra vector object. This may represent a vector that is in fact distributed among multiple processors. The object requires an existing Epetra_Map for storing data when setting it up.

Definition at line 1333 of file trilinos_vector.h.

## ◆ nonlocal_vector

 std::unique_ptr TrilinosWrappers::MPI::Vector::nonlocal_vector
private

A vector object in Trilinos to be used for collecting the non-local elements if the vector was constructed with an additional IndexSet describing ghost elements.

Definition at line 1340 of file trilinos_vector.h.

## ◆ owned_elements

 IndexSet TrilinosWrappers::MPI::Vector::owned_elements
private

An IndexSet storing the indices this vector owns exclusively.

Definition at line 1345 of file trilinos_vector.h.

## ◆ SolverBase

 friend class SolverBase
friend

Definition at line 225 of file trilinos_precondition.h.

## ◆ internal::VectorReference

 friend class internal::VectorReference
friend

Definition at line 1348 of file trilinos_vector.h.