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

The LaspackMatrix class wraps a QMatrix object from the Laspack library. More...

#include <laspack_matrix.h>

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

Public Member Functions

 LaspackMatrix (const Parallel::Communicator &comm)
 Constructor; initializes the matrix to be empty, without any structure, i.e. More...
 
 LaspackMatrix (LaspackMatrix &&)=delete
 This class manages a C-style struct (QMatrix) manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor. More...
 
 LaspackMatrix (const LaspackMatrix &)=delete
 
LaspackMatrixoperator= (const LaspackMatrix &)=delete
 
LaspackMatrixoperator= (LaspackMatrix &&)=delete
 
virtual ~LaspackMatrix ()
 
virtual SparseMatrix< T > & operator= (const SparseMatrix< T > &) override
 This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual. More...
 
virtual SolverPackage solver_package () override
 
virtual bool need_full_sparsity_pattern () const override
 The LaspackMatrix 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 () override
 Restores the SparseMatrix<T> to a pristine state. 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...
 
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 bool require_sparsity_pattern () const
 
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...
 
Real l1_norm_diff (const SparseMatrix< T > &other_mat) const
 
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 print_petsc_binary (const std::string &filename)
 Write the contents of the matrix to a file in PETSc's binary sparse matrix format. More...
 
virtual void print_petsc_hdf5 (const std::string &filename)
 Write the contents of the matrix to a file in PETSc's HDF5 sparse matrix format. More...
 
virtual void read (const std::string &filename)
 Read the contents of the matrix from a file, with the file format inferred from the extension of filename. More...
 
virtual void read_coreform_hdf5 (const std::string &filename, const std::string &groupname="extraction")
 Read the contents of the matrix from a file, with the HDF5 sparse matrix format used by CoreForm, expecing sparse matrix data in the group given by groupname. More...
 
virtual void read_matlab (const std::string &filename)
 Read the contents of the matrix from the Matlab-script sparse matrix format used by PETSc. More...
 
virtual void read_petsc_binary (const std::string &filename)
 Read the contents of the matrix from a file in PETSc's binary sparse matrix format. More...
 
virtual void read_petsc_hdf5 (const std::string &filename)
 Read the contents of the matrix from a file in PETSc's HDF5 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...
 
virtual void scale (const T scale)
 Scales all elements of this matrix by scale. More...
 
virtual bool supports_hash_table () const
 
void use_hash_table (bool use_hash)
 Sets whether to use hash table assembly. More...
 
bool use_hash_table () const
 
virtual void restore_original_nonzero_pattern ()
 Reset the memory storage of the matrix. 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...
 
bool _use_hash_table
 Flag indicating whether the matrix is assembled using a hash table. 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 Member Functions

numeric_index_type pos (const numeric_index_type i, const numeric_index_type j) const
 

Private Attributes

QMatrix _QMat
 The Laspack sparse matrix pointer. More...
 
std::vector< numeric_index_type_csr
 The compressed row indices. More...
 
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
 The start of each row in the compressed row index data structure. More...
 
bool _closed
 Flag indicating if the matrix has been closed yet. More...
 

Friends

class LaspackVector< T >
 Make other Laspack datatypes friends. More...
 
class LaspackLinearSolver< T >
 

Detailed Description

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

The LaspackMatrix class wraps a QMatrix object from the Laspack library.

Currently Laspack only supports real datatypes, so this class is a full specialization of SparseMatrix<T> with T = Real. All overridden virtual functions are documented in sparse_matrix.h.

Author
Benjamin S. Kirk
Date
2003

Definition at line 56 of file laspack_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

◆ LaspackMatrix() [1/3]

template<typename T >
libMesh::LaspackMatrix< T >::LaspackMatrix ( 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 393 of file laspack_matrix.C.

393  :
394  SparseMatrix<T>(comm),
395  _closed (false)
396 {
397 }
const Parallel::Communicator & comm() const
bool _closed
Flag indicating if the matrix has been closed yet.

◆ LaspackMatrix() [2/3]

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

This class manages a C-style struct (QMatrix) manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor.

◆ LaspackMatrix() [3/3]

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

◆ ~LaspackMatrix()

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

Definition at line 402 of file laspack_matrix.C.

403 {
404  this->clear ();
405 }
virtual void clear() override
Restores the SparseMatrix<T> to a pristine state.

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 640 of file sparse_matrix.h.

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

644  {
645  libmesh_not_implemented();
646  }

◆ add() [1/2]

template<typename T >
void libMesh::LaspackMatrix< 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 557 of file laspack_matrix.C.

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

560 {
561  libmesh_assert (this->initialized());
562  libmesh_assert_less (i, this->m());
563  libmesh_assert_less (j, this->n());
564 
565  const numeric_index_type position = this->pos(i,j);
566 
567  // Sanity check
568  libmesh_assert_equal_to (*(_row_start[i]+position), j);
569 
570  Q_AddVal (&_QMat, i+1, position, value);
571 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
numeric_index_type pos(const numeric_index_type i, const numeric_index_type j) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override
virtual numeric_index_type n() const override
static const bool value
Definition: xdr_io.C:55

◆ add() [2/2]

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

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

Note
LASPACK does not provide a true axpy for matrices, so a hand-coded version with hopefully acceptable performance is provided.

Implements libMesh::SparseMatrix< T >.

Definition at line 585 of file laspack_matrix.C.

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

586 {
587  libmesh_assert (this->initialized());
588  libmesh_assert_equal_to (this->m(), X_in.m());
589  libmesh_assert_equal_to (this->n(), X_in.n());
590 
591  const LaspackMatrix<T> * X =
592  cast_ptr<const LaspackMatrix<T> *> (&X_in);
593 
594  _LPNumber a = static_cast<_LPNumber> (a_in);
595 
596  libmesh_assert(X);
597 
598  // loops taken from LaspackMatrix<T>::zero ()
599 
600  const numeric_index_type n_rows = this->m();
601 
602  for (numeric_index_type row=0; row<n_rows; row++)
603  {
604  auto r_start = _row_start[row];
605 
606  const numeric_index_type len = (_row_start[row+1] - _row_start[row]);
607 
608  // Make sure we agree on the row length
609  libmesh_assert_equal_to (len, Q_GetLen(&_QMat, row+1));
610  // compare matrix sparsity structures
611  libmesh_assert_equal_to (len, Q_GetLen(&(X->_QMat), row+1));
612 
613 
614  for (numeric_index_type l=0; l<len; l++)
615  {
616  const numeric_index_type j = *(r_start + l);
617 
618  // Make sure the data structures are working
619  libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, row+1, l));
620 
621  const _LPNumber value = a * Q_GetEl(const_cast<QMatrix*>(&(X->_QMat)), row+1, j+1);
622  Q_AddVal (&_QMat, row+1, l, value);
623  }
624  }
625 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override
virtual numeric_index_type n() const override
static const bool value
Definition: xdr_io.C:55

◆ 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 96 of file sparse_matrix.C.

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

99 {
100  libmesh_assert_equal_to (dm.m() / brows.size(), dm.n() / bcols.size());
101 
102  const numeric_index_type blocksize = cast_int<numeric_index_type>
103  (dm.m() / brows.size());
104 
105  libmesh_assert_equal_to (dm.m()%blocksize, 0);
106  libmesh_assert_equal_to (dm.n()%blocksize, 0);
107 
108  std::vector<numeric_index_type> rows, cols;
109 
110  rows.reserve(blocksize*brows.size());
111  cols.reserve(blocksize*bcols.size());
112 
113  for (auto & row : brows)
114  {
115  numeric_index_type i = row * blocksize;
116 
117  for (unsigned int v=0; v<blocksize; v++)
118  rows.push_back(i++);
119  }
120 
121  for (auto & col : bcols)
122  {
123  numeric_index_type j = col * blocksize;
124 
125  for (unsigned int v=0; v<blocksize; v++)
126  cols.push_back(j++);
127  }
128 
129  this->add_matrix (dm, rows, cols);
130 }
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 337 of file sparse_matrix.h.

339  { 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:96

◆ add_matrix() [1/2]

template<typename T >
void libMesh::LaspackMatrix< 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 259 of file laspack_matrix.C.

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

263 {
264  libmesh_assert (this->initialized());
265  unsigned int n_rows = cast_int<unsigned int>(rows.size());
266  unsigned int n_cols = cast_int<unsigned int>(cols.size());
267  libmesh_assert_equal_to (dm.m(), n_rows);
268  libmesh_assert_equal_to (dm.n(), n_cols);
269 
270 
271  for (unsigned int i=0; i<n_rows; i++)
272  for (unsigned int j=0; j<n_cols; j++)
273  this->add(rows[i],cols[j],dm(i,j));
274 }
virtual bool initialized() const
virtual void add(const numeric_index_type i, const numeric_index_type j, const T value) override
Add value to the element (i,j).
libmesh_assert(ctx)

◆ add_matrix() [2/2]

template<typename T >
void libMesh::LaspackMatrix< 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 576 of file laspack_matrix.C.

578 {
579  this->add_matrix (dm, dof_indices, dof_indices);
580 }
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 356 of file sparse_matrix.h.

360  { 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 77 of file sparse_matrix.C.

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

78 {
79  _dof_map = &dof_map;
80  if (!_sp)
81  _sp = dof_map.get_sparsity_pattern();
82 }
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 87 of file sparse_matrix.C.

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

88 {
89  _sp = &sp;
90 }
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 170 of file sparse_matrix.C.

Referenced by libMesh::CondensedEigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::StaticCondensation::init(), main(), libMesh::DofMap::process_mesh_constraint_rows(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

173 {
174  // Avoid unused parameter warnings when no solver packages are enabled.
176 
177  if (matrix_build_type == MatrixBuildType::DIAGONAL)
178  return std::make_unique<DiagonalMatrix<T>>(comm);
179 
180  // Build the appropriate vector
181  switch (solver_package)
182  {
183 
184 #ifdef LIBMESH_HAVE_LASPACK
185  case LASPACK_SOLVERS:
186  return std::make_unique<LaspackMatrix<T>>(comm);
187 #endif
188 
189 
190 #ifdef LIBMESH_HAVE_PETSC
191  case PETSC_SOLVERS:
192  return std::make_unique<PetscMatrix<T>>(comm);
193 #endif
194 
195 
196 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
197  case TRILINOS_SOLVERS:
198  return std::make_unique<EpetraMatrix<T>>(comm);
199 #endif
200 
201 
202 #ifdef LIBMESH_HAVE_EIGEN
203  case EIGEN_SOLVERS:
204  return std::make_unique<EigenSparseMatrix<T>>(comm);
205 #endif
206 
207  default:
208  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
209  }
210 }
const Parallel::Communicator & comm() const
void libmesh_ignore(const Args &...)
virtual SolverPackage solver_package()=0

◆ clear()

template<typename T >
void libMesh::LaspackMatrix< T >::clear ( )
overridevirtual

Restores the SparseMatrix<T> to a pristine state.

Implements libMesh::SparseMatrix< T >.

Definition at line 410 of file laspack_matrix.C.

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

411 {
412  if (this->initialized())
413  {
414  Q_Destr(&_QMat);
415  }
416 
417  _csr.clear();
418  _row_start.clear();
419  _closed = false;
420  this->_is_initialized = false;
421 }
virtual bool initialized() const
std::vector< numeric_index_type > _csr
The compressed row indices.
QMatrix _QMat
The Laspack sparse matrix pointer.
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
bool _closed
Flag indicating if the matrix has been closed yet.

◆ clone()

template<typename T >
std::unique_ptr< SparseMatrix< T > > libMesh::LaspackMatrix< 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 474 of file laspack_matrix.C.

475 {
476  // We don't currently have a faster implementation than making a
477  // zero clone and then filling in the values.
478  auto mat_copy = this->zero_clone();
479  mat_copy->add(1., *this);
480 
481  return mat_copy;
482 }
virtual std::unique_ptr< SparseMatrix< T > > zero_clone() const override

◆ close()

template<typename T >
void libMesh::LaspackMatrix< 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 668 of file laspack_matrix.C.

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

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), and libMesh::LaspackLinearSolver< T >::solve().

669 {
670  libmesh_assert(this->initialized());
671 
672  this->_closed = true;
673 
674  // We've probably changed some entries so we need to tell LASPACK
675  // that cached data is now invalid.
676  *_QMat.DiagElAlloc = _LPFalse;
677  *_QMat.ElSorted = _LPFalse;
678  if (*_QMat.ILUExists)
679  {
680  *_QMat.ILUExists = _LPFalse;
681  Q_Destr(_QMat.ILU);
682  }
683 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
libmesh_assert(ctx)
bool _closed
Flag indicating if the matrix has been closed yet.

◆ closed()

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

Implements libMesh::SparseMatrix< T >.

Definition at line 169 of file laspack_matrix.h.

References libMesh::LaspackMatrix< T >::_closed.

169 { return _closed; }
bool _closed
Flag indicating if the matrix has been closed yet.

◆ col_start()

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

Implements libMesh::SparseMatrix< T >.

Definition at line 521 of file laspack_matrix.C.

522 {
523  return 0;
524 }

◆ col_stop()

template<typename T >
numeric_index_type libMesh::LaspackMatrix< 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 529 of file laspack_matrix.C.

530 {
531  return this->n();
532 }
virtual numeric_index_type n() const override

◆ 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::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::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::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), 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::AdvectionSystem::assemble_claw_rhs(), 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::Partitioner::build_graph(), 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::CondensedEigenSystem::copy_super_to_sub(), 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< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), 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::SmoothnessEstimator::estimate_smoothness(), 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::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), 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::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_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_constraint_rows(), 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::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), 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::MeshBase::print_constraint_rows(), 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(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), 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::VariationalMeshSmoother::smooth(), libMesh::ClawSystem::solve_conservation_law(), 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(), VolumeTest::testC0PolygonMethods(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), 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(), update_current_local_solution(), 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::MeshTools::volume(), libMesh::STLIO::write(), 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 PetscMatrixBase subclasses. 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 520 of file sparse_matrix.h.

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

523  {
524  this->_get_submatrix(submatrix,
525  rows,
526  cols,
527  false); // false means DO NOT REUSE submatrix
528  }
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 538 of file sparse_matrix.h.

541  {
542  libmesh_not_implemented();
543  }

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

Definition at line 244 of file sparse_matrix.h.

244 { 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::LaspackMatrix< T >::get_diagonal ( NumericVector< T > &  dest) const
overridevirtual

Copies the diagonal part of the matrix into dest.

Implements libMesh::SparseMatrix< T >.

Definition at line 347 of file laspack_matrix.C.

348 {
349  libmesh_not_implemented();
350 }

◆ 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::LaspackMatrix< 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 363 of file laspack_matrix.C.

366 {
367  indices.clear();
368  values.clear();
369 
370  const numeric_index_type len = (_row_start[i+1] - _row_start[i]);
371 
372  // Make sure we agree on the row length
373  libmesh_assert_equal_to (len, Q_GetLen(&_QMat, i+1));
374 
375  auto r_start = _row_start[i];
376 
377  for (numeric_index_type l=0; l<len; l++)
378  {
379  const numeric_index_type j = *(r_start + l);
380 
381  // Make sure the data structures are working
382  libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, i+1, l));
383 
384  indices.push_back(j);
385 
386  values.push_back(Q_GetVal (&_QMat, i+1, l));
387  }
388 }
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.

◆ get_transpose()

template<typename T >
void libMesh::LaspackMatrix< 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 355 of file laspack_matrix.C.

356 {
357  libmesh_not_implemented();
358 }

◆ 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 >
void libMesh::LaspackMatrix< 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 >.

Definition at line 128 of file laspack_matrix.C.

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

135 {
136  // noz ignored... only used for multiple processors!
137  libmesh_assert_equal_to (m_in, m_l);
138  libmesh_assert_equal_to (n_in, n_l);
139  libmesh_assert_equal_to (m_in, n_in);
140  libmesh_assert_greater (nnz, 0);
141 
142  if ((m_in != m_l) ||
143  (n_in != n_l))
144  libmesh_not_implemented_msg("Laspack does not support distributed matrices");
145 
146  if (m_in != n_in)
147  libmesh_not_implemented_msg("Laspack does not support rectangular matrices");
148 
149  if (nnz < n_in)
150  libmesh_warning("Using inefficient LaspackMatrix allocation via this init() method");
151 
152  const dof_id_type n_rows = m_in;
153 
154  // Laspack doesn't let us assign sparse indices on the fly, so
155  // without a sparsity pattern we're stuck allocating a dense matrix
156  {
157  _csr.resize (m_in * m_in);
158  _row_start.reserve(m_in + 1);
159  }
160 
161  // Initialize the _csr data structure.
162  {
163  std::vector<numeric_index_type>::iterator position = _csr.begin();
164 
165  _row_start.push_back (position);
166 
167  for (numeric_index_type row=0; row<n_rows; row++)
168  {
169  // insert the row indices
170  for (const auto & col : make_range(n_rows))
171  {
172  libmesh_assert (position != _csr.end());
173  *position = col;
174  ++position;
175  }
176 
177  _row_start.push_back (position);
178  }
179  }
180 
181  Q_Constr(&_QMat, const_cast<char *>("Mat"), m_in, _LPFalse, Rowws, Normal, _LPTrue);
182 
183  this->_is_initialized = true;
184 
185  // Tell the matrix about its structure. Initialize it
186  // to zero.
187  for (numeric_index_type i=0; i<n_rows; i++)
188  {
189  auto rs = _row_start[i];
190 
191  const numeric_index_type length = _row_start[i+1] - rs;
192 
193  Q_SetLen (&_QMat, i+1, length);
194 
195  for (numeric_index_type l=0; l<length; l++)
196  {
197  const numeric_index_type j = *(rs+l);
198 
199  libmesh_assert_equal_to (this->pos(i,j), l);
200  Q_SetEntry (&_QMat, i+1, l, j+1, 0.);
201  }
202  }
203 }
std::vector< numeric_index_type > _csr
The compressed row indices.
QMatrix _QMat
The Laspack sparse matrix pointer.
numeric_index_type pos(const numeric_index_type i, const numeric_index_type j) const
dof_id_type numeric_index_type
Definition: id_types.h:99
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
libmesh_assert(ctx)
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
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:140
uint8_t dof_id_type
Definition: id_types.h:67

◆ init() [2/2]

template<typename T >
void libMesh::LaspackMatrix< 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 208 of file laspack_matrix.C.

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

209 {
210  // Ignore calls on initialized objects
211  if (this->initialized())
212  return;
213 
214  // We need a sparsity pattern for this!
215  libmesh_assert(this->_sp);
216 
217  // Clear initialized matrices
218  if (this->initialized())
219  this->clear();
220 
221  const numeric_index_type n_rows = this->_dof_map->n_dofs();
222 #ifndef NDEBUG
223  // The following variables are only used for assertions,
224  // so avoid declaring them when asserts are inactive.
225  const numeric_index_type n_cols = n_rows;
226  const numeric_index_type n_l = this->_dof_map->n_dofs_on_processor(0);
227  const numeric_index_type m_l = n_l;
228 #endif
229 
230  // Laspack Matrices only work for uniprocessor cases
231  libmesh_assert_equal_to (n_rows, n_cols);
232  libmesh_assert_equal_to (m_l, n_rows);
233  libmesh_assert_equal_to (n_l, n_cols);
234 
235 #ifndef NDEBUG
236  // The following variables are only used for assertions,
237  // so avoid declaring them when asserts are inactive.
238  const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();
239  const std::vector<numeric_index_type> & n_oz = this->_sp->get_n_oz();
240 #endif
241 
242  // Make sure the sparsity pattern isn't empty
243  libmesh_assert_equal_to (n_nz.size(), n_l);
244  libmesh_assert_equal_to (n_oz.size(), n_l);
245 
246  if (n_rows==0)
247  return;
248 
249  Q_Constr(&_QMat, const_cast<char *>("Mat"), n_rows, _LPFalse, Rowws, Normal, _LPTrue);
250 
251  this->_is_initialized = true;
252 
253  libmesh_assert_equal_to (n_rows, this->m());
254 }
virtual bool initialized() const
const std::vector< dof_id_type > & get_n_oz() const
The number of off-processor nonzeros in my portion of the global matrix.
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.
dof_id_type n_dofs(const unsigned int vn) const
Definition: dof_map.h:675
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
libmesh_assert(ctx)
dof_id_type n_dofs_on_processor(const processor_id_type proc) const
Definition: dof_map_base.h:197
const std::vector< dof_id_type > & get_n_nz() const
The number of on-processor nonzeros in my portion of the global matrix.
virtual void clear() override
Restores the SparseMatrix<T> to a pristine state.
DofMap const * _dof_map
The DofMap object associated with this object.
virtual numeric_index_type m() const override

◆ initialized()

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

Reimplemented in libMesh::StaticCondensation.

Definition at line 133 of file sparse_matrix.h.

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

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

◆ l1_norm()

template<typename T >
Real libMesh::LaspackMatrix< 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 279 of file laspack_matrix.C.

References libMesh::make_range().

280 {
281  // There does not seem to be a straightforward way to iterate over
282  // the columns of a LaspackMatrix. So we use some extra storage and
283  // keep track of the column sums while going over the row entries...
284  std::vector<Real> abs_col_sums(this->n());
285 
286  const numeric_index_type n_rows = this->m();
287 
288  for (numeric_index_type row : make_range(n_rows))
289  {
290  auto r_start = _row_start[row];
291 
292  const numeric_index_type len = (_row_start[row+1] - _row_start[row]);
293 
294  // Make sure we agree on the row length
295  libmesh_assert_equal_to (len, Q_GetLen(&_QMat, row+1));
296 
297  for (numeric_index_type l=0; l<len; l++)
298  {
299  const numeric_index_type j = *(r_start + l);
300 
301  // Make sure the data structures are working
302  libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, row+1, l));
303 
304  abs_col_sums[j] += std::abs(Q_GetVal (&_QMat, row+1, l));
305  }
306  }
307 
308  return *(std::max_element(abs_col_sums.begin(), abs_col_sums.end()));
309 }
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override
virtual numeric_index_type n() 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:140

◆ l1_norm_diff()

template<typename T>
Real libMesh::SparseMatrix< T >::l1_norm_diff ( const SparseMatrix< T > &  other_mat) const
inherited
Returns
The l1_norm() of the difference of this and other_mat

Definition at line 1124 of file sparse_matrix.C.

1125 {
1126  auto diff_mat = this->clone();
1127  diff_mat->add(-1.0, other_mat);
1128  return diff_mat->l1_norm();
1129 }
virtual std::unique_ptr< SparseMatrix< T > > clone() const =0

◆ linfty_norm()

template<typename T >
Real libMesh::LaspackMatrix< 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 314 of file laspack_matrix.C.

References libMesh::make_range(), and libMesh::Real.

315 {
316  const numeric_index_type n_rows = this->m();
317 
318  Real max_row_sum = 0;
319 
320  for (numeric_index_type row : make_range(n_rows))
321  {
322  Real row_sum = 0;
323 
324  const numeric_index_type len = (_row_start[row+1] - _row_start[row]);
325 
326  // Make sure we agree on the row length
327  libmesh_assert_equal_to (len, Q_GetLen(&_QMat, row+1));
328 
329  for (numeric_index_type l=0; l<len; l++)
330  {
331  // Make sure the data structures are working
332  libmesh_assert_equal_to ((*(_row_start[row] + l)+1), Q_GetPos
333  (&_QMat, row+1, l));
334 
335  row_sum += std::abs(Q_GetVal (&_QMat, row+1, l));
336  }
337 
338  max_row_sum = std::max(max_row_sum, row_sum);
339  }
340 
341  return max_row_sum;
342 }
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual numeric_index_type m() 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:140

◆ 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::PetscMatrixBase< T >, libMesh::PetscMatrixBase< libMesh::Number >, and libMesh::PetscMatrixBase< Number >.

Definition at line 254 of file sparse_matrix.h.

Referenced by libMesh::CondensedEigenSystem::copy_super_to_sub().

254 { 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::PetscMatrixBase< T >, libMesh::PetscMatrixBase< libMesh::Number >, and libMesh::PetscMatrixBase< Number >.

Definition at line 259 of file sparse_matrix.h.

259 { 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::LaspackMatrix< T >::m ( ) const
overridevirtual
Returns
The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 485 of file laspack_matrix.C.

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

486 {
487  libmesh_assert (this->initialized());
488 
489  return static_cast<numeric_index_type>(Q_GetDim(const_cast<QMatrix*>(&_QMat)));
490 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)

◆ 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 349 of file sparse_matrix.h.

350  { libmesh_not_implemented(); }

◆ n()

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

Implements libMesh::SparseMatrix< T >.

Definition at line 495 of file laspack_matrix.C.

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

496 {
497  libmesh_assert (this->initialized());
498 
499  return static_cast<numeric_index_type>(Q_GetDim(const_cast<QMatrix*>(&_QMat)));
500 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)

◆ 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 243 of file sparse_matrix.C.

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

244 {
245  if (!_sp)
246  return 0;
247  return _sp->n_nonzeros();
248 }
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::Partitioner::build_graph(), 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::UnstructuredMesh::copy_nodes_and_elements(), 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::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_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::DofMap::n_dofs_per_processor(), 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::MeshBase::print_constraint_rows(), 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::LaspackMatrix< T >::need_full_sparsity_pattern ( ) const
inlineoverridevirtual

The LaspackMatrix needs the full sparsity pattern.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 96 of file laspack_matrix.h.

97  { return true; }

◆ operator()()

template<typename T >
T libMesh::LaspackMatrix< 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 631 of file laspack_matrix.C.

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

633 {
634  libmesh_assert (this->initialized());
635  libmesh_assert_less (i, this->m());
636  libmesh_assert_less (j, this->n());
637 
638  return Q_GetEl (const_cast<QMatrix*>(&_QMat), i+1, j+1);
639 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
libmesh_assert(ctx)
virtual numeric_index_type m() const override
virtual numeric_index_type n() const override

◆ operator=() [1/3]

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

◆ operator=() [2/3]

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

◆ operator=() [3/3]

template<typename T>
virtual SparseMatrix<T>& libMesh::LaspackMatrix< T >::operator= ( const SparseMatrix< T > &  )
inlineoverridevirtual

This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual.

This function should be overridden in derived classes so that they can be copied correctly via references to the base class. This design usually isn't a good idea in general, but in this context it works because we usually don't have a mix of different kinds of SparseMatrix active in the library at a single time.

Returns
A reference to *this as the base type.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 82 of file laspack_matrix.h.

83  {
84  libmesh_not_implemented();
85  return *this;
86  }

◆ pos()

template<typename T >
numeric_index_type libMesh::LaspackMatrix< T >::pos ( const numeric_index_type  i,
const numeric_index_type  j 
) const
private
Returns
The position in the compressed row storage scheme of the \( (i,j) \) element.

Definition at line 644 of file laspack_matrix.C.

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

646 {
647  libmesh_assert_less (i, this->m());
648  libmesh_assert_less (j, this->n());
649  libmesh_assert_less (i+1, _row_start.size());
650  libmesh_assert (_row_start.back() == _csr.end());
651 
652  // note this requires the _csr to be sorted
653  auto p = std::equal_range (_row_start[i], _row_start[i+1], j);
654 
655  // Make sure the row contains the element j
656  libmesh_assert (p.first != p.second);
657 
658  // Make sure the values match
659  libmesh_assert (*p.first == j);
660 
661  // Return the position in the compressed row
662  return std::distance (_row_start[i], p.first);
663 }
std::vector< numeric_index_type > _csr
The compressed row indices.
Real distance(const Point &p)
libmesh_assert(ctx)
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override
virtual numeric_index_type n() const override

◆ print() [1/2]

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

Definition at line 136 of file sparse_matrix.C.

137 {
138  // std::complex<>::operator<<() is defined, but use this form
139 
140  if (sparse)
141  {
142  libmesh_not_implemented();
143  }
144 
145  os << "Real part:" << std::endl;
146  for (auto i : make_range(this->m()))
147  {
148  for (auto j : make_range(this->n()))
149  os << std::setw(8) << (*this)(i,j).real() << " ";
150  os << std::endl;
151  }
152 
153  os << std::endl << "Imaginary part:" << std::endl;
154  for (auto i : make_range(this->m()))
155  {
156  for (auto j : make_range(this->n()))
157  os << std::setw(8) << (*this)(i,j).imag() << " ";
158  os << std::endl;
159  }
160 }
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:140
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 252 of file sparse_matrix.C.

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

253 {
254  parallel_object_only();
255 
256  libmesh_assert (this->initialized());
257 
258  const numeric_index_type first_dof = this->row_start(),
259  end_dof = this->row_stop();
260 
261  // We'll print the matrix from processor 0 to make sure
262  // it's serialized properly
263  if (this->processor_id() == 0)
264  {
265  libmesh_assert_equal_to (first_dof, 0);
266  for (numeric_index_type i : make_range(end_dof))
267  {
268  if (sparse)
269  {
270  for (auto j : make_range(this->n()))
271  {
272  T c = (*this)(i,j);
273  if (c != static_cast<T>(0.0))
274  {
275  os << i << " " << j << " " << c << std::endl;
276  }
277  }
278  }
279  else
280  {
281  for (auto j : make_range(this->n()))
282  os << (*this)(i,j) << " ";
283  os << std::endl;
284  }
285  }
286 
287  std::vector<numeric_index_type> ibuf, jbuf;
288  std::vector<T> cbuf;
289  numeric_index_type currenti = end_dof;
290  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
291  {
292  this->comm().receive(p, ibuf);
293  this->comm().receive(p, jbuf);
294  this->comm().receive(p, cbuf);
295  libmesh_assert_equal_to (ibuf.size(), jbuf.size());
296  libmesh_assert_equal_to (ibuf.size(), cbuf.size());
297 
298  if (ibuf.empty())
299  continue;
300  libmesh_assert_greater_equal (ibuf.front(), currenti);
301  libmesh_assert_greater_equal (ibuf.back(), ibuf.front());
302 
303  std::size_t currentb = 0;
304  for (;currenti <= ibuf.back(); ++currenti)
305  {
306  if (sparse)
307  {
308  for (numeric_index_type j=0; j<this->n(); j++)
309  {
310  if (currentb < ibuf.size() &&
311  ibuf[currentb] == currenti &&
312  jbuf[currentb] == j)
313  {
314  os << currenti << " " << j << " " << cbuf[currentb] << std::endl;
315  currentb++;
316  }
317  }
318  }
319  else
320  {
321  for (auto j : make_range(this->n()))
322  {
323  if (currentb < ibuf.size() &&
324  ibuf[currentb] == currenti &&
325  jbuf[currentb] == j)
326  {
327  os << cbuf[currentb] << " ";
328  currentb++;
329  }
330  else
331  os << static_cast<T>(0.0) << " ";
332  }
333  os << std::endl;
334  }
335  }
336  }
337  if (!sparse)
338  {
339  for (; currenti != this->m(); ++currenti)
340  {
341  for (numeric_index_type j=0; j<this->n(); j++)
342  os << static_cast<T>(0.0) << " ";
343  os << std::endl;
344  }
345  }
346  }
347  else
348  {
349  std::vector<numeric_index_type> ibuf, jbuf;
350  std::vector<T> cbuf;
351 
352  // We'll assume each processor has access to entire
353  // matrix rows, so (*this)(i,j) is valid if i is a local index.
354  for (numeric_index_type i : make_range(first_dof, end_dof))
355  {
356  for (auto j : make_range(this->n()))
357  {
358  T c = (*this)(i,j);
359  if (c != static_cast<T>(0.0))
360  {
361  ibuf.push_back(i);
362  jbuf.push_back(j);
363  cbuf.push_back(c);
364  }
365  }
366  }
367  this->comm().send(0,ibuf);
368  this->comm().send(0,jbuf);
369  this->comm().send(0,cbuf);
370  }
371 }
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:140
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 >.

Definition at line 375 of file sparse_matrix.C.

376 {
377  parallel_object_only();
378 
379  libmesh_assert (this->initialized());
380 
381  const numeric_index_type first_dof = this->row_start(),
382  end_dof = this->row_stop();
383 
384  // We'll print the matrix from processor 0 to make sure
385  // it's serialized properly
386  if (this->processor_id() == 0)
387  {
388  std::unique_ptr<std::ofstream> file;
389 
390  if (name != "")
391  file = std::make_unique<std::ofstream>(name.c_str());
392 
393  std::ostream & os = (name == "") ? libMesh::out : *file;
394 
395  std::size_t sparsity_nonzeros = this->n_nonzeros();
396 
397  std::size_t real_nonzeros = 0;
398 
399  libmesh_assert_equal_to(first_dof, 0);
400  for (numeric_index_type i : make_range(end_dof))
401  {
402  for (auto j : make_range(this->n()))
403  {
404  T c = (*this)(i,j);
405  if (c != static_cast<T>(0.0))
406  ++real_nonzeros;
407  }
408  }
409 
410 
411  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
412  {
413  std::size_t nonzeros_on_p = 0;
414  this->comm().receive(p, nonzeros_on_p);
415  real_nonzeros += nonzeros_on_p;
416  }
417 
418  if (sparsity_nonzeros &&
419  sparsity_nonzeros != real_nonzeros)
420  libmesh_warning(sparsity_nonzeros <<
421  " nonzeros allocated, but " <<
422  real_nonzeros << " used.");
423 
424  // We probably want to be more consistent than that, if our
425  // sparsity is overallocated.
426 
427  // Print a header similar to PETSc's mat_view ascii_matlab
428  os << "%Mat Object: () " << this->n_processors() << " MPI processes\n"
429  << "% type: " << (this->n_processors() > 1 ? "mpi" : "seq") << "aij\n"
430  << "% Size = " << this->m() << ' ' << this->n() << '\n'
431  << "% Nonzeros = " << real_nonzeros << '\n'
432  << "zzz = zeros(" << real_nonzeros << ",3);\n"
433  << "zzz = [\n";
434 
435  for (numeric_index_type i : make_range(end_dof))
436  {
437  // FIXME - we need a base class way to iterate over a
438  // SparseMatrix row.
439  for (auto j : make_range(this->n()))
440  {
441  T c = (*this)(i,j);
442  if (c != static_cast<T>(0.0))
443  {
444  // Convert from 0-based to 1-based indexing
445  os << (i+1) << ' ' << (j+1) << " " << c << '\n';
446  }
447  }
448  }
449 
450  std::vector<numeric_index_type> ibuf, jbuf;
451  std::vector<T> cbuf;
452  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
453  {
454  this->comm().receive(p, ibuf);
455  this->comm().receive(p, jbuf);
456  this->comm().receive(p, cbuf);
457  libmesh_assert_equal_to (ibuf.size(), jbuf.size());
458  libmesh_assert_equal_to (ibuf.size(), cbuf.size());
459 
460  for (auto n : index_range(ibuf))
461  os << ibuf[n] << ' ' << jbuf[n] << " " << cbuf[n] << '\n';
462  }
463 
464  os << "];\n" << "Mat_sparse = spconvert(zzz);" << std::endl;
465  }
466  else
467  {
468  std::vector<numeric_index_type> ibuf, jbuf;
469  std::vector<T> cbuf;
470  std::size_t my_nonzeros = 0;
471 
472  // We'll assume each processor has access to entire
473  // matrix rows, so (*this)(i,j) is valid if i is a local index.
474  for (numeric_index_type i : make_range(first_dof, end_dof))
475  {
476  for (auto j : make_range(this->n()))
477  {
478  T c = (*this)(i,j);
479  if (c != static_cast<T>(0.0))
480  {
481  ibuf.push_back(i);
482  jbuf.push_back(j);
483  cbuf.push_back(c);
484  ++my_nonzeros;
485  }
486  }
487  }
488  this->comm().send(0,my_nonzeros);
489  this->comm().send(0,ibuf);
490  this->comm().send(0,jbuf);
491  this->comm().send(0,cbuf);
492  }
493 }
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:140
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:117
virtual numeric_index_type n() const =0

◆ print_personal()

template<typename T>
virtual void libMesh::LaspackMatrix< T >::print_personal ( std::ostream &  os = libMesh::out) const
inlineoverridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 171 of file laspack_matrix.h.

References libMesh::SparseMatrix< T >::print().

171 { this->print(os); }
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 packag...

◆ print_petsc_binary()

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

Write the contents of the matrix to a file in PETSc's binary sparse matrix format.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 498 of file sparse_matrix.C.

499 {
500  libmesh_not_implemented_msg
501  ("libMesh cannot write PETSc binary-format files from non-PETSc matrices");
502 }

◆ print_petsc_hdf5()

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

Write the contents of the matrix to a file in PETSc's HDF5 sparse matrix format.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 507 of file sparse_matrix.C.

508 {
509  libmesh_not_implemented_msg
510  ("libMesh cannot write PETSc HDF5-format files from non-PETSc matrices");
511 }

◆ 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::MeshFunction::check_found_elem(), 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_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::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::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::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(), 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::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::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::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::MeshBase::print_constraint_rows(), 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::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), 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::testBadGmsh(), 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::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), 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()

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

Read the contents of the matrix from a file, with the file format inferred from the extension of filename.

Definition at line 516 of file sparse_matrix.C.

517 {
518  {
519  std::ifstream in (filename.c_str());
520  libmesh_error_msg_if
521  (!in.good(), "ERROR: cannot read file:\n\t" <<
522  filename);
523  }
524 
525  std::string_view basename = Utility::basename_of(filename);
526 
527  const bool gzipped_file = Utility::ends_with(filename, ".gz");
528 
529  if (gzipped_file)
530  basename.remove_suffix(3);
531 
532  if (Utility::ends_with(basename, ".matlab") ||
533  Utility::ends_with(basename, ".m"))
534  this->read_matlab(filename);
535  else if (Utility::ends_with(basename, ".petsc64"))
536  {
537 #ifndef LIBMESH_HAVE_PETSC
538  libmesh_error_msg("Cannot load PETSc matrix file " <<
539  filename << " without PETSc-enabled libMesh.");
540 #endif
541 #if LIBMESH_DOF_ID_BYTES != 8
542  libmesh_error_msg("Cannot load 64-bit PETSc matrix file " <<
543  filename << " with non-64-bit libMesh.");
544 #endif
545  this->read_petsc_binary(filename);
546  }
547  else if (Utility::ends_with(basename, ".petsc32"))
548  {
549 #ifndef LIBMESH_HAVE_PETSC
550  libmesh_error_msg("Cannot load PETSc matrix file " <<
551  filename << " without PETSc-enabled libMesh.");
552 #endif
553 #if LIBMESH_DOF_ID_BYTES != 4
554  libmesh_error_msg("Cannot load 32-bit PETSc matrix file " <<
555  filename << " with non-32-bit libMesh.");
556 #endif
557  this->read_petsc_binary(filename);
558  }
559  else if (Utility::ends_with(basename, ".h5"))
560  {
561  this->read_coreform_hdf5(filename);
562  }
563  else
564  libmesh_error_msg(" ERROR: Unrecognized matrix file extension on: "
565  << basename
566  << "\n I understand the following:\n\n"
567  << " *.h5 -- CoreForm HDF5 sparse matrix format\n"
568  << " *.matlab -- Matlab sparse matrix format\n"
569  << " *.m -- Matlab sparse matrix format\n"
570  << " *.petsc32 -- PETSc binary format, 32-bit\n"
571  << " *.petsc64 -- PETSc binary format, 64-bit\n"
572  );
573 }
bool ends_with(std::string_view superstring, std::string_view suffix)
Look for a substring at the very end of a string.
Definition: utility.C:213
virtual void read_coreform_hdf5(const std::string &filename, const std::string &groupname="extraction")
Read the contents of the matrix from a file, with the HDF5 sparse matrix format used by CoreForm...
virtual void read_matlab(const std::string &filename)
Read the contents of the matrix from the Matlab-script sparse matrix format used by PETSc...
virtual void read_petsc_binary(const std::string &filename)
Read the contents of the matrix from a file in PETSc&#39;s binary sparse matrix format.
std::string_view basename_of(const std::string &fullname)
Definition: utility.C:108

◆ read_coreform_hdf5()

template<typename T >
void libMesh::SparseMatrix< T >::read_coreform_hdf5 ( const std::string &  filename,
const std::string &  groupname = "extraction" 
)
virtualinherited

Read the contents of the matrix from a file, with the HDF5 sparse matrix format used by CoreForm, expecing sparse matrix data in the group given by groupname.

This will be initialized with the sparsity from the file, linearly partitioned onto the number of processors available unless this matrix is pre-sized and pre-partitionsed.

Definition at line 578 of file sparse_matrix.C.

580 {
581 #ifndef LIBMESH_HAVE_HDF5
582  libmesh_ignore(filename, groupname);
583  libmesh_error_msg("ERROR: need HDF5 support to handle .h5 files!!!");
584 #else
585  LOG_SCOPE("read_coreform_hdf5()", "SparseMatrix");
586 
587  std::size_t num_rows, num_cols;
588 
589  hid_t group;
590 
591  auto check_open = [&filename](hid_t id, const std::string & objname)
592  {
593  if (id == H5I_INVALID_HID)
594  libmesh_error_msg("Couldn't open " + objname + " in " + filename);
595  };
596 
597  auto check_hdf5 = [&filename](auto hdf5val, const std::string & objname)
598  {
599  if (hdf5val < 0)
600  libmesh_error_msg("HDF5 error from " + objname + " in " + filename);
601  };
602 
603 
604  if (this->processor_id() == 0)
605  {
606  const hid_t file = H5Fopen(filename.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
607 
608  if (file == H5I_INVALID_HID)
609  libmesh_file_error(filename);
610 
611  group = H5Gopen(file, groupname.c_str(), H5P_DEFAULT);
612  check_open(group, groupname);
613 
614  auto read_size_attribute = [&filename, &group, &check_open, &check_hdf5]
615  (const std::string & attribute_name)
616  {
617  unsigned long long returnval = 0;
618 
619  const hid_t attr = H5Aopen(group, attribute_name.c_str(), H5P_DEFAULT);
620  check_open(attr, attribute_name);
621 
622  const hid_t attr_type = H5Aget_type(attr);
623  check_hdf5(attr_type, attribute_name + " type");
624 
625  // HDF5 will convert between the file's integer type and ours, but
626  // we do expect an integer type.
627  if (H5Tget_class(attr_type) != H5T_INTEGER)
628  libmesh_error_msg("Non-integer type for " + attribute_name + " in " + filename);
629 
630  H5Tclose(attr_type);
631 
632  // HDF5 is supposed to handle both upscaling and endianness
633  // conversions here
634  herr_t errval = H5Aread(attr, H5T_NATIVE_ULLONG, &returnval);
635  check_hdf5(errval, attribute_name + " read");
636 
637  H5Aclose(attr);
638 
639  return returnval;
640  };
641 
642  num_cols = read_size_attribute("num_cols");
643  num_rows = read_size_attribute("num_rows");
644 
645  this->comm().broadcast(num_cols);
646  this->comm().broadcast(num_rows);
647  }
648  else
649  {
650  this->comm().broadcast(num_cols);
651  this->comm().broadcast(num_rows);
652  }
653 
654  numeric_index_type new_row_start, new_row_stop,
655  new_col_start, new_col_stop;
656 
657  // If we need to reinit, we need to determine which rows+columns
658  // each processor is in charge of.
659  std::vector<numeric_index_type> new_row_starts, new_row_stops,
660  new_col_starts, new_col_stops;
661 
662  if (this->initialized() &&
663  num_cols == this->m() &&
664  num_rows == this->n())
665  {
666  new_row_start = this->row_start(),
667  new_row_stop = this->row_stop();
668 
669  new_col_start = this->col_start(),
670  new_col_stop = this->col_stop();
671  }
672  else
673  {
674  // Determine which rows/columns each processor will be in charge of
675  new_row_start = this->processor_id() * num_rows / this->n_processors(),
676  new_row_stop = (this->processor_id()+1) * num_rows / this->n_processors();
677 
678  new_col_start = this->processor_id() * num_cols / this->n_processors(),
679  new_col_stop = (this->processor_id()+1) * num_cols / this->n_processors();
680  }
681 
682  this->comm().gather(0, new_row_start, new_row_starts);
683  this->comm().gather(0, new_row_stop, new_row_stops);
684  this->comm().gather(0, new_col_start, new_col_starts);
685  this->comm().gather(0, new_col_stop, new_col_stops);
686 
687  numeric_index_type on_diagonal_nonzeros = 0,
688  off_diagonal_nonzeros = 0;
689 
690  std::vector<std::size_t> cols, row_offsets;
691  std::vector<double> vals;
692 
693  if (this->processor_id() == 0)
694  {
695  auto read_vector = [&filename, &group, &check_open, &check_hdf5]
696  (const std::string & dataname, auto hdf5_class,
697  auto hdf5_type, auto & datavec)
698  {
699  const hid_t data = H5Dopen1(group, dataname.c_str());
700  check_open(data, dataname.c_str());
701 
702  const hid_t data_type = H5Dget_type(data);
703  check_hdf5(data_type, dataname + " type");
704 
705  // HDF5 will convert between the file's integer type and ours, but
706  // we do expect an integer type.
707  if (H5Tget_class(data_type) != hdf5_class)
708  libmesh_error_msg("Unexpected type for " + dataname + " in " + filename);
709 
710  H5Tclose(data_type);
711 
712  const hid_t dataspace = H5Dget_space(data);
713  check_hdf5(dataspace, dataname + " space");
714 
715  int ndims = H5Sget_simple_extent_ndims(dataspace);
716  if (ndims != 1)
717  libmesh_error_msg("Non-vector space for " + dataname + " in " + filename);
718 
719  hsize_t len, maxlen;
720  herr_t errval = H5Sget_simple_extent_dims(dataspace, &len, &maxlen);
721  check_hdf5(errval, dataname + " dims");
722 
723  datavec.resize(len);
724 
725  errval = H5Dread(data, hdf5_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, datavec.data());
726  check_hdf5(errval, dataname + " read");
727  };
728 
729  read_vector("cols", H5T_INTEGER, H5T_NATIVE_ULLONG, cols);
730  read_vector("row_offsets", H5T_INTEGER, H5T_NATIVE_ULLONG, row_offsets);
731  read_vector("vals", H5T_FLOAT, H5T_NATIVE_DOUBLE, vals);
732 
733  if (cols.size() != vals.size())
734  libmesh_error_msg("Inconsistent cols/vals sizes in " + filename);
735 
736  if (row_offsets.size() != num_rows + 1)
737  libmesh_error_msg("Inconsistent row_offsets size in " + filename);
738 
739  // Data for the row we're working on
740  numeric_index_type current_row = 0;
741  processor_id_type current_proc = 0;
742  numeric_index_type current_on_diagonal_nonzeros = 0;
743  numeric_index_type current_off_diagonal_nonzeros = 0;
744  if (row_offsets[0] != 0)
745  libmesh_error_msg("Unexpected row_offsets[0] in " + filename);
746 
747  for (auto i : index_range(cols))
748  {
749  while (row_offsets[current_row+1] <= i)
750  {
751  ++current_row;
752  if (row_offsets[current_row] < row_offsets[current_row-1])
753  libmesh_error_msg("Non-monotonic row_offsets in " + filename);
754  current_on_diagonal_nonzeros = 0;
755  current_off_diagonal_nonzeros = 0;
756  }
757 
758  while (current_row >= (new_row_stops[current_proc]+1))
759  ++current_proc;
760 
761  // 0-based indexing in file
762  if (cols[i] >= new_col_starts[current_proc] &&
763  cols[i] < new_col_stops[current_proc])
764  {
765  ++current_on_diagonal_nonzeros;
766  on_diagonal_nonzeros =
767  std::max(on_diagonal_nonzeros,
768  current_on_diagonal_nonzeros);
769  }
770  else
771  {
772  ++current_off_diagonal_nonzeros;
773  off_diagonal_nonzeros =
774  std::max(off_diagonal_nonzeros,
775  current_off_diagonal_nonzeros);
776  }
777  }
778  }
779 
780  this->comm().broadcast(on_diagonal_nonzeros);
781  this->comm().broadcast(off_diagonal_nonzeros);
782 
783  this->init(num_rows, num_cols,
784  new_row_stop-new_row_start,
785  new_col_stop-new_col_start,
786  on_diagonal_nonzeros,
787  off_diagonal_nonzeros);
788 
789  // Set the matrix values last.
790  if (this->processor_id() == 0)
791  {
792  numeric_index_type current_row = 0;
793  for (auto i : index_range(cols))
794  {
795  while (row_offsets[current_row+1] <= i)
796  {
797  ++current_row;
798  libmesh_assert_greater_equal (row_offsets[current_row],
799  row_offsets[current_row-1]);
800  }
801  this->set(current_row, cols[i], vals[i]);
802  }
803  }
804 
805  this->close();
806 #endif // LIBMESH_HAVE_HDF5
807 }
virtual bool initialized() const
MPI_Datatype data_type
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
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:117
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.

◆ read_matlab()

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

Read the contents of the matrix from the Matlab-script sparse matrix format used by PETSc.

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 812 of file sparse_matrix.C.

Referenced by ConstraintOperatorTest::test1DCoarseningNewNodes().

813 {
814  LOG_SCOPE("read_matlab()", "SparseMatrix");
815 
816 #ifndef LIBMESH_HAVE_CXX11_REGEX
817  libmesh_not_implemented(); // What is your compiler?!? Email us!
818  libmesh_ignore(filename);
819 #else
820  parallel_object_only();
821 
822  const bool gzipped_file = Utility::ends_with(filename, ".gz");
823 
824  // The sizes we get from the file
825  std::size_t m = 0,
826  n = 0;
827 
828  // If we don't already have this size, we'll need to reinit, and
829  // determine which rows+columns each processor is in charge of.
830  std::vector<numeric_index_type> new_row_starts, new_row_stops,
831  new_col_starts, new_col_stops;
832 
833  numeric_index_type new_row_start, new_row_stop,
834  new_col_start, new_col_stop;
835 
836  // We'll read through the file three times: once to get a reliable
837  // value for the matrix size (so we can divvy it up among
838  // processors), then again to get the sparsity to send to each
839  // processor, then a final time to get the entries to send to each
840  // processor.
841  //
842  // We'll use an istream here; it might be an ifstream if we're
843  // opening a raw ASCII file or a gzstream if we're opening a
844  // compressed one.
845  std::unique_ptr<std::istream> file;
846 
847  // We'll need a temporary structure to cache matrix entries, because
848  // we need to read through the whole file before we know the size
849  // and sparsity structure with which we can init().
850  //
851  // Reading through the file three times via `seekg` doesn't work
852  // with our gzstream wrapper, and seems to take three times as long
853  // even with a plain ifstream. What happened to disk caching!?
854  std::vector<std::tuple<numeric_index_type, numeric_index_type, T>> entries;
855 
856  // First read through the file, saving size and entry data
857  {
858  // We'll read the matrix on processor 0 rather than try to juggle
859  // parallel I/O.
860  if (this->processor_id() == 0)
861  {
862  // We'll be using regular expressions to make ourselves slightly
863  // more robust to formatting.
864  const std::regex start_regex // assignment like "zzz = ["
865  ("\\s*\\w+\\s*=\\s*\\[");
866  const std::regex end_regex // end of assignment
867  ("^[^%]*\\]");
868 
869  if (gzipped_file)
870  {
871 #ifdef LIBMESH_HAVE_GZSTREAM
872  auto inf = std::make_unique<igzstream>();
873  libmesh_assert(inf);
874  inf->open(filename.c_str(), std::ios::in);
875  file = std::move(inf);
876 #else
877  libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
878 #endif
879  }
880  else
881  {
882  auto inf = std::make_unique<std::ifstream>();
883  libmesh_assert(inf);
884 
885  std::string new_name = Utility::unzip_file(filename);
886 
887  inf->open(new_name.c_str(), std::ios::in);
888  file = std::move(inf);
889  }
890 
891  // If we have a matrix with all-zero trailing rows, the only
892  // way to get the size is if it ended up in a comment
893  const std::regex size_regex // comment like "% size = 8 8"
894  ("%\\s*[Ss][Ii][Zz][Ee]\\s*=\\s*(\\d+)\\s+(\\d+)");
895  const std::string whitespace = " \t";
896 
897  bool have_started = false;
898  bool have_ended = false;
899  std::size_t largest_i_seen = 0, largest_j_seen = 0;
900 
901  // Data for the row we're working on
902  // Use 1-based indexing for current_row, as in the file
903  std::size_t current_row = 1;
904 
905  for (std::string line; std::getline(*file, line);)
906  {
907  std::smatch sm;
908 
909  // First, try to match an entry. This is the most common
910  // case so we won't rely on slow std::regex for it.
911  // stringstream is at least an improvement over that.
912 
913  // Look for row/col/val like "1 1 -2.0e-4"
914 
915  std::istringstream l(line);
916 
917  std::size_t i, j;
918  T value;
919 
920  l >> i >> j >> value;
921 
922  if (!l.fail())
923  {
924  libmesh_error_msg_if
925  (!have_started, "Confused by premature entries in matrix file " << filename);
926 
927  entries.emplace_back(cast_int<numeric_index_type>(i),
928  cast_int<numeric_index_type>(j),
929  value);
930 
931  libmesh_error_msg_if
932  (!i || !j, "Expected 1-based indexing in matrix file "
933  << filename);
934 
935  current_row = std::max(current_row, i);
936 
937  libmesh_error_msg_if
938  (i < current_row,
939  "Can't handle out-of-order entries in matrix file "
940  << filename);
941 
942  largest_i_seen = std::max(i, largest_i_seen);
943  largest_j_seen = std::max(j, largest_j_seen);
944  }
945 
946  else if (std::regex_search(line, sm, size_regex))
947  {
948  const std::string msize = sm[1];
949  const std::string nsize = sm[2];
950  m = std::stoull(msize);
951  n = std::stoull(nsize);
952  }
953 
954  else if (std::regex_search(line, start_regex))
955  have_started = true;
956 
957  else if (std::regex_search(line, end_regex))
958  {
959  have_ended = true;
960  break;
961  }
962  }
963 
964  libmesh_error_msg_if
965  (!have_started, "Confused by missing assignment beginning in matrix file " << filename);
966 
967  libmesh_error_msg_if
968  (!have_ended, "Confused by missing assignment ending in matrix file " << filename);
969 
970  libmesh_error_msg_if
971  (m > largest_i_seen, "Confused by missing final row(s) in matrix file " << filename);
972 
973  libmesh_error_msg_if
974  (m > 0 && m < largest_i_seen, "Confused by extra final row(s) in matrix file " << filename);
975 
976  if (!m)
977  m = largest_i_seen;
978 
979  libmesh_error_msg_if
980  (n > largest_j_seen, "Confused by missing final column(s) in matrix file " << filename);
981 
982  libmesh_error_msg_if
983  (n > 0 && n < largest_j_seen, "Confused by extra final column(s) in matrix file " << filename);
984 
985  if (!n)
986  n = largest_j_seen;
987 
988  this->comm().broadcast(m);
989  this->comm().broadcast(n);
990  }
991  else
992  {
993  this->comm().broadcast(m);
994  this->comm().broadcast(n);
995  }
996 
997  if (this->initialized() &&
998  m == this->m() &&
999  n == this->n())
1000  {
1001  new_row_start = this->row_start(),
1002  new_row_stop = this->row_stop();
1003 
1004  new_col_start = this->col_start(),
1005  new_col_stop = this->col_stop();
1006  }
1007  else
1008  {
1009  // Determine which rows/columns each processor will be in charge of
1010  new_row_start = this->processor_id() * m / this->n_processors(),
1011  new_row_stop = (this->processor_id()+1) * m / this->n_processors();
1012 
1013  new_col_start = this->processor_id() * n / this->n_processors(),
1014  new_col_stop = (this->processor_id()+1) * n / this->n_processors();
1015  }
1016 
1017  this->comm().gather(0, new_row_start, new_row_starts);
1018  this->comm().gather(0, new_row_stop, new_row_stops);
1019  this->comm().gather(0, new_col_start, new_col_starts);
1020  this->comm().gather(0, new_col_stop, new_col_stops);
1021 
1022  } // Done reading entry data and broadcasting matrix size
1023 
1024  // Calculate the matrix sparsity and initialize it second
1025  {
1026  // Deduce the sparsity pattern, or at least the maximum number of
1027  // on- and off- diagonal non-zeros per row.
1028  numeric_index_type on_diagonal_nonzeros =0,
1029  off_diagonal_nonzeros =0;
1030 
1031  if (this->processor_id() == 0)
1032  {
1033  // Data for the row we're working on
1034  // Use 1-based indexing for current_row, as in the file
1035  numeric_index_type current_row = 1;
1036  processor_id_type current_proc = 0;
1037  numeric_index_type current_on_diagonal_nonzeros = 0;
1038  numeric_index_type current_off_diagonal_nonzeros = 0;
1039 
1040  for (auto [i, j, value] : entries)
1041  {
1042  if (i > current_row)
1043  {
1044  current_row = i;
1045  // +1 for 1-based indexing in file
1046  while (current_row >= (new_row_stops[current_proc]+1))
1047  ++current_proc;
1048  current_on_diagonal_nonzeros = 0;
1049  current_off_diagonal_nonzeros = 0;
1050  }
1051 
1052  // +1 for 1-based indexing in file
1053  if (j >= (new_col_starts[current_proc]+1) &&
1054  j < (new_col_stops[current_proc]+1))
1055  {
1056  ++current_on_diagonal_nonzeros;
1057  on_diagonal_nonzeros =
1058  std::max(on_diagonal_nonzeros,
1059  current_on_diagonal_nonzeros);
1060  }
1061  else
1062  {
1063  ++current_off_diagonal_nonzeros;
1064  off_diagonal_nonzeros =
1065  std::max(off_diagonal_nonzeros,
1066  current_off_diagonal_nonzeros);
1067  }
1068  }
1069  }
1070 
1071  this->comm().broadcast(on_diagonal_nonzeros);
1072  this->comm().broadcast(off_diagonal_nonzeros);
1073 
1074  this->init(m, n,
1075  new_row_stop-new_row_start,
1076  new_col_stop-new_col_start,
1077  on_diagonal_nonzeros,
1078  off_diagonal_nonzeros);
1079  }
1080 
1081  // Set the matrix values last.
1082  // Convert from 1-based to 0-based indexing
1083  if (this->processor_id() == 0)
1084  for (auto [i, j, value] : entries)
1085  this->set(i-1, j-1, value);
1086 
1087  this->close();
1088 #endif
1089 }
virtual bool initialized() const
bool ends_with(std::string_view superstring, std::string_view suffix)
Look for a substring at the very end of a string.
Definition: utility.C:213
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
std::string unzip_file(std::string_view name)
Create an unzipped copy of a bz2 or xz file, returning the name of the now-unzipped file that can be ...
Definition: utility.C:164
libmesh_assert(ctx)
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:55
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.

◆ read_petsc_binary()

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

Read the contents of the matrix from a file in PETSc's binary sparse matrix format.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 1094 of file sparse_matrix.C.

1095 {
1096  libmesh_not_implemented_msg
1097  ("libMesh cannot read PETSc binary-format files into non-PETSc matrices");
1098 }

◆ read_petsc_hdf5()

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

Read the contents of the matrix from a file in PETSc's HDF5 sparse matrix format.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 1103 of file sparse_matrix.C.

1104 {
1105  libmesh_not_implemented_msg
1106  ("libMesh cannot read PETSc HDF5-format files into non-PETSc matrices");
1107 }

◆ 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 551 of file sparse_matrix.h.

554  {
555  this->_get_submatrix(submatrix,
556  rows,
557  cols,
558  true); // true means REUSE submatrix
559  }
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.

◆ require_sparsity_pattern()

template<typename T>
virtual bool libMesh::SparseMatrix< T >::require_sparsity_pattern ( ) const
inlinevirtualinherited
Returns
Whether this matrix needs the sparsity pattern computed by the DofMap

Reimplemented in libMesh::StaticCondensation, libMesh::PetscMatrixShellMatrix< T >, and libMesh::PetscMatrixShellMatrix< Number >.

Definition at line 168 of file sparse_matrix.h.

168 { return !this->use_hash_table(); }
bool use_hash_table() const

◆ restore_original_nonzero_pattern()

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

Reset the memory storage of the matrix.

Unlike clear(), this does not destroy the matrix but rather will reset the matrix to use the original preallocation or when using hash table matrix assembly (see use_hash_table()) will reset (clear) the hash table used for assembly. In the words of the MatResetPreallocation documentation in PETSc, 'current values in the matrix are lost in this call', so a user can expect to have back their original sparsity pattern in a zeroed state

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

Definition at line 630 of file sparse_matrix.h.

630 { libmesh_not_implemented(); }

◆ row_start()

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

Implements libMesh::SparseMatrix< T >.

Definition at line 505 of file laspack_matrix.C.

506 {
507  return 0;
508 }

◆ row_stop()

template<typename T >
numeric_index_type libMesh::LaspackMatrix< 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 513 of file laspack_matrix.C.

514 {
515  return this->m();
516 }
virtual numeric_index_type m() const override

◆ scale()

template<typename T>
void libMesh::SparseMatrix< T >::scale ( const T  scale)
virtualinherited

Scales all elements of this matrix by scale.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 1112 of file sparse_matrix.C.

1113 {
1114  libmesh_assert(this->closed());
1115 
1116  for (const auto i : make_range(this->row_start(), this->row_stop()))
1117  for (const auto j : make_range(this->col_start(), this->col_stop()))
1118  this->set(i, j, (*this)(i, j) * scale);
1119 }
virtual numeric_index_type row_stop() const =0
libmesh_assert(ctx)
virtual numeric_index_type col_stop() const =0
virtual numeric_index_type col_start() const =0
virtual bool closed() const =0
virtual numeric_index_type row_start() 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:140
virtual void scale(const T scale)
Scales all elements of this matrix by scale.

◆ set()

template<typename T >
void libMesh::LaspackMatrix< 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 537 of file laspack_matrix.C.

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

540 {
541  libmesh_assert (this->initialized());
542  libmesh_assert_less (i, this->m());
543  libmesh_assert_less (j, this->n());
544 
545  const numeric_index_type position = this->pos(i,j);
546 
547  // Sanity check
548  libmesh_assert_equal_to (*(_row_start[i]+position), j);
549  libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, i+1, position));
550 
551  Q_SetEntry (&_QMat, i+1, position, j+1, value);
552 }
virtual bool initialized() const
QMatrix _QMat
The Laspack sparse matrix pointer.
numeric_index_type pos(const numeric_index_type i, const numeric_index_type j) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override
virtual numeric_index_type n() const override
static const bool value
Definition: xdr_io.C:55

◆ solver_package()

template<typename T>
virtual SolverPackage libMesh::LaspackMatrix< T >::solver_package ( )
inlineoverridevirtual

Implements libMesh::SparseMatrix< T >.

Definition at line 88 of file laspack_matrix.h.

References libMesh::LASPACK_SOLVERS.

◆ supports_hash_table()

template<typename T>
virtual bool libMesh::SparseMatrix< T >::supports_hash_table ( ) const
inlinevirtualinherited
Returns
Whether the matrix supports hash table assembly

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 605 of file sparse_matrix.h.

605 { return false; }

◆ update_sparsity_pattern()

template<typename T >
void libMesh::LaspackMatrix< 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 laspack_matrix.C.

References 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 = sparsity_pattern.size();
51 
52  // Initialize the _row_start data structure,
53  // allocate storage for the _csr array
54  {
55  std::size_t size = 0;
56 
57  for (numeric_index_type row=0; row<n_rows; row++)
58  size += sparsity_pattern[row].size();
59 
60  _csr.resize (size);
61  _row_start.reserve(n_rows + 1);
62  }
63 
64 
65  // Initialize the _csr data structure.
66  {
67  std::vector<numeric_index_type>::iterator position = _csr.begin();
68 
69  _row_start.push_back (position);
70 
71  for (numeric_index_type row=0; row<n_rows; row++)
72  {
73  // insert the row indices
74  for (const auto & col : sparsity_pattern[row])
75  {
76  libmesh_assert (position != _csr.end());
77  *position = col;
78  ++position;
79  }
80 
81  _row_start.push_back (position);
82  }
83  }
84 
85 
86  // Initialize the matrix
87  libmesh_assert (!this->initialized());
88  this->init ();
89  libmesh_assert (this->initialized());
90  //libMesh::out << "n_rows=" << n_rows << std::endl;
91  //libMesh::out << "m()=" << m() << std::endl;
92  libmesh_assert_equal_to (n_rows, this->m());
93 
94  // Tell the matrix about its structure. Initialize it
95  // to zero.
96  for (numeric_index_type i=0; i<n_rows; i++)
97  {
98  auto rs = _row_start[i];
99 
100  const numeric_index_type length = _row_start[i+1] - rs;
101 
102  Q_SetLen (&_QMat, i+1, length);
103 
104  for (numeric_index_type l=0; l<length; l++)
105  {
106  const numeric_index_type j = *(rs+l);
107 
108  // sanity check
109  //libMesh::out << "m()=" << m() << std::endl;
110  //libMesh::out << "(i,j,l) = (" << i
111  // << "," << j
112  // << "," << l
113  // << ")" << std::endl;
114  //libMesh::out << "pos(i,j)=" << pos(i,j)
115  // << std::endl;
116  libmesh_assert_equal_to (this->pos(i,j), l);
117  Q_SetEntry (&_QMat, i+1, l, j+1, 0.);
118  }
119  }
120 
121  // That's it!
122  //libmesh_here();
123 }
virtual bool initialized() 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.
std::vector< numeric_index_type > _csr
The compressed row indices.
QMatrix _QMat
The Laspack sparse matrix pointer.
numeric_index_type pos(const numeric_index_type i, const numeric_index_type j) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
virtual void clear() override
Restores the SparseMatrix<T> to a pristine state.
DofMap const * _dof_map
The DofMap object associated with this object.
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override

◆ use_hash_table() [1/2]

template<typename T >
void libMesh::SparseMatrix< T >::use_hash_table ( bool  use_hash)
inherited

Sets whether to use hash table assembly.

This will error if the passed-in value is true and the matrix type does not support hash tables. Hash table or hash map assembly means storing maps from i-j locations in the matrix to values. Because it is a hash map as opposed to a contiguous array of data, no preallocation is required to use it

Definition at line 678 of file sparse_matrix.h.

Referenced by PetscMatrixTest::testPetscCopyFromHash().

679 {
680  libmesh_error_msg_if(use_hash && !this->supports_hash_table(),
681  "This matrix class does not support hash table assembly");
682  this->_use_hash_table = use_hash;
683 }
bool _use_hash_table
Flag indicating whether the matrix is assembled using a hash table.
virtual bool supports_hash_table() const

◆ use_hash_table() [2/2]

template<typename T>
bool libMesh::SparseMatrix< T >::use_hash_table ( ) const
inlineinherited
Returns
Whether this matrix is using hash table assembly. Hash table or hash map assembly means storing maps from i-j locations in the matrix to values. Because it is a hash map as opposed to a contiguous array of data, no preallocation is required to use it

Definition at line 620 of file sparse_matrix.h.

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

620 { return _use_hash_table; }
bool _use_hash_table
Flag indicating whether the matrix is assembled using a hash table.

◆ 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 214 of file sparse_matrix.C.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBSCMConstruction::Aq_inner_product(), libMesh::AdvectionSystem::assemble_claw_rhs(), 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().

216 {
217  dest.zero();
218  this->vector_mult_add(dest,arg);
219 }
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 224 of file sparse_matrix.C.

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

226 {
227  /* This functionality is actually implemented in the \p
228  NumericVector class. */
229  dest.add_vector(arg,*this);
230 }

◆ zero()

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

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 426 of file laspack_matrix.C.

427 {
428  const numeric_index_type n_rows = this->m();
429 
430  for (numeric_index_type row=0; row<n_rows; row++)
431  {
432  auto r_start = _row_start[row];
433 
434  const numeric_index_type len = (_row_start[row+1] - _row_start[row]);
435 
436  // Make sure we agree on the row length
437  libmesh_assert_equal_to (len, Q_GetLen(&_QMat, row+1));
438 
439  for (numeric_index_type l=0; l<len; l++)
440  {
441  const numeric_index_type j = *(r_start + l);
442 
443  // Make sure the data structures are working
444  libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, row+1, l));
445 
446  Q_SetEntry (&_QMat, row+1, l, j+1, 0.);
447  }
448  }
449 
450  this->close();
451 }
QMatrix _QMat
The Laspack sparse matrix pointer.
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
dof_id_type numeric_index_type
Definition: id_types.h:99
std::vector< std::vector< numeric_index_type >::const_iterator > _row_start
The start of each row in the compressed row index data structure.
virtual numeric_index_type m() const override

◆ zero_clone()

template<typename T >
std::unique_ptr< SparseMatrix< T > > libMesh::LaspackMatrix< 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 456 of file laspack_matrix.C.

457 {
458  // Make empty copy with matching comm, initialize, zero, and return.
459  auto mat_copy = std::make_unique<LaspackMatrix<T>>(this->comm());
460  if (this->_dof_map)
461  mat_copy->attach_dof_map(*this->_dof_map);
462  else
463  mat_copy->init(this->m(), this->n(), this->local_m(),
464  this->local_n(), this->local_n());
465 
466  mat_copy->zero();
467 
468  return mat_copy;
469 }
virtual numeric_index_type local_m() const
Get the number of rows owned by this process.
const Parallel::Communicator & comm() const
virtual numeric_index_type local_n() const
Get the number of columns owned by this process.
DofMap const * _dof_map
The DofMap object associated with this object.
virtual numeric_index_type m() const override
virtual numeric_index_type n() const override

◆ 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::DiagonalMatrix< T >, and libMesh::PetscMatrix< T >.

Definition at line 235 of file sparse_matrix.C.

236 {
237  /* This functionality isn't implemented or stubbed in every subclass yet */
238  libmesh_not_implemented();
239 }

Friends And Related Function Documentation

◆ LaspackLinearSolver< T >

template<typename T>
friend class LaspackLinearSolver< T >
friend

Definition at line 215 of file laspack_matrix.h.

◆ LaspackVector< T >

template<typename T>
friend class LaspackVector< T >
friend

Make other Laspack datatypes friends.

Definition at line 214 of file laspack_matrix.h.

Member Data Documentation

◆ _closed

template<typename T>
bool libMesh::LaspackMatrix< T >::_closed
private

Flag indicating if the matrix has been closed yet.

Definition at line 209 of file laspack_matrix.h.

Referenced by libMesh::LaspackMatrix< T >::closed().

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

◆ _csr

template<typename T>
std::vector<numeric_index_type> libMesh::LaspackMatrix< T >::_csr
private

The compressed row indices.

Definition at line 198 of file laspack_matrix.h.

◆ _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 652 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().

◆ _is_initialized

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

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

◆ _QMat

template<typename T>
QMatrix libMesh::LaspackMatrix< T >::_QMat
private

The Laspack sparse matrix pointer.

Definition at line 193 of file laspack_matrix.h.

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), and libMesh::LaspackLinearSolver< T >::solve().

◆ _row_start

template<typename T>
std::vector<std::vector<numeric_index_type>::const_iterator> libMesh::LaspackMatrix< T >::_row_start
private

The start of each row in the compressed row index data structure.

Definition at line 204 of file laspack_matrix.h.

◆ _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 659 of file sparse_matrix.h.

◆ _use_hash_table

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

Flag indicating whether the matrix is assembled using a hash table.

Definition at line 669 of file sparse_matrix.h.

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


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