libMesh
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Attributes | List of all members
libMesh::EpetraMatrix< T > Class Template Referencefinal

This class provides a nice interface to the Epetra data structures for parallel, sparse matrices. More...

#include <trilinos_epetra_matrix.h>

Inheritance diagram for libMesh::EpetraMatrix< T >:
[legend]

Public Member Functions

 EpetraMatrix (const Parallel::Communicator &comm)
 Constructor; initializes the matrix to be empty, without any structure, i.e. More...
 
 EpetraMatrix (Epetra_FECrsMatrix *m, const Parallel::Communicator &comm)
 Constructor. More...
 
 EpetraMatrix (EpetraMatrix &&)=delete
 This class manages the lifetime of an Epetra_FECrsMatrix manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor. More...
 
 EpetraMatrix (const EpetraMatrix &)=delete
 
EpetraMatrixoperator= (const EpetraMatrix &)=delete
 
EpetraMatrixoperator= (EpetraMatrix &&)=delete
 
virtual ~EpetraMatrix ()
 
virtual bool need_full_sparsity_pattern () const override
 The EpetraMatrix needs the full sparsity pattern. More...
 
virtual void update_sparsity_pattern (const SparsityPattern::Graph &) override
 Updates the matrix sparsity pattern. More...
 
virtual void init (const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1) override
 Initialize SparseMatrix with the specified sizes. More...
 
virtual void init (ParallelType=PARALLEL) override
 Initialize this matrix using the sparsity structure computed by dof_map. More...
 
virtual void clear () noexcept override
 clear() is called from the destructor, so it should not throw. More...
 
virtual void zero () override
 Set all entries to 0. More...
 
virtual std::unique_ptr< SparseMatrix< T > > zero_clone () const override
 
virtual std::unique_ptr< SparseMatrix< T > > clone () const override
 
virtual void close () override
 Calls the SparseMatrix's internal assembly routines, ensuring that the values are consistent across processors. More...
 
virtual numeric_index_type m () const override
 
virtual numeric_index_type n () const override
 
virtual numeric_index_type row_start () const override
 
virtual numeric_index_type row_stop () const override
 
virtual numeric_index_type col_start () const override
 
virtual numeric_index_type col_stop () const override
 
virtual void set (const numeric_index_type i, const numeric_index_type j, const T value) override
 Set the element (i,j) to value. More...
 
virtual void add (const numeric_index_type i, const numeric_index_type j, const T value) override
 Add value to the element (i,j). More...
 
virtual void add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
 Add the full matrix dm to the SparseMatrix. More...
 
virtual void add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
 Same as add_matrix, but assumes the row and column maps are the same. More...
 
virtual void add (const T a, const SparseMatrix< T > &X) override
 Compute A += a*X for scalar a, matrix X. More...
 
virtual T operator() (const numeric_index_type i, const numeric_index_type j) const override
 
virtual Real l1_norm () const override
 
virtual Real linfty_norm () const override
 
virtual bool closed () const override
 
virtual void print_personal (std::ostream &os=libMesh::out) const override
 Print the contents of the matrix to the screen in a package-personalized style, if available. More...
 
virtual void get_diagonal (NumericVector< T > &dest) const override
 Copies the diagonal part of the matrix into dest. More...
 
virtual void get_transpose (SparseMatrix< T > &dest) const override
 Copies the transpose of the matrix into dest, which may be *this. More...
 
virtual void get_row (numeric_index_type i, std::vector< numeric_index_type > &indices, std::vector< T > &values) const override
 Get a row from the matrix. More...
 
void swap (EpetraMatrix< T > &)
 Swaps the internal data pointers, no actual values are swapped. More...
 
Epetra_FECrsMatrix * mat ()
 
const Epetra_FECrsMatrix * mat () const
 
virtual bool initialized () const
 
void attach_dof_map (const DofMap &dof_map)
 Set a pointer to the DofMap to use. More...
 
void attach_sparsity_pattern (const SparsityPattern::Build &sp)
 Set a pointer to a sparsity pattern to use. More...
 
virtual void zero_rows (std::vector< numeric_index_type > &rows, T diag_value=0.0)
 Sets all row entries to 0 then puts diag_value in the diagonal entry. More...
 
virtual void flush ()
 For PETSc matrix , this function is similar to close but without shrinking memory. More...
 
virtual numeric_index_type local_m () const
 Get the number of rows owned by this process. More...
 
virtual numeric_index_type local_n () const
 Get the number of columns owned by this process. More...
 
virtual void add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)
 Add the full matrix dm to the SparseMatrix. More...
 
virtual void add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices)
 Same as add_block_matrix(), but assumes the row and column maps are the same. More...
 
virtual void matrix_matrix_mult (SparseMatrix< T > &, SparseMatrix< T > &, bool)
 Compute Y = A*X for matrix X. More...
 
virtual void add_sparse_matrix (const SparseMatrix< T > &, const std::map< numeric_index_type, numeric_index_type > &, const std::map< numeric_index_type, numeric_index_type > &, const T)
 Add scalar* spm to the rows and cols of this matrix (A): A(rows[i], cols[j]) += scalar * spm(i,j) More...
 
virtual std::size_t n_nonzeros () const
 
void print (std::ostream &os=libMesh::out, const bool sparse=false) const
 Print the contents of the matrix to the screen in a uniform style, regardless of matrix/solver package being used. More...
 
template<>
void print (std::ostream &os, const bool sparse) const
 
virtual void print_matlab (const std::string &="") const
 Print the contents of the matrix in Matlab's sparse matrix format. More...
 
virtual void read_matlab (const std::string &filename)
 Read the contents of the matrix from Matlab's sparse matrix format. More...
 
virtual void create_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const
 This function creates a matrix called "submatrix" which is defined by the row and column indices given in the "rows" and "cols" entries. More...
 
virtual void create_submatrix_nosort (SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &) const
 Similar to the above function, this function creates a submatrix which is defined by the indices given in the rows and cols vectors. More...
 
virtual void reinit_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const
 This function is similar to the one above, but it allows you to reuse the existing sparsity pattern of "submatrix" instead of reallocating it again. More...
 
void vector_mult (NumericVector< T > &dest, const NumericVector< T > &arg) const
 Multiplies the matrix by the NumericVector arg and stores the result in NumericVector dest. More...
 
void vector_mult_add (NumericVector< T > &dest, const NumericVector< T > &arg) const
 Multiplies the matrix by the NumericVector arg and adds the result to the NumericVector dest. More...
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static std::unique_ptr< SparseMatrix< T > > build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package(), const MatrixBuildType matrix_build_type=MatrixBuildType::AUTOMATIC)
 Builds a SparseMatrix<T> using the linear solver package specified by solver_package. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
static void disable_print_counter_info ()
 

Protected Types

typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 Data structure to log the information. More...
 

Protected Member Functions

virtual void _get_submatrix (SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
 Protected implementation of the create_submatrix and reinit_submatrix routines. More...
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 

Protected Attributes

DofMap const * _dof_map
 The DofMap object associated with this object. More...
 
SparsityPattern::Build const * _sp
 The sparsity pattern associated with this object. More...
 
bool _is_initialized
 Flag indicating whether or not the matrix has been initialized. More...
 
const Parallel::Communicator_communicator
 

Static Protected Attributes

static Counts _counts
 Actually holds the data. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 

Private Attributes

Epetra_FECrsMatrix * _mat
 Actual Epetra datatype to hold matrix entries. More...
 
Epetra_Map * _map
 Holds the distributed Map. More...
 
Epetra_CrsGraph * _graph
 Holds the sparsity pattern. More...
 
bool _destroy_mat_on_exit
 This boolean value should only be set to false for the constructor which takes an Epetra_FECrsMatrix object. More...
 
bool _use_transpose
 Epetra has no GetUseTranspose so we need to keep track of whether we're transposed manually. More...
 

Detailed Description

template<typename T>
class libMesh::EpetraMatrix< T >

This class provides a nice interface to the Epetra data structures for parallel, sparse matrices.

All overridden virtual functions are documented in sparse_matrix.h.

Author
Benjamin S. Kirk
Date
2008

Definition at line 63 of file trilinos_epetra_matrix.h.

Member Typedef Documentation

◆ Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts
protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

◆ EpetraMatrix() [1/4]

template<typename T >
libMesh::EpetraMatrix< T >::EpetraMatrix ( const Parallel::Communicator comm)

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 init(...).

Definition at line 364 of file trilinos_epetra_matrix.C.

364  :
365  SparseMatrix<T>(comm),
366  _destroy_mat_on_exit(true),
367  _use_transpose(false)
368 {}
bool _destroy_mat_on_exit
This boolean value should only be set to false for the constructor which takes an Epetra_FECrsMatrix ...
const Parallel::Communicator & comm() const
bool _use_transpose
Epetra has no GetUseTranspose so we need to keep track of whether we&#39;re transposed manually...

◆ EpetraMatrix() [2/4]

template<typename T >
libMesh::EpetraMatrix< T >::EpetraMatrix ( Epetra_FECrsMatrix *  m,
const Parallel::Communicator comm 
)

Constructor.

Creates a EpetraMatrix assuming you already have a valid Epetra_FECrsMatrix object. In this case, m is NOT destroyed by the EpetraMatrix destructor when this object goes out of scope. This allows ownership of m to remain with the original creator, and to simply provide additional functionality with the EpetraMatrix.

Definition at line 374 of file trilinos_epetra_matrix.C.

References libMesh::SparseMatrix< T >::_is_initialized, libMesh::EpetraMatrix< T >::_mat, and libMesh::EpetraMatrix< T >::m().

375  :
376  SparseMatrix<T>(comm),
377  _destroy_mat_on_exit(false),
378  _use_transpose(false) // dumb guess is the best we can do...
379 {
380  this->_mat = m;
381  this->_is_initialized = true;
382 }
bool _destroy_mat_on_exit
This boolean value should only be set to false for the constructor which takes an Epetra_FECrsMatrix ...
const Parallel::Communicator & comm() const
bool _use_transpose
Epetra has no GetUseTranspose so we need to keep track of whether we&#39;re transposed manually...
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
virtual numeric_index_type m() const override
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ EpetraMatrix() [3/4]

template<typename T>
libMesh::EpetraMatrix< T >::EpetraMatrix ( EpetraMatrix< T > &&  )
delete

This class manages the lifetime of an Epetra_FECrsMatrix manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor.

◆ EpetraMatrix() [4/4]

template<typename T>
libMesh::EpetraMatrix< T >::EpetraMatrix ( const EpetraMatrix< T > &  )
delete

◆ ~EpetraMatrix()

template<typename T >
libMesh::EpetraMatrix< T >::~EpetraMatrix ( )
virtual

Definition at line 388 of file trilinos_epetra_matrix.C.

389 {
390  this->clear();
391 }
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.

Member Function Documentation

◆ _get_submatrix()

template<typename T>
virtual void libMesh::SparseMatrix< T >::_get_submatrix ( SparseMatrix< T > &  ,
const std::vector< numeric_index_type > &  ,
const std::vector< numeric_index_type > &  ,
const bool   
) const
inlineprotectedvirtualinherited

Protected implementation of the create_submatrix and reinit_submatrix routines.

Note
This function must be overridden in derived classes for it to work properly!

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 530 of file sparse_matrix.h.

Referenced by libMesh::SparseMatrix< ValOut >::create_submatrix(), and libMesh::SparseMatrix< ValOut >::reinit_submatrix().

534  {
535  libmesh_not_implemented();
536  }

◆ add() [1/2]

template<typename T >
void libMesh::EpetraMatrix< T >::add ( const numeric_index_type  i,
const numeric_index_type  j,
const T  value 
)
overridevirtual

Add value to the element (i,j).

Throws an error if the entry does not exist. Zero values can be "added" to non-existent entries.

Implements libMesh::SparseMatrix< T >.

Definition at line 491 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), libMesh::libmesh_assert(), and value.

494 {
495  libmesh_assert (this->initialized());
496 
497  int
498  epetra_i = static_cast<int>(i),
499  epetra_j = static_cast<int>(j);
500 
501  T epetra_value = value;
502 
503  _mat->SumIntoGlobalValues (epetra_i, 1, &epetra_value, &epetra_j);
504 }
virtual bool initialized() const
libmesh_assert(ctx)
static const bool value
Definition: xdr_io.C:54
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ add() [2/2]

template<typename T >
void libMesh::EpetraMatrix< T >::add ( const T  a,
const SparseMatrix< T > &  X 
)
overridevirtual

Compute A += a*X for scalar a, matrix X.

Note
It is advisable to not only allocate appropriate memory with init(), but also explicitly zero the terms of this whenever you add a non-zero value to X.
X will be closed, if not already done, before performing any work.

Implements libMesh::SparseMatrix< T >.

Definition at line 518 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), libMesh::libmesh_assert(), libMesh::SparseMatrix< T >::m(), and libMesh::SparseMatrix< T >::n().

519 {
520 #ifdef LIBMESH_TRILINOS_HAVE_EPETRAEXT
521  libmesh_assert (this->initialized());
522 
523  // sanity check. but this cannot avoid
524  // crash due to incompatible sparsity structure...
525  libmesh_assert_equal_to (this->m(), X_in.m());
526  libmesh_assert_equal_to (this->n(), X_in.n());
527 
528  const EpetraMatrix<T> * X =
529  cast_ptr<const EpetraMatrix<T> *> (&X_in);
530 
531  EpetraExt::MatrixMatrix::Add (*X->_mat, false, a_in, *_mat, 1.);
532 #else
533  libmesh_error_msg("ERROR: EpetraExt is required for EpetraMatrix::add()!");
534 #endif
535 }
virtual bool initialized() const
virtual numeric_index_type n() const override
virtual numeric_index_type m() const override
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ add_block_matrix() [1/2]

template<typename T>
void libMesh::SparseMatrix< T >::add_block_matrix ( const DenseMatrix< T > &  dm,
const std::vector< numeric_index_type > &  brows,
const std::vector< numeric_index_type > &  bcols 
)
virtualinherited

Add the full matrix dm to the SparseMatrix.

This is useful for adding an element matrix at assembly time. The matrix is assumed blocked, and brow, bcol correspond to the block row and column indices.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 82 of file sparse_matrix.C.

Referenced by libMesh::SparseMatrix< ValOut >::add_block_matrix().

85 {
86  libmesh_assert_equal_to (dm.m() / brows.size(), dm.n() / bcols.size());
87 
88  const numeric_index_type blocksize = cast_int<numeric_index_type>
89  (dm.m() / brows.size());
90 
91  libmesh_assert_equal_to (dm.m()%blocksize, 0);
92  libmesh_assert_equal_to (dm.n()%blocksize, 0);
93 
94  std::vector<numeric_index_type> rows, cols;
95 
96  rows.reserve(blocksize*brows.size());
97  cols.reserve(blocksize*bcols.size());
98 
99  for (auto & row : brows)
100  {
101  numeric_index_type i = row * blocksize;
102 
103  for (unsigned int v=0; v<blocksize; v++)
104  rows.push_back(i++);
105  }
106 
107  for (auto & col : bcols)
108  {
109  numeric_index_type j = col * blocksize;
110 
111  for (unsigned int v=0; v<blocksize; v++)
112  cols.push_back(j++);
113  }
114 
115  this->add_matrix (dm, rows, cols);
116 }
virtual void add_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols)=0
Add the full matrix dm to the SparseMatrix.
dof_id_type numeric_index_type
Definition: id_types.h:99

◆ add_block_matrix() [2/2]

template<typename T>
virtual void libMesh::SparseMatrix< T >::add_block_matrix ( const DenseMatrix< T > &  dm,
const std::vector< numeric_index_type > &  dof_indices 
)
inlinevirtualinherited

Same as add_block_matrix(), but assumes the row and column maps are the same.

Thus the matrix dm must be square.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 308 of file sparse_matrix.h.

310  { this->add_block_matrix (dm, dof_indices, dof_indices); }
virtual void add_block_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)
Add the full matrix dm to the SparseMatrix.
Definition: sparse_matrix.C:82

◆ add_matrix() [1/2]

template<typename T >
void libMesh::EpetraMatrix< T >::add_matrix ( const DenseMatrix< T > &  dm,
const std::vector< numeric_index_type > &  rows,
const std::vector< numeric_index_type > &  cols 
)
overridevirtual

Add the full matrix dm to the SparseMatrix.

This is useful for adding an element matrix at assembly time.

Implements libMesh::SparseMatrix< T >.

Definition at line 278 of file trilinos_epetra_matrix.C.

References libMesh::DenseMatrix< T >::get_values(), libMesh::initialized(), libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), and libMesh::numeric_trilinos_cast().

281 {
282  libmesh_assert (this->initialized());
283 
284  const numeric_index_type m = dm.m();
285  const numeric_index_type n = dm.n();
286 
287  libmesh_assert_equal_to (rows.size(), m);
288  libmesh_assert_equal_to (cols.size(), n);
289 
290  _mat->SumIntoGlobalValues(m, numeric_trilinos_cast(rows.data()),
291  n, numeric_trilinos_cast(cols.data()),
292  dm.get_values().data());
293 }
virtual bool initialized() const
virtual numeric_index_type n() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type m() const override
libmesh_assert(ctx)
int * numeric_trilinos_cast(const numeric_index_type *p)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ add_matrix() [2/2]

template<typename T >
void libMesh::EpetraMatrix< T >::add_matrix ( const DenseMatrix< T > &  dm,
const std::vector< numeric_index_type > &  dof_indices 
)
overridevirtual

Same as add_matrix, but assumes the row and column maps are the same.

Thus the matrix dm must be square.

Implements libMesh::SparseMatrix< T >.

Definition at line 509 of file trilinos_epetra_matrix.C.

511 {
512  this->add_matrix (dm, dof_indices, dof_indices);
513 }
virtual void add_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
Add the full matrix dm to the SparseMatrix.

◆ add_sparse_matrix()

template<typename T>
virtual void libMesh::SparseMatrix< T >::add_sparse_matrix ( const SparseMatrix< T > &  ,
const std::map< numeric_index_type, numeric_index_type > &  ,
const std::map< numeric_index_type, numeric_index_type > &  ,
const T   
)
inlinevirtualinherited

Add scalar* spm to the rows and cols of this matrix (A): A(rows[i], cols[j]) += scalar * spm(i,j)

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 327 of file sparse_matrix.h.

331  { libmesh_not_implemented(); }

◆ attach_dof_map()

template<typename T >
void libMesh::SparseMatrix< T >::attach_dof_map ( const DofMap dof_map)
inherited

Set a pointer to the DofMap to use.

If a separate sparsity pattern is not being used, use the one from the DofMap.

The lifetime of dof_map must exceed the lifetime of this.

Definition at line 63 of file sparse_matrix.C.

Referenced by libMesh::__libmesh_tao_hessian(), and libMesh::DofMap::update_sparsity_pattern().

64 {
65  _dof_map = &dof_map;
66  if (!_sp)
67  _sp = dof_map.get_sparsity_pattern();
68 }
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.
const SparsityPattern::Graph & get_sparsity_pattern() const
Rows of sparse matrix indices, indexed by the offset from the first DoF on this processor.
DofMap const * _dof_map
The DofMap object associated with this object.

◆ attach_sparsity_pattern()

template<typename T >
void libMesh::SparseMatrix< T >::attach_sparsity_pattern ( const SparsityPattern::Build sp)
inherited

Set a pointer to a sparsity pattern to use.

Useful in cases where a matrix requires a wider (or for efficiency narrower) pattern than most matrices in the system, or in cases where no system sparsity pattern is being calculated by the DofMap.

The lifetime of sp must exceed the lifetime of this.

Definition at line 73 of file sparse_matrix.C.

Referenced by libMesh::DofMap::update_sparsity_pattern().

74 {
75  _sp = &sp;
76 }
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.

◆ build()

template<typename T >
std::unique_ptr< SparseMatrix< T > > libMesh::SparseMatrix< T >::build ( const Parallel::Communicator comm,
const SolverPackage  solver_package = libMesh::default_solver_package(),
const MatrixBuildType  matrix_build_type = MatrixBuildType::AUTOMATIC 
)
staticinherited

Builds a SparseMatrix<T> using the linear solver package specified by solver_package.

Definition at line 156 of file sparse_matrix.C.

Referenced by libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::DofMap::process_mesh_constraint_rows(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

159 {
160  // Avoid unused parameter warnings when no solver packages are enabled.
162 
163  if (matrix_build_type == MatrixBuildType::DIAGONAL)
164  return std::make_unique<DiagonalMatrix<T>>(comm);
165 
166  // Build the appropriate vector
167  switch (solver_package)
168  {
169 
170 #ifdef LIBMESH_HAVE_LASPACK
171  case LASPACK_SOLVERS:
172  return std::make_unique<LaspackMatrix<T>>(comm);
173 #endif
174 
175 
176 #ifdef LIBMESH_HAVE_PETSC
177  case PETSC_SOLVERS:
178  return std::make_unique<PetscMatrix<T>>(comm);
179 #endif
180 
181 
182 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
183  case TRILINOS_SOLVERS:
184  return std::make_unique<EpetraMatrix<T>>(comm);
185 #endif
186 
187 
188 #ifdef LIBMESH_HAVE_EIGEN
189  case EIGEN_SOLVERS:
190  return std::make_unique<EigenSparseMatrix<T>>(comm);
191 #endif
192 
193  default:
194  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
195  }
196 }
const Parallel::Communicator & comm() const
void libmesh_ignore(const Args &...)

◆ clear()

template<typename T >
void libMesh::EpetraMatrix< T >::clear ( )
overridevirtualnoexcept

clear() is called from the destructor, so it should not throw.

Implements libMesh::SparseMatrix< T >.

Definition at line 240 of file trilinos_epetra_matrix.C.

References libMesh::libMeshPrivateData::_is_initialized.

241 {
242  // FIXME: clear() doesn't actually free the memory managed by this
243  // class, so it probably leaks memory.
244  // delete _mat;
245  // delete _map;
246 
247  this->_is_initialized = false;
248 }
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.

◆ clone()

template<typename T >
std::unique_ptr< SparseMatrix< T > > libMesh::EpetraMatrix< T >::clone ( ) const
overridevirtual
Returns
A smart pointer to a copy of this matrix.
Note
This must be overridden in the derived classes.

Implements libMesh::SparseMatrix< T >.

Definition at line 225 of file trilinos_epetra_matrix.C.

226 {
227  // We don't currently have a faster implementation than making a
228  // zero clone and then filling in the values.
229  auto mat_copy = this->zero_clone();
230  mat_copy->add(1., *this);
231 
232  // Work around an issue on older compilers. We are able to simply
233  // "return mat_copy;" on newer compilers
234  return std::unique_ptr<SparseMatrix<T>>(mat_copy.release());
235 }
virtual std::unique_ptr< SparseMatrix< T > > zero_clone() const override

◆ close()

template<typename T >
void libMesh::EpetraMatrix< T >::close ( )
overridevirtual

Calls the SparseMatrix's internal assembly routines, ensuring that the values are consistent across processors.

Implements libMesh::SparseMatrix< T >.

Definition at line 396 of file trilinos_epetra_matrix.C.

References libMesh::libmesh_assert().

Referenced by libMesh::AztecLinearSolver< T >::solve().

397 {
399 
400  _mat->GlobalAssemble();
401 }
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ closed()

template<typename T >
bool libMesh::EpetraMatrix< T >::closed ( ) const
overridevirtual
Returns
true if the matrix has been assembled.

Implements libMesh::SparseMatrix< T >.

Definition at line 576 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

577 {
578  libmesh_assert (this->initialized());
579  libmesh_assert(this->_mat);
580 
581  return this->_mat->Filled();
582 }
virtual bool initialized() const
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ col_start()

template<typename T >
numeric_index_type libMesh::EpetraMatrix< T >::col_start ( ) const
overridevirtual
Returns
The index of the first matrix column owned by this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 448 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

449 {
450  libmesh_assert (this->initialized());
452 
453  return static_cast<numeric_index_type>(_map->MinMyGID());
454 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Epetra_Map * _map
Holds the distributed Map.

◆ col_stop()

template<typename T >
numeric_index_type libMesh::EpetraMatrix< T >::col_stop ( ) const
overridevirtual
Returns
The index of the last matrix column (+1) owned by this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 459 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

460 {
461  libmesh_assert (this->initialized());
463 
464  return static_cast<numeric_index_type>(_map->MaxMyGID())+1;
465 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Epetra_Map * _map
Holds the distributed Map.

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

98  { return _communicator; }
const Parallel::Communicator & _communicator

◆ create_submatrix()

template<typename T>
virtual void libMesh::SparseMatrix< T >::create_submatrix ( SparseMatrix< T > &  submatrix,
const std::vector< numeric_index_type > &  rows,
const std::vector< numeric_index_type > &  cols 
) const
inlinevirtualinherited

This function creates a matrix called "submatrix" which is defined by the row and column indices given in the "rows" and "cols" entries.

Currently this operation is only defined for the PetscMatrix type. Note: The rows and cols vectors need to be sorted; Use the nosort version below if rows and cols vectors are not sorted; The rows and cols only contain indices that are owned by this processor.

Definition at line 444 of file sparse_matrix.h.

Referenced by libMesh::libmesh_petsc_DMCreateInterpolation(), and libMesh::CondensedEigenSystem::solve().

447  {
448  this->_get_submatrix(submatrix,
449  rows,
450  cols,
451  false); // false means DO NOT REUSE submatrix
452  }
virtual void _get_submatrix(SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
Protected implementation of the create_submatrix and reinit_submatrix routines.

◆ create_submatrix_nosort()

template<typename T>
virtual void libMesh::SparseMatrix< T >::create_submatrix_nosort ( SparseMatrix< T > &  ,
const std::vector< numeric_index_type > &  ,
const std::vector< numeric_index_type > &   
) const
inlinevirtualinherited

Similar to the above function, this function creates a submatrix which is defined by the indices given in the rows and cols vectors.

Note: Both rows and cols can be unsorted; Use the above function for better efficiency if your indices are sorted; rows and cols can contain indices that are owned by other processors.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 462 of file sparse_matrix.h.

465  {
466  libmesh_not_implemented();
467  }

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

Methods to enable/disable the reference counter output from print_info()

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ flush()

template<typename T>
virtual void libMesh::SparseMatrix< T >::flush ( )
inlinevirtualinherited

For PETSc matrix , this function is similar to close but without shrinking memory.

This is useful when we want to switch between ADD_VALUES and INSERT_VALUES. close should be called before using the matrix.

Reimplemented in libMesh::PetscMatrix< T >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 215 of file sparse_matrix.h.

215 { close(); }
virtual void close()=0
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...

◆ get_diagonal()

template<typename T >
void libMesh::EpetraMatrix< T >::get_diagonal ( NumericVector< T > &  dest) const
overridevirtual

Copies the diagonal part of the matrix into dest.

Implements libMesh::SparseMatrix< T >.

Definition at line 301 of file trilinos_epetra_matrix.C.

References libMesh::EpetraVector< T >::vec().

302 {
303  // Convert vector to EpetraVector.
304  EpetraVector<T> * epetra_dest = cast_ptr<EpetraVector<T> *>(&dest);
305 
306  // Call Epetra function.
307  _mat->ExtractDiagonalCopy(*(epetra_dest->vec()));
308 }
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ get_info()

std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

◆ get_row()

template<typename T >
void libMesh::EpetraMatrix< T >::get_row ( numeric_index_type  i,
std::vector< numeric_index_type > &  indices,
std::vector< T > &  values 
) const
overridevirtual

Get a row from the matrix.

Parameters
iThe matrix row to get
indicesA container that will be filled with the column indices corresponding to (possibly) non-zero values
valuesA container holding the column values

Implements libMesh::SparseMatrix< T >.

Definition at line 332 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::make_range().

335 {
336  libmesh_assert (this->initialized());
337  libmesh_assert(this->_mat);
338  libmesh_assert (this->_mat->MyGlobalRow(static_cast<int>(i)));
339  libmesh_assert_greater_equal (i, this->row_start());
340  libmesh_assert_less (i, this->row_stop());
341 
342  int row_length;
343  int * row_indices;
344  double * row_values;
345 
346  _mat->ExtractMyRowView (i-this->row_start(),
347  row_length,
348  row_values,
349  row_indices);
350 
351  indices.resize(row_length);
352  values.resize(row_length);
353 
354  for (auto i : make_range(row_length))
355  {
356  indices[i] = row_indices[i];
357  values[i] = row_values[i];
358  }
359 }
virtual bool initialized() const
virtual numeric_index_type row_stop() const override
libmesh_assert(ctx)
virtual numeric_index_type row_start() const override
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ get_transpose()

template<typename T >
void libMesh::EpetraMatrix< T >::get_transpose ( SparseMatrix< T > &  dest) const
overridevirtual

Copies the transpose of the matrix into dest, which may be *this.

Implements libMesh::SparseMatrix< T >.

Definition at line 313 of file trilinos_epetra_matrix.C.

References libMesh::EpetraMatrix< T >::_mat, and libMesh::EpetraMatrix< T >::_use_transpose.

314 {
315  // Make sure the SparseMatrix passed in is really a EpetraMatrix
316  EpetraMatrix<T> & epetra_dest = cast_ref<EpetraMatrix<T> &>(dest);
317 
318  // We currently only support calling get_transpose() with ourself
319  // as the destination. Previously, this called the default copy
320  // constructor which was not safe because this class manually
321  // manages memory.
322  if (&epetra_dest != this)
323  libmesh_not_implemented();
324 
325  epetra_dest._use_transpose = !epetra_dest._use_transpose;
326  epetra_dest._mat->SetUseTranspose(epetra_dest._use_transpose);
327 }

◆ increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ init() [1/2]

template<typename T>
virtual void libMesh::EpetraMatrix< T >::init ( const numeric_index_type  m,
const numeric_index_type  n,
const numeric_index_type  m_l,
const numeric_index_type  n_l,
const numeric_index_type  nnz = 30,
const numeric_index_type  noz = 10,
const numeric_index_type  blocksize = 1 
)
overridevirtual

Initialize SparseMatrix with the specified sizes.

Parameters
mThe global number of rows.
nThe global number of columns.
m_lThe local number of rows.
n_lThe local number of columns.
nnzThe number of on-diagonal nonzeros per row (defaults to 30).
nozThe number of off-diagonal nonzeros per row (defaults to 10).
blocksizeOptional value indicating dense coupled blocks for systems with multiple variables all of the same type.

Implements libMesh::SparseMatrix< T >.

◆ init() [2/2]

template<typename T >
void libMesh::EpetraMatrix< T >::init ( ParallelType  type = PARALLEL)
overridevirtual

Initialize this matrix using the sparsity structure computed by dof_map.

Parameters
typeThe serial/parallel/ghosted type of the matrix

Implements libMesh::SparseMatrix< T >.

Definition at line 177 of file trilinos_epetra_matrix.C.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::initialized(), and libMesh::libmesh_assert().

178 {
179  libmesh_assert(this->_dof_map);
180 
181  {
182  // Clear initialized matrices
183  if (this->initialized())
184  this->clear();
185 
186  this->_is_initialized = true;
187  }
188 
189 
190  _mat = new Epetra_FECrsMatrix (Copy, *_graph);
191 }
virtual bool initialized() const
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
Epetra_CrsGraph * _graph
Holds the sparsity pattern.
libmesh_assert(ctx)
DofMap const * _dof_map
The DofMap object associated with this object.
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ initialized()

template<typename T>
virtual bool libMesh::SparseMatrix< T >::initialized ( ) const
inlinevirtualinherited
Returns
true if the matrix has been initialized, false otherwise.

Definition at line 109 of file sparse_matrix.h.

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), libMesh::ImplicitSystem::assemble(), and libMesh::System::init_matrices().

109 { return _is_initialized; }
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.

◆ l1_norm()

template<typename T >
Real libMesh::EpetraMatrix< T >::l1_norm ( ) const
overridevirtual
Returns
The \( \ell_1 \)-norm of the matrix, that is the max column sum: \( |M|_1 = \max_{j} \sum_{i} |M_{ij}| \)

This is the natural matrix norm that is compatible with the \( \ell_1 \)-norm for vectors, i.e. \( |Mv|_1 \leq |M|_1 |v|_1 \). (cf. Haemmerlin-Hoffmann : Numerische Mathematik)

Implements libMesh::SparseMatrix< T >.

Definition at line 253 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::Real.

254 {
255  libmesh_assert (this->initialized());
256 
258 
259  return static_cast<Real>(_mat->NormOne());
260 }
virtual bool initialized() const
libmesh_assert(ctx)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ linfty_norm()

template<typename T >
Real libMesh::EpetraMatrix< T >::linfty_norm ( ) const
overridevirtual
Returns
The \( \ell_{\infty} \)-norm of the matrix, that is the max row sum:

\( |M|_{\infty} = \max_{i} \sum_{j} |M_{ij}| \)

This is the natural matrix norm that is compatible to the \( \ell_{\infty} \)-norm of vectors, i.e. \( |Mv|_{\infty} \leq |M|_{\infty} |v|_{\infty} \). (cf. Haemmerlin-Hoffmann : Numerische Mathematik)

Implements libMesh::SparseMatrix< T >.

Definition at line 265 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::Real.

266 {
267  libmesh_assert (this->initialized());
268 
269 
271 
272  return static_cast<Real>(_mat->NormInf());
273 }
virtual bool initialized() const
libmesh_assert(ctx)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ local_m()

template<typename T>
virtual numeric_index_type libMesh::SparseMatrix< T >::local_m ( ) const
inlinevirtualinherited

Get the number of rows owned by this process.

Reimplemented in libMesh::PetscMatrix< T >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 225 of file sparse_matrix.h.

225 { return row_stop() - row_start(); }
virtual numeric_index_type row_stop() const =0
virtual numeric_index_type row_start() const =0

◆ local_n()

template<typename T>
virtual numeric_index_type libMesh::SparseMatrix< T >::local_n ( ) const
inlinevirtualinherited

Get the number of columns owned by this process.

Reimplemented in libMesh::PetscMatrix< T >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 230 of file sparse_matrix.h.

230 { return col_stop() - col_start(); }
virtual numeric_index_type col_stop() const =0
virtual numeric_index_type col_start() const =0

◆ m()

template<typename T >
numeric_index_type libMesh::EpetraMatrix< T >::m ( ) const
overridevirtual
Returns
The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 406 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

Referenced by libMesh::EpetraMatrix< T >::EpetraMatrix().

407 {
408  libmesh_assert (this->initialized());
409 
410  return static_cast<numeric_index_type>(_mat->NumGlobalRows());
411 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ mat() [1/2]

template<typename T>
Epetra_FECrsMatrix* libMesh::EpetraMatrix< T >::mat ( )
inline
Returns
The raw Epetra_FECrsMatrix pointer.
Note
This is generally not required in user-level code.
Don't do anything crazy like deleting the pointer, or very bad things will likely happen!

Definition at line 207 of file trilinos_epetra_matrix.h.

References libMesh::EpetraMatrix< T >::_mat, and libMesh::libmesh_assert().

Referenced by libMesh::TrilinosPreconditioner< T >::init(), libMesh::NoxNonlinearSolver< Number >::solve(), and libMesh::AztecLinearSolver< T >::solve().

207 { libmesh_assert(_mat); return _mat; }
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ mat() [2/2]

template<typename T>
const Epetra_FECrsMatrix* libMesh::EpetraMatrix< T >::mat ( ) const
inline

Definition at line 209 of file trilinos_epetra_matrix.h.

References libMesh::EpetraMatrix< T >::_mat, and libMesh::libmesh_assert().

209 { libmesh_assert(_mat); return _mat; }
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ matrix_matrix_mult()

template<typename T>
virtual void libMesh::SparseMatrix< T >::matrix_matrix_mult ( SparseMatrix< T > &  ,
SparseMatrix< T > &  ,
bool   
)
inlinevirtualinherited

Compute Y = A*X for matrix X.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 320 of file sparse_matrix.h.

321  { libmesh_not_implemented(); }

◆ n()

template<typename T >
numeric_index_type libMesh::EpetraMatrix< T >::n ( ) const
overridevirtual
Returns
The column-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 416 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

417 {
418  libmesh_assert (this->initialized());
419 
420  return static_cast<numeric_index_type>(_mat->NumGlobalCols());
421 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ n_nonzeros()

template<typename T >
std::size_t libMesh::SparseMatrix< T >::n_nonzeros ( ) const
virtualinherited
Returns
the global number of non-zero entries in the matrix sparsity pattern

Definition at line 229 of file sparse_matrix.C.

Referenced by libMesh::SparseMatrix< ValOut >::n_nonzeros().

230 {
231  if (!_sp)
232  return 0;
233  return _sp->n_nonzeros();
234 }
std::size_t n_nonzeros() const
The total number of nonzeros in the global matrix.
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.

◆ n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 103 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and TIMPI::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
const Parallel::Communicator & _communicator
processor_id_type size() const
uint8_t processor_id_type
libmesh_assert(ctx)

◆ need_full_sparsity_pattern()

template<typename T>
virtual bool libMesh::EpetraMatrix< T >::need_full_sparsity_pattern ( ) const
inlineoverridevirtual

The EpetraMatrix needs the full sparsity pattern.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 103 of file trilinos_epetra_matrix.h.

104  { return true; }

◆ operator()()

template<typename T >
T libMesh::EpetraMatrix< T >::operator() ( const numeric_index_type  i,
const numeric_index_type  j 
) const
overridevirtual
Returns
A copy of matrix entry (i,j).
Note
This may be an expensive operation, and you should always be careful where you call this function.

Implements libMesh::SparseMatrix< T >.

Definition at line 541 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

543 {
544  libmesh_assert (this->initialized());
545  libmesh_assert(this->_mat);
546  libmesh_assert (this->_mat->MyGlobalRow(static_cast<int>(i)));
547  libmesh_assert_greater_equal (i, this->row_start());
548  libmesh_assert_less (i, this->row_stop());
549 
550 
551  int row_length;
552  int * row_indices;
553  double * values;
554 
555  _mat->ExtractMyRowView (i-this->row_start(),
556  row_length,
557  values,
558  row_indices);
559 
560  //libMesh::out << "row_length=" << row_length << std::endl;
561 
562  int * index = std::lower_bound (row_indices, row_indices+row_length, j);
563 
564  libmesh_assert_less (*index, row_length);
565  libmesh_assert_equal_to (static_cast<numeric_index_type>(row_indices[*index]), j);
566 
567  //libMesh::out << "val=" << values[*index] << std::endl;
568 
569  return values[*index];
570 }
virtual bool initialized() const
virtual numeric_index_type row_stop() const override
libmesh_assert(ctx)
virtual numeric_index_type row_start() const override
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ operator=() [1/2]

template<typename T>
EpetraMatrix& libMesh::EpetraMatrix< T >::operator= ( const EpetraMatrix< T > &  )
delete

◆ operator=() [2/2]

template<typename T>
EpetraMatrix& libMesh::EpetraMatrix< T >::operator= ( EpetraMatrix< T > &&  )
delete

◆ print() [1/2]

template<>
void libMesh::SparseMatrix< Complex >::print ( std::ostream &  os,
const bool  sparse 
) const
inherited

Definition at line 122 of file sparse_matrix.C.

123 {
124  // std::complex<>::operator<<() is defined, but use this form
125 
126  if (sparse)
127  {
128  libmesh_not_implemented();
129  }
130 
131  os << "Real part:" << std::endl;
132  for (auto i : make_range(this->m()))
133  {
134  for (auto j : make_range(this->n()))
135  os << std::setw(8) << (*this)(i,j).real() << " ";
136  os << std::endl;
137  }
138 
139  os << std::endl << "Imaginary part:" << std::endl;
140  for (auto i : make_range(this->m()))
141  {
142  for (auto j : make_range(this->n()))
143  os << std::setw(8) << (*this)(i,j).imag() << " ";
144  os << std::endl;
145  }
146 }
boost::multiprecision::float128 real(const boost::multiprecision::float128 in)
virtual numeric_index_type m() const =0
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
boost::multiprecision::float128 imag(const boost::multiprecision::float128)
virtual numeric_index_type n() const =0

◆ print() [2/2]

template<typename T >
void libMesh::SparseMatrix< T >::print ( std::ostream &  os = libMesh::out,
const bool  sparse = false 
) const
inherited

Print the contents of the matrix to the screen in a uniform style, regardless of matrix/solver package being used.

Definition at line 238 of file sparse_matrix.C.

Referenced by libMesh::EigenSparseMatrix< T >::print_personal(), and libMesh::LaspackMatrix< T >::print_personal().

239 {
240  parallel_object_only();
241 
242  libmesh_assert (this->initialized());
243 
244  const numeric_index_type first_dof = this->row_start(),
245  end_dof = this->row_stop();
246 
247  // We'll print the matrix from processor 0 to make sure
248  // it's serialized properly
249  if (this->processor_id() == 0)
250  {
251  libmesh_assert_equal_to (first_dof, 0);
252  for (numeric_index_type i : make_range(end_dof))
253  {
254  if (sparse)
255  {
256  for (auto j : make_range(this->n()))
257  {
258  T c = (*this)(i,j);
259  if (c != static_cast<T>(0.0))
260  {
261  os << i << " " << j << " " << c << std::endl;
262  }
263  }
264  }
265  else
266  {
267  for (auto j : make_range(this->n()))
268  os << (*this)(i,j) << " ";
269  os << std::endl;
270  }
271  }
272 
273  std::vector<numeric_index_type> ibuf, jbuf;
274  std::vector<T> cbuf;
275  numeric_index_type currenti = end_dof;
276  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
277  {
278  this->comm().receive(p, ibuf);
279  this->comm().receive(p, jbuf);
280  this->comm().receive(p, cbuf);
281  libmesh_assert_equal_to (ibuf.size(), jbuf.size());
282  libmesh_assert_equal_to (ibuf.size(), cbuf.size());
283 
284  if (ibuf.empty())
285  continue;
286  libmesh_assert_greater_equal (ibuf.front(), currenti);
287  libmesh_assert_greater_equal (ibuf.back(), ibuf.front());
288 
289  std::size_t currentb = 0;
290  for (;currenti <= ibuf.back(); ++currenti)
291  {
292  if (sparse)
293  {
294  for (numeric_index_type j=0; j<this->n(); j++)
295  {
296  if (currentb < ibuf.size() &&
297  ibuf[currentb] == currenti &&
298  jbuf[currentb] == j)
299  {
300  os << currenti << " " << j << " " << cbuf[currentb] << std::endl;
301  currentb++;
302  }
303  }
304  }
305  else
306  {
307  for (auto j : make_range(this->n()))
308  {
309  if (currentb < ibuf.size() &&
310  ibuf[currentb] == currenti &&
311  jbuf[currentb] == j)
312  {
313  os << cbuf[currentb] << " ";
314  currentb++;
315  }
316  else
317  os << static_cast<T>(0.0) << " ";
318  }
319  os << std::endl;
320  }
321  }
322  }
323  if (!sparse)
324  {
325  for (; currenti != this->m(); ++currenti)
326  {
327  for (numeric_index_type j=0; j<this->n(); j++)
328  os << static_cast<T>(0.0) << " ";
329  os << std::endl;
330  }
331  }
332  }
333  else
334  {
335  std::vector<numeric_index_type> ibuf, jbuf;
336  std::vector<T> cbuf;
337 
338  // We'll assume each processor has access to entire
339  // matrix rows, so (*this)(i,j) is valid if i is a local index.
340  for (numeric_index_type i : make_range(first_dof, end_dof))
341  {
342  for (auto j : make_range(this->n()))
343  {
344  T c = (*this)(i,j);
345  if (c != static_cast<T>(0.0))
346  {
347  ibuf.push_back(i);
348  jbuf.push_back(j);
349  cbuf.push_back(c);
350  }
351  }
352  }
353  this->comm().send(0,ibuf);
354  this->comm().send(0,jbuf);
355  this->comm().send(0,cbuf);
356  }
357 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
virtual numeric_index_type row_stop() const =0
processor_id_type n_processors() const
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type m() const =0
libmesh_assert(ctx)
virtual numeric_index_type row_start() const =0
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
processor_id_type processor_id() const
virtual numeric_index_type n() const =0

◆ print_info()

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out)
staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ print_matlab()

template<typename T >
void libMesh::SparseMatrix< T >::print_matlab ( const std::string &  name = "") const
virtualinherited

Print the contents of the matrix in Matlab's sparse matrix format.

Optionally prints the matrix to the file named name. If name is not specified it is dumped to the screen.

Reimplemented in libMesh::PetscMatrix< T >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 361 of file sparse_matrix.C.

362 {
363  parallel_object_only();
364 
365  libmesh_assert (this->initialized());
366 
367  const numeric_index_type first_dof = this->row_start(),
368  end_dof = this->row_stop();
369 
370  // We'll print the matrix from processor 0 to make sure
371  // it's serialized properly
372  if (this->processor_id() == 0)
373  {
374  std::unique_ptr<std::ofstream> file;
375 
376  if (name != "")
377  file = std::make_unique<std::ofstream>(name.c_str());
378 
379  std::ostream & os = (name == "") ? libMesh::out : *file;
380 
381  std::size_t sparsity_nonzeros = this->n_nonzeros();
382 
383  std::size_t real_nonzeros = 0;
384 
385  libmesh_assert_equal_to(first_dof, 0);
386  for (numeric_index_type i : make_range(end_dof))
387  {
388  for (auto j : make_range(this->n()))
389  {
390  T c = (*this)(i,j);
391  if (c != static_cast<T>(0.0))
392  ++real_nonzeros;
393  }
394  }
395 
396 
397  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
398  {
399  std::size_t nonzeros_on_p = 0;
400  this->comm().receive(p, nonzeros_on_p);
401  real_nonzeros += nonzeros_on_p;
402  }
403 
404  if (sparsity_nonzeros &&
405  sparsity_nonzeros != real_nonzeros)
406  libmesh_warning(sparsity_nonzeros <<
407  " nonzeros allocated, but " <<
408  real_nonzeros << " used.");
409 
410  // We probably want to be more consistent than that, if our
411  // sparsity is overallocated.
412 
413  // Print a header similar to PETSc's mat_view ascii_matlab
414  os << "%Mat Object: () " << this->n_processors() << " MPI processes\n"
415  << "% type: " << (this->n_processors() > 1 ? "mpi" : "seq") << "aij\n"
416  << "% Size = " << this->m() << ' ' << this->n() << '\n'
417  << "% Nonzeros = " << real_nonzeros << '\n'
418  << "zzz = zeros(" << real_nonzeros << ",3);\n"
419  << "zzz = [\n";
420 
421  for (numeric_index_type i : make_range(end_dof))
422  {
423  // FIXME - we need a base class way to iterate over a
424  // SparseMatrix row.
425  for (auto j : make_range(this->n()))
426  {
427  T c = (*this)(i,j);
428  if (c != static_cast<T>(0.0))
429  {
430  // Convert from 0-based to 1-based indexing
431  os << (i+1) << ' ' << (j+1) << " " << c << '\n';
432  }
433  }
434  }
435 
436  std::vector<numeric_index_type> ibuf, jbuf;
437  std::vector<T> cbuf;
438  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
439  {
440  this->comm().receive(p, ibuf);
441  this->comm().receive(p, jbuf);
442  this->comm().receive(p, cbuf);
443  libmesh_assert_equal_to (ibuf.size(), jbuf.size());
444  libmesh_assert_equal_to (ibuf.size(), cbuf.size());
445 
446  for (auto n : index_range(ibuf))
447  os << ibuf[n] << ' ' << jbuf[n] << " " << cbuf[n] << '\n';
448  }
449 
450  os << "];\n" << "Mat_sparse = spconvert(zzz);" << std::endl;
451  }
452  else
453  {
454  std::vector<numeric_index_type> ibuf, jbuf;
455  std::vector<T> cbuf;
456  std::size_t my_nonzeros = 0;
457 
458  // We'll assume each processor has access to entire
459  // matrix rows, so (*this)(i,j) is valid if i is a local index.
460  for (numeric_index_type i : make_range(first_dof, end_dof))
461  {
462  for (auto j : make_range(this->n()))
463  {
464  T c = (*this)(i,j);
465  if (c != static_cast<T>(0.0))
466  {
467  ibuf.push_back(i);
468  jbuf.push_back(j);
469  cbuf.push_back(c);
470  ++my_nonzeros;
471  }
472  }
473  }
474  this->comm().send(0,my_nonzeros);
475  this->comm().send(0,ibuf);
476  this->comm().send(0,jbuf);
477  this->comm().send(0,cbuf);
478  }
479 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
virtual bool initialized() const
virtual std::size_t n_nonzeros() const
const Parallel::Communicator & comm() const
virtual numeric_index_type row_stop() const =0
processor_id_type n_processors() const
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type m() const =0
libmesh_assert(ctx)
virtual numeric_index_type row_start() const =0
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const
OStreamProxy out
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
virtual numeric_index_type n() const =0

◆ print_personal()

template<typename T >
void libMesh::EpetraMatrix< T >::print_personal ( std::ostream &  os = libMesh::out) const
overridevirtual

Print the contents of the matrix to the screen in a package-personalized style, if available.

Implements libMesh::SparseMatrix< T >.

Definition at line 597 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

598 {
599  libmesh_assert (this->initialized());
601 
602  os << *_mat;
603 }
virtual bool initialized() const
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and TIMPI::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
processor_id_type rank() const
const Parallel::Communicator & _communicator

◆ read_matlab()

template<typename T >
void libMesh::SparseMatrix< T >::read_matlab ( const std::string &  filename)
virtualinherited

Read the contents of the matrix from Matlab's sparse matrix format.

If the size and sparsity of the matrix in filename appears consistent with the existing sparsity of this then the existing parallel decomposition and sparsity will be retained. If not, then this will be initialized with the sparsity from the file, linearly partitioned onto the number of processors available.

Definition at line 483 of file sparse_matrix.C.

Referenced by ConstraintOperatorTest::test1DCoarseningNewNodes().

484 {
485 #ifndef LIBMESH_HAVE_CXX11_REGEX
486  libmesh_not_implemented(); // What is your compiler?!? Email us!
487  libmesh_ignore(filename);
488 #else
489  parallel_object_only();
490 
491  // The sizes we get from the file
492  std::size_t m = 0,
493  n = 0;
494 
495  // We'll read through the file three times: once to get a reliable
496  // value for the matrix size (so we can divvy it up among
497  // processors), then again to get the sparsity to send to each
498  // processor, then a final time to get the entries to send to each
499  // processor.
500  std::unique_ptr<std::ifstream> file;
501 
502  // We'll be using regular expressions to make ourselves slightly
503  // more robust to formatting.
504  const std::regex start_regex // assignment like "zzz = ["
505  ("\\s*\\w+\\s*=\\s*\\[");
506  const std::regex entry_regex // row/col/val like "1 1 -2.0e-4"
507  ("(\\d+)\\s+(\\d+)\\s+([+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?))");
508  const std::regex end_regex // end of assignment
509  ("^[^%]*\\]");
510 
511  // We'll read the matrix on processor 0 rather than try to juggle
512  // parallel I/O. Start by reading to deduce the size.
513  if (this->processor_id() == 0)
514  {
515  file = std::make_unique<std::ifstream>(filename.c_str());
516 
517  // If we have a matrix with all-zero trailing rows, the only
518  // way to get the size is if it ended up in a comment
519  const std::regex size_regex // comment like "% size = 8 8"
520  ("%\\s*[Ss][Ii][Zz][Ee]\\s*=\\s*(\\d+)\\s+(\\d+)");
521 
522  // Get the size
523  bool have_started = false;
524  bool have_ended = false;
525  std::size_t largest_i_seen = 0, largest_j_seen = 0;
526  for (std::string line; std::getline(*file, line);)
527  {
528  std::smatch sm;
529 
530  if (std::regex_search(line, sm, size_regex))
531  {
532  const std::string msize = sm[1];
533  const std::string nsize = sm[2];
534  m = std::stoull(msize);
535  n = std::stoull(nsize);
536  }
537 
538  if (std::regex_search(line, start_regex))
539  have_started = true;
540 
541  if (std::regex_search(line, sm, entry_regex))
542  {
543  libmesh_error_msg_if
544  (!have_started, "Confused by premature entries in matrix file " << filename);
545 
546  const std::string istr = sm[1];
547  const std::string jstr = sm[2];
548 
549  std::size_t i = std::stoull(istr);
550  largest_i_seen = std::max(i, largest_i_seen);
551  std::size_t j = std::stoull(jstr);
552  largest_j_seen = std::max(j, largest_j_seen);
553  }
554 
555  if (std::regex_search(line, end_regex))
556  {
557  have_ended = true;
558  break;
559  }
560  }
561 
562  libmesh_error_msg_if
563  (!have_started, "Confused by missing assignment beginning in matrix file " << filename);
564 
565  libmesh_error_msg_if
566  (!have_ended, "Confused by missing assignment ending in matrix file " << filename);
567 
568  libmesh_error_msg_if
569  (m > largest_i_seen, "Confused by missing final row(s) in matrix file " << filename);
570 
571  libmesh_error_msg_if
572  (m > 0 && m < largest_i_seen, "Confused by extra final row(s) in matrix file " << filename);
573 
574  if (!m)
575  m = largest_i_seen;
576 
577  libmesh_error_msg_if
578  (n > largest_j_seen, "Confused by missing final column(s) in matrix file " << filename);
579 
580  libmesh_error_msg_if
581  (n > 0 && n < largest_j_seen, "Confused by extra final column(s) in matrix file " << filename);
582 
583  if (!n)
584  n = largest_j_seen;
585 
586  this->comm().broadcast(m);
587  this->comm().broadcast(n);
588  }
589  else
590  {
591  this->comm().broadcast(m);
592  this->comm().broadcast(n);
593  }
594 
595  // If we don't already have this size, we'll need to reinit later,
596  // and we'll need to redetermine which rows each processor is in
597  // charge of.
598 
600  new_row_start = this->processor_id() * m / this->n_processors(),
601  new_row_stop = (this->processor_id()+1) * m / this->n_processors();
603  new_col_start = this->processor_id() * n / this->n_processors(),
604  new_col_stop = (this->processor_id()+1) * n / this->n_processors();
605 
606  if (this->initialized() &&
607  m == this->m() &&
608  n == this->n())
609  {
610  new_row_start = this->row_start(),
611  new_row_stop = this->row_stop();
612 
613  new_col_start = this->col_start(),
614  new_col_stop = this->col_stop();
615  }
616 
617  std::vector<numeric_index_type> new_row_starts, new_row_stops,
618  new_col_starts, new_col_stops;
619 
620  this->comm().gather(0, new_row_start, new_row_starts);
621  this->comm().gather(0, new_row_stop, new_row_stops);
622  this->comm().gather(0, new_col_start, new_col_starts);
623  this->comm().gather(0, new_col_stop, new_col_stops);
624 
625  // Reread to deduce the sparsity pattern, or at least the maximum
626  // number of on- and off- diagonal non-zeros per row.
627  numeric_index_type on_diagonal_nonzeros =0,
628  off_diagonal_nonzeros =0;
629 
630  if (this->processor_id() == 0)
631  {
632  file->seekg(0);
633 
634  bool have_started = false;
635 
636  // Data for the row we're working on
637 
638  // Use 1-based indexing for current_row, as in the file
639  numeric_index_type current_row = 1;
640  processor_id_type current_proc = 0;
641  numeric_index_type current_on_diagonal_nonzeros = 0;
642  numeric_index_type current_off_diagonal_nonzeros = 0;
643 
644  for (std::string line; std::getline(*file, line);)
645  {
646  std::smatch sm;
647 
648  if (std::regex_search(line, start_regex))
649  have_started = true;
650 
651  if (have_started && std::regex_search(line, sm, entry_regex))
652  {
653  const std::string istr = sm[1];
654  const std::string jstr = sm[2];
655 
656  const numeric_index_type i = std::stoull(istr);
657  const numeric_index_type j = std::stoull(jstr);
658 
659  libmesh_error_msg_if
660  (!i || !j, "Expected 1-based indexing in matrix file "
661  << filename);
662 
663  libmesh_error_msg_if
664  (i < current_row,
665  "Can't handle out-of-order entries in matrix file "
666  << filename);
667  if (i > current_row)
668  {
669  current_row = i;
670  // +1 for 1-based indexing in file
671  while (current_row >= (new_row_stops[current_proc]+1))
672  ++current_proc;
673  current_on_diagonal_nonzeros = 0;
674  current_off_diagonal_nonzeros = 0;
675  }
676 
677  // +1 for 1-based indexing in file
678  if (j >= (new_col_starts[current_proc]+1) &&
679  j < (new_col_stops[current_proc]+1))
680  {
681  ++current_on_diagonal_nonzeros;
682  on_diagonal_nonzeros =
683  std::max(on_diagonal_nonzeros,
684  current_on_diagonal_nonzeros);
685  }
686  else
687  {
688  ++current_off_diagonal_nonzeros;
689  off_diagonal_nonzeros =
690  std::max(off_diagonal_nonzeros,
691  current_off_diagonal_nonzeros);
692  }
693  }
694 
695  if (std::regex_search(line, end_regex))
696  break;
697  }
698  }
699 
700  this->comm().broadcast(on_diagonal_nonzeros);
701  this->comm().broadcast(off_diagonal_nonzeros);
702 
703  this->init(m, n,
704  new_row_stop-new_row_start,
705  new_col_stop-new_col_start,
706  on_diagonal_nonzeros,
707  off_diagonal_nonzeros);
708 
709  // One last reread to set values
710  if (this->processor_id() == 0)
711  {
712  file->seekg(0);
713 
714  bool have_started = false;
715 
716  for (std::string line; std::getline(*file, line);)
717  {
718  std::smatch sm;
719 
720  if (std::regex_search(line, start_regex))
721  have_started = true;
722 
723  if (have_started && std::regex_search(line, sm, entry_regex))
724  {
725  const std::string istr = sm[1];
726  const std::string jstr = sm[2];
727  const std::string cstr = sm[3];
728 
729  const numeric_index_type i = std::stoull(istr);
730  const numeric_index_type j = std::stoull(jstr);
731 
732  // Try to be compatible with
733  // higher-than-double-precision T
734  std::stringstream ss(cstr);
735  T value;
736  ss >> value;
737 
738  // Convert from 1-based to 0-based indexing
739  this->set(i-1, j-1, value);
740  }
741 
742  if (std::regex_search(line, end_regex))
743  break;
744  }
745  }
746  this->close();
747 #endif
748 }
virtual bool initialized() const
void gather(const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
const Parallel::Communicator & comm() const
virtual numeric_index_type row_stop() const =0
uint8_t processor_id_type
processor_id_type n_processors() const
void libmesh_ignore(const Args &...)
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type m() const =0
virtual numeric_index_type col_stop() const =0
virtual numeric_index_type col_start() const =0
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
virtual void close()=0
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
virtual numeric_index_type row_start() const =0
static const bool value
Definition: xdr_io.C:54
processor_id_type processor_id() const
virtual numeric_index_type n() const =0
virtual void init(const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1)=0
Initialize SparseMatrix with the specified sizes.

◆ reinit_submatrix()

template<typename T>
virtual void libMesh::SparseMatrix< T >::reinit_submatrix ( SparseMatrix< T > &  submatrix,
const std::vector< numeric_index_type > &  rows,
const std::vector< numeric_index_type > &  cols 
) const
inlinevirtualinherited

This function is similar to the one above, but it allows you to reuse the existing sparsity pattern of "submatrix" instead of reallocating it again.

This should hopefully be more efficient if you are frequently extracting submatrices of the same size.

Definition at line 475 of file sparse_matrix.h.

478  {
479  this->_get_submatrix(submatrix,
480  rows,
481  cols,
482  true); // true means REUSE submatrix
483  }
virtual void _get_submatrix(SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
Protected implementation of the create_submatrix and reinit_submatrix routines.

◆ row_start()

template<typename T >
numeric_index_type libMesh::EpetraMatrix< T >::row_start ( ) const
overridevirtual
Returns
The index of the first matrix row stored on this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 426 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

427 {
428  libmesh_assert (this->initialized());
430 
431  return static_cast<numeric_index_type>(_map->MinMyGID());
432 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Epetra_Map * _map
Holds the distributed Map.

◆ row_stop()

template<typename T >
numeric_index_type libMesh::EpetraMatrix< T >::row_stop ( ) const
overridevirtual
Returns
The index of the last matrix row (+1) stored on this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 437 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

438 {
439  libmesh_assert (this->initialized());
441 
442  return static_cast<numeric_index_type>(_map->MaxMyGID())+1;
443 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Epetra_Map * _map
Holds the distributed Map.

◆ set()

template<typename T >
void libMesh::EpetraMatrix< T >::set ( const numeric_index_type  i,
const numeric_index_type  j,
const T  value 
)
overridevirtual

Set the element (i,j) to value.

Throws an error if the entry does not exist. Zero values can be "stored" in non-existent fields.

Implements libMesh::SparseMatrix< T >.

Definition at line 470 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), libMesh::libmesh_assert(), and value.

473 {
474  libmesh_assert (this->initialized());
475 
476  int
477  epetra_i = static_cast<int>(i),
478  epetra_j = static_cast<int>(j);
479 
480  T epetra_value = value;
481 
482  if (_mat->Filled())
483  _mat->ReplaceGlobalValues (epetra_i, 1, &epetra_value, &epetra_j);
484  else
485  _mat->InsertGlobalValues (epetra_i, 1, &epetra_value, &epetra_j);
486 }
virtual bool initialized() const
libmesh_assert(ctx)
static const bool value
Definition: xdr_io.C:54
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ swap()

template<typename T >
void libMesh::EpetraMatrix< T >::swap ( EpetraMatrix< T > &  m)

Swaps the internal data pointers, no actual values are swapped.

Definition at line 586 of file trilinos_epetra_matrix.C.

References libMesh::EpetraMatrix< T >::_destroy_mat_on_exit, and libMesh::EpetraMatrix< T >::_mat.

587 {
588  std::swap(_mat, m._mat);
589  std::swap(_destroy_mat_on_exit, m._destroy_mat_on_exit);
590 }
bool _destroy_mat_on_exit
This boolean value should only be set to false for the constructor which takes an Epetra_FECrsMatrix ...
virtual numeric_index_type m() const override
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ update_sparsity_pattern()

template<typename T >
void libMesh::EpetraMatrix< T >::update_sparsity_pattern ( const SparsityPattern::Graph sparsity_pattern)
overridevirtual

Updates the matrix sparsity pattern.

This will tell the underlying matrix storage scheme how to map the \( (i,j) \) elements.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 42 of file trilinos_epetra_matrix.C.

References libMesh::index_range(), libMesh::TriangleWrapper::init(), libMesh::initialized(), and libMesh::libmesh_assert().

43 {
44  // clear data, start over
45  this->clear ();
46 
47  // big trouble if this fails!
48  libmesh_assert(this->_dof_map);
49 
50  const numeric_index_type n_rows = cast_int<numeric_index_type>
51  (sparsity_pattern.size());
52 
53  const numeric_index_type m = this->_dof_map->n_dofs();
54  const numeric_index_type n = m;
55  const numeric_index_type n_l = this->_dof_map->n_dofs_on_processor(this->processor_id());
56  const numeric_index_type m_l = n_l;
57 
58  // error checking
59 #ifndef NDEBUG
60  {
61  libmesh_assert_equal_to (n, m);
62  libmesh_assert_equal_to (n_l, m_l);
63 
65  summed_m_l = m_l,
66  summed_n_l = n_l;
67 
68  this->comm().sum (summed_m_l);
69  this->comm().sum (summed_n_l);
70 
71  libmesh_assert_equal_to (m, summed_m_l);
72  libmesh_assert_equal_to (n, summed_n_l);
73  }
74 #endif
75 
76  // build a map defining the data distribution
77  _map = new Epetra_Map (static_cast<int>(m),
78  m_l,
79  0,
80  Epetra_MpiComm (this->comm().get()));
81 
82  libmesh_assert_equal_to (static_cast<numeric_index_type>(_map->NumGlobalPoints()), m);
83  libmesh_assert_equal_to (static_cast<numeric_index_type>(_map->MaxAllGID()+1), m);
84 
85  const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();
86  const std::vector<numeric_index_type> & n_oz = this->_sp->get_n_oz();
87 
88  // Make sure the sparsity pattern isn't empty
89  libmesh_assert_equal_to (n_nz.size(), n_l);
90  libmesh_assert_equal_to (n_oz.size(), n_l);
91 
92  // Epetra wants the total number of nonzeros, both local and remote.
93  std::vector<int> n_nz_tot; n_nz_tot.reserve(n_nz.size());
94 
95  for (auto i : index_range(n_nz))
96  n_nz_tot.push_back(std::min(n_nz[i] + n_oz[i], n));
97 
98  if (m==0)
99  return;
100 
101  _graph = new Epetra_CrsGraph(Copy, *_map, n_nz_tot.data());
102 
103  // Tell the matrix about its structure. Initialize it
104  // to zero.
105  for (numeric_index_type i=0; i<n_rows; i++)
106  _graph->InsertGlobalIndices(_graph->GRID(i),
107  cast_int<numeric_index_type>(sparsity_pattern[i].size()),
108  const_cast<int *>(reinterpret_cast<const int *>(sparsity_pattern[i].data())));
109 
110  _graph->FillComplete();
111 
112  //Initialize the matrix
113  libmesh_assert (!this->initialized());
114  this->init ();
115  libmesh_assert (this->initialized());
116 }
virtual bool initialized() const
dof_id_type n_dofs_on_processor(const processor_id_type proc) const
Definition: dof_map.h:675
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.
const std::vector< dof_id_type > & get_n_oz() const
The number of off-processor nonzeros in my portion of the global matrix.
void sum(T &r) const
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.
const Parallel::Communicator & comm() const
virtual void init(const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1) override
Initialize SparseMatrix with the specified sizes.
virtual numeric_index_type n() const override
dof_id_type n_dofs() const
Definition: dof_map.h:659
dof_id_type numeric_index_type
Definition: id_types.h:99
Epetra_CrsGraph * _graph
Holds the sparsity pattern.
virtual numeric_index_type m() const override
libmesh_assert(ctx)
const std::vector< dof_id_type > & get_n_nz() const
The number of on-processor nonzeros in my portion of the global matrix.
DofMap const * _dof_map
The DofMap object associated with this object.
processor_id_type processor_id() const
Epetra_Map * _map
Holds the distributed Map.
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ vector_mult()

template<typename T>
void libMesh::SparseMatrix< T >::vector_mult ( NumericVector< T > &  dest,
const NumericVector< T > &  arg 
) const
inherited

Multiplies the matrix by the NumericVector arg and stores the result in NumericVector dest.

Definition at line 200 of file sparse_matrix.C.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBSCMConstruction::Aq_inner_product(), libMesh::RBSCMConstruction::B_inner_product(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), AssembleOptimization::gradient(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), AssembleOptimization::objective(), libMesh::RBConstruction::print_basis_function_orthogonality(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), and libMesh::RBConstruction::update_residual_terms().

202 {
203  dest.zero();
204  this->vector_mult_add(dest,arg);
205 }
void vector_mult_add(NumericVector< T > &dest, const NumericVector< T > &arg) const
Multiplies the matrix by the NumericVector arg and adds the result to the NumericVector dest...

◆ vector_mult_add()

template<typename T>
void libMesh::SparseMatrix< T >::vector_mult_add ( NumericVector< T > &  dest,
const NumericVector< T > &  arg 
) const
inherited

Multiplies the matrix by the NumericVector arg and adds the result to the NumericVector dest.

Definition at line 210 of file sparse_matrix.C.

Referenced by libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

212 {
213  /* This functionality is actually implemented in the \p
214  NumericVector class. */
215  dest.add_vector(arg,*this);
216 }

◆ zero()

template<typename T >
void libMesh::EpetraMatrix< T >::zero ( )
overridevirtual

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 196 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::libmesh_assert().

197 {
198  libmesh_assert (this->initialized());
199 
200  _mat->Scale(0.0);
201 }
virtual bool initialized() const
libmesh_assert(ctx)
Epetra_FECrsMatrix * _mat
Actual Epetra datatype to hold matrix entries.

◆ zero_clone()

template<typename T >
std::unique_ptr< SparseMatrix< T > > libMesh::EpetraMatrix< T >::zero_clone ( ) const
overridevirtual
Returns
A smart pointer to a copy of this matrix with the same type, size, and partitioning, but with all zero entries.
Note
This must be overridden in the derived classes.

Implements libMesh::SparseMatrix< T >.

Definition at line 206 of file trilinos_epetra_matrix.C.

207 {
208  // This function is marked as "not implemented" since it hasn't been
209  // tested, the code below might serve as a possible implementation.
210  libmesh_not_implemented();
211 
212  // Make empty copy with matching comm, initialize, and return.
213  auto mat_copy = std::make_unique<EpetraMatrix<T>>(this->comm());
214  mat_copy->init();
215  mat_copy->zero();
216 
217  // Work around an issue on older compilers. We are able to simply
218  // "return mat_copy;" on newer compilers
219  return std::unique_ptr<SparseMatrix<T>>(mat_copy.release());
220 }
const Parallel::Communicator & comm() const

◆ zero_rows()

template<typename T>
void libMesh::SparseMatrix< T >::zero_rows ( std::vector< numeric_index_type > &  rows,
diag_value = 0.0 
)
virtualinherited

Sets all row entries to 0 then puts diag_value in the diagonal entry.

Reimplemented in libMesh::PetscMatrix< T >, and libMesh::DiagonalMatrix< T >.

Definition at line 221 of file sparse_matrix.C.

222 {
223  /* This functionality isn't implemented or stubbed in every subclass yet */
224  libmesh_not_implemented();
225 }

Member Data Documentation

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

◆ _destroy_mat_on_exit

template<typename T>
bool libMesh::EpetraMatrix< T >::_destroy_mat_on_exit
private

This boolean value should only be set to false for the constructor which takes an Epetra_FECrsMatrix object.

Definition at line 233 of file trilinos_epetra_matrix.h.

Referenced by libMesh::EpetraMatrix< T >::swap().

◆ _dof_map

template<typename T>
DofMap const* libMesh::SparseMatrix< T >::_dof_map
protectedinherited

The DofMap object associated with this object.

May be queried for degree-of-freedom counts on processors.

Definition at line 542 of file sparse_matrix.h.

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

◆ _graph

template<typename T>
Epetra_CrsGraph* libMesh::EpetraMatrix< T >::_graph
private

Holds the sparsity pattern.

Definition at line 227 of file trilinos_epetra_matrix.h.

◆ _is_initialized

template<typename T>
bool libMesh::SparseMatrix< T >::_is_initialized
protectedinherited

◆ _map

template<typename T>
Epetra_Map* libMesh::EpetraMatrix< T >::_map
private

Holds the distributed Map.

Definition at line 222 of file trilinos_epetra_matrix.h.

◆ _mat

template<typename T>
Epetra_FECrsMatrix* libMesh::EpetraMatrix< T >::_mat
private

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects
staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _sp

template<typename T>
SparsityPattern::Build const* libMesh::SparseMatrix< T >::_sp
protectedinherited

The sparsity pattern associated with this object.

Should be queried for entry counts (or with need_full_sparsity_pattern, patterns) when needed.

Definition at line 549 of file sparse_matrix.h.

◆ _use_transpose

template<typename T>
bool libMesh::EpetraMatrix< T >::_use_transpose
private

Epetra has no GetUseTranspose so we need to keep track of whether we're transposed manually.

Definition at line 239 of file trilinos_epetra_matrix.h.

Referenced by libMesh::EpetraMatrix< T >::get_transpose().


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