Reference documentation for deal.II version 9.3.3
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Namespaces | Classes | Typedefs | Functions | Variables
Collaboration diagram for TrilinosWrappers:

Namespaces

namespace  TrilinosWrappers
 
namespace  TrilinosWrappers::MPI
 
namespace  TrilinosWrappers::internal
 
namespace  TrilinosWrappers::internal::BlockLinearOperatorImplementation
 
namespace  internal
 
namespace  internal::LinearOperatorImplementation
 

Classes

class  TrilinosWrappers::BlockSparsityPattern
 
class  TrilinosWrappers::BlockSparseMatrix
 
class  TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< PayloadBlockType >
 
class  LinearAlgebra::EpetraWrappers::Vector
 
class  TrilinosWrappers::MPI::BlockVector
 
class  internal::LinearOperatorImplementation::ReinitHelper< Vector >
 
class  internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::BlockVector >
 
struct  is_serial_vector< TrilinosWrappers::MPI::BlockVector >
 
class  TrilinosWrappers::PreconditionBase
 
struct  TrilinosWrappers::PreconditionBase::AdditionalData
 
class  TrilinosWrappers::PreconditionJacobi
 
struct  TrilinosWrappers::PreconditionJacobi::AdditionalData
 
class  TrilinosWrappers::PreconditionSSOR
 
struct  TrilinosWrappers::PreconditionSSOR::AdditionalData
 
class  TrilinosWrappers::PreconditionSOR
 
struct  TrilinosWrappers::PreconditionSOR::AdditionalData
 
class  TrilinosWrappers::PreconditionBlockJacobi
 
struct  TrilinosWrappers::PreconditionBlockJacobi::AdditionalData
 
class  TrilinosWrappers::PreconditionBlockSSOR
 
struct  TrilinosWrappers::PreconditionBlockSSOR::AdditionalData
 
class  TrilinosWrappers::PreconditionBlockSOR
 
struct  TrilinosWrappers::PreconditionBlockSOR::AdditionalData
 
class  TrilinosWrappers::PreconditionIC
 
struct  TrilinosWrappers::PreconditionIC::AdditionalData
 
class  TrilinosWrappers::PreconditionILU
 
struct  TrilinosWrappers::PreconditionILU::AdditionalData
 
class  TrilinosWrappers::PreconditionILUT
 
struct  TrilinosWrappers::PreconditionILUT::AdditionalData
 
class  TrilinosWrappers::PreconditionBlockwiseDirect
 
struct  TrilinosWrappers::PreconditionBlockwiseDirect::AdditionalData
 
class  TrilinosWrappers::PreconditionChebyshev
 
struct  TrilinosWrappers::PreconditionChebyshev::AdditionalData
 
class  TrilinosWrappers::PreconditionAMG
 
struct  TrilinosWrappers::PreconditionAMG::AdditionalData
 
class  TrilinosWrappers::PreconditionAMGMueLu
 
struct  TrilinosWrappers::PreconditionAMGMueLu::AdditionalData
 
class  TrilinosWrappers::PreconditionIdentity
 
struct  TrilinosWrappers::PreconditionIdentity::AdditionalData
 
class  TrilinosWrappers::SolverBase
 
class  TrilinosWrappers::SolverCG
 
class  TrilinosWrappers::SolverCGS
 
class  TrilinosWrappers::SolverBicgstab
 
class  TrilinosWrappers::SolverTFQMR
 
class  TrilinosWrappers::SolverDirect
 
class  TrilinosWrappers::SparseMatrixIterators::Iterator< Constness >
 
class  TrilinosWrappers::SparseMatrix
 
class  TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload
 
class  TrilinosWrappers::SparsityPatternIterators::Accessor
 
class  TrilinosWrappers::SparsityPattern
 
class  LinearAlgebra::TpetraWrappers::Vector< Number >
 
class  TrilinosWrappers::MPI::Vector
 
class  internal::LinearOperatorImplementation::ReinitHelper< TrilinosWrappers::MPI::Vector >
 
struct  is_serial_vector< TrilinosWrappers::MPI::Vector >
 

Typedefs

using TrilinosWrappers::BlockSparseMatrix::BaseClass = BlockMatrixBase< SparseMatrix >
 
using TrilinosWrappers::BlockSparseMatrix::BlockType = BaseClass::BlockType
 
using TrilinosWrappers::BlockSparseMatrix::value_type = BaseClass::value_type
 
using TrilinosWrappers::BlockSparseMatrix::pointer = BaseClass::pointer
 
using TrilinosWrappers::BlockSparseMatrix::const_pointer = BaseClass::const_pointer
 
using TrilinosWrappers::BlockSparseMatrix::reference = BaseClass::reference
 
using TrilinosWrappers::BlockSparseMatrix::const_reference = BaseClass::const_reference
 
using TrilinosWrappers::BlockSparseMatrix::size_type = BaseClass::size_type
 
using TrilinosWrappers::BlockSparseMatrix::iterator = BaseClass::iterator
 
using TrilinosWrappers::BlockSparseMatrix::const_iterator = BaseClass::const_iterator
 
using TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< PayloadBlockType >::BlockType = PayloadBlockType
 
using TrilinosWrappers::MPI::BlockVector::BaseClass = ::BlockVectorBase< MPI::Vector >
 
using TrilinosWrappers::MPI::BlockVector::BlockType = BaseClass::BlockType
 
using TrilinosWrappers::MPI::BlockVector::value_type = BaseClass::value_type
 
using TrilinosWrappers::MPI::BlockVector::pointer = BaseClass::pointer
 
using TrilinosWrappers::MPI::BlockVector::const_pointer = BaseClass::const_pointer
 
using TrilinosWrappers::MPI::BlockVector::reference = BaseClass::reference
 
using TrilinosWrappers::MPI::BlockVector::const_reference = BaseClass::const_reference
 
using TrilinosWrappers::MPI::BlockVector::size_type = BaseClass::size_type
 
using TrilinosWrappers::MPI::BlockVector::iterator = BaseClass::iterator
 
using TrilinosWrappers::MPI::BlockVector::const_iterator = BaseClass::const_iterator
 
using TrilinosWrappers::PreconditionBase::size_type = ::types::global_dof_index
 
using TrilinosWrappers::MPI::Vector::value_type = TrilinosScalar
 
using TrilinosWrappers::MPI::Vector::real_type = TrilinosScalar
 
using TrilinosWrappers::MPI::Vector::size_type = ::types::global_dof_index
 
using TrilinosWrappers::MPI::Vector::iterator = value_type *
 
using TrilinosWrappers::MPI::Vector::const_iterator = const value_type *
 
using TrilinosWrappers::MPI::Vector::reference = internal::VectorReference
 
using TrilinosWrappers::MPI::Vector::const_reference = const internal::VectorReference
 

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 ()
 
size_type 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::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< PayloadBlockType >::TrilinosBlockPayload (const 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::PreconditionJacobi::AdditionalData::AdditionalData (const double omega=1, const double min_diagonal=0, const unsigned int n_sweeps=1)
 
void TrilinosWrappers::PreconditionJacobi::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 TrilinosWrappers::PreconditionSSOR::AdditionalData::AdditionalData (const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)
 
void TrilinosWrappers::PreconditionSSOR::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 TrilinosWrappers::PreconditionSOR::AdditionalData::AdditionalData (const double omega=1, const double min_diagonal=0, const unsigned int overlap=0, const unsigned int n_sweeps=1)
 
void TrilinosWrappers::PreconditionSOR::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionBlockJacobi::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionBlockSSOR::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionBlockSOR::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionIC::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionILU::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionILUT::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 TrilinosWrappers::PreconditionBlockwiseDirect::AdditionalData::AdditionalData (const unsigned int overlap=0)
 
void TrilinosWrappers::PreconditionBlockwiseDirect::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 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)
 
void TrilinosWrappers::PreconditionChebyshev::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
 TrilinosWrappers::PreconditionAMG::AdditionalData::AdditionalData (const bool elliptic=true, const bool higher_order_elements=false, const unsigned int n_cycles=1, const bool w_cyle=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 AdditionalData &additional_data=AdditionalData())
 
void TrilinosWrappers::PreconditionAMG::initialize (const Epetra_RowMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
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::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)
 
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_cyle=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, const AdditionalData &additional_data=AdditionalData())
 
void TrilinosWrappers::PreconditionAMGMueLu::initialize (const Epetra_CrsMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
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::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)
 
void TrilinosWrappers::PreconditionAMGMueLu::clear ()
 
size_type TrilinosWrappers::PreconditionAMGMueLu::memory_consumption () const
 
void TrilinosWrappers::PreconditionIdentity::initialize (const SparseMatrix &matrix, const AdditionalData &additional_data=AdditionalData())
 
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)
 

Variables

double TrilinosWrappers::PreconditionJacobi::AdditionalData::omega
 
double TrilinosWrappers::PreconditionJacobi::AdditionalData::min_diagonal
 
unsigned int TrilinosWrappers::PreconditionJacobi::AdditionalData::n_sweeps
 
double TrilinosWrappers::PreconditionSSOR::AdditionalData::omega
 
double TrilinosWrappers::PreconditionSSOR::AdditionalData::min_diagonal
 
unsigned int TrilinosWrappers::PreconditionSSOR::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionSSOR::AdditionalData::n_sweeps
 
double TrilinosWrappers::PreconditionSOR::AdditionalData::omega
 
double TrilinosWrappers::PreconditionSOR::AdditionalData::min_diagonal
 
unsigned int TrilinosWrappers::PreconditionSOR::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionSOR::AdditionalData::n_sweeps
 
unsigned int TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::block_size
 
std::string TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::block_creation_type
 
double TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::omega
 
double TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::min_diagonal
 
unsigned int TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::n_sweeps
 
unsigned int TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::block_size
 
std::string TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::block_creation_type
 
double TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::omega
 
double TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::min_diagonal
 
unsigned int TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::n_sweeps
 
unsigned int TrilinosWrappers::PreconditionBlockSOR::AdditionalData::block_size
 
std::string TrilinosWrappers::PreconditionBlockSOR::AdditionalData::block_creation_type
 
double TrilinosWrappers::PreconditionBlockSOR::AdditionalData::omega
 
double TrilinosWrappers::PreconditionBlockSOR::AdditionalData::min_diagonal
 
unsigned int TrilinosWrappers::PreconditionBlockSOR::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionBlockSOR::AdditionalData::n_sweeps
 
unsigned int TrilinosWrappers::PreconditionIC::AdditionalData::ic_fill
 
double TrilinosWrappers::PreconditionIC::AdditionalData::ic_atol
 
double TrilinosWrappers::PreconditionIC::AdditionalData::ic_rtol
 
unsigned int TrilinosWrappers::PreconditionIC::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionILU::AdditionalData::ilu_fill
 
double TrilinosWrappers::PreconditionILU::AdditionalData::ilu_atol
 
double TrilinosWrappers::PreconditionILU::AdditionalData::ilu_rtol
 
unsigned int TrilinosWrappers::PreconditionILU::AdditionalData::overlap
 
double TrilinosWrappers::PreconditionILUT::AdditionalData::ilut_drop
 
unsigned int TrilinosWrappers::PreconditionILUT::AdditionalData::ilut_fill
 
double TrilinosWrappers::PreconditionILUT::AdditionalData::ilut_atol
 
double TrilinosWrappers::PreconditionILUT::AdditionalData::ilut_rtol
 
unsigned int TrilinosWrappers::PreconditionILUT::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionBlockwiseDirect::AdditionalData::overlap
 
unsigned int TrilinosWrappers::PreconditionChebyshev::AdditionalData::degree
 
double TrilinosWrappers::PreconditionChebyshev::AdditionalData::max_eigenvalue
 
double TrilinosWrappers::PreconditionChebyshev::AdditionalData::eigenvalue_ratio
 
double TrilinosWrappers::PreconditionChebyshev::AdditionalData::min_eigenvalue
 
double TrilinosWrappers::PreconditionChebyshev::AdditionalData::min_diagonal
 
bool TrilinosWrappers::PreconditionChebyshev::AdditionalData::nonzero_starting
 
bool TrilinosWrappers::PreconditionAMG::AdditionalData::elliptic
 
bool TrilinosWrappers::PreconditionAMG::AdditionalData::higher_order_elements
 
unsigned int TrilinosWrappers::PreconditionAMG::AdditionalData::n_cycles
 
bool TrilinosWrappers::PreconditionAMG::AdditionalData::w_cycle
 
double TrilinosWrappers::PreconditionAMG::AdditionalData::aggregation_threshold
 
std::vector< std::vector< bool > > TrilinosWrappers::PreconditionAMG::AdditionalData::constant_modes
 
unsigned int TrilinosWrappers::PreconditionAMG::AdditionalData::smoother_sweeps
 
unsigned int TrilinosWrappers::PreconditionAMG::AdditionalData::smoother_overlap
 
bool TrilinosWrappers::PreconditionAMG::AdditionalData::output_details
 
const char * TrilinosWrappers::PreconditionAMG::AdditionalData::smoother_type
 
const char * TrilinosWrappers::PreconditionAMG::AdditionalData::coarse_type
 
std::shared_ptr< SparseMatrixTrilinosWrappers::PreconditionAMG::trilinos_matrix
 
bool TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::elliptic
 
unsigned int TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::n_cycles
 
bool TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::w_cycle
 
double TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::aggregation_threshold
 
std::vector< std::vector< bool > > TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::constant_modes
 
unsigned int TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::smoother_sweeps
 
unsigned int TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::smoother_overlap
 
bool TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::output_details
 
const char * TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::smoother_type
 
const char * TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::coarse_type
 
std::shared_ptr< SparseMatrixTrilinosWrappers::PreconditionAMGMueLu::trilinos_matrix
 

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

Creation of a BlockLinearOperator

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)
 
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>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > TrilinosWrappers::block_diagonal_operator (const TrilinosWrappers::BlockSparseMatrix &block_matrix)
 
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>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_operator (const TrilinosWrappers::BlockSparseMatrix &block_matrix)
 
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>
BlockLinearOperator< Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload > > block_diagonal_operator (const TrilinosWrappers::BlockSparseMatrix &block_matrix)
 
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)
 

Access to underlying Trilinos data

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 TrilinosScalar s)
 
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.

Author
Martin Kronbichler, Wolfgang Bangerth, 2008

Typedef Documentation

◆ BaseClass [1/2]

Typedef the base class for simpler access to its own alias.

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]

template<typename PayloadBlockType >
using TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< PayloadBlockType >::BlockType = PayloadBlockType

Type of payload held by each subblock

Definition at line 588 of file trilinos_block_sparse_matrix.h.

◆ BaseClass [2/2]

Typedef the base class for simpler access to its own alias.

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 86 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 411 of file trilinos_vector.h.

◆ real_type

Definition at line 412 of file trilinos_vector.h.

◆ size_type [4/4]

Definition at line 413 of file trilinos_vector.h.

◆ iterator [3/3]

Definition at line 414 of file trilinos_vector.h.

◆ const_iterator [3/3]

Definition at line 415 of file trilinos_vector.h.

◆ reference [3/3]

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

Definition at line 416 of file trilinos_vector.h.

◆ const_reference [3/3]

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

Definition at line 417 of file trilinos_vector.h.

Function Documentation

◆ 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 BlockSparseMatrix< number >::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.

Definition at line 36 of file petsc_parallel_block_sparse_matrix.cc.

◆ 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()

BlockSparseMatrix::size_type 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.

◆ TrilinosBlockPayload()

template<typename PayloadBlockType >
template<typename... Args>
TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload< PayloadBlockType >::TrilinosBlockPayload ( const 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/4]

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/4]

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.

◆ 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 142 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 178 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 219 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 254 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 95 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 123 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 138 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 154 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.

See also
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 178 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 42 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 56 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 67 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 78 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 87 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 94 of file trilinos_precondition.cc.

◆ AdditionalData() [1/13]

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 101 of file trilinos_precondition.cc.

◆ initialize() [1/22]

void PreconditionJacobi< MatrixType >::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 113 of file trilinos_precondition.cc.

◆ AdditionalData() [2/13]

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 153 of file trilinos_precondition.cc.

◆ initialize() [2/22]

void PreconditionSSOR< MatrixType >::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 166 of file trilinos_precondition.cc.

◆ AdditionalData() [3/13]

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 206 of file trilinos_precondition.cc.

◆ initialize() [3/22]

void PreconditionSOR< MatrixType >::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 219 of file trilinos_precondition.cc.

◆ AdditionalData() [4/13]

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 259 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 275 of file trilinos_precondition.cc.

◆ AdditionalData() [5/13]

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 326 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 344 of file trilinos_precondition.cc.

◆ AdditionalData() [6/13]

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 395 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 413 of file trilinos_precondition.cc.

◆ AdditionalData() [7/13]

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 464 of file trilinos_precondition.cc.

◆ initialize() [7/22]

void TrilinosWrappers::PreconditionIC::initialize ( const SparseMatrix matrix,
const AdditionalData additional_data = AdditionalData() 
)

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

Definition at line 477 of file trilinos_precondition.cc.

◆ AdditionalData() [8/13]

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 514 of file trilinos_precondition.cc.

◆ initialize() [8/22]

void TrilinosWrappers::PreconditionILU::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 527 of file trilinos_precondition.cc.

◆ AdditionalData() [9/13]

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 565 of file trilinos_precondition.cc.

◆ initialize() [9/22]

void TrilinosWrappers::PreconditionILUT::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 580 of file trilinos_precondition.cc.

◆ AdditionalData() [10/13]

TrilinosWrappers::PreconditionBlockwiseDirect::AdditionalData::AdditionalData ( const unsigned int  overlap = 0)

Constructor.

Definition at line 619 of file trilinos_precondition.cc.

◆ initialize() [10/22]

void TrilinosWrappers::PreconditionBlockwiseDirect::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 627 of file trilinos_precondition.cc.

◆ AdditionalData() [11/13]

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 661 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 679 of file trilinos_precondition.cc.

◆ AdditionalData() [12/13]

TrilinosWrappers::PreconditionAMG::AdditionalData::AdditionalData ( const bool  elliptic = true,
const bool  higher_order_elements = false,
const unsigned int  n_cycles = 1,
const bool  w_cyle = 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" 
)

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;
...
TrilinosWrappers::PreconditionAMG::AdditionalData data;
dof_handler,
dof_handler.get_fe_collection().component_mask(field_extractor),
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:1304

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]

void TrilinosWrappers::PreconditionAMG::initialize ( const SparseMatrix matrix,
const AdditionalData additional_data = AdditionalData() 
)

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]

void TrilinosWrappers::PreconditionAMG::initialize ( const Epetra_RowMatrix &  matrix,
const AdditionalData additional_data = AdditionalData() 
)

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.

◆ AdditionalData() [13/13]

TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::AdditionalData ( const bool  elliptic = true,
const unsigned int  n_cycles = 1,
const bool  w_cyle = 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" 
)

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]

void TrilinosWrappers::PreconditionAMGMueLu::initialize ( const SparseMatrix matrix,
const AdditionalData additional_data = AdditionalData() 
)

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]

void TrilinosWrappers::PreconditionAMGMueLu::initialize ( const Epetra_CrsMatrix &  matrix,
const AdditionalData additional_data = AdditionalData() 
)

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]

void PreconditionIdentity::initialize ( const SparseMatrix matrix,
const AdditionalData additional_data = AdditionalData() 
)

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 722 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 766 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 772 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 778 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 785 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 204 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.

See also
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.

See also
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.

See also
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.

See also
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 198 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.

See also
vectors with ghost elements

Definition at line 157 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.

See also
vectors with ghost elements

Definition at line 360 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 283 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.

See Compressing distributed objects for more information.

Definition at line 582 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 418 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 498 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 527 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 551 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 715 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 732 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:1013

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

See also
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.

◆ add_and_dot()

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

this->add(a, V);
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 742 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 775 of file trilinos_vector.cc.

◆ operator()() [1/2]

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

Provide access to a given element, both read and write.

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

Provide read-only access to an element.

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 654 of file trilinos_vector.cc.

◆ operator[]() [1/2]

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

Provide access to a given element, both read and write.

Exactly the same as operator().

◆ operator[]() [2/2]

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

Provide read-only access to an element.

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.

◆ add() [1/7]

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.

◆ add() [2/7]

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.

◆ add() [3/7]

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.

◆ add() [4/7]

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

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

◆ add() [5/7]

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 680 of file trilinos_vector.cc.

◆ add() [6/7]

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

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

◆ add() [7/7]

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.

◆ sadd() [1/2]

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

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

◆ sadd() [2/2]

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 814 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 862 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 875 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 1366 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 2245 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 2256 of file trilinos_vector.h.

◆ linear_operator() [3/4]

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() [4/4]

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.

◆ block_operator() [3/4]

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 142 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 178 of file trilinos_linear_operator.h.

◆ block_diagonal_operator() [3/4]

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 219 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 254 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 1366 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."

Variable Documentation

◆ preconditioner

Teuchos::RCP<Epetra_Operator> TrilinosWrappers::PreconditionBase::preconditioner
protected

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

Definition at line 236 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 243 of file trilinos_precondition.h.

◆ vector_distributor

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

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

Definition at line 252 of file trilinos_precondition.h.

◆ omega [1/6]

double TrilinosWrappers::PreconditionJacobi::AdditionalData::omega

This specifies the relaxation parameter in the Jacobi preconditioner.

Definition at line 298 of file trilinos_precondition.h.

◆ min_diagonal [1/7]

double TrilinosWrappers::PreconditionJacobi::AdditionalData::min_diagonal

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 307 of file trilinos_precondition.h.

◆ n_sweeps [1/6]

unsigned int TrilinosWrappers::PreconditionJacobi::AdditionalData::n_sweeps

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

Definition at line 313 of file trilinos_precondition.h.

◆ omega [2/6]

double TrilinosWrappers::PreconditionSSOR::AdditionalData::omega

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

Definition at line 385 of file trilinos_precondition.h.

◆ min_diagonal [2/7]

double TrilinosWrappers::PreconditionSSOR::AdditionalData::min_diagonal

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 394 of file trilinos_precondition.h.

◆ overlap [1/8]

unsigned int TrilinosWrappers::PreconditionSSOR::AdditionalData::overlap

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

Definition at line 400 of file trilinos_precondition.h.

◆ n_sweeps [2/6]

unsigned int TrilinosWrappers::PreconditionSSOR::AdditionalData::n_sweeps

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

Definition at line 406 of file trilinos_precondition.h.

◆ omega [3/6]

double TrilinosWrappers::PreconditionSOR::AdditionalData::omega

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

Definition at line 479 of file trilinos_precondition.h.

◆ min_diagonal [3/7]

double TrilinosWrappers::PreconditionSOR::AdditionalData::min_diagonal

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 488 of file trilinos_precondition.h.

◆ overlap [2/8]

unsigned int TrilinosWrappers::PreconditionSOR::AdditionalData::overlap

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

Definition at line 494 of file trilinos_precondition.h.

◆ n_sweeps [3/6]

unsigned int TrilinosWrappers::PreconditionSOR::AdditionalData::n_sweeps

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

Definition at line 500 of file trilinos_precondition.h.

◆ block_size [1/3]

unsigned int TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::block_size

This specifies the size of blocks.

Definition at line 565 of file trilinos_precondition.h.

◆ block_creation_type [1/3]

std::string TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::block_creation_type

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 574 of file trilinos_precondition.h.

◆ omega [4/6]

double TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::omega

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

Definition at line 580 of file trilinos_precondition.h.

◆ min_diagonal [4/7]

double TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::min_diagonal

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 589 of file trilinos_precondition.h.

◆ n_sweeps [4/6]

unsigned int TrilinosWrappers::PreconditionBlockJacobi::AdditionalData::n_sweeps

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

Definition at line 595 of file trilinos_precondition.h.

◆ block_size [2/3]

unsigned int TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::block_size

This specifies the size of blocks.

Definition at line 669 of file trilinos_precondition.h.

◆ block_creation_type [2/3]

std::string TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::block_creation_type

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 678 of file trilinos_precondition.h.

◆ omega [5/6]

double TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::omega

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

Definition at line 684 of file trilinos_precondition.h.

◆ min_diagonal [5/7]

double TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::min_diagonal

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 693 of file trilinos_precondition.h.

◆ overlap [3/8]

unsigned int TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::overlap

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

Definition at line 699 of file trilinos_precondition.h.

◆ n_sweeps [5/6]

unsigned int TrilinosWrappers::PreconditionBlockSSOR::AdditionalData::n_sweeps

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

Definition at line 705 of file trilinos_precondition.h.

◆ block_size [3/3]

unsigned int TrilinosWrappers::PreconditionBlockSOR::AdditionalData::block_size

This specifies the size of blocks.

Definition at line 780 of file trilinos_precondition.h.

◆ block_creation_type [3/3]

std::string TrilinosWrappers::PreconditionBlockSOR::AdditionalData::block_creation_type

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 789 of file trilinos_precondition.h.

◆ omega [6/6]

double TrilinosWrappers::PreconditionBlockSOR::AdditionalData::omega

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

Definition at line 795 of file trilinos_precondition.h.

◆ min_diagonal [6/7]

double TrilinosWrappers::PreconditionBlockSOR::AdditionalData::min_diagonal

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 804 of file trilinos_precondition.h.

◆ overlap [4/8]

unsigned int TrilinosWrappers::PreconditionBlockSOR::AdditionalData::overlap

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

Definition at line 810 of file trilinos_precondition.h.

◆ n_sweeps [6/6]

unsigned int TrilinosWrappers::PreconditionBlockSOR::AdditionalData::n_sweeps

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

Definition at line 816 of file trilinos_precondition.h.

◆ ic_fill

unsigned int TrilinosWrappers::PreconditionIC::AdditionalData::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 908 of file trilinos_precondition.h.

◆ ic_atol

double TrilinosWrappers::PreconditionIC::AdditionalData::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 915 of file trilinos_precondition.h.

◆ ic_rtol

double TrilinosWrappers::PreconditionIC::AdditionalData::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 921 of file trilinos_precondition.h.

◆ overlap [5/8]

unsigned int TrilinosWrappers::PreconditionIC::AdditionalData::overlap

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

Definition at line 927 of file trilinos_precondition.h.

◆ ilu_fill

unsigned int TrilinosWrappers::PreconditionILU::AdditionalData::ilu_fill

Additional fill-in, see class documentation above.

Definition at line 1022 of file trilinos_precondition.h.

◆ ilu_atol

double TrilinosWrappers::PreconditionILU::AdditionalData::ilu_atol

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

Definition at line 1028 of file trilinos_precondition.h.

◆ ilu_rtol

double TrilinosWrappers::PreconditionILU::AdditionalData::ilu_rtol

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

Definition at line 1034 of file trilinos_precondition.h.

◆ overlap [6/8]

unsigned int TrilinosWrappers::PreconditionILU::AdditionalData::overlap

Overlap between processors. See the class documentation for details.

Definition at line 1039 of file trilinos_precondition.h.

◆ ilut_drop

double TrilinosWrappers::PreconditionILUT::AdditionalData::ilut_drop

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

Definition at line 1129 of file trilinos_precondition.h.

◆ ilut_fill

unsigned int TrilinosWrappers::PreconditionILUT::AdditionalData::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 1139 of file trilinos_precondition.h.

◆ ilut_atol

double TrilinosWrappers::PreconditionILUT::AdditionalData::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 1146 of file trilinos_precondition.h.

◆ ilut_rtol

double TrilinosWrappers::PreconditionILUT::AdditionalData::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 1152 of file trilinos_precondition.h.

◆ overlap [7/8]

unsigned int TrilinosWrappers::PreconditionILUT::AdditionalData::overlap

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

Definition at line 1158 of file trilinos_precondition.h.

◆ overlap [8/8]

unsigned int TrilinosWrappers::PreconditionBlockwiseDirect::AdditionalData::overlap

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

Definition at line 1208 of file trilinos_precondition.h.

◆ degree

unsigned int TrilinosWrappers::PreconditionChebyshev::AdditionalData::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 1254 of file trilinos_precondition.h.

◆ max_eigenvalue

double TrilinosWrappers::PreconditionChebyshev::AdditionalData::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 1260 of file trilinos_precondition.h.

◆ eigenvalue_ratio

double TrilinosWrappers::PreconditionChebyshev::AdditionalData::eigenvalue_ratio

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

Definition at line 1265 of file trilinos_precondition.h.

◆ min_eigenvalue

double TrilinosWrappers::PreconditionChebyshev::AdditionalData::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 1271 of file trilinos_precondition.h.

◆ min_diagonal [7/7]

double TrilinosWrappers::PreconditionChebyshev::AdditionalData::min_diagonal

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

Definition at line 1277 of file trilinos_precondition.h.

◆ nonzero_starting

bool TrilinosWrappers::PreconditionChebyshev::AdditionalData::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 1289 of file trilinos_precondition.h.

◆ elliptic [1/2]

bool TrilinosWrappers::PreconditionAMG::AdditionalData::elliptic

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 1469 of file trilinos_precondition.h.

◆ higher_order_elements

bool TrilinosWrappers::PreconditionAMG::AdditionalData::higher_order_elements

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

Definition at line 1475 of file trilinos_precondition.h.

◆ n_cycles [1/2]

unsigned int TrilinosWrappers::PreconditionAMG::AdditionalData::n_cycles

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

Definition at line 1481 of file trilinos_precondition.h.

◆ w_cycle [1/2]

bool TrilinosWrappers::PreconditionAMG::AdditionalData::w_cycle

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

Definition at line 1487 of file trilinos_precondition.h.

◆ aggregation_threshold [1/2]

double TrilinosWrappers::PreconditionAMG::AdditionalData::aggregation_threshold

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 1498 of file trilinos_precondition.h.

◆ constant_modes [1/2]

std::vector<std::vector<bool> > TrilinosWrappers::PreconditionAMG::AdditionalData::constant_modes

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 equation problem with n_component, the provided constant_modes should fulfill the following requirements:

  • n_component.size() == n_component
  • n_component[*].size() == n_dof_local or n_component[*].size() == n_dof_global
  • n_component[ic][id] == "idth DoF is corresponding to component ic

Definition at line 1516 of file trilinos_precondition.h.

◆ smoother_sweeps [1/2]

unsigned int TrilinosWrappers::PreconditionAMG::AdditionalData::smoother_sweeps

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]

unsigned int TrilinosWrappers::PreconditionAMG::AdditionalData::smoother_overlap

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]

bool TrilinosWrappers::PreconditionAMG::AdditionalData::output_details

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]

const char* TrilinosWrappers::PreconditionAMG::AdditionalData::smoother_type

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]

const char* TrilinosWrappers::PreconditionAMG::AdditionalData::coarse_type

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

bool TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::elliptic

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]

unsigned int TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::n_cycles

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

Definition at line 1761 of file trilinos_precondition.h.

◆ w_cycle [2/2]

bool TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::w_cycle

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]

double TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::aggregation_threshold

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]

std::vector<std::vector<bool> > TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::constant_modes

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]

unsigned int TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::smoother_sweeps

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]

unsigned int TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::smoother_overlap

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]

bool TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::output_details

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]

const char* TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::smoother_type

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]

const char* TrilinosWrappers::PreconditionAMGMueLu::AdditionalData::coarse_type

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<SparseMatrix> 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 1316 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 1322 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 1328 of file trilinos_vector.h.

◆ vector

std::unique_ptr<Epetra_FEVector> 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 1335 of file trilinos_vector.h.

◆ nonlocal_vector

std::unique_ptr<Epetra_MultiVector> 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 1342 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 1347 of file trilinos_vector.h.

Friends

◆ SolverBase

friend class SolverBase
friend

Definition at line 229 of file trilinos_precondition.h.

◆ internal::VectorReference

friend class internal::VectorReference
friend

Definition at line 1350 of file trilinos_vector.h.