This class provides a nice interface to the PETSc C-based AIJ data structures for parallel, sparse matrices. More...

#include <petsc_matrix.h>

Inheritance diagram for libMesh::PetscMatrix< T >:

Public Member Functions
	PetscMatrix (const Parallel::Communicator &comm_in)
	Constructor; initializes the matrix to be empty, without any structure, i.e. More...

	PetscMatrix (Mat m, const Parallel::Communicator &comm_in, bool destroy_on_exit=false)
	Constructor. More...

	PetscMatrix (const Parallel::Communicator &comm_in, 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 n_nz=30, const numeric_index_type n_oz=10, const numeric_index_type blocksize=1)
	Constructor. More...

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

	PetscMatrix (const PetscMatrix &)=delete

PetscMatrix &	operator= (PetscMatrix &&)=delete

virtual	~PetscMatrix ()

PetscMatrix &	operator= (const PetscMatrix &)

virtual SparseMatrix< T > &	operator= (const SparseMatrix< T > &v) override
	This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual. More...

virtual void	init (const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type n_nz=30, const numeric_index_type n_oz=10, const numeric_index_type blocksize=1) override
	Initialize a PETSc matrix. More...

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 std::vector< numeric_index_type > &n_nz, const std::vector< numeric_index_type > &n_oz, const numeric_index_type blocksize=1)
	Initialize a PETSc matrix. More...

virtual void	init (ParallelType=PARALLEL) override
	Initialize this matrix using the sparsity structure computed by `dof_map`. More...

void	update_preallocation_and_zero ()
	Update the sparsity pattern based on `dof_map`, and set the matrix to zero. More...

void	reset_preallocation ()
	Reset matrix to use the original nonzero pattern provided by users. 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	zero_rows (std::vector< numeric_index_type > &rows, T diag_value=0.0) override
	Sets all row entries to 0 then puts `diag_value` in the diagonal entry. More...

virtual void	flush () override
	For PETSc matrix , this function is similar to close but without shrinking memory. More...

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_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols) override
	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) override
	Same as `add_block_matrix()`, but assumes the row and column maps are the same. More...

virtual void	add (const T a, const SparseMatrix< T > &X) override
	Compute A += a*X for scalar `a`, matrix `X`. More...

virtual void	matrix_matrix_mult (SparseMatrix< T > &X, SparseMatrix< T > &Y, bool reuse=false) override
	Compute Y = A*X for matrix `X`. More...

virtual void	add_sparse_matrix (const SparseMatrix< T > &spm, const std::map< numeric_index_type, numeric_index_type > &row_ltog, const std::map< numeric_index_type, numeric_index_type > &col_ltog, const T scalar) override
	Add `scalar` `spm` to the rows and cols of this matrix (A): A(rows[i], cols[j]) += scalar spm(i,j) More...

virtual T	operator() (const numeric_index_type i, const numeric_index_type j) const override

virtual Real	l1_norm () const override

Real	frobenius_norm () const

virtual Real	linfty_norm () const override

virtual void	print_personal (std::ostream &os=libMesh::out) const override
	Print the contents of the matrix to the screen with the PETSc viewer. More...

virtual void	print_matlab (const std::string &name="") const override
	Print the contents of the matrix in Matlab's sparse matrix format. More...

virtual void	print_petsc_binary (const std::string &filename) const override
	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) const override
	Write the contents of the matrix to a file in PETSc's HDF5 sparse matrix format. More...

virtual void	read_petsc_binary (const std::string &filename) override
	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) override
	Read the contents of the matrix from a file in PETSc's HDF5 sparse matrix format. 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 void	create_submatrix_nosort (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const override
	Similar to the `create_submatrix` function, this function creates a `submatrix` which is defined by the indices given in the `rows` and `cols` vectors. More...

virtual void	scale (const T scale) override
	Scales all elements of this matrix by `scale`. More...

std::unique_ptr< PetscMatrix< T > >	copy_from_hash ()
	Creates a copy of the current hash table matrix and then performs assembly. More...

virtual bool	supports_hash_table () const override

virtual void	restore_original_nonzero_pattern () override
	Reset the memory storage of the matrix. More...

void	init_without_preallocation (numeric_index_type m, numeric_index_type n, numeric_index_type m_l, numeric_index_type n_l, numeric_index_type blocksize)
	Perform matrix initialization steps sans preallocation. More...

void	finish_initialization ()
	Finish up the initialization process. More...

virtual SolverPackage	solver_package () override

Mat	mat ()

Mat	mat () const

virtual void	clear () noexcept override
	clear() is called from the destructor, so it should not throw. More...

void	set_destroy_mat_on_exit (bool destroy=true)
	If set to false, we don't delete the Mat on destruction and allow instead for `PETSc` to manage it. More...

void	swap (PetscMatrixBase< T > &)
	Swaps the internal data pointers of two PetscMatrices, no actual values are swapped. More...

void	set_context ()
	Set the context (ourself) for `_mat`. More...

virtual numeric_index_type	m () const override

virtual numeric_index_type	local_m () const final
	Get the number of rows owned by this process. More...

virtual numeric_index_type	n () const override

virtual numeric_index_type	local_n () const final
	Get the number of columns owned by this process. More...

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	close () override
	Calls the SparseMatrix's internal assembly routines, ensuring that the values are consistent across processors. More...

virtual bool	closed () const override

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 bool	require_sparsity_pattern () const

virtual void	update_sparsity_pattern (const SparsityPattern::Graph &)
	Updates the matrix sparsity pattern. More...

Real	l1_norm_diff (const SparseMatrix< T > &other_mat) const

virtual std::size_t	n_nonzeros () const

void	print (std::ostream &os=libMesh::out, const bool sparse=false) const
	Print the contents of the matrix to the screen in a uniform style, regardless of matrix/solver package being used. More...

void	print (const std::string &filename) const
	Print the contents of the matrix to a file, with a file format depending on the extension of `filename`. More...

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

virtual void	print_coreform_hdf5 (const std::string &filename, const std::string &groupname="extraction") const
	Print the contents of the matrix to a file, with the HDF5 sparse matrix format used by CoreForm, putting CSR sparse matrix data in the group given by `groupname`. More...

virtual void	read (const std::string &filename)
	Read the contents of the matrix from a file, with the file format inferred from the extension of `filename`. More...

virtual void	read_coreform_hdf5 (const std::string &filename, const std::string &groupname="extraction")
	Read the contents of the matrix from a file, with the HDF5 sparse matrix format used by CoreForm, expecing sparse matrix data in the group given by `groupname`. More...

virtual void	read_matlab (const std::string &filename)
	Read the contents of the matrix from the Matlab-script sparse matrix format used by PETSc. More...

virtual void	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	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...

void	use_hash_table (bool use_hash)
	Sets whether to use hash table assembly. More...

bool	use_hash_table () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static PetscMatrixBase< T > *	get_context (Mat mat, const TIMPI::Communicator &comm)

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
void	preallocate (numeric_index_type m_l, const std::vector< numeric_index_type > &n_nz, const std::vector< numeric_index_type > &n_oz, numeric_index_type blocksize)

virtual void	_get_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols, const bool reuse_submatrix) const override
	This function either creates or re-initializes a matrix called `submatrix` which is defined by the indices given in the `rows` and `cols` vectors. More...

void	_petsc_viewer (const std::string &filename, PetscViewerType viewertype, PetscFileMode filemode)

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
PetscMatrixType	_mat_type

Mat	_mat
	PETSc matrix datatype to store values. More...

bool	_destroy_mat_on_exit
	This boolean value should only be set to `false` for the constructor which takes a PETSc Mat object. More...

DofMap const *	_dof_map
	The `DofMap` object associated with this object. More...

SparsityPattern::Build const *	_sp
	The `sparsity` pattern associated with this object. More...

bool	_is_initialized
	Flag indicating whether or not the matrix has been initialized. More...

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

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...

static Threads::atomic< unsigned int >	_n_objects
	The number of objects. More...

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting. More...

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called. More...

Private Member Functions
template<NormType N>
Real	norm () const

Private Attributes
std::mutex	_petsc_matrix_mutex

Threads::spin_mutex	_petsc_matrix_mutex

Friends
class	::PetscMatrixTest

Detailed Description

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

This class provides a nice interface to the PETSc C-based AIJ data structures for parallel, sparse matrices.

All overridden virtual functions are documented in sparse_matrix.h.

Author: Benjamin S. Kirk

Date: 2002 SparseMatrix interface to PETSc Mat.

Definition at line 61 of file petsc_matrix.h.

Member Typedef Documentation

◆ Counts

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

◆ PetscMatrix() [1/5]

template<typename T >

libMesh::PetscMatrix< T >::PetscMatrix ( const Parallel::Communicator & comm_in )

explicit

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 86 of file petsc_matrix.C.

                                                                 :
   PetscMatrixBase<T>(comm_in), _mat_type(AIJ)
 {
 }

◆ PetscMatrix() [2/5]

template<typename T >

libMesh::PetscMatrix< T >::PetscMatrix	(	Mat	m,
		const Parallel::Communicator &	comm_in,
		bool	destroy_on_exit = `false`
	)

explicit

Constructor.

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

Definition at line 96 of file petsc_matrix.C.

References libMesh::PetscMatrix< T >::_mat_type, libMesh::AIJ, and libMesh::HYPRE.

                                                         :
   PetscMatrixBase<T>(mat_in, comm_in, destroy_on_exit)
 {
   MatType mat_type;
   LibmeshPetscCall(MatGetType(mat_in, &mat_type));
   PetscBool is_hypre;
   LibmeshPetscCall(PetscStrcmp(mat_type, MATHYPRE, &is_hypre));
   if (is_hypre == PETSC_TRUE)
     _mat_type = HYPRE;
   else
     _mat_type = AIJ;
 }

◆ PetscMatrix() [3/5]

template<typename T >

libMesh::PetscMatrix< T >::PetscMatrix	(	const Parallel::Communicator &	comm_in,
		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	n_nz = `30`,
		const numeric_index_type	n_oz = `10`,
		const numeric_index_type	blocksize = `1`
	)

explicit

Constructor.

Creates and initializes a PetscMatrix with the given structure. See init(...) for a description of the parameters.

Definition at line 115 of file petsc_matrix.C.

References libMesh::PetscMatrix< T >::init().

                                                                    :
   PetscMatrixBase<T>(comm_in), _mat_type(AIJ)
 {
   this->init(m_in, n_in, m_l, n_l, n_nz, n_oz, blocksize_in);
 }

◆ PetscMatrix() [4/5]

template<typename T>

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

delete

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

◆ PetscMatrix() [5/5]

template<typename T>

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

delete

◆ ~PetscMatrix()

template<typename T >

libMesh::PetscMatrix< T >::~PetscMatrix ( )

virtualdefault

Member Function Documentation

◆ _get_submatrix()

template<typename T >

void libMesh::PetscMatrix< T >::_get_submatrix	(	SparseMatrix< T > &	submatrix,
		const std::vector< numeric_index_type > &	rows,
		const std::vector< numeric_index_type > &	cols,
		const bool	reuse_submatrix
	)		const

overrideprotectedvirtual

This function either creates or re-initializes a matrix called submatrix which is defined by the indices given in the rows and cols vectors.

This function is implemented in terms of MatGetSubMatrix(). The reuse_submatrix parameter determines whether or not PETSc will treat submatrix as one which has already been used (had memory allocated) or as a new matrix.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 802 of file petsc_matrix.C.

References libMesh::SparseMatrix< T >::_is_initialized, libMesh::PetscMatrixBase< T >::_mat, libMesh::SparseMatrix< T >::clear(), libMesh::PetscMatrixBase< T >::close(), libMesh::closed(), libMesh::WrappedPetsc< T >::get(), libMesh::SparseMatrix< T >::initialized(), and libMesh::numeric_petsc_cast().

 {
   if (!this->closed())
     {
       libmesh_deprecated();
       libmesh_warning("The matrix must be assembled before calling PetscMatrix::create_submatrix().\n"
                       "Please update your code, as this warning will become an error in a future release.");
       const_cast<PetscMatrix<T> *>(this)->close();
     }
 
   semiparallel_only();
 
   // Make sure the SparseMatrix passed in is really a PetscMatrix
   PetscMatrix<T> * petsc_submatrix = cast_ptr<PetscMatrix<T> *>(&submatrix);
 
   // If we're not reusing submatrix and submatrix is already initialized
   // then we need to clear it, otherwise we get a memory leak.
   if (!reuse_submatrix && submatrix.initialized())
     submatrix.clear();
 
   // Construct row and column index sets.
   WrappedPetsc<IS> isrow;
   LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                    cast_int<PetscInt>(rows.size()),
                                    numeric_petsc_cast(rows.data()),
                                    PETSC_USE_POINTER,
                                    isrow.get()));
 
   WrappedPetsc<IS> iscol;
   LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                    cast_int<PetscInt>(cols.size()),
                                    numeric_petsc_cast(cols.data()),
                                    PETSC_USE_POINTER,
                                    iscol.get()));
 
   // Extract submatrix
   LibmeshPetscCall(LibMeshCreateSubMatrix(this->_mat,
                                           isrow,
                                           iscol,
                                           (reuse_submatrix ? MAT_REUSE_MATRIX : MAT_INITIAL_MATRIX),
                                           (&petsc_submatrix->_mat)));
 
   // Specify that the new submatrix is initialized and close it.
   petsc_submatrix->_is_initialized = true;
   petsc_submatrix->close();
 }

◆ _petsc_viewer()

template<typename T >

void libMesh::PetscMatrix< T >::_petsc_viewer	(	const std::string &	filename,
		PetscViewerType	viewertype,
		PetscFileMode	filemode
	)

protected

Definition at line 661 of file petsc_matrix.C.

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

Referenced by libMesh::PetscMatrix< T >::print_petsc_binary(), and libMesh::PetscMatrix< T >::print_petsc_hdf5().

 {
   parallel_object_only();
 
   // We'll get matrix sizes from the file, but we need to at least
   // have a Mat object
   if (!this->initialized())
     {
       LibmeshPetscCall(MatCreate(this->comm().get(), &this->_mat));
       this->_is_initialized = true;
     }
 
   PetscViewer viewer;
   LibmeshPetscCall(PetscViewerCreate(this->comm().get(), &viewer));
   LibmeshPetscCall(PetscViewerSetType(viewer, viewertype));
   LibmeshPetscCall(PetscViewerSetFromOptions(viewer));
   LibmeshPetscCall(PetscViewerFileSetMode(viewer, filemode));
   LibmeshPetscCall(PetscViewerFileSetName(viewer, filename.c_str()));
   if (filemode == FILE_MODE_READ)
     LibmeshPetscCall(MatLoad(this->_mat, viewer));
   else
     LibmeshPetscCall(MatView(this->_mat, viewer));
   LibmeshPetscCall(PetscViewerDestroy(&viewer));
 }

◆ add() [1/2]

template<typename T >

void libMesh::PetscMatrix< 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 989 of file petsc_matrix.C.

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

Referenced by PetscMatrixTest::testPetscCopyFromHash().

 {
   libmesh_assert (this->initialized());
 
   PetscInt i_val=i, j_val=j;
 
   PetscScalar petsc_value = static_cast<PetscScalar>(value);
   std::scoped_lock lock(this->_petsc_matrix_mutex);
   LibmeshPetscCall(MatSetValues(this->_mat, 1, &i_val, 1, &j_val,
                                 &petsc_value, ADD_VALUES));
 }

◆ add() [2/2]

template<typename T >

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

overridevirtual

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

Note: The matrices A and X need to have the same nonzero pattern, otherwise PETSc will crash!; It is advisable to not only allocate appropriate memory with init(), but also explicitly zero the terms of this whenever you add a non-zero value to X.; X will be closed, if not already done, before performing any work.

Implements libMesh::SparseMatrix< T >.

Definition at line 1019 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   // sanity check. but this cannot avoid
   // crash due to incompatible sparsity structure...
   libmesh_assert_equal_to (this->m(), X_in.m());
   libmesh_assert_equal_to (this->n(), X_in.n());
 
   PetscScalar a = static_cast<PetscScalar>      (a_in);
   const PetscMatrix<T> * X = cast_ptr<const PetscMatrix<T> *> (&X_in);
 
   libmesh_assert (X);
 
   // the matrix from which we copy the values has to be assembled/closed
   libmesh_assert(X->closed());
 
   semiparallel_only();
 
   LibmeshPetscCall(MatAXPY(this->_mat, a, X->_mat, DIFFERENT_NONZERO_PATTERN));
 }

◆ add_block_matrix() [1/2]

template<typename T >

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

overridevirtual

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 from libMesh::SparseMatrix< T >.

Definition at line 761 of file petsc_matrix.C.

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

Referenced by libMesh::PetscMatrix< T >::add_block_matrix().

 {
   libmesh_assert (this->initialized());
 
   const numeric_index_type n_brows =
     cast_int<numeric_index_type>(brows.size());
   const numeric_index_type n_bcols =
     cast_int<numeric_index_type>(bcols.size());
 
 #ifndef NDEBUG
   const numeric_index_type n_rows  =
     cast_int<numeric_index_type>(dm.m());
   const numeric_index_type n_cols  =
     cast_int<numeric_index_type>(dm.n());
   const numeric_index_type blocksize = n_rows / n_brows;
 
   libmesh_assert_equal_to (n_cols / n_bcols, blocksize);
   libmesh_assert_equal_to (blocksize*n_brows, n_rows);
   libmesh_assert_equal_to (blocksize*n_bcols, n_cols);
 
   PetscInt petsc_blocksize;
   LibmeshPetscCall(MatGetBlockSize(this->_mat, &petsc_blocksize));
   libmesh_assert_equal_to (blocksize, static_cast<numeric_index_type>(petsc_blocksize));
 #endif
 
   std::scoped_lock lock(this->_petsc_matrix_mutex);
   // These casts are required for PETSc <= 2.1.5
   LibmeshPetscCall(MatSetValuesBlocked(this->_mat,
                                        n_brows, numeric_petsc_cast(brows.data()),
                                        n_bcols, numeric_petsc_cast(bcols.data()),
                                        pPS(const_cast<T*>(dm.get_values().data())),
                                        ADD_VALUES));
 }

◆ add_block_matrix() [2/2]

template<typename T>

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

inlineoverridevirtual

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

Thus the matrix dm must be square.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 197 of file petsc_matrix.h.

References libMesh::PetscMatrix< T >::add_block_matrix().

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

libMesh::PetscMatrix::add_block_matrix

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

Add the full matrix dm to the SparseMatrix.

Definition: petsc_matrix.C:761

◆ add_matrix() [1/2]

template<typename T >

void libMesh::PetscMatrix< 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 735 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   const numeric_index_type n_rows = dm.m();
   const numeric_index_type n_cols = dm.n();
 
   libmesh_assert_equal_to (rows.size(), n_rows);
   libmesh_assert_equal_to (cols.size(), n_cols);
 
   std::scoped_lock lock(this->_petsc_matrix_mutex);
   LibmeshPetscCall(MatSetValues(this->_mat,
                                 n_rows, numeric_petsc_cast(rows.data()),
                                 n_cols, numeric_petsc_cast(cols.data()),
                                 pPS(const_cast<T*>(dm.get_values().data())),
                                 ADD_VALUES));
 }

◆ add_matrix() [2/2]

template<typename T >

void libMesh::PetscMatrix< 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 1006 of file petsc_matrix.C.

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

◆ add_sparse_matrix()

template<typename T >

void libMesh::PetscMatrix< T >::add_sparse_matrix	(	const SparseMatrix< T > &	spm,
		const std::map< numeric_index_type, numeric_index_type > &	row_ltog,
		const std::map< numeric_index_type, numeric_index_type > &	col_ltog,
		const T	scalar
	)

overridevirtual

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1073 of file petsc_matrix.C.

References libMesh::closed(), libMesh::index_range(), libMesh::SparseMatrix< T >::m(), libMesh::SparseMatrix< T >::n(), and libMesh::PS().

 {
   // size of spm is usually greater than row_ltog and col_ltog in parallel as the indices are owned by the processor
   // also, we should allow adding certain parts of spm to _mat
   libmesh_assert_greater_equal(spm.m(), row_ltog.size());
   libmesh_assert_greater_equal(spm.n(), col_ltog.size());
 
   // make sure matrix has larger size than spm
   libmesh_assert_greater_equal(this->m(), spm.m());
   libmesh_assert_greater_equal(this->n(), spm.n());
 
   if (!this->closed())
     this->close();
 
   auto pscm = cast_ptr<const PetscMatrix<T> *>(&spm);
 
   PetscInt ncols = 0;
 
   const PetscInt * lcols;
   const PetscScalar * vals;
 
   std::vector<PetscInt> gcols;
   std::vector<PetscScalar> values;
 
   for (auto ltog : row_ltog)
   {
     PetscInt grow[] = {static_cast<PetscInt>(ltog.second)}; // global row index
 
     LibmeshPetscCall(MatGetRow(pscm->_mat, static_cast<PetscInt>(ltog.first), &ncols, &lcols, &vals));
 
     // get global indices (gcols) from lcols, increment values = vals*scalar
     gcols.resize(ncols);
     values.resize(ncols);
     for (auto i : index_range(gcols))
     {
       gcols[i] = libmesh_map_find(col_ltog, lcols[i]);
       values[i] = PS(scalar) * vals[i];
     }
 
     LibmeshPetscCall(MatSetValues(this->_mat, 1, grow, ncols, gcols.data(), values.data(), ADD_VALUES));
     LibmeshPetscCall(MatRestoreRow(pscm->_mat, static_cast<PetscInt>(ltog.first), &ncols, &lcols, &vals));
   }
   // Note: We are not closing the matrix because it is expensive to do so when adding multiple sparse matrices.
   //       Remember to manually close the matrix once all changes to the matrix have been made.
 }

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

Referenced by libMesh::__libmesh_tao_hessian(), DMlibMeshJacobian(), libMesh::libmesh_petsc_snes_jacobian(), 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 110 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 193 of file sparse_matrix.C.

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

 {
   // 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::PetscMatrixBase< T >::clear ( )

overridevirtualnoexceptinherited

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

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 74 of file petsc_matrix_base.C.

Referenced by libMesh::StaticCondensation::clear().

 {
   if ((this->initialized()) && (this->_destroy_mat_on_exit))
     {
       exceptionless_semiparallel_only();
 
       // If we encounter an error here, print a warning but otherwise
       // keep going since we may be recovering from an exception.
       PetscErrorCode ierr = MatDestroy (&_mat);
       if (ierr)
         libmesh_warning("Warning: MatDestroy returned a non-zero error code which we ignored.");
 
       this->_is_initialized = false;
     }
 }

◆ clone()

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::PetscMatrix< 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 454 of file petsc_matrix.C.

References libMesh::closed().

 {
   libmesh_error_msg_if(!this->closed(), "Matrix must be closed before it can be cloned!");
 
   // Copy the nonzero pattern and numerical values
   Mat copy;
   LibmeshPetscCall(MatDuplicate(this->_mat, MAT_COPY_VALUES, &copy));
 
   // Call wrapping PetscMatrix constructor, have it take over
   // ownership.
   auto ret = std::make_unique<PetscMatrix<T>>(copy, this->comm());
   ret->set_destroy_mat_on_exit(true);
 
   return ret;
 }

◆ close()

template<typename T >

void libMesh::PetscMatrixBase< T >::close ( )

overridevirtualinherited

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

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 226 of file petsc_matrix_base.C.

Referenced by libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), DMlibMeshJacobian(), libMesh::PetscMatrix< T >::get_transpose(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), and libMesh::PetscLinearSolver< Number >::solve_common().

 {
   semiparallel_only();
 
   // BSK - 1/19/2004
   // strictly this check should be OK, but it seems to
   // fail on matrix-free matrices.  Do they falsely
   // state they are assembled?  Check with the developers...
   //   if (this->closed())
   //     return;
 
   MatAssemblyBeginEnd(this->comm(), this->_mat, MAT_FINAL_ASSEMBLY);
 }

◆ closed()

template<typename T >

bool libMesh::PetscMatrixBase< T >::closed ( ) const

overridevirtualinherited

Returns: true if the matrix has been assembled.

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 241 of file petsc_matrix_base.C.

Referenced by libMesh::PetscMatrix< T >::add().

 {
   libmesh_assert (this->initialized());
 
   PetscBool assembled;
 
   LibmeshPetscCall(MatAssembled(this->_mat, &assembled));
 
   return (assembled == PETSC_TRUE);
 }

◆ col_start()

template<typename T >

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

overridevirtualinherited

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

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 202 of file petsc_matrix_base.C.

 {
   libmesh_assert (this->initialized());
 
   PetscInt start=0, stop=0;
 
   LibmeshPetscCall(MatGetOwnershipRangeColumn(this->_mat, &start, &stop));
 
   return static_cast<numeric_index_type>(start);
 }

◆ col_stop()

template<typename T >

numeric_index_type libMesh::PetscMatrixBase< T >::col_stop ( ) const

overridevirtualinherited

Returns: The index of the last matrix column (+1) owned by this processor.

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 214 of file petsc_matrix_base.C.

 {
   libmesh_assert (this->initialized());
 
   PetscInt start=0, stop=0;
 
   LibmeshPetscCall(MatGetOwnershipRangeColumn(this->_mat, &start, &stop));
 
   return static_cast<numeric_index_type>(stop);
 }

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

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:120

◆ copy_from_hash()

template<typename T >

std::unique_ptr< PetscMatrix< T > > libMesh::PetscMatrix< T >::copy_from_hash ( )

Creates a copy of the current hash table matrix and then performs assembly.

This is very useful in cases where you are not done filling this matrix but want to be able to read the current state of it

Definition at line 1254 of file petsc_matrix.C.

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

Referenced by PetscMatrixTest::testPetscCopyFromHash().

 {
   Mat xaij;
   libmesh_assert(this->initialized());
   libmesh_assert(!this->closed());
   LibmeshPetscCall(MatDuplicate(this->_mat, MAT_DO_NOT_COPY_VALUES, &xaij));
   LibmeshPetscCall(MatCopyHashToXAIJ(this->_mat, xaij));
   return std::make_unique<PetscMatrix<T>>(xaij, this->comm(), /*destroy_on_exit=*/true);
 }

◆ create_submatrix()

template<typename T>

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

inlinevirtualinherited

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

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

Definition at line 534 of file sparse_matrix.h.

Referenced by libMesh::CondensedEigenSystem::copy_super_to_sub(), 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 >

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

overridevirtual

Similar to the create_submatrix 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 from libMesh::SparseMatrix< T >.

Definition at line 853 of file petsc_matrix.C.

References libMesh::SparseMatrix< T >::_is_initialized, libMesh::PetscMatrixBase< T >::_mat, libMesh::PetscMatrixBase< T >::close(), libMesh::closed(), libMesh::ParallelObject::comm(), libMesh::MeshTools::Generation::Private::idx(), and libMesh::index_range().

 {
   if (!this->closed())
     {
       libmesh_deprecated();
       libmesh_warning("The matrix must be assembled before calling PetscMatrix::create_submatrix_nosort().\n"
                       "Please update your code, as this warning will become an error in a future release.");
       const_cast<PetscMatrix<T> *>(this)->close();
     }
 
   // Make sure the SparseMatrix passed in is really a PetscMatrix
   PetscMatrix<T> * petsc_submatrix = cast_ptr<PetscMatrix<T> *>(&submatrix);
 
   LibmeshPetscCall(MatZeroEntries(petsc_submatrix->_mat));
 
   PetscInt pc_ncols = 0;
   const PetscInt * pc_cols;
   const PetscScalar * pc_vals;
 
   // // data for creating the submatrix
   std::vector<PetscInt> sub_cols;
   std::vector<PetscScalar> sub_vals;
 
   for (auto i : index_range(rows))
   {
     PetscInt sub_rid[] = {static_cast<PetscInt>(i)};
     PetscInt rid = static_cast<PetscInt>(rows[i]);
     // only get value from local rows, and set values to the corresponding columns in the submatrix
     if (rows[i]>= this->row_start() && rows[i]< this->row_stop())
     {
       // get one row of data from the original matrix
       LibmeshPetscCall(MatGetRow(this->_mat, rid, &pc_ncols, &pc_cols, &pc_vals));
       // extract data from certain cols, save the indices and entries sub_cols and sub_vals
       for (auto j : index_range(cols))
       {
         for (unsigned int idx = 0; idx< static_cast<unsigned int>(pc_ncols); idx++)
         {
           if (pc_cols[idx] == static_cast<PetscInt>(cols[j]))
             {
               sub_cols.push_back(static_cast<PetscInt>(j));
               sub_vals.push_back(pc_vals[idx]);
             }
         }
       }
       // set values
       LibmeshPetscCall(MatSetValues(petsc_submatrix->_mat,
                                     1,
                                     sub_rid,
                                     static_cast<PetscInt>(sub_vals.size()),
                                     sub_cols.data(),
                                     sub_vals.data(),
                                     INSERT_VALUES));
       LibmeshPetscCall(MatRestoreRow(this->_mat, rid, &pc_ncols, &pc_cols, &pc_vals));
       // clear data for this row
       sub_cols.clear();
       sub_vals.clear();
     }
   }
   MatAssemblyBeginEnd(petsc_submatrix->comm(), petsc_submatrix->_mat, MAT_FINAL_ASSEMBLY);
   // Specify that the new submatrix is initialized and close it.
   petsc_submatrix->_is_initialized = true;
   petsc_submatrix->close();
 }

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   _enable_print_counter = true;
   return;
 }

◆ finish_initialization()

template<typename T >

void libMesh::PetscMatrix< T >::finish_initialization ( )

Finish up the initialization process.

This method does a few things which include

Setting the option to make new nonzeroes an error (otherwise users will just have a silent (often huge) performance penalty
Marking the matrix as initialized

Definition at line 329 of file petsc_matrix.C.

References libMesh::libMeshPrivateData::_is_initialized.

Referenced by PetscMatrixTest::testPetscCopyFromHash().

 {
   // Make it an error for PETSc to allocate new nonzero entries during assembly. For old PETSc
   // versions this option must be set after preallocation for MPIAIJ matrices
   LibmeshPetscCall(MatSetOption(this->_mat, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
   this->_is_initialized = true;
 }

◆ flush()

template<typename T >

void libMesh::PetscMatrix< T >::flush ( )

overridevirtual

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 from libMesh::SparseMatrix< T >.

Definition at line 962 of file petsc_matrix.C.

 {
   semiparallel_only();
 
   MatAssemblyBeginEnd(this->comm(), this->_mat, MAT_FLUSH_ASSEMBLY);
 }

◆ frobenius_norm()

template<typename T >

Real libMesh::PetscMatrix< T >::frobenius_norm ( ) const

Definition at line 497 of file petsc_matrix.C.

 {
   return PetscMatrix<T>::norm<NORM_FROBENIUS>();
 }

◆ get_context()

template<typename T >

PetscMatrixBase< T > * libMesh::PetscMatrixBase< T >::get_context	(	Mat	mat,
		const TIMPI::Communicator &	comm
	)

staticinherited

Returns: The context for mat if it exists, else a nullptr

Definition at line 116 of file petsc_matrix_base.C.

Referenced by DMlibMeshJacobian(), form_matrixA(), and libMesh::libmesh_petsc_snes_jacobian().

 {
   void * ctx;
   PetscContainer container;
   LibmeshPetscCall2(comm, PetscObjectQuery((PetscObject)mat, "PetscMatrixCtx", (PetscObject *)&container));
   if (!container)
     return nullptr;
 
   LibmeshPetscCall2(comm, PetscContainerGetPointer(container, &ctx));
   libmesh_assert(ctx);
   return static_cast<PetscMatrixBase<T> *>(ctx);
 }

◆ get_diagonal()

template<typename T >

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

overridevirtual

Copies the diagonal part of the matrix into dest.

Implements libMesh::SparseMatrix< T >.

Definition at line 921 of file petsc_matrix.C.

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

 {
   // Make sure the NumericVector passed in is really a PetscVector
   PetscVector<T> & petsc_dest = cast_ref<PetscVector<T> &>(dest);
 
   // Needs a const_cast since PETSc does not work with const.
   LibmeshPetscCall(MatGetDiagonal(const_cast<PetscMatrix<T> *>(this)->mat(),petsc_dest.vec()));
 }

◆ 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::PetscMatrix< 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 1148 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   const PetscScalar * petsc_row;
   const PetscInt    * petsc_cols;
 
   PetscInt
     ncols=0,
     i_val = static_cast<PetscInt>(i_in);
 
   // the matrix needs to be closed for this to work
   // this->close();
   // but closing it is a semiparallel operation; we want operator()
   // to run on one processor.
   libmesh_assert(this->closed());
 
   // PETSc makes no effort at being thread safe. Helgrind complains about
   // possible data races even just in PetscFunctionBegin (due to things
   // like stack counter incrementing). Perhaps we could ignore
   // this, but there are legitimate data races for Mat data members like
   // mat->getrowactive between MatGetRow and MatRestoreRow. Moreover,
   // there could be a write into mat->rowvalues during MatGetRow from
   // one thread while we are attempting to read from mat->rowvalues
   // (through petsc_cols) during data copy in another thread. So
   // the safe thing to do is to lock the whole method
 
   std::lock_guard<std::mutex> lock(_petsc_matrix_mutex);
 
   LibmeshPetscCall(MatGetRow(this->_mat, i_val, &ncols, &petsc_cols, &petsc_row));
 
   // Copy the data
   indices.resize(static_cast<std::size_t>(ncols));
   values.resize(static_cast<std::size_t>(ncols));
 
   for (auto i : index_range(indices))
   {
     indices[i] = static_cast<numeric_index_type>(petsc_cols[i]);
     values[i] = static_cast<T>(petsc_row[i]);
   }
 
   LibmeshPetscCall(MatRestoreRow(this->_mat, i_val,
                                  &ncols, &petsc_cols, &petsc_row));
 }

◆ get_transpose()

template<typename T >

void libMesh::PetscMatrix< 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 933 of file petsc_matrix.C.

References libMesh::SparseMatrix< T >::_is_initialized, libMesh::PetscMatrixBase< T >::_mat, libMesh::SparseMatrix< T >::clear(), and libMesh::PetscMatrixBase< T >::close().

 {
   // Make sure the SparseMatrix passed in is really a PetscMatrix
   PetscMatrix<T> & petsc_dest = cast_ref<PetscMatrix<T> &>(dest);
 
   // If we aren't reusing the matrix then need to clear dest,
   // otherwise we get a memory leak
   if (&petsc_dest != this)
     dest.clear();
 
   if (&petsc_dest == this)
     // The MAT_REUSE_MATRIX flag was replaced by MAT_INPLACE_MATRIX
     // in PETSc 3.7.0
 #if PETSC_VERSION_LESS_THAN(3,7,0)
     LibmeshPetscCall(MatTranspose(this->_mat,MAT_REUSE_MATRIX, &petsc_dest._mat));
 #else
     LibmeshPetscCall(MatTranspose(this->_mat, MAT_INPLACE_MATRIX, &petsc_dest._mat));
 #endif
   else
     LibmeshPetscCall(MatTranspose(this->_mat,MAT_INITIAL_MATRIX, &petsc_dest._mat));
 
   // Specify that the transposed matrix is initialized and close it.
   petsc_dest._is_initialized = true;
   petsc_dest.close();
 }

◆ 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/3]

template<typename T >

void libMesh::PetscMatrix< 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	n_nz = `30`,
		const numeric_index_type	n_oz = `10`,
		const numeric_index_type	blocksize = `1`
	)

overridevirtual

Initialize a PETSc matrix.

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.
n_nz	The number of nonzeros in each row of the DIAGONAL portion of the local submatrix.
n_oz	The number of nonzeros in each row of the OFF-DIAGONAL portion of the local submatrix.
blocksize	Optional value indicating dense coupled blocks for systems with multiple variables all of the same type.

Implements libMesh::SparseMatrix< T >.

Definition at line 214 of file petsc_matrix.C.

References libMesh::AIJ, finish_initialization(), and libMesh::HYPRE.

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

 {
   this->init_without_preallocation(m_in, n_in, m_l, n_l, blocksize_in);
 
   PetscInt n_nz       = static_cast<PetscInt>(nnz);
   PetscInt n_oz       = static_cast<PetscInt>(noz);
 
 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
   if (blocksize > 1)
     {
       LibmeshPetscCall(MatSeqBAIJSetPreallocation(this->_mat, blocksize, n_nz/blocksize, NULL));
       LibmeshPetscCall(MatMPIBAIJSetPreallocation(this->_mat, blocksize,
                                                   n_nz/blocksize, NULL,
                                                   n_oz/blocksize, NULL));
     }
   else
 #endif
     {
       switch (this->_mat_type) {
         case AIJ:
           LibmeshPetscCall(MatSeqAIJSetPreallocation(this->_mat, n_nz, NULL));
           LibmeshPetscCall(MatMPIAIJSetPreallocation(this->_mat, n_nz, NULL, n_oz, NULL));
           break;
 
         case HYPRE:
 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
           LibmeshPetscCall(MatHYPRESetPreallocation(this->_mat, n_nz, NULL, n_oz, NULL));
 #else
           libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
 #endif
           break;
 
         default: libmesh_error_msg("Unsupported petsc matrix type");
       }
     }
 
   this->finish_initialization();
 }

◆ init() [2/3]

template<typename T >

void libMesh::PetscMatrix< 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 std::vector< numeric_index_type > &	n_nz,
		const std::vector< numeric_index_type > &	n_oz,
		const numeric_index_type	blocksize = `1`
	)

Initialize a PETSc matrix.

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.
n_nz	array containing the number of nonzeros in each row of the DIAGONAL portion of the local submatrix.
n_oz	Array containing the number of nonzeros in each row of the OFF-DIAGONAL portion of the local submatrix.
blocksize	Optional value indicating dense coupled blocks for systems with multiple variables all of the same type.

Definition at line 338 of file petsc_matrix.C.

References finish_initialization().

 {
   this->init_without_preallocation(m_in, n_in, m_l, n_l, blocksize_in);
   this->preallocate(m_l, n_nz, n_oz, blocksize_in);
 
   this->finish_initialization();
 }

◆ init() [3/3]

template<typename T>

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

◆ init_without_preallocation()

template<typename T >

void libMesh::PetscMatrix< T >::init_without_preallocation	(	numeric_index_type	m,
		numeric_index_type	n,
		numeric_index_type	m_l,
		numeric_index_type	n_l,
		numeric_index_type	blocksize
	)

Perform matrix initialization steps sans preallocation.

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
blocksize	The matrix block size

Definition at line 135 of file petsc_matrix.C.

References libMesh::AIJ, libMesh::HYPRE, libMesh::initialized(), and libMesh::libmesh_ignore().

Referenced by PetscMatrixTest::testPetscCopyFromHash().

 {
   // So compilers don't warn when !LIBMESH_ENABLE_BLOCKED_STORAGE
   libmesh_ignore(blocksize_in);
 
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
 
   PetscInt m_global   = static_cast<PetscInt>(m_in);
   PetscInt n_global   = static_cast<PetscInt>(n_in);
   PetscInt m_local    = static_cast<PetscInt>(m_l);
   PetscInt n_local    = static_cast<PetscInt>(n_l);
 
   LibmeshPetscCall(MatCreate(this->comm().get(), &this->_mat));
   LibmeshPetscCall(MatSetSizes(this->_mat, m_local, n_local, m_global, n_global));
   PetscInt blocksize  = static_cast<PetscInt>(blocksize_in);
   LibmeshPetscCall(MatSetBlockSize(this->_mat,blocksize));
   LibmeshPetscCall(MatSetOptionsPrefix(this->_mat, ""));
 
 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
   if (blocksize > 1)
     {
       // specified blocksize, bs>1.
       // double check sizes.
       libmesh_assert_equal_to (m_local  % blocksize, 0);
       libmesh_assert_equal_to (n_local  % blocksize, 0);
       libmesh_assert_equal_to (m_global % blocksize, 0);
       libmesh_assert_equal_to (n_global % blocksize, 0);
       libmesh_assert_equal_to (n_nz     % blocksize, 0);
       libmesh_assert_equal_to (n_oz     % blocksize, 0);
 
       LibmeshPetscCall(MatSetType(this->_mat, MATBAIJ)); // Automatically chooses seqbaij or mpibaij
 
       // MatSetFromOptions needs to happen before Preallocation routines
       // since MatSetFromOptions can change matrix type and remove incompatible
       // preallocation
       LibmeshPetscCall(MatSetFromOptions(this->_mat));
     }
   else
 #endif
     {
       switch (this->_mat_type) {
         case AIJ:
           LibmeshPetscCall(MatSetType(this->_mat, MATAIJ)); // Automatically chooses seqaij or mpiaij
 
           // MatSetFromOptions needs to happen before Preallocation routines
           // since MatSetFromOptions can change matrix type and remove incompatible
           // preallocation
           LibmeshPetscCall(MatSetFromOptions(this->_mat));
           break;
 
         case HYPRE:
 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
           LibmeshPetscCall(MatSetType(this->_mat, MATHYPRE));
 
           // MatSetFromOptions needs to happen before Preallocation routines
           // since MatSetFromOptions can change matrix type and remove incompatible
           // preallocation
           LibmeshPetscCall(MatSetFromOptions(this->_mat));
 #else
           libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
 #endif
           break;
 
         default: libmesh_error_msg("Unsupported petsc matrix type");
       }
     }
 
   this->set_context ();
 }

◆ initialized()

template<typename T>

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

inlinevirtualinherited

Returns: true if the matrix has been initialized, false otherwise.

Reimplemented in libMesh::StaticCondensation.

Definition at line 133 of file sparse_matrix.h.

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

133 { return _is_initialized; }

libMesh::SparseMatrix::_is_initialized

bool _is_initialized

Flag indicating whether or not the matrix has been initialized.

Definition: sparse_matrix.h:678

◆ l1_norm()

template<typename T >

Real libMesh::PetscMatrix< 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 492 of file petsc_matrix.C.

 {
   return PetscMatrix<T>::norm<NORM_1>();
 }

◆ l1_norm_diff()

template<typename T>

Real libMesh::SparseMatrix< T >::l1_norm_diff ( const SparseMatrix< T > & other_mat ) const

inherited

Returns: The l1_norm() of the difference of this and other_mat

Definition at line 1362 of file sparse_matrix.C.

 {
   auto diff_mat = this->clone();
   diff_mat->add(-1.0, other_mat);
   return diff_mat->l1_norm();
 }

◆ linfty_norm()

template<typename T >

Real libMesh::PetscMatrix< 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 502 of file petsc_matrix.C.

 {
   return PetscMatrix<T>::norm<NORM_INFINITY>();
 }

◆ local_m()

template<typename T >

numeric_index_type libMesh::PetscMatrixBase< T >::local_m ( ) const

finalvirtualinherited

Get the number of rows owned by this process.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 142 of file petsc_matrix_base.C.

 {
   libmesh_assert (this->initialized());
 
   PetscInt m = 0;
 
   LibmeshPetscCall(MatGetLocalSize (this->_mat, &m, NULL));
 
   return static_cast<numeric_index_type>(m);
 }

◆ local_n()

template<typename T >

numeric_index_type libMesh::PetscMatrixBase< T >::local_n ( ) const

finalvirtualinherited

Get the number of columns owned by this process.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 166 of file petsc_matrix_base.C.

 {
   libmesh_assert (this->initialized());
 
   PetscInt n = 0;
 
   LibmeshPetscCall(MatGetLocalSize (this->_mat, NULL, &n));
 
   return static_cast<numeric_index_type>(n);
 }

◆ m()

template<typename T >

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

overridevirtualinherited

Returns: The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 130 of file petsc_matrix_base.C.

 {
   libmesh_assert (this->initialized());
 
   PetscInt petsc_m=0, petsc_n=0;
 
   LibmeshPetscCall(MatGetSize (this->_mat, &petsc_m, &petsc_n));
 
   return static_cast<numeric_index_type>(petsc_m);
 }

◆ mat() [1/2]

template<typename T>

Mat libMesh::PetscMatrixBase< T >::mat ( )

inlineinherited

Returns: The raw PETSc matrix pointer.

Note: This is generally not required in user-level code.; Don't do anything crazy like calling MatDestroy() on it, or very bad things will likely happen!

Definition at line 120 of file petsc_matrix_base.h.

Referenced by libMesh::StaticCondensation::add_matrix(), libMesh::PetscLinearSolver< Number >::init(), libMesh::libmesh_petsc_DMCreateInterpolation(), libMesh::libmesh_petsc_DMCreateRestriction(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), libMesh::PetscDiffSolver::solve(), libMesh::TaoOptimizationSolver< T >::solve(), libMesh::PetscNonlinearSolver< Number >::solve(), and libMesh::PetscLinearSolver< Number >::solve_common().

120 { libmesh_assert (_mat); return _mat; }

libMesh::libmesh_assert

libmesh_assert(ctx)

libMesh::PetscMatrixBase::_mat

Mat _mat

PETSc matrix datatype to store values.

Definition: petsc_matrix_base.h:180

◆ mat() [2/2]

template<typename T>

Mat libMesh::PetscMatrixBase< T >::mat ( ) const

inlineinherited

Definition at line 121 of file petsc_matrix_base.h.

121 { libmesh_assert(_mat); return _mat; }

libMesh::libmesh_assert

libmesh_assert(ctx)

libMesh::PetscMatrixBase::_mat

Mat _mat

PETSc matrix datatype to store values.

Definition: petsc_matrix_base.h:180

◆ matrix_matrix_mult()

template<typename T >

void libMesh::PetscMatrix< T >::matrix_matrix_mult	(	SparseMatrix< T > &	X,
		SparseMatrix< T > &	Y,
		bool	reuse = `false`
	)

overridevirtual

Compute Y = A*X for matrix X.

Set reuse = true if this->_mat and X have the same nonzero pattern as before, and Y is obtained from a previous call to this function with reuse = false

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1043 of file petsc_matrix.C.

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

Referenced by libMesh::PetscPreconditioner< T >::set_hypre_ads_data().

 {
   libmesh_assert (this->initialized());
 
   // sanity check
   // we do not check the Y_out size here as we will initialize & close it at the end
   libmesh_assert_equal_to (this->n(), X_in.m());
 
   const PetscMatrix<T> * X = cast_ptr<const PetscMatrix<T> *> (&X_in);
   PetscMatrix<T> * Y = cast_ptr<PetscMatrix<T> *> (&Y_out);
 
   // the matrix from which we copy the values has to be assembled/closed
   libmesh_assert(X->closed());
 
   semiparallel_only();
 
   if (reuse)
     LibmeshPetscCall(MatMatMult(this->_mat, X->_mat, MAT_REUSE_MATRIX, PETSC_DEFAULT, &Y->_mat));
   else
   {
     Y->clear();
     LibmeshPetscCall(MatMatMult(this->_mat, X->_mat, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &Y->_mat));
   }
   // Specify that the new matrix is initialized
   // We do not close it here as `MatMatMult` ensures Y being closed
   Y->_is_initialized = true;
 }

◆ n()

template<typename T >

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

overridevirtualinherited

Returns: The column-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 154 of file petsc_matrix_base.C.

 {
   libmesh_assert (this->initialized());
 
   PetscInt petsc_m=0, petsc_n=0;
 
   LibmeshPetscCall(MatGetSize (this->_mat, &petsc_m, &petsc_n));
 
   return static_cast<numeric_index_type>(petsc_n);
 }

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

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:132

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

   {
     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 PetscMatrixBase subclasses. 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 162 of file sparse_matrix.h.

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

163 { return false; }

◆ norm()

template<typename T >

template<NormType N>

Real libMesh::PetscMatrix< T >::norm ( ) const

private

Returns: A norm of the matrix, where the type of norm to compute is determined by the template parameter N of the PETSc-defined type NormType. The valid template arguments are NORM_1, NORM_FROBENIUS and NORM_INFINITY, as used to define l1_norm(), frobenius_norm() and linfty_norm().

Definition at line 474 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   semiparallel_only();
 
   PetscReal petsc_value;
   Real value;
 
   libmesh_assert (this->closed());
 
   LibmeshPetscCall(MatNorm(this->_mat, N, &petsc_value));
 
   value = static_cast<Real>(petsc_value);
 
   return value;
 }

◆ operator()()

template<typename T >

T libMesh::PetscMatrix< 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 1123 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   // If the entry is not in the sparse matrix, it is 0.
   T value=0.;
 
   PetscInt
     i_val=static_cast<PetscInt>(i_in),
     j_val=static_cast<PetscInt>(j_in);
 
 
   // the matrix needs to be closed for this to work
   // this->close();
   // but closing it is a semiparallel operation; we want operator()
   // to run on one processor.
   libmesh_assert(this->closed());
 
   LibmeshPetscCall(MatGetValue(this->_mat, i_val, j_val, &value));
 
   return value;
 }

◆ operator=() [1/3]

template<typename T>

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

delete

◆ operator=() [2/3]

template<typename T >

PetscMatrix< T > & libMesh::PetscMatrix< T >::operator= ( const PetscMatrix< T > & v )

Definition at line 1198 of file petsc_matrix.C.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::PetscMatrixBase< T >::_mat, and libMesh::libmesh_assert().

 {
   semiparallel_only();
 
   if (this->_mat)
     {
       PetscBool assembled;
       LibmeshPetscCall(MatAssembled(this->_mat, &assembled));
 #ifndef NDEBUG
       const bool cxx_assembled = (assembled == PETSC_TRUE) ? true : false;
       libmesh_assert(this->_communicator.verify(cxx_assembled));
 #endif
 
       if (!assembled)
         // MatCopy does not work with an unassembled matrix. We could use MatDuplicate but then we
         // would have to destroy the matrix we manage and others might be relying on that data. So
         // we just assemble here regardless of the preceding level of matrix fill
         this->close();
       LibmeshPetscCall(MatCopy(v._mat, this->_mat, DIFFERENT_NONZERO_PATTERN));
     }
   else
       LibmeshPetscCall(MatDuplicate(v._mat, MAT_COPY_VALUES, &this->_mat));
 
   this->_is_initialized = true;
 
   return *this;
 }

◆ operator=() [3/3]

template<typename T >

SparseMatrix< T > & libMesh::PetscMatrix< T >::operator= ( const SparseMatrix< T > & )

overridevirtual

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

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

Returns: A reference to *this as the base type.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1227 of file petsc_matrix.C.

 {
   *this = cast_ref<const PetscMatrix<T> &>(v);
   return *this;
 }

◆ preallocate()

template<typename T>

void libMesh::PetscMatrix< T >::preallocate	(	numeric_index_type	m_l,
		const std::vector< numeric_index_type > &	n_nz,
		const std::vector< numeric_index_type > &	n_oz,
		numeric_index_type	blocksize
	)

protected

Definition at line 260 of file petsc_matrix.C.

References libMesh::AIJ, libMesh::HYPRE, libMesh::libmesh_ignore(), and libMesh::numeric_petsc_cast().

 {
   // Make sure the sparsity pattern isn't empty unless the matrix is 0x0
   libmesh_assert_equal_to (n_nz.size(), m_l);
   libmesh_assert_equal_to (n_oz.size(), m_l);
   // Avoid unused warnings when not configured with block storage
   libmesh_ignore(blocksize_in);
 
 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
   PetscInt blocksize  = static_cast<PetscInt>(blocksize_in);
 
   if (blocksize > 1)
     {
       // transform the per-entry n_nz and n_oz arrays into their block counterparts.
       std::vector<numeric_index_type> b_n_nz, b_n_oz;
 
       transform_preallocation_arrays (blocksize,
                                       n_nz, n_oz,
                                       b_n_nz, b_n_oz);
 
       LibmeshPetscCall(MatSeqBAIJSetPreallocation (this->_mat,
                                                    blocksize,
                                                    0,
                                                    numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data())));
 
       LibmeshPetscCall(MatMPIBAIJSetPreallocation (this->_mat,
                                                    blocksize,
                                                    0,
                                                    numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data()),
                                                    0,
                                                    numeric_petsc_cast(b_n_oz.empty() ? nullptr : b_n_oz.data())));
     }
   else
 #endif
     {
       switch (this->_mat_type) {
         case AIJ:
           LibmeshPetscCall(MatSeqAIJSetPreallocation (this->_mat,
                                                       0,
                                                       numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data())));
           LibmeshPetscCall(MatMPIAIJSetPreallocation (this->_mat,
                                                       0,
                                                       numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
                                                       0,
                                                       numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data())));
           break;
 
         case HYPRE:
 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
           LibmeshPetscCall(MatHYPRESetPreallocation (this->_mat,
                                                      0,
                                                      numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
                                                      0,
                                                      numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data())));
 #else
           libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
 #endif
           break;
 
         default: libmesh_error_msg("Unsupported petsc matrix type");
       }
 
     }
 }

◆ print() [1/3]

template<>

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

inherited

Definition at line 159 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/3]

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 275 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() [3/3]

template<typename T >

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

inherited

Print the contents of the matrix to a file, with a file format depending on the extension of filename.

Definition at line 754 of file sparse_matrix.C.

 {
   {
     std::ofstream outstr (filename.c_str());
     libmesh_error_msg_if
       (!outstr.good(), "ERROR: cannot write to file:\n\t" <<
        filename);
   }
 
   std::string_view basename = Utility::basename_of(filename);
 
   const bool gzipped_file = Utility::ends_with(filename, ".gz");
 
   if (gzipped_file)
     basename.remove_suffix(3);
 
   if (Utility::ends_with(basename, ".matlab") ||
       Utility::ends_with(basename, ".m"))
     this->print_matlab(filename);
   else if (Utility::ends_with(basename, ".petsc64"))
     {
 #ifndef LIBMESH_HAVE_PETSC
       libmesh_error_msg("Cannot load PETSc matrix file " <<
                         filename << " without PETSc-enabled libMesh.");
 #elif LIBMESH_DOF_ID_BYTES != 8
       libmesh_error_msg("Cannot load 64-bit PETSc matrix file " <<
                         filename << " with non-64-bit libMesh.");
 #endif
       if (gzipped_file)
         libmesh_not_implemented_msg("Gzipped PETSc matrices are not currently supported");
       this->print_petsc_binary(filename);
     }
   else if (Utility::ends_with(basename, ".petsc32"))
     {
 #ifndef LIBMESH_HAVE_PETSC
       libmesh_error_msg("Cannot load PETSc matrix file " <<
                         filename << " without PETSc-enabled libMesh.");
 #elif LIBMESH_DOF_ID_BYTES != 4
       libmesh_error_msg("Cannot load 32-bit PETSc matrix file " <<
                         filename << " with non-32-bit libMesh.");
 #endif
       if (gzipped_file)
         libmesh_not_implemented_msg("Gzipped PETSc matrices are not currently supported");
       this->print_petsc_binary(filename);
     }
   else if (Utility::ends_with(basename, ".h5"))
     {
       if (gzipped_file)
         libmesh_not_implemented_msg("Gzipped HDF5 matrices are not currently supported");
       this->print_coreform_hdf5(filename);
     }
   else
     libmesh_error_msg(" ERROR: Unrecognized matrix file extension on: "
                       << basename
                       << "\n   I understand the following:\n\n"
                       << "     *.h5        -- CoreForm HDF5 sparse matrix format\n"
                       << "     *.matlab    -- Matlab sparse matrix format\n"
                       << "     *.matlab.gz -- Matlab sparse matrix format, gzipped\n"
                       << "     *.m         -- Matlab sparse matrix format\n"
                       << "     *.m.gz      -- Matlab sparse matrix format, gzipped\n"
                       << "     *.petsc32   -- PETSc binary format, 32-bit\n"
                       << "     *.petsc64   -- PETSc binary format, 64-bit\n"
                      );
 }

◆ print_coreform_hdf5()

template<typename T >

void libMesh::SparseMatrix< T >::print_coreform_hdf5	(	const std::string &	filename,
		const std::string &	groupname = `"extraction"`
	)		const

virtualinherited

Print the contents of the matrix to a file, with the HDF5 sparse matrix format used by CoreForm, putting CSR sparse matrix data in the group given by groupname.

Definition at line 521 of file sparse_matrix.C.

 {
 #if defined(LIBMESH_USE_COMPLEX_NUMBERS) || !defined(LIBMESH_HAVE_HDF5)
   // TODO: HDF5 version 2.0.0 and later adds native support for
   // complex numbers with the H5T_NATIVE_DOUBLE_COMPLEX type [0], so
   // we could consider supporting T==std::complex<Real> in the future.
   // [0]: https://forum.hdfgroup.org/t/coming-in-the-next-hdf5-release-native-support-for-complex-number-datatypes/13543
   libmesh_ignore(filename, groupname);
   libmesh_error_msg("ERROR: need HDF5 support to handle .h5 files!!!");
 #else
   LOG_SCOPE("print_coreform_hdf5()", "SparseMatrix");
 
   // In this implementation, we copy the SparseMatrix entries into a
   // std::vector<double>, so this won't work for any Number type for
   // which sizeof(Number) > sizeof(double).
   if constexpr (sizeof(T) > sizeof(double))
     libmesh_not_implemented();
 
   const numeric_index_type first_dof = this->row_start(),
                            end_dof   = this->row_stop();
 
   std::vector<std::size_t> cols, row_offsets;
   std::vector<double> vals;
 
   if (this->processor_id() == 0)
     row_offsets.push_back(0);
 
   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))
             {
               cols.push_back(j);
               vals.push_back(c);
             }
         }
       // This is a *local* row offset; proc 0 may need to adjust later
       row_offsets.push_back(cols.size());
     }
 
   if (this->processor_id() == 0)
     {
       const hid_t file = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC,
                                    H5P_DEFAULT, H5P_DEFAULT);
       if (file == H5I_INVALID_HID)
         libmesh_file_error(filename);
 
       const hid_t group =
         H5Gcreate2(file, groupname.c_str(), H5P_DEFAULT, H5P_DEFAULT,
                    H5P_DEFAULT);
       check_open(filename, group, groupname);
 
       auto write_size_attribute = [&filename, &group]
         (const std::string & attribute_name, unsigned long long writeval)
       {
         const hid_t fspace = H5Screate(H5S_SCALAR);
         check_hdf5(filename, fspace, attribute_name + " fspace");
 
         const hid_t attr = H5Acreate2(group, attribute_name.c_str(),
                                       H5T_STD_I64LE, fspace,
                                       H5P_DEFAULT, H5P_DEFAULT);
         check_hdf5(filename, attr, attribute_name);
 
         // HDF5 is supposed to handle both upscaling and endianness
         // conversions here
         const herr_t errval = H5Awrite(attr, H5T_NATIVE_ULLONG, &writeval);
         check_hdf5(filename, errval, attribute_name + " write");
 
         H5Aclose(attr);
         H5Sclose(fspace);
       };
 
       write_size_attribute("num_cols", this->n());
       write_size_attribute("num_rows", this->m());
 
       auto write_vector = [&filename, &group]
         (const std::string & dataname, auto hdf5_file_type,
          auto hdf5_native_type, auto & datavec)
       {
         const hsize_t len[1] = {cast_int<hsize_t>(datavec.size())};
 
         const hid_t space = H5Screate_simple(1, len, nullptr);
         check_hdf5(filename, space, dataname + " space");
 
         const hid_t data =
           H5Dcreate2(group, dataname.c_str(), hdf5_file_type, space,
                      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
         check_hdf5(filename, data, dataname + " data");
 
         const hid_t errval =
           H5Dwrite(data, hdf5_native_type, H5S_ALL, H5S_ALL,
                    H5P_DEFAULT, datavec.data());
         check_hdf5(filename, errval, dataname + " write");
 
         H5Dclose(data);
         H5Sclose(space);
       };
 
       std::vector<std::size_t> vals_sizes, first_dofs;
       this->comm().gather(0, vals.size(), vals_sizes);
       this->comm().gather(0, cast_int<std::size_t>(first_dof), first_dofs);
       first_dofs.push_back(this->m());
 
       this->comm().allgather(cols);
       this->comm().allgather(vals);
       this->comm().allgather(row_offsets);
 
       libmesh_assert_equal_to(vals.size(),
                               cols.size());
       libmesh_assert_equal_to(vals.size(),
                               std::accumulate(vals_sizes.begin(),
                                               vals_sizes.end(),
                                               std::size_t(0)));
 
       std::size_t extra_offset = 0;
       for (auto p : make_range(processor_id_type(1), this->n_processors()))
         {
           extra_offset += vals_sizes[p-1];
           for (auto i : make_range(first_dofs[p]+1, first_dofs[p+1]+1))
             row_offsets[i] += extra_offset;
         }
 
       write_vector("cols", H5T_STD_U64LE, H5T_NATIVE_ULLONG, cols);
       write_vector("row_offsets", H5T_STD_U64LE, H5T_NATIVE_ULLONG, row_offsets);
       write_vector("vals", H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE, vals);
 
       H5Gclose(group);
       H5Fclose(file);
     }
   else
     {
       std::vector<std::size_t> dummy;
       this->comm().gather(0, vals.size(), dummy);
       this->comm().gather(0, cast_int<std::size_t>(first_dof), dummy);
       this->comm().allgather(cols);
       this->comm().allgather(vals);
       this->comm().allgather(row_offsets);
     }
 #endif // LIBMESH_HAVE_HDF5
 }

◆ 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::PetscMatrix< T >::print_matlab ( const std::string & name = "" ) const

overridevirtual

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 from libMesh::SparseMatrix< T >.

Definition at line 510 of file petsc_matrix.C.

References libMesh::closed(), libMesh::WrappedPetsc< T >::get(), libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::Quality::name().

 {
   libmesh_assert (this->initialized());
 
   semiparallel_only();
 
   if (!this->closed())
     {
       libmesh_deprecated();
       libmesh_warning("The matrix must be assembled before calling PetscMatrix::print_matlab().\n"
                       "Please update your code, as this warning will become an error in a future release.");
       const_cast<PetscMatrix<T> *>(this)->close();
     }
 
   // Create an ASCII file containing the matrix
   // if a filename was provided.
   if (name != "")
     {
       WrappedPetsc<PetscViewer> petsc_viewer;
 
       LibmeshPetscCall(PetscViewerASCIIOpen( this->comm().get(),
                                              name.c_str(),
                                              petsc_viewer.get()));
 
 #if PETSC_VERSION_LESS_THAN(3,7,0)
       LibmeshPetscCall(PetscViewerSetFormat (petsc_viewer,
                                              PETSC_VIEWER_ASCII_MATLAB));
 #else
       LibmeshPetscCall(PetscViewerPushFormat (petsc_viewer,
                                               PETSC_VIEWER_ASCII_MATLAB));
 #endif
 
       LibmeshPetscCall(MatView (this->_mat, petsc_viewer));
     }
 
   // Otherwise the matrix will be dumped to the screen.
   else
     {
 #if PETSC_VERSION_LESS_THAN(3,7,0)
       LibmeshPetscCall(PetscViewerSetFormat (PETSC_VIEWER_STDOUT_WORLD,
                                              PETSC_VIEWER_ASCII_MATLAB));
 #else
       LibmeshPetscCall(PetscViewerPushFormat (PETSC_VIEWER_STDOUT_WORLD,
                                               PETSC_VIEWER_ASCII_MATLAB));
 #endif
 
       LibmeshPetscCall(MatView (this->_mat, PETSC_VIEWER_STDOUT_WORLD));
     }
 }

◆ print_personal()

template<typename T >

void libMesh::PetscMatrix< T >::print_personal ( std::ostream & os = libMesh::out ) const

overridevirtual

Print the contents of the matrix to the screen with the PETSc viewer.

This function only allows printing to standard out since we have limited ourselves to one PETSc implementation for writing.

Implements libMesh::SparseMatrix< T >.

Definition at line 565 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   // Routine must be called in parallel on parallel matrices
   // and serial on serial matrices.
   semiparallel_only();
 
   // #ifndef NDEBUG
   //   if (os != std::cout)
   //     libMesh::err << "Warning! PETSc can only print to std::cout!" << std::endl;
   // #endif
 
   // Matrix must be in an assembled state to be printed
   if (!this->closed())
     {
       libmesh_deprecated();
       libmesh_warning("The matrix must be assembled before calling PetscMatrix::print_personal().\n"
                       "Please update your code, as this warning will become an error in a future release.");
       const_cast<PetscMatrix<T> *>(this)->close();
     }
 
   // Print to screen if ostream is stdout
   if (os.rdbuf() == std::cout.rdbuf())
     LibmeshPetscCall(MatView(this->_mat, NULL));
 
   // Otherwise, print to the requested file, in a roundabout way...
   else
     {
       // We will create a temporary filename, and file, for PETSc to
       // write to.
       std::string temp_filename;
 
       {
         // Template for temporary filename
         char c[] = "temp_petsc_matrix.XXXXXX";
 
         // Generate temporary, unique filename only on processor 0.  We will
         // use this filename for PetscViewerASCIIOpen, before copying it into
         // the user's stream
         if (this->processor_id() == 0)
           {
             int fd = mkstemp(c);
 
             // Check to see that mkstemp did not fail.
             libmesh_error_msg_if(fd == -1, "mkstemp failed in PetscMatrix::print_personal()");
 
             // mkstemp returns a file descriptor for an open file,
             // so let's close it before we hand it to PETSc!
             ::close (fd);
           }
 
         // Store temporary filename as string, makes it easier to broadcast
         temp_filename = c;
       }
 
       // Now broadcast the filename from processor 0 to all processors.
       this->comm().broadcast(temp_filename);
 
       // PetscViewer object for passing to MatView
       PetscViewer petsc_viewer;
 
       // This PETSc function only takes a string and handles the opening/closing
       // of the file internally.  Since print_personal() takes a reference to
       // an ostream, we have to do an extra step...  print_personal() should probably
       // have a version that takes a string to get rid of this problem.
       LibmeshPetscCall(PetscViewerASCIIOpen( this->comm().get(),
                                              temp_filename.c_str(),
                                              &petsc_viewer));
 
       // Probably don't need to set the format if it's default...
       //      ierr = PetscViewerSetFormat (petsc_viewer,
       //   PETSC_VIEWER_DEFAULT);
       //      LIBMESH_CHKERR(ierr);
 
       // Finally print the matrix using the viewer
       LibmeshPetscCall(MatView (this->_mat, petsc_viewer));
 
       if (this->processor_id() == 0)
         {
           // Now the inefficient bit: open temp_filename as an ostream and copy the contents
           // into the user's desired ostream.  We can't just do a direct file copy, we don't even have the filename!
           std::ifstream input_stream(temp_filename.c_str());
           os << input_stream.rdbuf();  // The "most elegant" way to copy one stream into another.
           // os.close(); // close not defined in ostream
 
           // Now remove the temporary file
           input_stream.close();
           std::remove(temp_filename.c_str());
         }
     }
 }

◆ print_petsc_binary()

template<typename T >

void libMesh::PetscMatrix< T >::print_petsc_binary ( const std::string & filename ) const

overridevirtual

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 691 of file petsc_matrix.C.

References libMesh::PetscMatrix< T >::_petsc_viewer(), libMesh::initialized(), and libMesh::libmesh_assert().

 {
   libmesh_assert (this->initialized());
 
   // Our helper here isn't const-correct for writes
   PetscMatrix<T> * nonconst_this = const_cast<PetscMatrix<T>*>(this);
   nonconst_this->_petsc_viewer(filename, PETSCVIEWERBINARY, FILE_MODE_WRITE);
 }

◆ print_petsc_hdf5()

template<typename T >

void libMesh::PetscMatrix< T >::print_petsc_hdf5 ( const std::string & filename ) const

overridevirtual

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 703 of file petsc_matrix.C.

References libMesh::PetscMatrix< T >::_petsc_viewer(), libMesh::initialized(), and libMesh::libmesh_assert().

 {
   libmesh_assert (this->initialized());
 
   // Our helper here isn't const-correct for writes
   PetscMatrix<T> * nonconst_this = const_cast<PetscMatrix<T>*>(this);
   nonconst_this->_petsc_viewer(filename, PETSCVIEWERHDF5, FILE_MODE_WRITE);
 }

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

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

TIMPI::Communicator::rank

processor_id_type rank() const

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:120

◆ read()

template<typename T >

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

virtualinherited

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

Definition at line 686 of file sparse_matrix.C.

 {
   {
     std::ifstream in (filename.c_str());
     libmesh_error_msg_if
       (!in.good(), "ERROR: cannot read file:\n\t" <<
        filename);
   }
 
   std::string_view basename = Utility::basename_of(filename);
 
   const bool gzipped_file = Utility::ends_with(filename, ".gz");
 
   if (gzipped_file)
     basename.remove_suffix(3);
 
   if (Utility::ends_with(basename, ".matlab") ||
       Utility::ends_with(basename, ".m"))
     this->read_matlab(filename);
   else if (Utility::ends_with(basename, ".petsc64"))
     {
 #ifndef LIBMESH_HAVE_PETSC
       libmesh_error_msg("Cannot load PETSc matrix file " <<
                         filename << " without PETSc-enabled libMesh.");
 #elif LIBMESH_DOF_ID_BYTES != 8
       libmesh_error_msg("Cannot load 64-bit PETSc matrix file " <<
                         filename << " with non-64-bit libMesh.");
 #endif
       if (gzipped_file)
         libmesh_not_implemented_msg("Gzipped PETSc matrices are not currently supported");
       this->read_petsc_binary(filename);
     }
   else if (Utility::ends_with(basename, ".petsc32"))
     {
 #ifndef LIBMESH_HAVE_PETSC
       libmesh_error_msg("Cannot load PETSc matrix file " <<
                         filename << " without PETSc-enabled libMesh.");
 #elif LIBMESH_DOF_ID_BYTES != 4
       libmesh_error_msg("Cannot load 32-bit PETSc matrix file " <<
                         filename << " with non-32-bit libMesh.");
 #endif
       if (gzipped_file)
         libmesh_not_implemented_msg("Gzipped PETSc matrices are not currently supported");
       this->read_petsc_binary(filename);
     }
   else if (Utility::ends_with(basename, ".h5"))
     {
       if (gzipped_file)
         libmesh_not_implemented_msg("Gzipped HDF5 matrices are not currently supported");
       this->read_coreform_hdf5(filename);
     }
   else
     libmesh_error_msg(" ERROR: Unrecognized matrix file extension on: "
                       << basename
                       << "\n   I understand the following:\n\n"
                       << "     *.h5        -- CoreForm HDF5 sparse matrix format\n"
                       << "     *.matlab    -- Matlab sparse matrix format\n"
                       << "     *.matlab.gz -- Matlab sparse matrix format, gzipped\n"
                       << "     *.m         -- Matlab sparse matrix format\n"
                       << "     *.m.gz      -- Matlab sparse matrix format, gzipped\n"
                       << "     *.petsc32   -- PETSc binary format, 32-bit\n"
                       << "     *.petsc64   -- PETSc binary format, 64-bit\n"
                      );
 }

◆ read_coreform_hdf5()

template<typename T >

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

virtualinherited

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

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

Definition at line 822 of file sparse_matrix.C.

 {
 #ifndef LIBMESH_HAVE_HDF5
   libmesh_ignore(filename, groupname);
   libmesh_error_msg("ERROR: need HDF5 support to handle .h5 files!!!");
 #else
   LOG_SCOPE("read_coreform_hdf5()", "SparseMatrix");
 
   std::size_t num_rows = 0, num_cols = 0;
 
   // These are only used on pid 0, but avoid "uninitialized" warnings
   hid_t group = H5I_INVALID_HID;
   hid_t file = H5I_INVALID_HID;
 
   if (this->processor_id() == 0)
     {
       file = H5Fopen(filename.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
 
       if (file == H5I_INVALID_HID)
         libmesh_file_error(filename);
 
       group = H5Gopen(file, groupname.c_str(), H5P_DEFAULT);
       check_open(filename, group, groupname);
 
       auto read_size_attribute = [&filename, &group]
         (const std::string & attribute_name)
       {
         unsigned long long returnval = 0;
 
         const hid_t attr = H5Aopen(group, attribute_name.c_str(), H5P_DEFAULT);
         check_open(filename, attr, attribute_name);
 
         const hid_t attr_type = H5Aget_type(attr);
         check_hdf5(filename, attr_type, attribute_name + " type");
 
         // HDF5 will convert between the file's integer type and ours, but
         // we do expect an integer type.
         if (H5Tget_class(attr_type) != H5T_INTEGER)
           libmesh_error_msg("Non-integer type for " + attribute_name + " in " + filename);
 
         H5Tclose(attr_type);
 
         // HDF5 is supposed to handle both upscaling and endianness
         // conversions here
         const herr_t errval = H5Aread(attr, H5T_NATIVE_ULLONG, &returnval);
         check_hdf5(filename, errval, attribute_name + " read");
 
         H5Aclose(attr);
 
         return returnval;
       };
 
       num_cols = read_size_attribute("num_cols");
       num_rows = read_size_attribute("num_rows");
 
       this->comm().broadcast(num_cols);
       this->comm().broadcast(num_rows);
     }
   else
     {
       this->comm().broadcast(num_cols);
       this->comm().broadcast(num_rows);
     }
 
   numeric_index_type new_row_start, new_row_stop,
                      new_col_start, new_col_stop;
 
   // If we need to reinit, we need to determine which rows+columns
   // each processor is in charge of.
   std::vector<numeric_index_type> new_row_starts, new_row_stops,
                                   new_col_starts, new_col_stops;
 
   if (this->initialized() &&
       num_cols == this->n() &&
       num_rows == this->m())
     {
       new_row_start = this->row_start(),
       new_row_stop  = this->row_stop();
 
       new_col_start = this->col_start(),
       new_col_stop  = this->col_stop();
     }
   else
     {
       // Determine which rows/columns each processor will be in charge of
       new_row_start =     this->processor_id() * num_rows / this->n_processors(),
       new_row_stop  = (this->processor_id()+1) * num_rows / this->n_processors();
 
       new_col_start =     this->processor_id() * num_cols / this->n_processors(),
       new_col_stop  = (this->processor_id()+1) * num_cols / this->n_processors();
     }
 
   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);
 
   numeric_index_type on_diagonal_nonzeros = 0,
                      off_diagonal_nonzeros = 0;
 
   std::vector<std::size_t> cols, row_offsets;
   std::vector<double> vals;
 
   if (this->processor_id() == 0)
     {
       auto read_vector = [&filename, &group]
         (const std::string & dataname, auto hdf5_class,
          auto hdf5_type, auto & datavec)
       {
         const hid_t data = H5Dopen1(group, dataname.c_str());
         check_open(filename, data, dataname.c_str());
 
         const hid_t data_type = H5Dget_type(data);
         check_hdf5(filename, data_type, dataname + " type");
 
         // HDF5 will convert between the file's integer type and ours, but
         // we do expect an integer type.
         if (H5Tget_class(data_type) != hdf5_class)
           libmesh_error_msg("Unexpected type for " + dataname + " in " + filename);
 
         H5Tclose(data_type);
 
         const hid_t dataspace = H5Dget_space(data);
         check_hdf5(filename, dataspace, dataname + " space");
 
         int ndims = H5Sget_simple_extent_ndims(dataspace);
         if (ndims != 1)
           libmesh_error_msg("Non-vector space for " + dataname + " in " + filename);
 
         hsize_t len, maxlen;
         herr_t errval = H5Sget_simple_extent_dims(dataspace, &len, &maxlen);
         check_hdf5(filename, errval, dataname + " dims");
 
         datavec.resize(len);
 
         errval = H5Dread(data, hdf5_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, datavec.data());
         check_hdf5(filename, errval, dataname + " read");
 
         H5Dclose(data);
       };
 
       read_vector("cols", H5T_INTEGER, H5T_NATIVE_ULLONG, cols);
       read_vector("row_offsets", H5T_INTEGER, H5T_NATIVE_ULLONG, row_offsets);
       read_vector("vals", H5T_FLOAT, H5T_NATIVE_DOUBLE, vals);
 
       if (cols.size() != vals.size())
         libmesh_error_msg("Inconsistent cols/vals sizes in " + filename);
 
       if (row_offsets.size() != num_rows + 1)
         libmesh_error_msg("Inconsistent row_offsets size in " + filename);
 
       // Data for the row we're working on
       numeric_index_type current_row = 0;
       processor_id_type current_proc = 0;
       numeric_index_type current_on_diagonal_nonzeros = 0;
       numeric_index_type current_off_diagonal_nonzeros = 0;
       if (row_offsets[0] != 0)
         libmesh_error_msg("Unexpected row_offsets[0] in " + filename);
 
       for (auto i : index_range(cols))
         {
           while (row_offsets[current_row+1] <= i)
             {
               ++current_row;
               if (row_offsets[current_row] < row_offsets[current_row-1])
                 libmesh_error_msg("Non-monotonic row_offsets in " + filename);
               current_on_diagonal_nonzeros = 0;
               current_off_diagonal_nonzeros = 0;
             }
 
           while (current_row >= new_row_stops[current_proc])
             ++current_proc;
 
           // 0-based indexing in file
           if (cols[i] >= new_col_starts[current_proc] &&
               cols[i] < new_col_stops[current_proc])
             {
               ++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);
             }
         }
     }
 
   this->comm().broadcast(on_diagonal_nonzeros);
   this->comm().broadcast(off_diagonal_nonzeros);
 
   this->init(num_rows, num_cols,
              new_row_stop-new_row_start,
              new_col_stop-new_col_start,
              on_diagonal_nonzeros,
              off_diagonal_nonzeros);
 
   // Set the matrix values last.
   if (this->processor_id() == 0)
     {
       numeric_index_type current_row = 0;
       for (auto i : index_range(cols))
         {
           while (row_offsets[current_row+1] <= i)
             {
               ++current_row;
               libmesh_assert_greater_equal (row_offsets[current_row],
                                             row_offsets[current_row-1]);
             }
           this->set(current_row, cols[i], vals[i]);
         }
 
       H5Gclose(group);
       H5Fclose(file);
     }
 
   this->close();
 #endif // LIBMESH_HAVE_HDF5
 }

◆ read_matlab()

template<typename T >

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

virtualinherited

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

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

Definition at line 1050 of file sparse_matrix.C.

Referenced by ConstraintOperatorTest::test1DCoarseningNewNodes().

 {
   LOG_SCOPE("read_matlab()", "SparseMatrix");
 
 #ifndef LIBMESH_HAVE_CXX11_REGEX
   libmesh_not_implemented();  // What is your compiler?!?  Email us!
   libmesh_ignore(filename);
 #else
   parallel_object_only();
 
   const bool gzipped_file = Utility::ends_with(filename, ".gz");
 
   // The sizes we get from the file
   std::size_t m = 0,
               n = 0;
 
   // If we don't already have this size, we'll need to reinit, and
   // determine which rows+columns each processor is in charge of.
   std::vector<numeric_index_type> new_row_starts, new_row_stops,
                                   new_col_starts, new_col_stops;
 
   numeric_index_type new_row_start, new_row_stop,
                      new_col_start, new_col_stop;
 
   // 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.
   //
   // We'll use an istream here; it might be an ifstream if we're
   // opening a raw ASCII file or a gzstream if we're opening a
   // compressed one.
   std::unique_ptr<std::istream> file;
 
   // We'll need a temporary structure to cache matrix entries, because
   // we need to read through the whole file before we know the size
   // and sparsity structure with which we can init().
   //
   // Reading through the file three times via `seekg` doesn't work
   // with our gzstream wrapper, and seems to take three times as long
   // even with a plain ifstream.  What happened to disk caching!?
   std::vector<std::tuple<numeric_index_type, numeric_index_type, T>> entries;
 
   // First read through the file, saving size and entry data
   {
   // We'll read the matrix on processor 0 rather than try to juggle
   // parallel I/O.
   if (this->processor_id() == 0)
     {
       // 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 end_regex // end of assignment
         ("^[^%]*\\]");
 
       if (gzipped_file)
         {
 #ifdef LIBMESH_HAVE_GZSTREAM
           auto inf = std::make_unique<igzstream>();
           libmesh_assert(inf);
           inf->open(filename.c_str(), std::ios::in);
           file = std::move(inf);
 #else
           libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
 #endif
         }
       else
         {
           auto inf = std::make_unique<std::ifstream>();
           libmesh_assert(inf);
 
           std::string new_name = Utility::unzip_file(filename);
 
           inf->open(new_name.c_str(), std::ios::in);
           file = std::move(inf);
         }
 
       // 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+)");
       const std::string whitespace = " \t";
 
       bool have_started = false;
       bool have_ended = false;
       std::size_t largest_i_seen = 0, largest_j_seen = 0;
 
       // Data for the row we're working on
       // Use 1-based indexing for current_row, as in the file
       std::size_t current_row = 1;
 
       for (std::string line; std::getline(*file, line);)
         {
           std::smatch sm;
 
           // First, try to match an entry.  This is the most common
           // case so we won't rely on slow std::regex for it.
           // stringstream is at least an improvement over that.
 
           // Look for row/col/val like "1 1 -2.0e-4"
 
           std::istringstream l(line);
 
           std::size_t i, j;
           T value;
 
           l >> i >> j >> value;
 
           if (!l.fail())
             {
               libmesh_error_msg_if
                 (!have_started, "Confused by premature entries in matrix file " << filename);
 
               entries.emplace_back(cast_int<numeric_index_type>(i),
                                    cast_int<numeric_index_type>(j),
                                    value);
 
               libmesh_error_msg_if
                 (!i || !j, "Expected 1-based indexing in matrix file "
                  << filename);
 
               current_row = std::max(current_row, i);
 
               libmesh_error_msg_if
                 (i < current_row,
                  "Can't handle out-of-order entries in matrix file "
                  << filename);
 
               largest_i_seen = std::max(i, largest_i_seen);
               largest_j_seen = std::max(j, largest_j_seen);
             }
 
           else 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);
             }
 
           else if (std::regex_search(line, start_regex))
             have_started = true;
 
           else 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 (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();
     }
   else
     {
       // Determine which rows/columns each processor will be in charge of
       new_row_start =     this->processor_id() * m / this->n_processors(),
       new_row_stop  = (this->processor_id()+1) * m / this->n_processors();
 
       new_col_start =     this->processor_id() * n / this->n_processors(),
       new_col_stop  = (this->processor_id()+1) * n / this->n_processors();
     }
 
   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);
 
   } // Done reading entry data and broadcasting matrix size
 
   // Calculate the matrix sparsity and initialize it second
   {
   // 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)
     {
       // 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 (auto [i, j, value] : entries)
         {
           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);
             }
         }
     }
 
   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);
   }
 
   // Set the matrix values last.
   // Convert from 1-based to 0-based indexing
   if (this->processor_id() == 0)
     for (auto [i, j, value] : entries)
       this->set(i-1, j-1, value);
 
   this->close();
 #endif
 }

◆ read_petsc_binary()

template<typename T >

void libMesh::PetscMatrix< T >::read_petsc_binary ( const std::string & filename )

overridevirtual

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 715 of file petsc_matrix.C.

 {
   LOG_SCOPE("read_petsc_binary()", "PetscMatrix");
 
   this->_petsc_viewer(filename, PETSCVIEWERBINARY, FILE_MODE_READ);
 }

◆ read_petsc_hdf5()

template<typename T >

void libMesh::PetscMatrix< T >::read_petsc_hdf5 ( const std::string & filename )

overridevirtual

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 725 of file petsc_matrix.C.

 {
   LOG_SCOPE("read_petsc_hdf5()", "PetscMatrix");
 
   this->_petsc_viewer(filename, PETSCVIEWERHDF5, FILE_MODE_READ);
 }

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

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

◆ require_sparsity_pattern()

template<typename T>

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

inlinevirtualinherited

Returns: Whether this matrix needs the sparsity pattern computed by the DofMap

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

Definition at line 168 of file sparse_matrix.h.

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

libMesh::SparseMatrix::use_hash_table

bool use_hash_table() const

Definition: sparse_matrix.h:634

◆ reset_preallocation()

template<typename T >

void libMesh::PetscMatrix< T >::reset_preallocation ( )

Reset matrix to use the original nonzero pattern provided by users.

Definition at line 385 of file petsc_matrix.C.

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

 {
   semiparallel_only();
 
 #if !PETSC_VERSION_LESS_THAN(3,9,0)
   libmesh_assert (this->initialized());
 
   LibmeshPetscCall(MatResetPreallocation(this->_mat));
 #else
   libmesh_warning("Your version of PETSc doesn't support resetting of "
                   "preallocation, so we will use your most recent sparsity "
                   "pattern. This may result in a degradation of performance\n");
 #endif
 }

◆ restore_original_nonzero_pattern()

template<typename T >

void libMesh::PetscMatrix< T >::restore_original_nonzero_pattern ( )

overridevirtual

Reset the memory storage of the matrix.

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1267 of file petsc_matrix.C.

 {
   semiparallel_only();
 
   if (this->_use_hash_table)
 #if PETSC_RELEASE_GREATER_EQUALS(3, 23, 0)
     // This performs MatReset plus re-establishes the hash table
     LibmeshPetscCall(MatResetHash(this->_mat));
 #else
     libmesh_error_msg("Resetting hash tables not supported until PETSc version 3.23");
 #endif
   else
     this->reset_preallocation();
 }

◆ row_start()

template<typename T >

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

overridevirtualinherited

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

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 178 of file petsc_matrix_base.C.

Referenced by libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), and libMesh::PetscPreconditioner< T >::set_hypre_ams_data().

 {
   libmesh_assert (this->initialized());
 
   PetscInt start=0, stop=0;
 
   LibmeshPetscCall(MatGetOwnershipRange(this->_mat, &start, &stop));
 
   return static_cast<numeric_index_type>(start);
 }

◆ row_stop()

template<typename T >

numeric_index_type libMesh::PetscMatrixBase< T >::row_stop ( ) const

overridevirtualinherited

Returns: The index of the last matrix row (+1) stored on this processor.

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 190 of file petsc_matrix_base.C.

Referenced by libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), and libMesh::PetscPreconditioner< T >::set_hypre_ams_data().

 {
   libmesh_assert (this->initialized());
 
   PetscInt start=0, stop=0;
 
   LibmeshPetscCall(MatGetOwnershipRange(this->_mat, &start, &stop));
 
   return static_cast<numeric_index_type>(stop);
 }

◆ scale()

template<typename T >

void libMesh::PetscMatrix< T >::scale ( const T scale )

overridevirtual

Scales all elements of this matrix by scale.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1234 of file petsc_matrix.C.

References libMesh::closed(), libMesh::libmesh_assert(), libMesh::PS(), and libMesh::MeshTools::Modification::scale().

 {
   libmesh_assert(this->closed());
 
   LibmeshPetscCall(MatScale(this->_mat, PS(scale)));
 }

◆ set()

template<typename T >

void libMesh::PetscMatrix< 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 972 of file petsc_matrix.C.

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

Referenced by libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), and libMesh::PetscPreconditioner< T >::set_hypre_ams_data().

 {
   libmesh_assert (this->initialized());
 
   PetscInt i_val=i, j_val=j;
 
   PetscScalar petsc_value = static_cast<PetscScalar>(value);
   std::scoped_lock lock(this->_petsc_matrix_mutex);
   LibmeshPetscCall(MatSetValues(this->_mat, 1, &i_val, 1, &j_val,
                                 &petsc_value, INSERT_VALUES));
 }

◆ set_context()

template<typename T >

void libMesh::PetscMatrixBase< T >::set_context ( )

inherited

Set the context (ourself) for _mat.

Definition at line 105 of file petsc_matrix_base.C.

 {
   libmesh_assert(this->_mat);
   PetscContainer container;
   LibmeshPetscCall(PetscContainerCreate(this->comm().get(), &container));
   LibmeshPetscCall(PetscContainerSetPointer(container, this));
   LibmeshPetscCall(PetscObjectCompose((PetscObject)(Mat)this->_mat, "PetscMatrixCtx", (PetscObject)container));
   LibmeshPetscCall(PetscContainerDestroy(&container));
 }

◆ set_destroy_mat_on_exit()

template<typename T >

void libMesh::PetscMatrixBase< T >::set_destroy_mat_on_exit ( bool destroy = true )

inherited

If set to false, we don't delete the Mat on destruction and allow instead for PETSc to manage it.

Definition at line 91 of file petsc_matrix_base.C.

 {
   this->_destroy_mat_on_exit = destroy;
 }

◆ solver_package()

template<typename T>

virtual SolverPackage libMesh::PetscMatrixBase< T >::solver_package ( )

inlineoverridevirtualinherited

Implements libMesh::SparseMatrix< T >.

Reimplemented in libMesh::StaticCondensation, and libMesh::StaticCondensation.

Definition at line 107 of file petsc_matrix_base.h.

   {
     return PETSC_SOLVERS;
   }

◆ supports_hash_table()

template<typename T >

bool libMesh::PetscMatrix< T >::supports_hash_table ( ) const

overridevirtual

Returns: Whether the matrix supports hash table assembly

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1242 of file petsc_matrix.C.

 {
 #if PETSC_RELEASE_LESS_THAN(3,19,0)
   return false;
 #else
   return true;
 #endif
 }

◆ swap()

template<typename T>

void libMesh::PetscMatrixBase< T >::swap ( PetscMatrixBase< T > & m_in )

inherited

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

Definition at line 98 of file petsc_matrix_base.C.

Referenced by DMlibMeshJacobian().

 {
   std::swap(_mat, m_in._mat);
   std::swap(_destroy_mat_on_exit, m_in._destroy_mat_on_exit);
 }

◆ update_preallocation_and_zero()

template<typename T >

void libMesh::PetscMatrix< T >::update_preallocation_and_zero ( )

Update the sparsity pattern based on dof_map, and set the matrix to zero.

This is useful in cases where the sparsity pattern changes during a computation.

Definition at line 379 of file petsc_matrix.C.

 {
   libmesh_not_implemented();
 }

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

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

175 {}

◆ use_hash_table() [1/2]

template<typename T >

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

inherited

Sets whether to use hash table assembly.

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

Definition at line 692 of file sparse_matrix.h.

Referenced by PetscMatrixTest::testPetscCopyFromHash().

 {
   libmesh_error_msg_if(use_hash && !this->supports_hash_table(),
                        "This matrix class does not support hash table assembly");
   this->_use_hash_table = use_hash;
 }

◆ use_hash_table() [2/2]

template<typename T>

bool libMesh::SparseMatrix< T >::use_hash_table ( ) const

inlineinherited

Returns: Whether this matrix is using hash table assembly. Hash table or hash map assembly means storing maps from i-j locations in the matrix to values. Because it is a hash map as opposed to a contiguous array of data, no preallocation is required to use it

Definition at line 634 of file sparse_matrix.h.

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

634 { return _use_hash_table; }

libMesh::SparseMatrix::_use_hash_table

bool _use_hash_table

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

Definition: sparse_matrix.h:683

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

 {
   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 247 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::PetscMatrix< T >::zero ( )

overridevirtual

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 401 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   semiparallel_only();
 
   PetscInt m_l, n_l;
 
   LibmeshPetscCall(MatGetLocalSize(this->_mat,&m_l,&n_l));
 
   if (n_l)
     LibmeshPetscCall(MatZeroEntries(this->_mat));
 }

◆ zero_clone()

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::PetscMatrix< 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 435 of file petsc_matrix.C.

References libMesh::closed().

 {
   libmesh_error_msg_if(!this->closed(), "Matrix must be closed before it can be cloned!");
 
   // Copy the nonzero pattern only
   Mat copy;
   LibmeshPetscCall(MatDuplicate(this->_mat, MAT_DO_NOT_COPY_VALUES, &copy));
 
   // Call wrapping PetscMatrix constructor, have it take over
   // ownership.
   auto ret = std::make_unique<PetscMatrix<T>>(copy, this->comm());
   ret->set_destroy_mat_on_exit(true);
 
   return ret;
 }

◆ zero_rows()

template<typename T >

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

overridevirtual

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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 416 of file petsc_matrix.C.

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

 {
   libmesh_assert (this->initialized());
 
   semiparallel_only();
 
   // As of petsc-dev at the time of 3.1.0, MatZeroRows now takes two additional
   // optional arguments.  The optional arguments (x,b) can be used to specify the
   // solutions for the zeroed rows (x) and right hand side (b) to update.
   // Could be useful for setting boundary conditions...
   if (!rows.empty())
     LibmeshPetscCall(MatZeroRows(this->_mat, cast_int<PetscInt>(rows.size()),
                                  numeric_petsc_cast(rows.data()), PS(diag_value),
                                  NULL, NULL));
   else
     LibmeshPetscCall(MatZeroRows(this->_mat, 0, NULL, PS(diag_value), NULL, NULL));
 }

Friends And Related Function Documentation

◆ ::PetscMatrixTest

template<typename T>

friend class ::PetscMatrixTest

friend

Definition at line 366 of file petsc_matrix.h.

Member Data Documentation

◆ _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::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _destroy_mat_on_exit

template<typename T>

bool libMesh::PetscMatrixBase< T >::_destroy_mat_on_exit

protectedinherited

This boolean value should only be set to false for the constructor which takes a PETSc Mat object.

Definition at line 186 of file petsc_matrix_base.h.

Referenced by libMesh::PetscMatrixBase< Number >::swap().

◆ _dof_map

template<typename T>

DofMap const* libMesh::SparseMatrix< T >::_dof_map

protectedinherited

The DofMap object associated with this object.

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

Definition at line 666 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 678 of file sparse_matrix.h.

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

◆ _mat

template<typename T>

Mat libMesh::PetscMatrixBase< T >::_mat

protectedinherited

PETSc matrix datatype to store values.

Definition at line 180 of file petsc_matrix_base.h.

Referenced by libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::PetscMatrix< T >::add(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), libMesh::PetscMatrix< T >::get_transpose(), libMesh::PetscMatrixBase< Number >::mat(), libMesh::PetscMatrix< T >::operator=(), and libMesh::PetscMatrixBase< Number >::swap().

◆ _mat_type

template<typename T>

PetscMatrixType libMesh::PetscMatrix< T >::_mat_type

protected

Definition at line 349 of file petsc_matrix.h.

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

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

◆ _petsc_matrix_mutex [1/2]

template<typename T>

std::mutex libMesh::PetscMatrix< T >::_petsc_matrix_mutex

mutableprivate

Definition at line 353 of file petsc_matrix.h.

◆ _petsc_matrix_mutex [2/2]

template<typename T>

Threads::spin_mutex libMesh::PetscMatrix< T >::_petsc_matrix_mutex

mutableprivate

Definition at line 355 of file petsc_matrix.h.

◆ _sp

template<typename T>

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

protectedinherited

The sparsity pattern associated with this object.

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

Definition at line 673 of file sparse_matrix.h.

◆ _use_hash_table

template<typename T>

bool libMesh::SparseMatrix< T >::_use_hash_table

protectedinherited

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

Definition at line 683 of file sparse_matrix.h.

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

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

include/numerics/petsc_matrix.h
src/numerics/petsc_matrix.C

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

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

Member Typedef Documentation

◆ Counts

Constructor & Destructor Documentation

◆ PetscMatrix() [1/5]

◆ PetscMatrix() [2/5]

◆ PetscMatrix() [3/5]

◆ PetscMatrix() [4/5]

◆ PetscMatrix() [5/5]

◆ ~PetscMatrix()

Member Function Documentation

◆ _get_submatrix()

◆ _petsc_viewer()

◆ add() [1/2]

◆ add() [2/2]

◆ add_block_matrix() [1/2]

◆ add_block_matrix() [2/2]

◆ add_matrix() [1/2]

◆ add_matrix() [2/2]

◆ add_sparse_matrix()

◆ attach_dof_map()

◆ attach_sparsity_pattern()

◆ build()

◆ clear()

◆ clone()

◆ close()

◆ closed()

◆ col_start()

◆ col_stop()

◆ comm()

◆ copy_from_hash()

◆ create_submatrix()

◆ create_submatrix_nosort()

◆ disable_print_counter_info()

◆ enable_print_counter_info()

◆ finish_initialization()

◆ flush()

◆ frobenius_norm()

◆ get_context()

◆ get_diagonal()

◆ get_info()

◆ get_row()

◆ get_transpose()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ init() [1/3]

◆ init() [2/3]

◆ init() [3/3]

◆ init_without_preallocation()

◆ initialized()

◆ l1_norm()

◆ l1_norm_diff()

◆ linfty_norm()

◆ local_m()

◆ local_n()

◆ m()

◆ mat() [1/2]

◆ mat() [2/2]

◆ matrix_matrix_mult()

◆ n()

◆ n_nonzeros()

◆ n_objects()

◆ n_processors()

◆ need_full_sparsity_pattern()

◆ norm()

◆ operator()()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ preallocate()

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