Reference documentation for deal.II version 9.1.1

#include <deal.II/lac/trilinos_sparsity_pattern.h>
Public Types  
using  size_type = ::types::global_dof_index 
using  const_iterator = SparsityPatternIterators::Iterator 
Public Member Functions  
Basic constructors and initialization  
SparsityPattern ()  
SparsityPattern (const size_type m, const size_type n, const size_type n_entries_per_row=0)  
SparsityPattern (const size_type m, const size_type n, const std::vector< size_type > &n_entries_per_row)  
SparsityPattern (SparsityPattern &&other) noexcept  
SparsityPattern (const SparsityPattern &input_sparsity_pattern)  
virtual  ~SparsityPattern () override=default 
void  reinit (const size_type m, const size_type n, const size_type n_entries_per_row=0) 
void  reinit (const size_type m, const size_type n, const std::vector< size_type > &n_entries_per_row) 
void  copy_from (const SparsityPattern &input_sparsity_pattern) 
template<typename SparsityPatternType >  
void  copy_from (const SparsityPatternType &nontrilinos_sparsity_pattern) 
SparsityPattern &  operator= (const SparsityPattern &input_sparsity_pattern) 
void  clear () 
void  compress () 
Constructors and initialization using an Epetra_Map description  
SparsityPattern (const Epetra_Map ¶llel_partitioning, const size_type n_entries_per_row=0)  
SparsityPattern (const Epetra_Map ¶llel_partitioning, const std::vector< size_type > &n_entries_per_row)  
SparsityPattern (const Epetra_Map &row_parallel_partitioning, const Epetra_Map &col_parallel_partitioning, const size_type n_entries_per_row=0)  
SparsityPattern (const Epetra_Map &row_parallel_partitioning, const Epetra_Map &col_parallel_partitioning, const std::vector< size_type > &n_entries_per_row)  
void  reinit (const Epetra_Map ¶llel_partitioning, const size_type n_entries_per_row=0) 
void  reinit (const Epetra_Map ¶llel_partitioning, const std::vector< size_type > &n_entries_per_row) 
void  reinit (const Epetra_Map &row_parallel_partitioning, const Epetra_Map &col_parallel_partitioning, const size_type n_entries_per_row=0) 
void  reinit (const Epetra_Map &row_parallel_partitioning, const Epetra_Map &col_parallel_partitioning, const std::vector< size_type > &n_entries_per_row) 
template<typename SparsityPatternType >  
void  reinit (const Epetra_Map &row_parallel_partitioning, const Epetra_Map &col_parallel_partitioning, const SparsityPatternType &nontrilinos_sparsity_pattern, const bool exchange_data=false) 
template<typename SparsityPatternType >  
void  reinit (const Epetra_Map ¶llel_partitioning, const SparsityPatternType &nontrilinos_sparsity_pattern, const bool exchange_data=false) 
Constructors and initialization using an IndexSet description  
SparsityPattern (const IndexSet ¶llel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD, const size_type n_entries_per_row=0)  
SparsityPattern (const IndexSet ¶llel_partitioning, const MPI_Comm &communicator, const std::vector< size_type > &n_entries_per_row)  
SparsityPattern (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD, const size_type n_entries_per_row=0)  
SparsityPattern (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const MPI_Comm &communicator, const std::vector< size_type > &n_entries_per_row)  
SparsityPattern (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const IndexSet &writable_rows, const MPI_Comm &communicator=MPI_COMM_WORLD, const size_type n_entries_per_row=0)  
void  reinit (const IndexSet ¶llel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD, const size_type n_entries_per_row=0) 
void  reinit (const IndexSet ¶llel_partitioning, const MPI_Comm &communicator, const std::vector< size_type > &n_entries_per_row) 
void  reinit (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const MPI_Comm &communicator=MPI_COMM_WORLD, const size_type n_entries_per_row=0) 
void  reinit (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const IndexSet &writeable_rows, const MPI_Comm &communicator=MPI_COMM_WORLD, const size_type n_entries_per_row=0) 
void  reinit (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const MPI_Comm &communicator, const std::vector< size_type > &n_entries_per_row) 
template<typename SparsityPatternType >  
void  reinit (const IndexSet &row_parallel_partitioning, const IndexSet &col_parallel_partitioning, const SparsityPatternType &nontrilinos_sparsity_pattern, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool exchange_data=false) 
template<typename SparsityPatternType >  
void  reinit (const IndexSet ¶llel_partitioning, const SparsityPatternType &nontrilinos_sparsity_pattern, const MPI_Comm &communicator=MPI_COMM_WORLD, const bool exchange_data=false) 
Information on the sparsity pattern  
bool  is_compressed () const 
unsigned int  max_entries_per_row () const 
size_type  n_rows () const 
size_type  n_cols () const 
unsigned int  local_size () const 
std::pair< size_type, size_type >  local_range () const 
bool  in_local_range (const size_type index) const 
size_type  n_nonzero_elements () const 
size_type  row_length (const size_type row) const 
size_type  bandwidth () const 
bool  empty () const 
bool  exists (const size_type i, const size_type j) const 
bool  row_is_stored_locally (const size_type i) const 
std::size_t  memory_consumption () const 
Adding entries  
void  add (const size_type i, const size_type j) 
template<typename ForwardIterator >  
void  add_entries (const size_type row, ForwardIterator begin, ForwardIterator end, const bool indices_are_sorted=false) 
Access of underlying Trilinos data  
const Epetra_FECrsGraph &  trilinos_sparsity_pattern () const 
const Epetra_Map &  domain_partitioner () const 
const Epetra_Map &  range_partitioner () const 
const Epetra_Map &  row_partitioner () const 
const Epetra_Map &  col_partitioner () const 
const Epetra_Comm &  trilinos_communicator () const 
MPI_Comm  get_mpi_communicator () const 
Partitioners  
IndexSet  locally_owned_domain_indices () const 
IndexSet  locally_owned_range_indices () const 
Iterators  
const_iterator  begin () const 
const_iterator  end () const 
const_iterator  begin (const size_type r) const 
const_iterator  end (const size_type r) const 
Input/Output  
void  write_ascii () 
void  print (std::ostream &out, const bool write_extended_trilinos_info=false) const 
void  print_gnuplot (std::ostream &out) const 
Public Member Functions inherited from Subscriptor  
Subscriptor ()  
Subscriptor (const Subscriptor &)  
Subscriptor (Subscriptor &&) noexcept  
virtual  ~Subscriptor () 
Subscriptor &  operator= (const Subscriptor &) 
Subscriptor &  operator= (Subscriptor &&) noexcept 
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 
template<class Archive >  
void  serialize (Archive &ar, const unsigned int version) 
Static Public Member Functions  
static ::ExceptionBase &  ExcTrilinosError (int arg1) 
static ::ExceptionBase &  ExcInvalidIndex (size_type arg1, size_type arg2) 
static ::ExceptionBase &  ExcSourceEqualsDestination () 
static ::ExceptionBase &  ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4) 
static ::ExceptionBase &  ExcAccessToNonPresentElement (size_type arg1, size_type arg2) 
Static Public Member Functions inherited from Subscriptor  
static ::ExceptionBase &  ExcInUse (int arg1, std::string arg2, std::string arg3) 
static ::ExceptionBase &  ExcNoSubscriber (std::string arg1, std::string arg2) 
Private Attributes  
std::unique_ptr< Epetra_Map >  column_space_map 
std::unique_ptr< Epetra_FECrsGraph >  graph 
std::unique_ptr< Epetra_CrsGraph >  nonlocal_graph 
Friends  
class  TrilinosWrappers::SparseMatrix 
class  SparsityPatternIterators::Accessor 
class  SparsityPatternIterators::Iterator 
This class implements a wrapper class to use the Trilinos distributed sparsity pattern class Epetra_FECrsGraph. This class is designed to be used for construction of parallel Trilinos matrices. The functionality of this class is modeled after the existing sparsity pattern classes, with the difference that this class can work fully in parallel according to a partitioning of the sparsity pattern rows.
This class has many similarities to the DynamicSparsityPattern, since it can dynamically add elements to the pattern without any memory being previously reserved for it. However, it also has a method SparsityPattern::compress(), that finalizes the pattern and enables its use with Trilinos sparse matrices.
Definition at line 275 of file trilinos_sparsity_pattern.h.
Declare type for container size.
Definition at line 281 of file trilinos_sparsity_pattern.h.
Declare an alias for the iterator class.
Definition at line 286 of file trilinos_sparsity_pattern.h.
SparsityPattern::SparsityPattern  (  ) 
Default constructor. Generates an empty (zerosize) sparsity pattern.
Definition at line 84 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const size_type  m, 
const size_type  n,  
const size_type  n_entries_per_row = 0 

) 
Generate a sparsity pattern that is completely stored locally, having \(m\) rows and \(n\) columns. The resulting matrix will be completely stored locally, too.
It is possible to specify the number of columns entries per row using the optional n_entries_per_row
argument. However, this value does not need to be accurate or even given at all, since one does usually not have this kind of information before building the sparsity pattern (the usual case when the function DoFTools::make_sparsity_pattern() is called). The entries are allocated dynamically in a similar manner as for the deal.II DynamicSparsityPattern classes. However, a good estimate will reduce the setup time of the sparsity pattern.
Definition at line 134 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const size_type  m, 
const size_type  n,  
const std::vector< size_type > &  n_entries_per_row  
) 
Generate a sparsity pattern that is completely stored locally, having \(m\) rows and \(n\) columns. The resulting matrix will be completely stored locally, too.
The vector n_entries_per_row
specifies the number of entries in each row (an information usually not available, though).
Definition at line 143 of file trilinos_sparsity_pattern.cc.

noexcept 
Move constructor. Create a new sparse matrix by stealing the internal data.
Definition at line 153 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const SparsityPattern &  input_sparsity_pattern  ) 
Copy constructor. Sets the calling sparsity pattern to be the same as the input sparsity pattern.
Definition at line 164 of file trilinos_sparsity_pattern.cc.

overridevirtualdefault 
Destructor. Made virtual so that one can use pointers to this class.
SparsityPattern::SparsityPattern  (  const Epetra_Map &  parallel_partitioning, 
const size_type  n_entries_per_row = 0 

) 
Constructor for a square sparsity pattern using an Epetra_map for the description of the parallel partitioning. Moreover, the number of nonzero entries in the rows of the sparsity pattern can be specified. Note that this number does not need to be exact, and it is allowed that the actual sparsity structure has more nonzero entries than specified in the constructor (the usual case when the function DoFTools::make_sparsity_pattern() is called). However it is still advantageous to provide good estimates here since a good value will avoid repeated allocation of memory, which considerably increases the performance when creating the sparsity pattern.
Definition at line 98 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const Epetra_Map &  parallel_partitioning, 
const std::vector< size_type > &  n_entries_per_row  
) 
Same as before, but now use the exact number of nonzeros in each m row. Since we know the number of elements in the sparsity pattern exactly in this case, we can already allocate the right amount of memory, which makes the creation process by the respective SparsityPattern::reinit call considerably faster. However, this is a rather unusual situation, since knowing the number of entries in each row is usually connected to knowing the indices of nonzero entries, which the sparsity pattern is designed to describe.
Definition at line 106 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const Epetra_Map &  row_parallel_partitioning, 
const Epetra_Map &  col_parallel_partitioning,  
const size_type  n_entries_per_row = 0 

) 
This constructor is similar to the one above, but it now takes two different Epetra maps for rows and columns. This interface is meant to be used for generating rectangular sparsity pattern, where one map describes the parallel partitioning of the dofs associated with the sparsity pattern rows and the other one of the sparsity pattern columns. Note that there is no real parallelism along the columns – the processor that owns a certain row always owns all the column elements, no matter how far they might be spread out. The second Epetra_Map is only used to specify the number of columns and for specifying the correct domain space when performing matrixvector products with vectors based on the same column map.
The number of columns entries per row is specified as the maximum number of entries argument.
Definition at line 115 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const Epetra_Map &  row_parallel_partitioning, 
const Epetra_Map &  col_parallel_partitioning,  
const std::vector< size_type > &  n_entries_per_row  
) 
This constructor is similar to the one above, but it now takes two different Epetra maps for rows and columns. This interface is meant to be used for generating rectangular matrices, where one map specifies the parallel distribution of rows and the second one specifies the distribution of degrees of freedom associated with matrix columns. This second map is however not used for the distribution of the columns themselves – rather, all column elements of a row are stored on the same processor. The vector n_entries_per_row
specifies the number of entries in each row of the newly generated matrix.
Definition at line 124 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const IndexSet &  parallel_partitioning, 
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const size_type  n_entries_per_row = 0 

) 
Constructor for a square sparsity pattern using an IndexSet and an MPI communicator for the description of the parallel partitioning. Moreover, the number of nonzero entries in the rows of the sparsity pattern can be specified. Note that this number does not need to be exact, and it is even allowed that the actual sparsity structure has more nonzero entries than specified in the constructor. However it is still advantageous to provide good estimates here since a good value will avoid repeated allocation of memory, which considerably increases the performance when creating the sparsity pattern.
Definition at line 180 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const IndexSet &  parallel_partitioning, 
const MPI_Comm &  communicator,  
const std::vector< size_type > &  n_entries_per_row  
) 
Same as before, but now use the exact number of nonzeros in each m row. Since we know the number of elements in the sparsity pattern exactly in this case, we can already allocate the right amount of memory, which makes the creation process by the respective SparsityPattern::reinit call considerably faster. However, this is a rather unusual situation, since knowing the number of entries in each row is usually connected to knowing the indices of nonzero entries, which the sparsity pattern is designed to describe.
Definition at line 192 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const size_type  n_entries_per_row = 0 

) 
This constructor is similar to the one above, but it now takes two different index sets to describe the parallel partitioning of rows and columns. This interface is meant to be used for generating rectangular sparsity pattern. Note that there is no real parallelism along the columns – the processor that owns a certain row always owns all the column elements, no matter how far they might be spread out. The second Epetra_Map is only used to specify the number of columns and for internal arrangements when doing matrixvector products with vectors based on that column map.
The number of columns entries per row is specified as the maximum number of entries argument.
Definition at line 205 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const MPI_Comm &  communicator,  
const std::vector< size_type > &  n_entries_per_row  
) 
This constructor is similar to the one above, but it now takes two different index sets for rows and columns. This interface is meant to be used for generating rectangular matrices, where one map specifies the parallel distribution of rows and the second one specifies the distribution of degrees of freedom associated with matrix columns. This second map is however not used for the distribution of the columns themselves – rather, all column elements of a row are stored on the same processor. The vector n_entries_per_row
specifies the number of entries in each row of the newly generated matrix.
Definition at line 218 of file trilinos_sparsity_pattern.cc.
SparsityPattern::SparsityPattern  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const IndexSet &  writable_rows,  
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const size_type  n_entries_per_row = 0 

) 
This constructor constructs general sparsity patterns, possible non square ones. Constructing a sparsity pattern this way allows the user to explicitly specify the rows into which we are going to add elements. This set is required to be a superset of the first index set row_parallel_partitioning
that includes also rows that are owned by another processor (ghost rows). Note that elements can only be added to rows specified by writable_rows
.
This method is beneficial when the rows to which a processor is going to write can be determined before actually inserting elements into the matrix. For the typical parallel::distributed::Triangulation class used in deal.II, we know that a processor only will add row elements for what we call the locally relevant dofs (see DoFTools::extract_locally_relevant_dofs). The other constructors methods use general Trilinos facilities that allow to add elements to arbitrary rows (as done by all the other reinit functions). However, this flexibility come at a cost, the most prominent being that adding elements into the same matrix from multiple threads in shared memory is not safe whenever MPI is used. For these settings, the current method is the one to choose: It will store the offprocessor data as an additional sparsity pattern (that is then passed to the Trilinos matrix via the reinit method) which can be organized in such a way that threadsafety can be ensured (as long as the user makes sure to never write into the same matrix row simultaneously, of course).
Definition at line 232 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const size_type  m, 
const size_type  n,  
const size_type  n_entries_per_row = 0 

) 
Initialize a sparsity pattern that is completely stored locally, having \(m\) rows and \(n\) columns. The resulting matrix will be completely stored locally.
The number of columns entries per row is specified as the maximum number of entries argument. This does not need to be an accurate number since the entries are allocated dynamically in a similar manner as for the deal.II DynamicSparsityPattern classes, but a good estimate will reduce the setup time of the sparsity pattern.
Definition at line 248 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const size_type  m, 
const size_type  n,  
const std::vector< size_type > &  n_entries_per_row  
) 
Initialize a sparsity pattern that is completely stored locally, having \(m\) rows and \(n\) columns. The resulting matrix will be completely stored locally.
The vector n_entries_per_row
specifies the number of entries in each row.
Definition at line 261 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::copy_from  (  const SparsityPattern &  input_sparsity_pattern  ) 
Copy function. Sets the calling sparsity pattern to be the same as the input sparsity pattern.
Definition at line 734 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::copy_from  (  const SparsityPatternType &  nontrilinos_sparsity_pattern  ) 
Copy function from one of the deal.II sparsity patterns. If used in parallel, this function uses an adhoc partitioning of the rows and columns.
Definition at line 750 of file trilinos_sparsity_pattern.cc.
SparsityPattern & SparsityPattern::operator=  (  const SparsityPattern &  input_sparsity_pattern  ) 
Copy operator. This operation is only allowed for empty objects, to avoid potentially very costly operations automatically synthesized by the compiler. Use copy_from() instead if you know that you really want to copy a sparsity pattern with nontrivial content.
Definition at line 725 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::clear  (  ) 
Release all memory and return to a state just like after having called the default constructor.
This is a collective operation that needs to be called on all processors in order to avoid a dead lock.
Definition at line 766 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::compress  (  ) 
In analogy to our own SparsityPattern class, this function compresses the sparsity pattern and allows the resulting pattern to be used for actually generating a (Trilinosbased) matrix. This function also exchanges nonlocal data that might have accumulated during the addition of new elements. This function must therefore be called once the structure is fixed. This is a collective operation, i.e., it needs to be run on all processors when used in parallel.
Definition at line 787 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const Epetra_Map &  parallel_partitioning, 
const size_type  n_entries_per_row = 0 

) 
Reinitialization function for generating a square sparsity pattern using an Epetra_Map for the description of the parallel partitioning and the number of nonzero entries in the rows of the sparsity pattern. Note that this number does not need to be exact, and it is even allowed that the actual sparsity structure has more nonzero entries than specified in the constructor. However it is still advantageous to provide good estimates here since this will considerably increase the performance when creating the sparsity pattern.
This function does not create any entries by itself, but provides the correct data structures that can be used by the respective add() function.
Definition at line 476 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const Epetra_Map &  parallel_partitioning, 
const std::vector< size_type > &  n_entries_per_row  
) 
Same as before, but now use the exact number of nonzeros in each m row. Since we know the number of elements in the sparsity pattern exactly in this case, we can already allocate the right amount of memory, which makes process of adding entries to the sparsity pattern considerably faster. However, this is a rather unusual situation, since knowing the number of entries in each row is usually connected to knowing the indices of nonzero entries, which the sparsity pattern is designed to describe.
Definition at line 505 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const Epetra_Map &  row_parallel_partitioning, 
const Epetra_Map &  col_parallel_partitioning,  
const size_type  n_entries_per_row = 0 

) 
This reinit function is similar to the one above, but it now takes two different Epetra maps for rows and columns. This interface is meant to be used for generating rectangular sparsity pattern, where one map describes the parallel partitioning of the dofs associated with the sparsity pattern rows and the other one of the sparsity pattern columns. Note that there is no real parallelism along the columns – the processor that owns a certain row always owns all the column elements, no matter how far they might be spread out. The second Epetra_Map is only used to specify the number of columns and for internal arrangements when doing matrixvector products with vectors based on that column map.
The number of columns entries per row is specified by the argument n_entries_per_row
.
Definition at line 490 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const Epetra_Map &  row_parallel_partitioning, 
const Epetra_Map &  col_parallel_partitioning,  
const std::vector< size_type > &  n_entries_per_row  
) 
This reinit function is similar to the one above, but it now takes two different Epetra maps for rows and columns. This interface is meant to be used for generating rectangular matrices, where one map specifies the parallel distribution of rows and the second one specifies the distribution of degrees of freedom associated with matrix columns. This second map is however not used for the distribution of the columns themselves – rather, all column elements of a row are stored on the same processor. The vector n_entries_per_row
specifies the number of entries in each row of the newly generated matrix.
Definition at line 519 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const Epetra_Map &  row_parallel_partitioning, 
const Epetra_Map &  col_parallel_partitioning,  
const SparsityPatternType &  nontrilinos_sparsity_pattern,  
const bool  exchange_data = false 

) 
Reinit function. Takes one of the deal.II sparsity patterns and a parallel partitioning of the rows and columns for initializing the current Trilinos sparsity pattern. The optional argument exchange_data
can be used for reinitialization with a sparsity pattern that is not fully constructed. This feature is only implemented for input sparsity patterns of type DynamicSparsityPattern.
Definition at line 707 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const Epetra_Map &  parallel_partitioning, 
const SparsityPatternType &  nontrilinos_sparsity_pattern,  
const bool  exchange_data = false 

) 
Reinit function. Takes one of the deal.II sparsity patterns and a parallel partitioning of the rows and columns for initializing the current Trilinos sparsity pattern. The optional argument exchange_data
can be used for reinitialization with a sparsity pattern that is not fully constructed. This feature is only implemented for input sparsity patterns of type DynamicSparsityPattern.
Definition at line 690 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  parallel_partitioning, 
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const size_type  n_entries_per_row = 0 

) 
Reinitialization function for generating a square sparsity pattern using an IndexSet and an MPI communicator for the description of the parallel partitioning and the number of nonzero entries in the rows of the sparsity pattern. Note that this number does not need to be exact, and it is even allowed that the actual sparsity structure has more nonzero entries than specified in the constructor. However it is still advantageous to provide good estimates here since this will considerably increase the performance when creating the sparsity pattern.
This function does not create any entries by itself, but provides the correct data structures that can be used by the respective add() function.
Definition at line 534 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  parallel_partitioning, 
const MPI_Comm &  communicator,  
const std::vector< size_type > &  n_entries_per_row  
) 
Same as before, but now use the exact number of nonzeros in each m row. Since we know the number of elements in the sparsity pattern exactly in this case, we can already allocate the right amount of memory, which makes process of adding entries to the sparsity pattern considerably faster. However, this is a rather unusual situation, since knowing the number of entries in each row is usually connected to knowing the indices of nonzero entries, which the sparsity pattern is designed to describe.
Definition at line 547 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const size_type  n_entries_per_row = 0 

) 
This reinit function is similar to the one above, but it now takes two different index sets for rows and columns. This interface is meant to be used for generating rectangular sparsity pattern, where one index set describes the parallel partitioning of the dofs associated with the sparsity pattern rows and the other one of the sparsity pattern columns. Note that there is no real parallelism along the columns – the processor that owns a certain row always owns all the column elements, no matter how far they might be spread out. The second IndexSet is only used to specify the number of columns and for internal arrangements when doing matrixvector products with vectors based on an EpetraMap based on that IndexSet.
The number of columns entries per row is specified by the argument n_entries_per_row
.
Definition at line 560 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const IndexSet &  writeable_rows,  
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const size_type  n_entries_per_row = 0 

) 
This reinit function is used to specify general matrices, possibly non square ones. In addition to the arguments of the other reinit method above, it allows the user to explicitly specify the rows into which we are going to add elements. This set is a superset of the first index set row_parallel_partitioning
that includes also rows that are owned by another processor (ghost rows).
This method is beneficial when the rows to which a processor is going to write can be determined before actually inserting elements into the matrix. For the typical parallel::distributed::Triangulation class used in deal.II, we know that a processor only will add row elements for what we call the locally relevant dofs (see DoFTools::extract_locally_relevant_dofs). Trilinos matrices allow to add elements to arbitrary rows (as done by all the other reinit functions) and this is what all the other reinit methods do, too. However, this flexibility come at a cost, the most prominent being that adding elements into the same matrix from multiple threads in shared memory is not safe whenever MPI is used. For these settings, the current method is the one to choose: It will store the offprocessor data as an additional sparsity pattern (that is then passed to the Trilinos matrix via the reinit method) which can be organized in such a way that threadsafety can be ensured (as long as the user makes sure to never write into the same matrix row simultaneously, of course).
Definition at line 600 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const MPI_Comm &  communicator,  
const std::vector< size_type > &  n_entries_per_row  
) 
Same as before, but now using a vector n_entries_per_row
for specifying the number of entries in each row of the sparsity pattern.
Definition at line 580 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  row_parallel_partitioning, 
const IndexSet &  col_parallel_partitioning,  
const SparsityPatternType &  nontrilinos_sparsity_pattern,  
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const bool  exchange_data = false 

) 
Reinit function. Takes one of the deal.II sparsity patterns and the parallel partitioning of the rows and columns specified by two index sets and a parallel communicator for initializing the current Trilinos sparsity pattern. The optional argument exchange_data
can be used for reinitialization with a sparsity pattern that is not fully constructed. This feature is only implemented for input sparsity patterns of type DynamicSparsityPattern.
Definition at line 645 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::reinit  (  const IndexSet &  parallel_partitioning, 
const SparsityPatternType &  nontrilinos_sparsity_pattern,  
const MPI_Comm &  communicator = MPI_COMM_WORLD , 

const bool  exchange_data = false 

) 
Reinit function. Takes one of the deal.II sparsity patterns and a parallel partitioning of the rows and columns for initializing the current Trilinos sparsity pattern. The optional argument exchange_data
can be used for reinitialization with a sparsity pattern that is not fully constructed. This feature is only implemented for input sparsity patterns of type DynamicSparsityPattern.
Definition at line 669 of file trilinos_sparsity_pattern.cc.
bool TrilinosWrappers::SparsityPattern::is_compressed  (  )  const 
Return the state of the sparsity pattern, i.e., whether compress() needs to be called after an operation requiring data exchange.
unsigned int SparsityPattern::max_entries_per_row  (  )  const 
Return the maximum number of entries per row on the current processor.
Definition at line 1017 of file trilinos_sparsity_pattern.cc.
SparsityPattern::size_type SparsityPattern::n_rows  (  )  const 
Return the number of rows in this sparsity pattern.
Definition at line 962 of file trilinos_sparsity_pattern.cc.
SparsityPattern::size_type SparsityPattern::n_cols  (  )  const 
Return the number of columns in this sparsity pattern.
Definition at line 971 of file trilinos_sparsity_pattern.cc.
unsigned int SparsityPattern::local_size  (  )  const 
Return the local dimension of the sparsity pattern, i.e. the number of rows stored on the present MPI process. In the sequential case, this number is the same as n_rows(), but for parallel matrices it may be smaller.
To figure out which elements exactly are stored locally, use local_range().
Definition at line 985 of file trilinos_sparsity_pattern.cc.
std::pair< SparsityPattern::size_type, SparsityPattern::size_type > SparsityPattern::local_range  (  )  const 
Return a pair of indices indicating which rows of this sparsity pattern are stored locally. The first number is the index of the first row stored, the second the index of the one past the last one that is stored locally. If this is a sequential matrix, then the result will be the pair (0,n_rows()), otherwise it will be a pair (i,i+n), where n=local_size()
.
Definition at line 995 of file trilinos_sparsity_pattern.cc.
bool TrilinosWrappers::SparsityPattern::in_local_range  (  const size_type  index  )  const 
Return whether index
is in the local range or not, see also local_range().
SparsityPattern::size_type SparsityPattern::n_nonzero_elements  (  )  const 
Return the number of nonzero elements of this sparsity pattern.
Definition at line 1007 of file trilinos_sparsity_pattern.cc.
SparsityPattern::size_type SparsityPattern::row_length  (  const size_type  row  )  const 
Return the number of entries in the given row.
In a parallel context, the row in question may of course not be stored on the current processor, and in that case it is not possible to query the number of entries in it. In that case, the returned value is static_cast<size_type>(1)
.
Definition at line 1027 of file trilinos_sparsity_pattern.cc.
SparsityPattern::size_type SparsityPattern::bandwidth  (  )  const 
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of \(ij\) for which the index pair \((i,j)\) represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a \(n\times m\) matrix can have is \(\max\{n1,m1\}\).
Definition at line 936 of file trilinos_sparsity_pattern.cc.
bool TrilinosWrappers::SparsityPattern::empty  (  )  const 
Return whether the object is empty. It is empty if no memory is allocated, which is the same as when both dimensions are zero.
Return whether the index (i,j) exists in the sparsity pattern (i.e., it may be nonzero) or not.
Definition at line 855 of file trilinos_sparsity_pattern.cc.
bool SparsityPattern::row_is_stored_locally  (  const size_type  i  )  const 
Return whether a given row
is stored in the current object on this process.
Definition at line 846 of file trilinos_sparsity_pattern.cc.
std::size_t SparsityPattern::memory_consumption  (  )  const 
Determine an estimate for the memory consumption (in bytes) of this object. Currently not implemented for this class.
Definition at line 1186 of file trilinos_sparsity_pattern.cc.
Add the element (i,j) to the sparsity pattern.
void TrilinosWrappers::SparsityPattern::add_entries  (  const size_type  row, 
ForwardIterator  begin,  
ForwardIterator  end,  
const bool  indices_are_sorted = false 

) 
Add several elements in one row to the sparsity pattern.
const Epetra_FECrsGraph& TrilinosWrappers::SparsityPattern::trilinos_sparsity_pattern  (  )  const 
Return a const reference to the underlying Trilinos Epetra_CrsGraph data that stores the sparsity pattern.
const Epetra_Map & SparsityPattern::domain_partitioner  (  )  const 
Return a const reference to the underlying Trilinos Epetra_Map that sets the parallel partitioning of the domain space of this sparsity pattern, i.e., the partitioning of the vectors matrices based on this sparsity pattern are multiplied with.
Definition at line 1047 of file trilinos_sparsity_pattern.cc.
const Epetra_Map & SparsityPattern::range_partitioner  (  )  const 
Return a const reference to the underlying Trilinos Epetra_Map that sets the partitioning of the range space of this sparsity pattern, i.e., the partitioning of the vectors that are result from matrix vector products.
Definition at line 1058 of file trilinos_sparsity_pattern.cc.
const Epetra_Map & SparsityPattern::row_partitioner  (  )  const 
Return a const reference to the underlying Trilinos Epetra_Map that sets the partitioning of the sparsity pattern rows. Equal to the partitioning of the range.
Definition at line 1069 of file trilinos_sparsity_pattern.cc.
const Epetra_Map & SparsityPattern::col_partitioner  (  )  const 
Return a const reference to the underlying Trilinos Epetra_Map that sets the partitioning of the sparsity pattern columns. This is in general not equal to the partitioner Epetra_Map for the domain because of overlap in the matrix.
Definition at line 1080 of file trilinos_sparsity_pattern.cc.
const Epetra_Comm & SparsityPattern::trilinos_communicator  (  )  const 
Return a const reference to the communicator used for this object.
Definition at line 1091 of file trilinos_sparsity_pattern.cc.
MPI_Comm SparsityPattern::get_mpi_communicator  (  )  const 
Return the MPI communicator object in use with this matrix.
Definition at line 1099 of file trilinos_sparsity_pattern.cc.
IndexSet TrilinosWrappers::SparsityPattern::locally_owned_domain_indices  (  )  const 
Return the partitioning of the domain space of this pattern, i.e., the partitioning of the vectors a matrix based on this sparsity pattern has to be multiplied with.
IndexSet TrilinosWrappers::SparsityPattern::locally_owned_range_indices  (  )  const 
Return the partitioning of the range space of this pattern, i.e., the partitioning of the vectors that are the result from matrixvector products from a matrix based on this pattern.
const_iterator TrilinosWrappers::SparsityPattern::begin  (  )  const 
Iterator starting at the first entry.
const_iterator TrilinosWrappers::SparsityPattern::end  (  )  const 
Final iterator.
const_iterator TrilinosWrappers::SparsityPattern::begin  (  const size_type  r  )  const 
Iterator starting at the first entry of row r
.
Note that if the given row is empty, i.e. does not contain any nonzero entries, then the iterator returned by this function equals end(r)
. Note also that the iterator may not be dereferenceable in that case.
const_iterator TrilinosWrappers::SparsityPattern::end  (  const size_type  r  )  const 
Final iterator of row r
. It points to the first element past the end of line r
, or past the end of the entire sparsity pattern.
Note that the end iterator is not necessarily dereferenceable. This is in particular the case if it is the end iterator for the last row of a matrix.
void SparsityPattern::write_ascii  (  ) 
Abstract Trilinos object that helps view in ASCII other Trilinos objects. Currently this function is not implemented. TODO: Not implemented.
Definition at line 1117 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::print  (  std::ostream &  out, 
const bool  write_extended_trilinos_info = false 

)  const 
Print (the locally owned part of) the sparsity pattern to the given stream, using the format (line,col)
. The optional flag outputs the sparsity pattern in Trilinos style, where even the according processor number is printed to the stream, as well as a summary before actually writing the entries.
Definition at line 1128 of file trilinos_sparsity_pattern.cc.
void SparsityPattern::print_gnuplot  (  std::ostream &  out  )  const 
Print the sparsity of the matrix in a format that gnuplot
understands and which can be used to plot the sparsity pattern in a graphical way. The format consists of pairs i j
of nonzero elements, each representing one entry of this matrix, one per line of the output file. Indices are counted from zero on, as usual. Since sparsity patterns are printed in the same way as matrices are displayed, we print the negative of the column index, which means that the (0,0)
element is in the top left rather than in the bottom left corner.
Print the sparsity pattern in gnuplot by setting the data style to dots or points and use the plot
command.
Definition at line 1155 of file trilinos_sparsity_pattern.cc.

private 
Pointer to the usersupplied Epetra Trilinos mapping of the matrix columns that assigns parts of the matrix to the individual processes.
Definition at line 1223 of file trilinos_sparsity_pattern.h.

private 
A sparsity pattern object in Trilinos to be used for finite element based problems which allows for adding nonlocal elements to the pattern.
Definition at line 1230 of file trilinos_sparsity_pattern.h.

private 
A sparsity pattern object for the nonlocal part of the sparsity pattern that is going to be sent to the owning processor. Only used when the particular constructor or reinit method with writable_rows argument is set
Definition at line 1238 of file trilinos_sparsity_pattern.h.