Reference documentation for deal.II version GIT relicensing-756-gc37f912904 2024-05-25 08:20:01+00:00
\(\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\}}\)
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace > Class Template Reference

#include <deal.II/lac/trilinos_tpetra_vector.h>

Inheritance diagram for LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >:
Inheritance graph
[legend]

Public Types

using NodeType = Tpetra::KokkosCompat::KokkosDeviceWrapperNode< typename MemorySpace::kokkos_space::execution_space, typename MemorySpace::kokkos_space >
 
using value_type = Number
 
using real_type = typename numbers::NumberTraits< Number >::real_type
 
using size_type = VectorTraits::size_type
 
using reference = internal::VectorReference< Number, MemorySpace >
 
using const_reference = const internal::VectorReference< Number, MemorySpace >
 
using MapType = Tpetra::Map< int, ::types::signed_global_dof_index, NodeType >
 
using VectorType = Tpetra::Vector< Number, int, ::types::signed_global_dof_index, NodeType >
 
using ExportType = Tpetra::Export< int, ::types::signed_global_dof_index, NodeType >
 
using ImportType = Tpetra::Import< int, ::types::signed_global_dof_index, NodeType >
 

Public Member Functions

template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 
1: Basic Object-handling
 Vector ()
 
 Vector (const Vector &V)
 
 Vector (const Teuchos::RCP< VectorType > V)
 
 Vector (const IndexSet &parallel_partitioner, const MPI_Comm communicator)
 
 Vector (const IndexSet &locally_owned_entries, const IndexSet &ghost_entries, const MPI_Comm communicator, const bool vector_writable=false)
 
void clear ()
 
void reinit (const IndexSet &parallel_partitioner, const MPI_Comm communicator=MPI_COMM_WORLD, const bool omit_zeroing_entries=false)
 
void reinit (const IndexSet &locally_owned_entries, const IndexSet &locally_relevant_or_ghost_entries, const MPI_Comm communicator=MPI_COMM_WORLD, const bool vector_writable=false)
 
void reinit (const Vector< Number, MemorySpace > &V, const bool omit_zeroing_entries=false)
 
virtual void swap (Vector &v)
 
virtual void extract_subvector_to (const ArrayView< const types::global_dof_index > &indices, ArrayView< Number > &elements) const override
 
Vectoroperator= (const Vector &V)
 
template<typename OtherNumber >
Vectoroperator= (const ::Vector< OtherNumber > &V)
 
Vectoroperator= (const Number s)
 
void import_elements (const ReadWriteVector< Number > &V, VectorOperation::values operation, const Teuchos::RCP< const Utilities::MPI::CommunicationPatternBase > &communication_pattern)
 
void import_elements (const ReadWriteVector< Number > &V, VectorOperation::values operation, const std::shared_ptr< const Utilities::MPI::CommunicationPatternBase > &communication_pattern)
 
void import_elements (const ReadWriteVector< Number > &V, VectorOperation::values operation)
 
void import (const ReadWriteVector< Number > &V, VectorOperation::values operation, std::shared_ptr< const Utilities::MPI::CommunicationPatternBase > communication_pattern={})
 
2: Data-Access
reference operator() (const size_type index)
 
Number operator() (const size_type index) const
 
reference operator[] (const size_type index)
 
Number operator[] (const size_type index) const
 
3: Modification of vectors
Vectoroperator*= (const Number factor)
 
Vectoroperator/= (const Number factor)
 
Vectoroperator+= (const Vector< Number, MemorySpace > &V)
 
Vectoroperator-= (const Vector< Number, MemorySpace > &V)
 
Number operator* (const Vector< Number, MemorySpace > &V) const
 
void add (const Number a)
 
void add (const Number a, const Vector< Number, MemorySpace > &V)
 
void add (const Number a, const Vector< Number, MemorySpace > &V, const Number b, const Vector< Number, MemorySpace > &W)
 
void add (const std::vector< size_type > &indices, const std::vector< Number > &values)
 
void add (const size_type n_elements, const size_type *indices, const Number *values)
 
void sadd (const Number s, const Number a, const Vector< Number, MemorySpace > &V)
 
void set (const size_type n_elements, const size_type *indices, const Number *values)
 
void scale (const Vector< Number, MemorySpace > &scaling_factors)
 
void equ (const Number a, const Vector< Number, MemorySpace > &V)
 
bool all_zero () const
 
bool is_non_negative () const
 
4: Scalar products, norms and related operations
Number mean_value () const
 
real_type l1_norm () const
 
real_type l2_norm () const
 
real_type linfty_norm () const
 
real_type norm_sqr () const
 
Number add_and_dot (const Number a, const Vector< Number, MemorySpace > &V, const Vector< Number, MemorySpace > &W)
 
5: Scalar products, norms and related operations
bool has_ghost_elements () const
 
bool operator== (const Vector< Number, MemorySpace > &v) const
 
bool operator!= (const Vector< Number, MemorySpace > &v) const
 
virtual size_type size () const override
 
size_type locally_owned_size () const
 
std::pair< size_type, size_typelocal_range () const
 
bool in_local_range (const size_type index) const
 
bool is_compressed () const
 
MPI_Comm get_mpi_communicator () const
 
::IndexSet locally_owned_elements () const
 
6: Mixed stuff
void compress (const VectorOperation::values operation)
 
const Tpetra::Vector< Number, int, types::signed_global_dof_index > & trilinos_vector () const
 
Tpetra::Vector< Number, int, types::signed_global_dof_index > & trilinos_vector ()
 
Teuchos::RCP< const Tpetra::Vector< Number, int, types::signed_global_dof_index > > trilinos_rcp () const
 
Teuchos::RCP< Tpetra::Vector< Number, int, types::signed_global_dof_index > > trilinos_rcp ()
 
void print (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const
 
std::size_t memory_consumption () const
 
MPI_Comm mpi_comm () const
 
Subscriptor functionality

Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class.

void subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
void unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
unsigned int n_subscriptions () const
 
template<typename StreamType >
void list_subscribers (StreamType &stream) const
 
void list_subscribers () const
 

Static Public Member Functions

static ::ExceptionBaseExcDifferentParallelPartitioning ()
 
static ::ExceptionBaseExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4)
 
static ::ExceptionBaseExcMissingIndexSet ()
 
static ::ExceptionBaseExcTrilinosError (int arg1)
 
static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)
 

Private Types

using map_value_type = decltype(counter_map)::value_type
 
using map_iterator = decltype(counter_map)::iterator
 

Private Member Functions

void create_tpetra_comm_pattern (const IndexSet &source_index_set, const MPI_Comm mpi_comm)
 
void check_no_subscribers () const noexcept
 

Private Attributes

bool compressed
 
bool has_ghost
 
Teuchos::RCP< VectorTypevector
 
Teuchos::RCP< VectorTypenonlocal_vector
 
::IndexSet source_stored_elements
 
Teuchos::RCP< const TpetraWrappers::CommunicationPatterntpetra_comm_pattern
 
std::atomic< unsigned intcounter
 
std::map< std::string, unsigned intcounter_map
 
std::vector< std::atomic< bool > * > validity_pointers
 
const std::type_info * object_info
 

Static Private Attributes

static std::mutex mutex
 

Friends

class internal::VectorReference< Number, MemorySpace >
 

Detailed Description

template<typename Number, typename MemorySpace = ::MemorySpace::Host>
class LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >

This class implements a wrapper to the Trilinos distributed vector class Tpetra::Vector. This class requires Trilinos to be compiled with MPI support.

Moreover, this class takes an optional template argument for the memory space used. By default, all memory is allocated on the CPU.

Definition at line 283 of file trilinos_tpetra_vector.h.

Member Typedef Documentation

◆ NodeType

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::NodeType = Tpetra::KokkosCompat::KokkosDeviceWrapperNode< typename MemorySpace::kokkos_space::execution_space, typename MemorySpace::kokkos_space>

Declare some of the standard types used in all containers.

Definition at line 290 of file trilinos_tpetra_vector.h.

◆ value_type

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::value_type = Number

Definition at line 298 of file trilinos_tpetra_vector.h.

◆ real_type

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::real_type = typename numbers::NumberTraits<Number>::real_type

Definition at line 299 of file trilinos_tpetra_vector.h.

◆ size_type

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::size_type = VectorTraits::size_type

Definition at line 300 of file trilinos_tpetra_vector.h.

◆ reference

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::reference = internal::VectorReference<Number, MemorySpace>

Definition at line 301 of file trilinos_tpetra_vector.h.

◆ const_reference

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::const_reference = const internal::VectorReference<Number, MemorySpace>

Definition at line 302 of file trilinos_tpetra_vector.h.

◆ MapType

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::MapType = Tpetra::Map<int, ::types::signed_global_dof_index, NodeType>

Definition at line 304 of file trilinos_tpetra_vector.h.

◆ VectorType

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::VectorType = Tpetra:: Vector<Number, int, ::types::signed_global_dof_index, NodeType>

Definition at line 306 of file trilinos_tpetra_vector.h.

◆ ExportType

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::ExportType = Tpetra::Export<int, ::types::signed_global_dof_index, NodeType>

Definition at line 308 of file trilinos_tpetra_vector.h.

◆ ImportType

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
using LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::ImportType = Tpetra::Import<int, ::types::signed_global_dof_index, NodeType>

Definition at line 310 of file trilinos_tpetra_vector.h.

◆ map_value_type

using Subscriptor::map_value_type = decltype(counter_map)::value_type
privateinherited

The data type used in counter_map.

Definition at line 229 of file subscriptor.h.

◆ map_iterator

using Subscriptor::map_iterator = decltype(counter_map)::iterator
privateinherited

The iterator type used in counter_map.

Definition at line 234 of file subscriptor.h.

Constructor & Destructor Documentation

◆ Vector() [1/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::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.

◆ Vector() [2/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::Vector ( const Vector< Number, MemorySpace > &  V)

Copy constructor. Sets the dimension and the partitioning to that of the given vector and copies all elements.

◆ Vector() [3/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::Vector ( const Teuchos::RCP< VectorType V)

Copy constructor from Teuchos::RCP<Tpetra::Vector>.

◆ Vector() [4/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::Vector ( const IndexSet parallel_partitioner,
const MPI_Comm  communicator 
)
explicit

TODO: This is not used 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.

◆ Vector() [5/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::Vector ( const IndexSet locally_owned_entries,
const IndexSet ghost_entries,
const MPI_Comm  communicator,
const bool  vector_writable = false 
)
explicit

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.

Depending on whether the locally_relevant_or_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

Member Function Documentation

◆ clear()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::clear ( )

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

◆ reinit() [1/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::reinit ( const IndexSet parallel_partitioner,
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) or left untouched (true).

◆ reinit() [2/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::reinit ( const IndexSet locally_owned_entries,
const IndexSet locally_relevant_or_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.

Depending on whether the locally_relevant_or_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

◆ reinit() [3/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::reinit ( const Vector< Number, MemorySpace > &  V,
const bool  omit_zeroing_entries = false 
)

Change the dimension to that of the vector V. The elements of V are not copied.

◆ swap()

template<typename Number , typename MemorySpace >
void Vector< Number, MemorySpace >::swap ( Vector< Number, MemorySpace > &  v)
inlinevirtual

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.

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.

This function is virtual in order to allow for derived classes to handle memory separately.

Definition at line 1113 of file trilinos_tpetra_vector.h.

◆ extract_subvector_to()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
virtual void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::extract_subvector_to ( const ArrayView< const types::global_dof_index > &  indices,
ArrayView< Number > &  elements 
) const
overridevirtual

Extract a range of elements all at once.

Implements ReadVector< Number >.

◆ operator=() [1/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator= ( const Vector< Number, MemorySpace > &  V)

Copy function. This function takes a Vector and copies all the elements. The Vector will have the same parallel distribution as V.

The semantics of this operator are complex. If the two vectors have the same size, and if either the left or right hand side vector of the assignment (i.e., either the input vector on the right hand side, or the calling vector to the left of the assignment operator) currently has ghost elements, then the left hand side vector will also have ghost values and will consequently be a read-only vector (see also the glossary entry on the issue). Otherwise, the left hand vector will be a writable vector after this operation. These semantics facilitate having a vector with ghost elements on the left hand side of the assignment, and a vector without ghost elements on the right hand side, with the resulting left hand side vector having the correct values in both its locally owned and its ghost elements.

On the other hand, if the left hand side vector does not have the correct size yet, or is perhaps an entirely uninitialized vector, then the assignment is simply a copy operation in the usual sense: In that case, if the right hand side has no ghost elements (i.e., is a completely distributed vector), then the left hand side will have no ghost elements either. And if the right hand side has ghost elements (and is consequently read-only), then the left hand side will have these same properties after the operation.

◆ operator=() [2/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
template<typename OtherNumber >
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator= ( const ::Vector< OtherNumber > &  V)

Copy function. This function takes a Vector and copies all the elements. The Vector will have the same parallel distribution as V.

◆ operator=() [3/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator= ( const Number  s)

Sets all elements of the vector to the scalar s. This operation is only allowed if s is equal to zero.

◆ import_elements() [1/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::import_elements ( const ReadWriteVector< Number > &  V,
VectorOperation::values  operation,
const Teuchos::RCP< const Utilities::MPI::CommunicationPatternBase > &  communication_pattern 
)

Imports all the elements present in the vector's IndexSet from the input vector V. VectorOperation::values operation is used to decide if the elements in V should be added to the current vector or replace the current elements. The last parameter can be used if the same communication pattern is used multiple times. This can be used to improve performance.

◆ import_elements() [2/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::import_elements ( const ReadWriteVector< Number > &  V,
VectorOperation::values  operation,
const std::shared_ptr< const Utilities::MPI::CommunicationPatternBase > &  communication_pattern 
)
Deprecated:
Use Teuchos::RCP<> instead of std::shared_ptr<>.

◆ import_elements() [3/3]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::import_elements ( const ReadWriteVector< Number > &  V,
VectorOperation::values  operation 
)

◆ import()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::import ( const ReadWriteVector< Number > &  V,
VectorOperation::values  operation,
std::shared_ptr< const Utilities::MPI::CommunicationPatternBase communication_pattern = {} 
)
inline
Deprecated:
Use import_elements() instead.

Definition at line 525 of file trilinos_tpetra_vector.h.

◆ operator()() [1/2]

template<typename Number , typename MemorySpace >
internal::VectorReference< Number, MemorySpace > Vector< Number, MemorySpace >::operator() ( const size_type  index)
inline

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.

Definition at line 1371 of file trilinos_tpetra_vector.h.

◆ operator()() [2/2]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Number LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::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.

◆ operator[]() [1/2]

template<typename Number , typename MemorySpace >
internal::VectorReference< Number, MemorySpace > Vector< Number, MemorySpace >::operator[] ( const size_type  index)
inline

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

Exactly the same as operator().

Definition at line 1378 of file trilinos_tpetra_vector.h.

◆ operator[]() [2/2]

template<typename Number , typename MemorySpace >
Number Vector< Number, MemorySpace >::operator[] ( const size_type  index) const
inline

Provide read-only access to an element.

Exactly the same as operator().

Definition at line 1385 of file trilinos_tpetra_vector.h.

◆ operator*=()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator*= ( const Number  factor)

Multiply the entire vector by a fixed factor.

◆ operator/=()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator/= ( const Number  factor)

Divide the entire vector by a fixed factor.

◆ operator+=()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator+= ( const Vector< Number, MemorySpace > &  V)

Add the vector V to the present one.

◆ operator-=()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Vector & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator-= ( const Vector< Number, MemorySpace > &  V)

Subtract the vector V from the present one.

◆ operator*()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Number LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator* ( const Vector< Number, MemorySpace > &  V) const

Return the scalar product of two vectors. The vectors need to have the same layout.

◆ add() [1/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::add ( const Number  a)

Add a to all components. Note that is a scalar not a vector.

◆ add() [2/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::add ( const Number  a,
const Vector< Number, MemorySpace > &  V 
)

Simple addition of a multiple of a vector, i.e. *this += a*V. The vectors need to have the same layout.

◆ add() [3/5]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::add ( const Number  a,
const Vector< Number, MemorySpace > &  V,
const Number  b,
const Vector< Number, MemorySpace > &  W 
)

Multiple addition of multiple of a vector, i.e. *this> += a*V+b*W. The vectors need to have the same layout.

◆ add() [4/5]

template<typename Number , typename MemorySpace >
void Vector< Number, MemorySpace >::add ( const std::vector< size_type > &  indices,
const std::vector< Number > &  values 
)
inline

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

Definition at line 1121 of file trilinos_tpetra_vector.h.

◆ add() [5/5]

template<typename Number , typename MemorySpace >
void Vector< Number, MemorySpace >::add ( const size_type  n_elements,
const size_type indices,
const Number *  values 
)
inline

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.

Definition at line 1135 of file trilinos_tpetra_vector.h.

◆ sadd()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::sadd ( const Number  s,
const Number  a,
const Vector< Number, MemorySpace > &  V 
)

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

◆ set()

template<typename Number , typename MemorySpace >
void Vector< Number, MemorySpace >::set ( const size_type  n_elements,
const size_type indices,
const Number *  values 
)
inline

A collective set operation: instead of setting individual elements of a vector, this function allows to set a whole set of elements at once. It is assumed that the elements to be set are located in contiguous memory.

Definition at line 1253 of file trilinos_tpetra_vector.h.

◆ scale()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::scale ( const Vector< Number, MemorySpace > &  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. The vectors need to have the same layout.

◆ equ()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::equ ( const Number  a,
const Vector< Number, MemorySpace > &  V 
)

Assignment *this = a*V.

◆ all_zero()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::all_zero ( ) const

Return whether the vector contains only elements with value zero.

◆ is_non_negative()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::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).

◆ mean_value()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Number LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::mean_value ( ) const

Return the mean value of the element of this vector.

◆ l1_norm()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
real_type LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::l1_norm ( ) const

Return the l1 norm of the vector (i.e., the sum of the absolute values of all entries among all processors).

◆ l2_norm()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
real_type LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::l2_norm ( ) const

Return the l2 norm of the vector (i.e., the square root of the sum of the square of all entries among all processors).

◆ linfty_norm()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
real_type LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::linfty_norm ( ) const

Return the maximum norm of the vector (i.e., the maximum absolute value among all entries and among all processors).

◆ norm_sqr()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
real_type LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::norm_sqr ( ) const

Return the square of the l2-norm.

◆ add_and_dot()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Number LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::add_and_dot ( const Number  a,
const Vector< Number, MemorySpace > &  V,
const Vector< Number, MemorySpace > &  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;

The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).

The vectors need to have the same layout.

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}\).

◆ has_ghost_elements()

template<typename Number , typename MemorySpace >
bool Vector< Number, MemorySpace >::has_ghost_elements ( ) const
inline

Return whether the vector has ghost elements or not.

Definition at line 1097 of file trilinos_tpetra_vector.h.

◆ operator==()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator== ( const Vector< Number, MemorySpace > &  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.

◆ operator!=()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::operator!= ( const Vector< Number, MemorySpace > &  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.

◆ size()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
virtual size_type LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::size ( ) const
overridevirtual

Return the global size of the vector, equal to the sum of the number of locally owned indices among all processors.

Implements ReadVector< Number >.

◆ locally_owned_size()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
size_type LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::locally_owned_size ( ) const

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

◆ local_range()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
std::pair< size_type, size_type > LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::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 is the number of elements stored on this processor and 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()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::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().

◆ is_compressed()

template<typename Number , typename MemorySpace >
bool Vector< Number, MemorySpace >::is_compressed ( ) const
inline

Return the state of the vector, i.e., whether compress() needs to be called after an operation requiring data exchange. A call to compress() is also needed when the method set() or add() has been called.

Definition at line 1106 of file trilinos_tpetra_vector.h.

◆ get_mpi_communicator()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
MPI_Comm LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::get_mpi_communicator ( ) const

Return the underlying MPI communicator.

◆ locally_owned_elements()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
::IndexSet LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::locally_owned_elements ( ) const

Return an index set that describes which elements of this vector are owned by the current 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:1193

◆ compress()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::compress ( const 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.

Parameters
operationThe 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.

◆ trilinos_vector() [1/2]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
const Tpetra::Vector< Number, int, types::signed_global_dof_index > & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::trilinos_vector ( ) const

Return a const reference to the underlying Trilinos Tpetra::Vector class.

◆ trilinos_vector() [2/2]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Tpetra::Vector< Number, int, types::signed_global_dof_index > & LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::trilinos_vector ( )

Return a (modifiable) reference to the underlying Trilinos Tpetra::Vector class.

◆ trilinos_rcp() [1/2]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Teuchos::RCP< const Tpetra::Vector< Number, int, types::signed_global_dof_index > > LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::trilinos_rcp ( ) const

Return a const Teuchos::RCP to the underlying Trilinos Tpetra::Vector class.

◆ trilinos_rcp() [2/2]

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Teuchos::RCP< Tpetra::Vector< Number, int, types::signed_global_dof_index > > LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::trilinos_rcp ( )

Return a (modifiable) Teuchos::RCP to the underlying Trilinos Tpetra::Vector class.

◆ print()

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

Prints the vector to the output stream out.

◆ memory_consumption()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
std::size_t LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::memory_consumption ( ) const

Return the memory consumption of this class in bytes.

◆ mpi_comm()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
MPI_Comm LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::mpi_comm ( ) const

Return the mpi communicator

◆ create_tpetra_comm_pattern()

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
void LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::create_tpetra_comm_pattern ( const IndexSet source_index_set,
const MPI_Comm  mpi_comm 
)
private

Create the CommunicationPattern for the communication between the IndexSet source_index_set and the current vector based on the communicator mpi_comm.

◆ subscribe()

void Subscriptor::subscribe ( std::atomic< bool > *const  validity,
const std::string &  identifier = "" 
) const
inherited

Subscribes a user of the object by storing the pointer validity. The subscriber may be identified by text supplied as identifier.

Definition at line 135 of file subscriptor.cc.

◆ unsubscribe()

void Subscriptor::unsubscribe ( std::atomic< bool > *const  validity,
const std::string &  identifier = "" 
) const
inherited

Unsubscribes a user from the object.

Note
The identifier and the validity pointer must be the same as the one supplied to subscribe().

Definition at line 155 of file subscriptor.cc.

◆ n_subscriptions()

unsigned int Subscriptor::n_subscriptions ( ) const
inlineinherited

Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.

Definition at line 300 of file subscriptor.h.

◆ list_subscribers() [1/2]

template<typename StreamType >
void Subscriptor::list_subscribers ( StreamType &  stream) const
inlineinherited

List the subscribers to the input stream.

Definition at line 317 of file subscriptor.h.

◆ list_subscribers() [2/2]

void Subscriptor::list_subscribers ( ) const
inherited

List the subscribers to deallog.

Definition at line 203 of file subscriptor.cc.

◆ serialize()

template<class Archive >
void Subscriptor::serialize ( Archive &  ar,
const unsigned int  version 
)
inlineinherited

Read or write the data of this object to or from a stream for the purpose of serialization using the BOOST serialization library.

This function does not actually serialize any of the member variables of this class. The reason is that what this class stores is only who subscribes to this object, but who does so at the time of storing the contents of this object does not necessarily have anything to do with who subscribes to the object when it is restored. Consequently, we do not want to overwrite the subscribers at the time of restoring, and then there is no reason to write the subscribers out in the first place.

Definition at line 309 of file subscriptor.h.

◆ check_no_subscribers()

void Subscriptor::check_no_subscribers ( ) const
privatenoexceptinherited

Check that there are no objects subscribing to this object. If this check passes then it is safe to destroy the current object. It this check fails then this function will either abort or print an error message to deallog (by using the AssertNothrow mechanism), but will not throw an exception.

Note
Since this function is just a consistency check it does nothing in release mode.
If this function is called when there is an uncaught exception then, rather than aborting, this function prints an error message to the standard error stream and returns.

Definition at line 52 of file subscriptor.cc.

Friends And Related Symbol Documentation

◆ internal::VectorReference< Number, MemorySpace >

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
friend class internal::VectorReference< Number, MemorySpace >
friend

Definition at line 1078 of file trilinos_tpetra_vector.h.

Member Data Documentation

◆ compressed

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::compressed
private

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

Definition at line 1044 of file trilinos_tpetra_vector.h.

◆ has_ghost

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
bool LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::has_ghost
private

Store whether the vector has ghost elements or not.

If the vector has no ghost elements, it can only access and modify entries included in the locally owned index set. And if the vector has ghost elements it can access and modify entries included in the locally relevant index set.

Definition at line 1054 of file trilinos_tpetra_vector.h.

◆ vector

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Teuchos::RCP<VectorType> LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::vector
private

Teuchos::RCP to the actual Tpetra vector object.

Definition at line 1059 of file trilinos_tpetra_vector.h.

◆ nonlocal_vector

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Teuchos::RCP<VectorType> LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::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 1066 of file trilinos_tpetra_vector.h.

◆ source_stored_elements

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
::IndexSet LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::source_stored_elements
private

IndexSet of the elements of the last imported vector.

Definition at line 1071 of file trilinos_tpetra_vector.h.

◆ tpetra_comm_pattern

template<typename Number , typename MemorySpace = ::MemorySpace::Host>
Teuchos::RCP<const TpetraWrappers::CommunicationPattern> LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace >::tpetra_comm_pattern
private

CommunicationPattern for the communication between the source_stored_elements IndexSet and the current vector.

Definition at line 1078 of file trilinos_tpetra_vector.h.

◆ counter

std::atomic<unsigned int> Subscriptor::counter
mutableprivateinherited

Store the number of objects which subscribed to this object. Initially, this number is zero, and upon destruction it shall be zero again (i.e. all objects which subscribed should have unsubscribed again).

The creator (and owner) of an object is counted in the map below if HE manages to supply identification.

We use the mutable keyword in order to allow subscription to constant objects also.

This counter may be read from and written to concurrently in multithreaded code: hence we use the std::atomic class template.

Definition at line 218 of file subscriptor.h.

◆ counter_map

std::map<std::string, unsigned int> Subscriptor::counter_map
mutableprivateinherited

In this map, we count subscriptions for each different identification string supplied to subscribe().

Definition at line 224 of file subscriptor.h.

◆ validity_pointers

std::vector<std::atomic<bool> *> Subscriptor::validity_pointers
mutableprivateinherited

In this vector, we store pointers to the validity bool in the SmartPointer objects that subscribe to this class.

Definition at line 240 of file subscriptor.h.

◆ object_info

const std::type_info* Subscriptor::object_info
mutableprivateinherited

Pointer to the typeinfo object of this object, from which we can later deduce the class name. Since this information on the derived class is neither available in the destructor, nor in the constructor, we obtain it in between and store it here.

Definition at line 248 of file subscriptor.h.

◆ mutex

std::mutex Subscriptor::mutex
staticprivateinherited

A mutex used to ensure data consistency when accessing the mutable members of this class. This lock is used in the subscribe() and unsubscribe() functions, as well as in list_subscribers().

Definition at line 271 of file subscriptor.h.


The documentation for this class was generated from the following files: