libMesh::EigenSparseMatrix< T > Class Template Reference

The EigenSparseMatrix class wraps a sparse matrix object from the Eigen library. More...

#include <eigen_sparse_matrix.h>

Inheritance diagram for libMesh::EigenSparseMatrix< T >:

Public Types
typedef EigenSM	DataType
	Convenient typedefs. More...
typedef Eigen::Triplet< T, eigen_idx_type >	TripletType

Public Member Functions
	EigenSparseMatrix (const Parallel::Communicator &comm)
	Constructor; initializes the matrix to be empty, without any structure, i.e. More...
	EigenSparseMatrix (EigenSparseMatrix &&)=default
	The 5 special functions can be defaulted for this class, as it does not manage any memory itself. More...
	EigenSparseMatrix (const EigenSparseMatrix &)=default
EigenSparseMatrix &	operator= (const EigenSparseMatrix &)=default
EigenSparseMatrix &	operator= (EigenSparseMatrix &&)=default
virtual	~EigenSparseMatrix ()=default
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 \leftarrow 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	need_full_sparsity_pattern () const
virtual void	update_sparsity_pattern (const SparsityPattern::Graph &)
	Updates the matrix sparsity pattern. More...
virtual void	zero_rows (std::vector< numeric_index_type > &rows, T diag_value=0.0)
	Sets all row entries to 0 then puts diag_value in the diagonal entry. More...
virtual void	flush ()
	For PETSc matrix , this function is similar to close but without shrinking memory. More...
virtual numeric_index_type	local_m () const
	Get the number of rows owned by this process. More...
virtual numeric_index_type	local_n () const
	Get the number of columns owned by this process. More...
virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)
	Add the full matrix dm to the SparseMatrix. More...
virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices)
	Same as add_block_matrix(), but assumes the row and column maps are the same. More...
virtual void	matrix_matrix_mult (SparseMatrix< T > &, SparseMatrix< T > &, bool)
	Compute Y = A*X for matrix X. More...
virtual void	add_sparse_matrix (const SparseMatrix< T > &, const std::map< numeric_index_type, numeric_index_type > &, const std::map< numeric_index_type, numeric_index_type > &, const T)
	Add scalar* spm to the rows and cols of this matrix (A): A(rows[i], cols[j]) += scalar * spm(i,j) More...
virtual std::size_t	n_nonzeros () const
void	print (std::ostream &os=libMesh::out, const bool sparse=false) const
	Print the contents of the matrix to the screen in a uniform style, regardless of matrix/solver package being used. More...
template<>
void	print (std::ostream &os, const bool sparse) const
virtual void	print_matlab (const std::string &="") const
	Print the contents of the matrix in Matlab's sparse matrix format. More...
virtual void	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_matlab (const std::string &filename)
	Read the contents of the matrix from Matlab's sparse matrix format. 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...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

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

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

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

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

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

Private Attributes
DataType	_mat
	Actual Eigen::SparseMatrix<> we are wrapping. More...
bool	_closed
	Flag indicating if the matrix has been closed yet. More...

Friends
class	EigenSparseVector< T >
	Make other Eigen datatypes friends. More...
class	EigenSparseLinearSolver< T >

Detailed Description

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

The EigenSparseMatrix class wraps a sparse matrix object from the Eigen library.

All overridden virtual functions are documented in sparse_matrix.h.

Author

Benjamin S. Kirk

Date

2013

Definition at line 54 of file eigen_sparse_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.

DataType

template<typename T>

typedef EigenSM libMesh::EigenSparseMatrix< T >::DataType

Convenient typedefs.

Definition at line 83 of file eigen_sparse_matrix.h.

TripletType

template<typename T>

typedef Eigen::Triplet<T,eigen_idx_type> libMesh::EigenSparseMatrix< T >::TripletType

Definition at line 84 of file eigen_sparse_matrix.h.

Constructor & Destructor Documentation

EigenSparseMatrix() [1/3]

template<typename T >

libMesh::EigenSparseMatrix< T >::EigenSparseMatrix

(

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 163 of file eigen_sparse_matrix.C.

                                                                             :
  SparseMatrix<T>(comm_in),
  _closed (false)
{
}

EigenSparseMatrix() [2/3]

template<typename T>

libMesh::EigenSparseMatrix< T >::EigenSparseMatrix ( EigenSparseMatrix< T > &&  )

default

The 5 special functions can be defaulted for this class, as it does not manage any memory itself.

EigenSparseMatrix() [3/3]

template<typename T>

libMesh::EigenSparseMatrix< T >::EigenSparseMatrix ( const EigenSparseMatrix< T > &  )

default

~EigenSparseMatrix()

template<typename T>

virtual libMesh::EigenSparseMatrix< T >::~EigenSparseMatrix ( )

virtualdefault

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

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

  {
    libmesh_not_implemented();
  }

add() [1/2]

template<typename T >

void libMesh::EigenSparseMatrix< 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 288 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());

  _mat.coeffRef(i,j) += value;
}

add() [2/2]

template<typename T >

void libMesh::EigenSparseMatrix< T >::add ( const T  a, const SparseMatrix< T > &  X  )

overridevirtual

Compute \( A \leftarrow A + a*X \) for scalar a, matrix X.

Implements libMesh::SparseMatrix< T >.

Definition at line 311 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());
  libmesh_assert_equal_to (this->m(), X_in.m());
  libmesh_assert_equal_to (this->n(), X_in.n());

  const EigenSparseMatrix<T> & X =
    cast_ref<const EigenSparseMatrix<T> &> (X_in);

  _mat += X._mat*a_in;
}

add_block_matrix() [1/2]

template<typename T>

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

virtualinherited

Add the full matrix dm to the SparseMatrix.

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

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 82 of file sparse_matrix.C.

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

{
  libmesh_assert_equal_to (dm.m() / brows.size(), dm.n() / bcols.size());

  const numeric_index_type blocksize = cast_int<numeric_index_type>
    (dm.m() / brows.size());

  libmesh_assert_equal_to (dm.m()%blocksize, 0);
  libmesh_assert_equal_to (dm.n()%blocksize, 0);

  std::vector<numeric_index_type> rows, cols;

  rows.reserve(blocksize*brows.size());
  cols.reserve(blocksize*bcols.size());

  for (auto & row : brows)
    {
      numeric_index_type i = row * blocksize;

      for (unsigned int v=0; v<blocksize; v++)
        rows.push_back(i++);
    }

  for (auto & col : bcols)
    {
      numeric_index_type j = col * blocksize;

      for (unsigned int v=0; v<blocksize; v++)
        cols.push_back(j++);
    }

  this->add_matrix (dm, rows, cols);
}

add_block_matrix() [2/2]

template<typename T>

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

inlinevirtualinherited

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

Thus the matrix dm must be square.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 308 of file sparse_matrix.h.

  { this->add_block_matrix (dm, dof_indices, dof_indices); }

add_matrix() [1/2]

template<typename T >

void libMesh::EigenSparseMatrix< 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 123 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());
  unsigned int n_rows = cast_int<unsigned int>(rows.size());
  unsigned int n_cols = cast_int<unsigned int>(cols.size());
  libmesh_assert_equal_to (dm.m(), n_rows);
  libmesh_assert_equal_to (dm.n(), n_cols);


  for (unsigned int i=0; i<n_rows; i++)
    for (unsigned int j=0; j<n_cols; j++)
      this->add(rows[i],cols[j],dm(i,j));
}

add_matrix() [2/2]

template<typename T >

void libMesh::EigenSparseMatrix< 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 302 of file eigen_sparse_matrix.C.

{
  this->add_matrix (dm, dof_indices, dof_indices);
}

add_sparse_matrix()

template<typename T>

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

inlinevirtualinherited

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

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 327 of file sparse_matrix.h.

  { libmesh_not_implemented(); }

attach_dof_map()

template<typename T >

void libMesh::SparseMatrix< T >::attach_dof_map ( const DofMap &  dof_map )

inherited

Set a pointer to the DofMap to use.

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

The lifetime of dof_map must exceed the lifetime of this.

Definition at line 63 of file sparse_matrix.C.

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

{
  _dof_map = &dof_map;
  if (!_sp)
    _sp = dof_map.get_sparsity_pattern();
}

attach_sparsity_pattern()

template<typename T >

void libMesh::SparseMatrix< T >::attach_sparsity_pattern ( const SparsityPattern::Build &  sp )

inherited

Set a pointer to a sparsity pattern to use.

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

The lifetime of sp must exceed the lifetime of this.

Definition at line 73 of file sparse_matrix.C.

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

{
  _sp = &sp;
}

build()

template<typename T >

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

staticinherited

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

Definition at line 156 of file sparse_matrix.C.

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

{
  // Avoid unused parameter warnings when no solver packages are enabled.
  libmesh_ignore(comm);

  if (matrix_build_type == MatrixBuildType::DIAGONAL)
    return std::make_unique<DiagonalMatrix<T>>(comm);

  // Build the appropriate vector
  switch (solver_package)
    {

#ifdef LIBMESH_HAVE_LASPACK
    case LASPACK_SOLVERS:
      return std::make_unique<LaspackMatrix<T>>(comm);
#endif


#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      return std::make_unique<PetscMatrix<T>>(comm);
#endif


#ifdef LIBMESH_TRILINOS_HAVE_EPETRA
    case TRILINOS_SOLVERS:
      return std::make_unique<EpetraMatrix<T>>(comm);
#endif


#ifdef LIBMESH_HAVE_EIGEN
    case EIGEN_SOLVERS:
      return std::make_unique<EigenSparseMatrix<T>>(comm);
#endif

    default:
      libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
    }
}

clear()

template<typename T >

void libMesh::EigenSparseMatrix< T >::clear ( )

overridevirtual

Restores the SparseMatrix<T> to a pristine state.

Implements libMesh::SparseMatrix< T >.

Definition at line 172 of file eigen_sparse_matrix.C.

References libMesh::libMeshPrivateData::_is_initialized.

{
  _mat.resize(0,0);

  _closed = false;
  this->_is_initialized = false;
}

clone()

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::EigenSparseMatrix< 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 214 of file eigen_sparse_matrix.C.

{
  return std::make_unique<EigenSparseMatrix<T>>(*this);
}

close()

template<typename T>

virtual void libMesh::EigenSparseMatrix< T >::close ( )

inlineoverridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 104 of file eigen_sparse_matrix.h.

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

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

{ this->_closed = true; }

closed()

template<typename T>

virtual bool libMesh::EigenSparseMatrix< T >::closed ( ) const

inlineoverridevirtual

Returns

true if the matrix has been assembled.

Implements libMesh::SparseMatrix< T >.

Definition at line 142 of file eigen_sparse_matrix.h.

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

{ return _closed; }

col_start()

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::col_start ( ) const

overridevirtual

Returns

The index of the first matrix column owned by this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 258 of file eigen_sparse_matrix.C.

{
  return 0;
}

col_stop()

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< 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 266 of file eigen_sparse_matrix.C.

{
  return this->n();
}

comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

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

  { return _communicator; }

create_submatrix()

template<typename T>

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

inlinevirtualinherited

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

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

Definition at line 469 of file sparse_matrix.h.

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

  {
    this->_get_submatrix(submatrix,
                         rows,
                         cols,
                         false); // false means DO NOT REUSE submatrix
  }

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

  {
    libmesh_not_implemented();
  }

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.

{
  _enable_print_counter = false;
  return;
}

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.

{
  _enable_print_counter = true;
  return;
}

flush()

template<typename T>

virtual void libMesh::SparseMatrix< T >::flush ( )

inlinevirtualinherited

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

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

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

Definition at line 215 of file sparse_matrix.h.

{ close(); }

get_diagonal()

template<typename T >

void libMesh::EigenSparseMatrix< T >::get_diagonal ( NumericVector< T > &  dest ) const

overridevirtual

Copies the diagonal part of the matrix into dest.

Implements libMesh::SparseMatrix< T >.

Definition at line 143 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseVector< T >::_vec.

{
  EigenSparseVector<T> & dest = cast_ref<EigenSparseVector<T> &>(dest_in);

  dest._vec = _mat.diagonal();
}

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

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

get_row()

template<typename T >

void libMesh::EigenSparseMatrix< 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

i	The matrix row to get
indices	A container that will be filled with the column indices corresponding to (possibly) non-zero values
values	A container holding the column values

Implements libMesh::SparseMatrix< T >.

Definition at line 385 of file eigen_sparse_matrix.C.

{
  indices.clear();
  values.clear();

  // InnerIterator is over rows in RowMajor ordering
  static_assert(EigenSM::IsRowMajor);

  for (EigenSM::InnerIterator it(_mat, i); it; ++it)
    {
      indices.push_back(it.col());
      values.push_back(it.value());
    }
}

get_transpose()

template<typename T >

void libMesh::EigenSparseMatrix< 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 153 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat.

{
  EigenSparseMatrix<T> & dest = cast_ref<EigenSparseMatrix<T> &>(dest_in);

  dest._mat = _mat.transpose();
}

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

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

init() [1/2]

template<typename T>

virtual void libMesh::EigenSparseMatrix< 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

m	The global number of rows.
n	The global number of columns.
m_l	The local number of rows.
n_l	The local number of columns.
nnz	The number of on-diagonal nonzeros per row (defaults to 30).
noz	The number of off-diagonal nonzeros per row (defaults to 10).
blocksize	Optional value indicating dense coupled blocks for systems with multiple variables all of the same type.

Implements libMesh::SparseMatrix< T >.

init() [2/2]

template<typename T >

void libMesh::EigenSparseMatrix< T >::init ( ParallelType  type = PARALLEL )

overridevirtual

Initialize this matrix using the sparsity structure computed by dof_map.

Parameters

type	The serial/parallel/ghosted type of the matrix

Implements libMesh::SparseMatrix< T >.

Definition at line 65 of file eigen_sparse_matrix.C.

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

{
  // Ignore calls on initialized objects
  if (this->initialized())
    return;

  // We need the DofMap for this!
  libmesh_assert(this->_dof_map);

  // Clear initialized matrices
  if (this->initialized())
    this->clear();

  const numeric_index_type n_rows   = this->_dof_map->n_dofs();
  const numeric_index_type n_cols   = n_rows;

#ifndef NDEBUG
  // The following variables are only used for assertions,
  // so avoid declaring them when asserts are inactive.
  const numeric_index_type n_l = this->_dof_map->n_dofs_on_processor(0);
  const numeric_index_type m_l = n_l;
#endif

  // Laspack Matrices only work for uniprocessor cases
  libmesh_assert_equal_to (n_rows, n_cols);
  libmesh_assert_equal_to (m_l, n_rows);
  libmesh_assert_equal_to (n_l, n_cols);

  const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();

#ifndef NDEBUG
  // The following variables are only used for assertions,
  // so avoid declaring them when asserts are inactive.
  const std::vector<numeric_index_type> & n_oz = this->_sp->get_n_oz();
#endif

  // Make sure the sparsity pattern isn't empty
  libmesh_assert_equal_to (n_nz.size(), n_l);
  libmesh_assert_equal_to (n_oz.size(), n_l);

  if (n_rows==0)
    {
      _mat.resize(0,0);
      return;
    }

  _mat.resize(n_rows,n_cols);
  _mat.reserve(n_nz);

  this->_is_initialized = true;

  libmesh_assert_equal_to (n_rows, this->m());
  libmesh_assert_equal_to (n_cols, this->n());
}

initialized()

template<typename T>

virtual bool libMesh::SparseMatrix< T >::initialized ( ) const

inlinevirtualinherited

Returns

true if the matrix has been initialized, false otherwise.

Definition at line 109 of file sparse_matrix.h.

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

{ return _is_initialized; }

l1_norm()

template<typename T >

Real libMesh::EigenSparseMatrix< 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 340 of file eigen_sparse_matrix.C.

References std::abs(), and libMesh::make_range().

{
  // There does not seem to be a straightforward way to iterate over
  // the columns of an EigenSparseMatrix.  So we use some extra
  // storage and keep track of the column sums while going over the
  // row entries...
  std::vector<Real> abs_col_sums(this->n());

  // For a row-major Eigen SparseMatrix like we're using, the
  // InnerIterator iterates over the non-zero entries of rows.
  for (auto row : make_range(this->m()))
    {
      EigenSM::InnerIterator it(_mat, row);
      for (; it; ++it)
        abs_col_sums[it.col()] += std::abs(it.value());
    }

  return *(std::max_element(abs_col_sums.begin(), abs_col_sums.end()));
}

linfty_norm()

template<typename T >

Real libMesh::EigenSparseMatrix< 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 363 of file eigen_sparse_matrix.C.

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

{
  Real max_abs_row_sum = 0.;

  // For a row-major Eigen SparseMatrix like we're using, the
  // InnerIterator iterates over the non-zero entries of rows.
  for (auto row : make_range(this->m()))
    {
      Real current_abs_row_sum = 0.;
      EigenSM::InnerIterator it(_mat, row);
      for (; it; ++it)
        current_abs_row_sum += std::abs(it.value());

      max_abs_row_sum = std::max(max_abs_row_sum, current_abs_row_sum);
    }

  return max_abs_row_sum;
}

local_m()

template<typename T>

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

inlinevirtualinherited

Get the number of rows owned by this process.

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

Definition at line 225 of file sparse_matrix.h.

{ return row_stop() - row_start(); }

local_n()

template<typename T>

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

inlinevirtualinherited

Get the number of columns owned by this process.

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

Definition at line 230 of file sparse_matrix.h.

{ return col_stop() - col_start(); }

m()

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::m ( ) const

overridevirtual

Returns

The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 222 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());

  return cast_int<numeric_index_type>(_mat.rows());
}

matrix_matrix_mult()

template<typename T>

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

inlinevirtualinherited

Compute Y = A*X for matrix X.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 320 of file sparse_matrix.h.

  { libmesh_not_implemented(); }

n()

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::n ( ) const

overridevirtual

Returns

The column-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 232 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());

  return cast_int<numeric_index_type>(_mat.cols());
}

n_nonzeros()

template<typename T >

std::size_t libMesh::SparseMatrix< T >::n_nonzeros ( ) const

virtualinherited

Returns

the global number of non-zero entries in the matrix sparsity pattern

Definition at line 229 of file sparse_matrix.C.

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

{
  if (!_sp)
    return 0;
  return _sp->n_nonzeros();
}

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

  { return _n_objects; }

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

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

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

need_full_sparsity_pattern()

template<typename T>

virtual bool libMesh::SparseMatrix< T >::need_full_sparsity_pattern ( ) const

inlinevirtualinherited

Returns

true if this sparse matrix format needs to be fed the graph of the sparse matrix.

This is true for LaspackMatrix, but not PetscMatrix. In the case where the full graph is not required, we can efficiently approximate it to provide a good estimate of the required size of the sparse matrix.

Reimplemented in libMesh::EpetraMatrix< T >, and libMesh::LaspackMatrix< T >.

Definition at line 138 of file sparse_matrix.h.

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

  { return false; }

operator()()

template<typename T >

T libMesh::EigenSparseMatrix< 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 327 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());

  return _mat.coeff(i,j);
}

operator=() [1/2]

template<typename T>

EigenSparseMatrix& libMesh::EigenSparseMatrix< T >::operator= ( const EigenSparseMatrix< T > &  )

default

operator=() [2/2]

template<typename T>

EigenSparseMatrix& libMesh::EigenSparseMatrix< T >::operator= ( EigenSparseMatrix< T > &&  )

default

print() [1/2]

template<>

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

inherited

Definition at line 122 of file sparse_matrix.C.

{
  // std::complex<>::operator<<() is defined, but use this form

  if (sparse)
    {
      libmesh_not_implemented();
    }

  os << "Real part:" << std::endl;
  for (auto i : make_range(this->m()))
    {
      for (auto j : make_range(this->n()))
        os << std::setw(8) << (*this)(i,j).real() << " ";
      os << std::endl;
    }

  os << std::endl << "Imaginary part:" << std::endl;
  for (auto i : make_range(this->m()))
    {
      for (auto j : make_range(this->n()))
        os << std::setw(8) << (*this)(i,j).imag() << " ";
      os << std::endl;
    }
}

print() [2/2]

template<typename T >

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

inherited

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

Definition at line 238 of file sparse_matrix.C.

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

{
  parallel_object_only();

  libmesh_assert (this->initialized());

  const numeric_index_type first_dof = this->row_start(),
                           end_dof   = this->row_stop();

  // We'll print the matrix from processor 0 to make sure
  // it's serialized properly
  if (this->processor_id() == 0)
    {
      libmesh_assert_equal_to (first_dof, 0);
      for (numeric_index_type i : make_range(end_dof))
        {
          if (sparse)
            {
              for (auto j : make_range(this->n()))
                {
                  T c = (*this)(i,j);
                  if (c != static_cast<T>(0.0))
                    {
                      os << i << " " << j << " " << c << std::endl;
                    }
                }
            }
          else
            {
              for (auto j : make_range(this->n()))
                os << (*this)(i,j) << " ";
              os << std::endl;
            }
        }

      std::vector<numeric_index_type> ibuf, jbuf;
      std::vector<T> cbuf;
      numeric_index_type currenti = end_dof;
      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          this->comm().receive(p, ibuf);
          this->comm().receive(p, jbuf);
          this->comm().receive(p, cbuf);
          libmesh_assert_equal_to (ibuf.size(), jbuf.size());
          libmesh_assert_equal_to (ibuf.size(), cbuf.size());

          if (ibuf.empty())
            continue;
          libmesh_assert_greater_equal (ibuf.front(), currenti);
          libmesh_assert_greater_equal (ibuf.back(), ibuf.front());

          std::size_t currentb = 0;
          for (;currenti <= ibuf.back(); ++currenti)
            {
              if (sparse)
                {
                  for (numeric_index_type j=0; j<this->n(); j++)
                    {
                      if (currentb < ibuf.size() &&
                          ibuf[currentb] == currenti &&
                          jbuf[currentb] == j)
                        {
                          os << currenti << " " << j << " " << cbuf[currentb] << std::endl;
                          currentb++;
                        }
                    }
                }
              else
                {
                  for (auto j : make_range(this->n()))
                    {
                      if (currentb < ibuf.size() &&
                          ibuf[currentb] == currenti &&
                          jbuf[currentb] == j)
                        {
                          os << cbuf[currentb] << " ";
                          currentb++;
                        }
                      else
                        os << static_cast<T>(0.0) << " ";
                    }
                  os << std::endl;
                }
            }
        }
      if (!sparse)
        {
          for (; currenti != this->m(); ++currenti)
            {
              for (numeric_index_type j=0; j<this->n(); j++)
                os << static_cast<T>(0.0) << " ";
              os << std::endl;
            }
        }
    }
  else
    {
      std::vector<numeric_index_type> ibuf, jbuf;
      std::vector<T> cbuf;

      // We'll assume each processor has access to entire
      // matrix rows, so (*this)(i,j) is valid if i is a local index.
      for (numeric_index_type i : make_range(first_dof, end_dof))
        {
          for (auto j : make_range(this->n()))
            {
              T c = (*this)(i,j);
              if (c != static_cast<T>(0.0))
                {
                  ibuf.push_back(i);
                  jbuf.push_back(j);
                  cbuf.push_back(c);
                }
            }
        }
      this->comm().send(0,ibuf);
      this->comm().send(0,jbuf);
      this->comm().send(0,cbuf);
    }
}

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

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

print_matlab()

template<typename T >

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

virtualinherited

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

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

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

Definition at line 361 of file sparse_matrix.C.

{
  parallel_object_only();

  libmesh_assert (this->initialized());

  const numeric_index_type first_dof = this->row_start(),
                           end_dof   = this->row_stop();

  // We'll print the matrix from processor 0 to make sure
  // it's serialized properly
  if (this->processor_id() == 0)
    {
      std::unique_ptr<std::ofstream> file;

      if (name != "")
        file = std::make_unique<std::ofstream>(name.c_str());

      std::ostream & os = (name == "") ? libMesh::out : *file;

      std::size_t sparsity_nonzeros = this->n_nonzeros();

      std::size_t real_nonzeros = 0;

      libmesh_assert_equal_to(first_dof, 0);
      for (numeric_index_type i : make_range(end_dof))
        {
          for (auto j : make_range(this->n()))
            {
              T c = (*this)(i,j);
              if (c != static_cast<T>(0.0))
                ++real_nonzeros;
            }
        }


      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          std::size_t nonzeros_on_p = 0;
          this->comm().receive(p, nonzeros_on_p);
          real_nonzeros += nonzeros_on_p;
        }

      if (sparsity_nonzeros &&
          sparsity_nonzeros != real_nonzeros)
        libmesh_warning(sparsity_nonzeros <<
                        " nonzeros allocated, but " <<
                        real_nonzeros << " used.");

      // We probably want to be more consistent than that, if our
      // sparsity is overallocated.

      // Print a header similar to PETSc's mat_view ascii_matlab
      os << "%Mat Object: () " << this->n_processors() << " MPI processes\n"
         << "%  type: " << (this->n_processors() > 1 ? "mpi" : "seq") << "aij\n"
         << "% Size = " << this->m() << ' ' << this->n() << '\n'
         << "% Nonzeros = " << real_nonzeros << '\n'
         << "zzz = zeros(" << real_nonzeros << ",3);\n"
         << "zzz = [\n";

      for (numeric_index_type i : make_range(end_dof))
        {
          // FIXME - we need a base class way to iterate over a
          // SparseMatrix row.
          for (auto j : make_range(this->n()))
            {
              T c = (*this)(i,j);
              if (c != static_cast<T>(0.0))
                {
                  // Convert from 0-based to 1-based indexing
                  os << (i+1) << ' ' << (j+1) << "  " << c << '\n';
                }
            }
        }

      std::vector<numeric_index_type> ibuf, jbuf;
      std::vector<T> cbuf;
      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          this->comm().receive(p, ibuf);
          this->comm().receive(p, jbuf);
          this->comm().receive(p, cbuf);
          libmesh_assert_equal_to (ibuf.size(), jbuf.size());
          libmesh_assert_equal_to (ibuf.size(), cbuf.size());

          for (auto n : index_range(ibuf))
            os << ibuf[n] << ' ' << jbuf[n] << "  " << cbuf[n] << '\n';
        }

      os << "];\n" << "Mat_sparse = spconvert(zzz);" << std::endl;
    }
  else
    {
      std::vector<numeric_index_type> ibuf, jbuf;
      std::vector<T> cbuf;
      std::size_t my_nonzeros = 0;

      // We'll assume each processor has access to entire
      // matrix rows, so (*this)(i,j) is valid if i is a local index.
      for (numeric_index_type i : make_range(first_dof, end_dof))
        {
          for (auto j : make_range(this->n()))
            {
              T c = (*this)(i,j);
              if (c != static_cast<T>(0.0))
                {
                  ibuf.push_back(i);
                  jbuf.push_back(j);
                  cbuf.push_back(c);
                  ++my_nonzeros;
                }
            }
        }
      this->comm().send(0,my_nonzeros);
      this->comm().send(0,ibuf);
      this->comm().send(0,jbuf);
      this->comm().send(0,cbuf);
    }
}

print_personal()

template<typename T>

virtual void libMesh::EigenSparseMatrix< 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 144 of file eigen_sparse_matrix.h.

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

{ this->print(os); }

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 >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 484 of file sparse_matrix.C.

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

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 >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 493 of file sparse_matrix.C.

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

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

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

  { return cast_int<processor_id_type>(_communicator.rank()); }

read_matlab()

template<typename T >

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

virtualinherited

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

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

Definition at line 502 of file sparse_matrix.C.

Referenced by ConstraintOperatorTest::test1DCoarseningNewNodes(), and ConstraintOperatorTest::testCoreform().

{
#ifndef LIBMESH_HAVE_CXX11_REGEX
  libmesh_not_implemented();  // What is your compiler?!?  Email us!
  libmesh_ignore(filename);
#else
  parallel_object_only();

  // The sizes we get from the file
  std::size_t m = 0,
              n = 0;

  // We'll read through the file three times: once to get a reliable
  // value for the matrix size (so we can divvy it up among
  // processors), then again to get the sparsity to send to each
  // processor, then a final time to get the entries to send to each
  // processor.
  std::unique_ptr<std::ifstream> file;

  // We'll be using regular expressions to make ourselves slightly
  // more robust to formatting.
  const std::regex start_regex // assignment like "zzz = ["
    ("\\s*\\w+\\s*=\\s*\\[");
  const std::regex entry_regex // row/col/val like "1 1 -2.0e-4"
    ("(\\d+)\\s+(\\d+)\\s+([+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?))");
  const std::regex end_regex // end of assignment
    ("^[^%]*\\]");

  // We'll read the matrix on processor 0 rather than try to juggle
  // parallel I/O.  Start by reading to deduce the size.
  if (this->processor_id() == 0)
    {
      file = std::make_unique<std::ifstream>(filename.c_str());

      // If we have a matrix with all-zero trailing rows, the only
      // way to get the size is if it ended up in a comment
      const std::regex size_regex // comment like "% size = 8 8"
        ("%\\s*[Ss][Ii][Zz][Ee]\\s*=\\s*(\\d+)\\s+(\\d+)");

      // Get the size
      bool have_started = false;
      bool have_ended = false;
      std::size_t largest_i_seen = 0, largest_j_seen = 0;
      for (std::string line; std::getline(*file, line);)
        {
          std::smatch sm;

          if (std::regex_search(line, sm, size_regex))
            {
              const std::string msize = sm[1];
              const std::string nsize = sm[2];
              m = std::stoull(msize);
              n = std::stoull(nsize);
            }

          if (std::regex_search(line, start_regex))
            have_started = true;

          if (std::regex_search(line, sm, entry_regex))
            {
              libmesh_error_msg_if
                (!have_started, "Confused by premature entries in matrix file " << filename);

              const std::string istr = sm[1];
              const std::string jstr = sm[2];

              std::size_t i = std::stoull(istr);
              largest_i_seen = std::max(i, largest_i_seen);
              std::size_t j = std::stoull(jstr);
              largest_j_seen = std::max(j, largest_j_seen);
            }

          if (std::regex_search(line, end_regex))
            {
              have_ended = true;
              break;
            }
        }

      libmesh_error_msg_if
        (!have_started, "Confused by missing assignment beginning in matrix file " << filename);

      libmesh_error_msg_if
        (!have_ended, "Confused by missing assignment ending in matrix file " << filename);

      libmesh_error_msg_if
        (m > largest_i_seen, "Confused by missing final row(s) in matrix file " << filename);

      libmesh_error_msg_if
        (m > 0 && m < largest_i_seen, "Confused by extra final row(s) in matrix file " << filename);

      if (!m)
        m = largest_i_seen;

      libmesh_error_msg_if
        (n > largest_j_seen, "Confused by missing final column(s) in matrix file " << filename);

      libmesh_error_msg_if
        (n > 0 && n < largest_j_seen, "Confused by extra final column(s) in matrix file " << filename);

      if (!n)
        n = largest_j_seen;

      this->comm().broadcast(m);
      this->comm().broadcast(n);
    }
  else
    {
      this->comm().broadcast(m);
      this->comm().broadcast(n);
    }

  // If we don't already have this size, we'll need to reinit later,
  // and we'll need to redetermine which rows each processor is in
  // charge of.

  numeric_index_type
    new_row_start =     this->processor_id() * m / this->n_processors(),
    new_row_stop  = (this->processor_id()+1) * m / this->n_processors();
  numeric_index_type
    new_col_start =     this->processor_id() * n / this->n_processors(),
    new_col_stop  = (this->processor_id()+1) * n / this->n_processors();

  if (this->initialized() &&
      m == this->m() &&
      n == this->n())
    {
      new_row_start = this->row_start(),
      new_row_stop  = this->row_stop();

      new_col_start = this->col_start(),
      new_col_stop  = this->col_stop();
    }

  std::vector<numeric_index_type> new_row_starts, new_row_stops,
                                  new_col_starts, new_col_stops;

  this->comm().gather(0, new_row_start, new_row_starts);
  this->comm().gather(0, new_row_stop, new_row_stops);
  this->comm().gather(0, new_col_start, new_col_starts);
  this->comm().gather(0, new_col_stop, new_col_stops);

  // Reread to deduce the sparsity pattern, or at least the maximum
  // number of on- and off- diagonal non-zeros per row.
  numeric_index_type  on_diagonal_nonzeros =0,
                     off_diagonal_nonzeros =0;

  if (this->processor_id() == 0)
    {
      file->seekg(0);

      bool have_started = false;

      // Data for the row we're working on

      // Use 1-based indexing for current_row, as in the file
      numeric_index_type current_row = 1;
      processor_id_type current_proc = 0;
      numeric_index_type current_on_diagonal_nonzeros = 0;
      numeric_index_type current_off_diagonal_nonzeros = 0;

      for (std::string line; std::getline(*file, line);)
        {
          std::smatch sm;

          if (std::regex_search(line, start_regex))
            have_started = true;

          if (have_started && std::regex_search(line, sm, entry_regex))
            {
              const std::string istr = sm[1];
              const std::string jstr = sm[2];

              const numeric_index_type i = std::stoull(istr);
              const numeric_index_type j = std::stoull(jstr);

              libmesh_error_msg_if
                (!i || !j, "Expected 1-based indexing in matrix file "
                 << filename);

              libmesh_error_msg_if
                (i < current_row,
                 "Can't handle out-of-order entries in matrix file "
                 << filename);
              if (i > current_row)
                {
                  current_row = i;
                  // +1 for 1-based indexing in file
                  while (current_row >= (new_row_stops[current_proc]+1))
                    ++current_proc;
                  current_on_diagonal_nonzeros = 0;
                  current_off_diagonal_nonzeros = 0;
                }

              // +1 for 1-based indexing in file
              if (j >= (new_col_starts[current_proc]+1) &&
                  j < (new_col_stops[current_proc]+1))
                {
                  ++current_on_diagonal_nonzeros;
                  on_diagonal_nonzeros =
                    std::max(on_diagonal_nonzeros,
                             current_on_diagonal_nonzeros);
                }
              else
                {
                  ++current_off_diagonal_nonzeros;
                  off_diagonal_nonzeros =
                    std::max(off_diagonal_nonzeros,
                             current_off_diagonal_nonzeros);
                }
            }

          if (std::regex_search(line, end_regex))
            break;
        }
    }

  this->comm().broadcast(on_diagonal_nonzeros);
  this->comm().broadcast(off_diagonal_nonzeros);

  this->init(m, n,
             new_row_stop-new_row_start,
             new_col_stop-new_col_start,
             on_diagonal_nonzeros,
             off_diagonal_nonzeros);

  // One last reread to set values
  if (this->processor_id() == 0)
    {
      file->seekg(0);

      bool have_started = false;

      for (std::string line; std::getline(*file, line);)
        {
          std::smatch sm;

          if (std::regex_search(line, start_regex))
            have_started = true;

          if (have_started && std::regex_search(line, sm, entry_regex))
            {
              const std::string istr = sm[1];
              const std::string jstr = sm[2];
              const std::string cstr = sm[3];

              const numeric_index_type i = std::stoull(istr);
              const numeric_index_type j = std::stoull(jstr);

              // Try to be compatible with
              // higher-than-double-precision T
              std::stringstream ss(cstr);
              T value;
              ss >> value;

              // Convert from 1-based to 0-based indexing
              this->set(i-1, j-1, value);
            }

          if (std::regex_search(line, end_regex))
            break;
        }
    }
  this->close();
#endif
}

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 >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 772 of file sparse_matrix.C.

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

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 >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 781 of file sparse_matrix.C.

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

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

  {
    this->_get_submatrix(submatrix,
                         rows,
                         cols,
                         true); // true means REUSE submatrix
  }

row_start()

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::row_start ( ) const

overridevirtual

Returns

The index of the first matrix row stored on this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 242 of file eigen_sparse_matrix.C.

{
  return 0;
}

row_stop()

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< 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 250 of file eigen_sparse_matrix.C.

{
  return this->m();
}

set()

template<typename T >

void libMesh::EigenSparseMatrix< 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 274 of file eigen_sparse_matrix.C.

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

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());

  _mat.coeffRef(i,j) = value;
}

update_sparsity_pattern()

template<typename T>

virtual void libMesh::SparseMatrix< T >::update_sparsity_pattern ( const SparsityPattern::Graph &  )

inlinevirtualinherited

Updates the matrix sparsity pattern.

When your SparseMatrix<T> implementation does not need this data, simply do not override this method.

Reimplemented in libMesh::EpetraMatrix< T >, and libMesh::LaspackMatrix< T >.

Definition at line 146 of file sparse_matrix.h.

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

{}

vector_mult()

template<typename T>

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

inherited

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

Definition at line 200 of file sparse_matrix.C.

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

{
  dest.zero();
  this->vector_mult_add(dest,arg);
}

vector_mult_add()

template<typename T>

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

inherited

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

Definition at line 210 of file sparse_matrix.C.

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

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

zero()

template<typename T >

void libMesh::EigenSparseMatrix< T >::zero ( )

overridevirtual

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 183 of file eigen_sparse_matrix.C.

{
  // This doesn't just zero, it clears the entire non-zero structure!
  _mat.setZero();

  if (this->_sp)
  {
    // Re-reserve our non-zero structure
    const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();
    _mat.reserve(n_nz);
  }
}

zero_clone()

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::EigenSparseMatrix< 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 199 of file eigen_sparse_matrix.C.

{
  // TODO: If there is a more efficient way to make a zeroed-out copy
  // of an EigenSM, we should call that instead.
  auto ret = std::make_unique<EigenSparseMatrix<T>>(*this);
  ret->zero();

  // Work around an issue on older compilers.  We are able to simply
  // "return ret;" on newer compilers
  return std::unique_ptr<SparseMatrix<T>>(ret.release());
}

zero_rows()

template<typename T>

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

virtualinherited

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

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

Definition at line 221 of file sparse_matrix.C.

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

Friends And Related Function Documentation

EigenSparseLinearSolver< T >

template<typename T>

friend class EigenSparseLinearSolver< T >

friend

Definition at line 169 of file eigen_sparse_matrix.h.

EigenSparseVector< T >

template<typename T>

friend class EigenSparseVector< T >

friend

Make other Eigen datatypes friends.

Definition at line 168 of file eigen_sparse_matrix.h.

Member Data Documentation

_closed

template<typename T>

bool libMesh::EigenSparseMatrix< T >::_closed

private

Flag indicating if the matrix has been closed yet.

Definition at line 163 of file eigen_sparse_matrix.h.

Referenced by libMesh::EigenSparseMatrix< T >::close(), and libMesh::EigenSparseMatrix< T >::closed().

_communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), and libMesh::BoundaryInfo::regenerate_id_sets().

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

_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 567 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

Flag indicating whether or not the matrix has been initialized.

Definition at line 579 of file sparse_matrix.h.

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), libMesh::PetscMatrix< libMesh::Number >::create_submatrix_nosort(), libMesh::EpetraMatrix< T >::EpetraMatrix(), libMesh::PetscMatrix< libMesh::Number >::get_transpose(), and libMesh::SparseMatrix< ValOut >::initialized().

_mat

template<typename T>

DataType libMesh::EigenSparseMatrix< T >::_mat

private

Actual Eigen::SparseMatrix<> we are wrapping.

Definition at line 158 of file eigen_sparse_matrix.h.

Referenced by libMesh::EigenSparseMatrix< T >::add(), libMesh::EigenSparseMatrix< T >::get_transpose(), and libMesh::EigenSparseLinearSolver< T >::solve().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

_sp

template<typename T>

SparsityPattern::Build const* libMesh::SparseMatrix< T >::_sp

protectedinherited

The sparsity pattern associated with this object.

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

Definition at line 574 of file sparse_matrix.h.

---

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

• include/numerics/eigen_sparse_matrix.h
• src/numerics/eigen_sparse_matrix.C