This class provides a nice interface to the PETSc C-based 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)
	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= (const PetscMatrix &)=delete

PetscMatrix &	operator= (PetscMatrix &&)=delete

virtual	~PetscMatrix ()

void	set_matrix_type (PetscMatrixType mat_type)

virtual void	init (const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1) override
	Initialize SparseMatrix with the specified sizes. More...

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 () 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	clear () override
	Restores the `SparseMatrix<T>` to a pristine state. More...

virtual void	zero () override
	Set all entries to 0. More...

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

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

virtual numeric_index_type	m () const override

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

virtual numeric_index_type	n () const override

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

void	get_local_size (numeric_index_type &m, numeric_index_type &n) const
	Get the number of rows and columns owned by this process. More...

virtual numeric_index_type	row_start () const override

virtual numeric_index_type	row_stop () const override

virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value) override
	Set the element (i,j) to `value`. More...

virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value) override
	Add `value` to the element (i,j). More...

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
	Add the full matrix `dm` to the SparseMatrix. More...

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
	Same as `add_matrix`, but assumes the row and column maps are the same. More...

virtual void	add_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 T	operator() (const numeric_index_type i, const numeric_index_type j) const override

virtual Real	l1_norm () const override

virtual Real	linfty_norm () const override

virtual bool	closed () const override

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

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

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

Mat	mat ()

void	get_row (numeric_index_type i, std::vector< numeric_index_type > &indices, std::vector< T > &values) const override
	Get a row from the matrix. More...

virtual bool	initialized () const

void	attach_dof_map (const DofMap &dof_map)
	Get a pointer to the `DofMap` to use. More...

virtual bool	need_full_sparsity_pattern () const

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

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

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

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< SparseMatrix< T > >	build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
	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=libMesh::out)
	Prints the reference information, by default to `libMesh::out`. More...

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...

static void	disable_print_counter_info ()

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

Protected Member Functions
virtual void	_get_submatrix (SparseMatrix< T > &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	increment_constructor_count (const std::string &name)
	Increments the construction counter. More...

void	increment_destructor_count (const std::string &name)
	Increments the destruction counter. More...

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

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

const Parallel::Communicator &	_communicator

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

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

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

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

Private Attributes
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...

PetscMatrixType	_mat_type

std::mutex	_petsc_matrix_mutex

Threads::spin_mutex	_petsc_matrix_mutex

Detailed Description

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

This class provides a nice interface to the PETSc C-based 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 87 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 117 of file reference_counter.h.

Constructor & Destructor Documentation

◆ PetscMatrix() [1/4]

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

                                                                 :
   SparseMatrix<T>(comm_in),
   _destroy_mat_on_exit(true),
   _mat_type(AIJ)
 {}

◆ PetscMatrix() [2/4]

template<typename T >

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

explicit

Constructor.

Creates a PetscMatrix assuming you already have a valid Mat object. In this case, m is NOT 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 103 of file petsc_matrix.C.

                                                                   :
   SparseMatrix<T>(comm_in),
   _destroy_mat_on_exit(false),
   _mat_type(AIJ)
 {
   this->_mat = mat_in;
   this->_is_initialized = true;
 }

◆ PetscMatrix() [3/4]

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

template<typename T>

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

delete

◆ ~PetscMatrix()

template<typename T >

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

virtual

Definition at line 117 of file petsc_matrix.C.

 {
   this->clear();
 }

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

 {
   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();
     }
  
   // 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.
   PetscErrorCode ierr=0;
   IS isrow, iscol;
  
   ierr = ISCreateLibMesh(this->comm().get(),
                          cast_int<PetscInt>(rows.size()),
                          numeric_petsc_cast(rows.data()),
                          PETSC_USE_POINTER,
                          &isrow); LIBMESH_CHKERR(ierr);
  
   ierr = ISCreateLibMesh(this->comm().get(),
                          cast_int<PetscInt>(cols.size()),
                          numeric_petsc_cast(cols.data()),
                          PETSC_USE_POINTER,
                          &iscol); LIBMESH_CHKERR(ierr);
  
   // Extract submatrix
   ierr = LibMeshCreateSubMatrix(_mat,
                                 isrow,
                                 iscol,
 #if PETSC_RELEASE_LESS_THAN(3,0,1)
                                 PETSC_DECIDE,
 #endif
                                 (reuse_submatrix ? MAT_REUSE_MATRIX : MAT_INITIAL_MATRIX),
                                 &(petsc_submatrix->_mat));  LIBMESH_CHKERR(ierr);
  
   // Specify that the new submatrix is initialized and close it.
   petsc_submatrix->_is_initialized = true;
   petsc_submatrix->close();
  
   // Clean up PETSc data structures
   ierr = LibMeshISDestroy(&isrow); LIBMESH_CHKERR(ierr);
   ierr = LibMeshISDestroy(&iscol); LIBMESH_CHKERR(ierr);
 }

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

 {
   libmesh_assert (this->initialized());
  
   PetscErrorCode ierr=0;
   PetscInt i_val=i, j_val=j;
  
   PetscScalar petsc_value = static_cast<PetscScalar>(value);
   ierr = MatSetValues(_mat, 1, &i_val, 1, &j_val,
                       &petsc_value, ADD_VALUES);
   LIBMESH_CHKERR(ierr);
 }

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

 {
   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);
  
   PetscErrorCode ierr=0;
  
   // the matrix from which we copy the values has to be assembled/closed
   libmesh_assert(X->closed());
  
   semiparallel_only();
  
   ierr = MatAXPY(_mat, a, X->_mat, DIFFERENT_NONZERO_PATTERN);
   LIBMESH_CHKERR(ierr);
 }

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

 {
   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());
  
   PetscErrorCode ierr=0;
  
 #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;
   ierr = MatGetBlockSize(_mat, &petsc_blocksize);
   LIBMESH_CHKERR(ierr);
   libmesh_assert_equal_to (blocksize, static_cast<numeric_index_type>(petsc_blocksize));
 #endif
  
   // These casts are required for PETSc <= 2.1.5
   ierr = MatSetValuesBlocked(_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);
   LIBMESH_CHKERR(ierr);
 }

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

◆ 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 219 of file petsc_matrix.h.

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

◆ add_matrix() [1/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 1161 of file petsc_matrix.C.

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

◆ add_matrix() [2/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 810 of file petsc_matrix.C.

 {
   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);
  
   PetscErrorCode ierr=0;
   ierr = MatSetValues(_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);
   LIBMESH_CHKERR(ierr);
 }

◆ attach_dof_map()

template<typename T>

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

inlineinherited

Get a pointer to the DofMap to use.

Definition at line 108 of file sparse_matrix.h.

109 { _dof_map = &dof_map; }

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

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

staticinherited

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

Definition at line 130 of file sparse_matrix.C.

 {
   // Avoid unused parameter warnings when no solver packages are enabled.
   libmesh_ignore(comm);
  
   // Build the appropriate vector
   switch (solver_package)
     {
  
 #ifdef LIBMESH_HAVE_LASPACK
     case LASPACK_SOLVERS:
       return libmesh_make_unique<LaspackMatrix<T>>(comm);
 #endif
  
  
 #ifdef LIBMESH_HAVE_PETSC
     case PETSC_SOLVERS:
       return libmesh_make_unique<PetscMatrix<T>>(comm);
 #endif
  
  
 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
     case TRILINOS_SOLVERS:
       return libmesh_make_unique<EpetraMatrix<T>>(comm);
 #endif
  
  
 #ifdef LIBMESH_HAVE_EIGEN
     case EIGEN_SOLVERS:
       return libmesh_make_unique<EigenSparseMatrix<T>>(comm);
 #endif
  
     default:
       libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
     }
 }

Referenced by libMesh::ImplicitSystem::add_matrix(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::EigenSystem::init_matrices(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

◆ clear()

template<typename T >

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

overridevirtual

Restores the SparseMatrix<T> to a pristine state.

Implements libMesh::SparseMatrix< T >.

Definition at line 560 of file petsc_matrix.C.

 {
   PetscErrorCode ierr=0;
  
   if ((this->initialized()) && (this->_destroy_mat_on_exit))
     {
       semiparallel_only();
  
       ierr = LibMeshMatDestroy (&_mat);
       LIBMESH_CHKERR(ierr);
  
       this->_is_initialized = false;
     }
 }

◆ close()

template<typename T >

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

overridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 989 of file petsc_matrix.C.

 {
   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;
  
   PetscErrorCode ierr=0;
  
   ierr = MatAssemblyBegin (_mat, MAT_FINAL_ASSEMBLY);
   LIBMESH_CHKERR(ierr);
   ierr = MatAssemblyEnd   (_mat, MAT_FINAL_ASSEMBLY);
   LIBMESH_CHKERR(ierr);
 }

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), libMesh::PetscLinearSolver< Number >::adjoint_solve(), libMesh::PetscMatrix< libMesh::Number >::get_transpose(), libMesh::PetscLinearSolver< Number >::solve(), libMesh::SlepcEigenSolver< libMesh::Number >::solve_generalized(), and libMesh::SlepcEigenSolver< libMesh::Number >::solve_standard().

◆ closed()

template<typename T >

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

overridevirtual

Returns: true if the matrix has been assembled.

Implements libMesh::SparseMatrix< T >.

Definition at line 1317 of file petsc_matrix.C.

 {
   libmesh_assert (this->initialized());
  
   PetscErrorCode ierr=0;
   PetscBool assembled;
  
   ierr = MatAssembled(_mat, &assembled);
   LIBMESH_CHKERR(ierr);
  
   return (assembled == PETSC_TRUE);
 }

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

◆ comm()

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

inlineinherited

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

Definition at line 94 of file parallel_object.h.

95 { return _communicator; }

References libMesh::ParallelObject::_communicator.

◆ create_submatrix()

template<typename T>

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

inlinevirtualinherited

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

Currently this operation is only defined for the PetscMatrix type.

Definition at line 358 of file sparse_matrix.h.

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

Referenced by libMesh::libmesh_petsc_DMCreateInterpolation().

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

 {
   _enable_print_counter = false;
   return;
 }

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

 {
   _enable_print_counter = true;
   return;
 }

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   semiparallel_only();
  
   PetscErrorCode ierr=0;
  
   ierr = MatAssemblyBegin (_mat, MAT_FLUSH_ASSEMBLY);
   LIBMESH_CHKERR(ierr);
   ierr = MatAssemblyEnd   (_mat, MAT_FLUSH_ASSEMBLY);
   LIBMESH_CHKERR(ierr);
 }

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

 {
   // 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.
   PetscErrorCode ierr =
     MatGetDiagonal(const_cast<PetscMatrix<T> *>(this)->mat(),petsc_dest.vec()); LIBMESH_CHKERR(ierr);
 }

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

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
  
   std::ostringstream oss;
  
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
  
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
  
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
  
   oss << " ---------------------------------------------------------------------------- \n";
  
   return oss.str();
  
 #else
  
   return "";
  
 #endif
 }

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

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

◆ get_local_size()

template<typename T >

void libMesh::PetscMatrix< T >::get_local_size	(	numeric_index_type &	m,
		numeric_index_type &	n
	)		const

Get the number of rows and columns owned by this process.

Parameters

i	Row size
j	Column size

Definition at line 1078 of file petsc_matrix.C.

 {
   libmesh_assert (this->initialized());
  
   PetscInt petsc_m = 0, petsc_n = 0;
  
   auto ierr = MatGetLocalSize (_mat, &petsc_m, &petsc_n);
   LIBMESH_CHKERR(ierr);
  
   m = static_cast<numeric_index_type>(petsc_m);
   n = static_cast<numeric_index_type>(petsc_n);
 }

◆ get_row()

template<typename T>

void libMesh::PetscMatrix< T >::get_row	(	numeric_index_type	,
		std::vector< numeric_index_type > &	,
		std::vector< T > &
	)		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

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1260 of file petsc_matrix.C.

 {
   libmesh_assert (this->initialized());
  
   const PetscScalar * petsc_row;
   const PetscInt    * petsc_cols;
  
   PetscErrorCode ierr=0;
   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
  
 #ifdef LIBMESH_HAVE_CXX11_THREAD
   std::lock_guard<std::mutex>
 #else
   Threads::spin_mutex::scoped_lock
 #endif
     lock(_petsc_matrix_mutex);
  
   ierr = MatGetRow(_mat, i_val, &ncols, &petsc_cols, &petsc_row);
   LIBMESH_CHKERR(ierr);
  
   // 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]);
   }
  
   ierr  = MatRestoreRow(_mat, i_val,
                         &ncols, &petsc_cols, &petsc_row);
   LIBMESH_CHKERR(ierr);
 }

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

 {
   // 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();
  
   PetscErrorCode ierr;
 #if PETSC_VERSION_LESS_THAN(3,0,0)
   if (&petsc_dest == this)
     ierr = MatTranspose(_mat,NULL);
   else
     ierr = MatTranspose(_mat,&petsc_dest._mat);
   LIBMESH_CHKERR(ierr);
 #else
   // FIXME - we can probably use MAT_REUSE_MATRIX in more situations
   if (&petsc_dest == this)
     ierr = MatTranspose(_mat,MAT_REUSE_MATRIX,&petsc_dest._mat);
   else
     ierr = MatTranspose(_mat,MAT_INITIAL_MATRIX,&petsc_dest._mat);
   LIBMESH_CHKERR(ierr);
 #endif
  
   // 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 )

inlineprotectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
  
   p.first++;
 }

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

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

◆ increment_destructor_count()

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

inlineprotectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
  
   p.second++;
 }

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

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

◆ init() [1/3]

template<typename T >

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

overridevirtual

Initialize this matrix using the sparsity structure computed by dof_map.

Implements libMesh::SparseMatrix< T >.

Definition at line 358 of file petsc_matrix.C.

 {
   libmesh_assert(this->_dof_map);
  
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
  
   this->_is_initialized = true;
  
  
   const numeric_index_type my_m = this->_dof_map->n_dofs();
   const numeric_index_type my_n = my_m;
   const numeric_index_type n_l  = this->_dof_map->n_dofs_on_processor(this->processor_id());
   const numeric_index_type m_l  = n_l;
  
  
   const std::vector<numeric_index_type> & n_nz = this->_dof_map->get_n_nz();
   const std::vector<numeric_index_type> & n_oz = this->_dof_map->get_n_oz();
  
   // 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);
  
   PetscErrorCode ierr = 0;
   PetscInt m_global   = static_cast<PetscInt>(my_m);
   PetscInt n_global   = static_cast<PetscInt>(my_n);
   PetscInt m_local    = static_cast<PetscInt>(m_l);
   PetscInt n_local    = static_cast<PetscInt>(n_l);
  
   ierr = MatCreate(this->comm().get(), &_mat);
   LIBMESH_CHKERR(ierr);
   ierr = MatSetSizes(_mat, m_local, n_local, m_global, n_global);
   LIBMESH_CHKERR(ierr);
   PetscInt blocksize  = static_cast<PetscInt>(this->_dof_map->block_size());
   ierr = MatSetBlockSize(_mat,blocksize);
   LIBMESH_CHKERR(ierr);
  
 #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);
  
       ierr = MatSetType(_mat, MATBAIJ); // Automatically chooses seqbaij or mpibaij
       LIBMESH_CHKERR(ierr);
  
       // 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);
  
       ierr = MatSeqBAIJSetPreallocation (_mat,
                                          blocksize,
                                          0,
                                          numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data()));
       LIBMESH_CHKERR(ierr);
  
       ierr = MatMPIBAIJSetPreallocation (_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()));
       LIBMESH_CHKERR(ierr);
     }
   else
 #endif
     {
       switch (_mat_type) {
         case AIJ:
           ierr = MatSetType(_mat, MATAIJ); // Automatically chooses seqaij or mpiaij
           LIBMESH_CHKERR(ierr);
           ierr = MatSeqAIJSetPreallocation (_mat,
                                             0,
                                             numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()));
           LIBMESH_CHKERR(ierr);
           ierr = MatMPIAIJSetPreallocation (_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
           ierr = MatSetType(_mat, MATHYPRE);
           LIBMESH_CHKERR(ierr);
           ierr = MatHYPRESetPreallocation (_mat,
                                            0,
                                            numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
                                            0,
                                            numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data()));
           LIBMESH_CHKERR(ierr);
 #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");
       }
     }
  
   // Make it an error for PETSc to allocate new nonzero entries during assembly
 #if PETSC_VERSION_LESS_THAN(3,0,0)
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR);
 #else
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
 #endif
   LIBMESH_CHKERR(ierr);
  
   // Is prefix information available somewhere? Perhaps pass in the system name?
   ierr = MatSetOptionsPrefix(_mat, "");
   LIBMESH_CHKERR(ierr);
   ierr = MatSetFromOptions(_mat);
   LIBMESH_CHKERR(ierr);
  
   this->zero();
 }

◆ 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 numeric_index_type	nnz = `30`,
		const numeric_index_type	noz = `10`,
		const numeric_index_type	blocksize = `1`
	)

overridevirtual

Initialize SparseMatrix with the specified sizes.

Parameters

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

Implements libMesh::SparseMatrix< T >.

Definition at line 129 of file petsc_matrix.C.

 {
   // So compilers don't warn when !LIBMESH_ENABLE_BLOCKED_STORAGE
   libmesh_ignore(blocksize_in);
  
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
  
   this->_is_initialized = true;
  
  
   PetscErrorCode ierr = 0;
   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);
   PetscInt n_nz       = static_cast<PetscInt>(nnz);
   PetscInt n_oz       = static_cast<PetscInt>(noz);
  
   ierr = MatCreate(this->comm().get(), &_mat);
   LIBMESH_CHKERR(ierr);
   ierr = MatSetSizes(_mat, m_local, n_local, m_global, n_global);
   LIBMESH_CHKERR(ierr);
   PetscInt blocksize  = static_cast<PetscInt>(blocksize_in);
   ierr = MatSetBlockSize(_mat,blocksize);
   LIBMESH_CHKERR(ierr);
  
 #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);
  
       ierr = MatSetType(_mat, MATBAIJ); // Automatically chooses seqbaij or mpibaij
       LIBMESH_CHKERR(ierr);
       ierr = MatSeqBAIJSetPreallocation(_mat, blocksize, n_nz/blocksize, NULL);
       LIBMESH_CHKERR(ierr);
       ierr = MatMPIBAIJSetPreallocation(_mat, blocksize,
                                         n_nz/blocksize, NULL,
                                         n_oz/blocksize, NULL);
       LIBMESH_CHKERR(ierr);
     }
   else
 #endif
     {
       switch (_mat_type) {
         case AIJ:
           ierr = MatSetType(_mat, MATAIJ); // Automatically chooses seqaij or mpiaij
           LIBMESH_CHKERR(ierr);
           ierr = MatSeqAIJSetPreallocation(_mat, n_nz, NULL);
           LIBMESH_CHKERR(ierr);
           ierr = MatMPIAIJSetPreallocation(_mat, n_nz, NULL, n_oz, NULL);
           LIBMESH_CHKERR(ierr);
           break;
  
         case HYPRE:
 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
           ierr = MatSetType(_mat, MATHYPRE);
           LIBMESH_CHKERR(ierr);
           ierr = MatHYPRESetPreallocation(_mat, n_nz, NULL, n_oz, NULL);
           LIBMESH_CHKERR(ierr);
 #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");
       }
     }
  
   // Make it an error for PETSc to allocate new nonzero entries during assembly
 #if PETSC_VERSION_LESS_THAN(3,0,0)
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR);
 #else
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
 #endif
   LIBMESH_CHKERR(ierr);
  
   // Is prefix information available somewhere? Perhaps pass in the system name?
   ierr = MatSetOptionsPrefix(_mat, "");
   LIBMESH_CHKERR(ierr);
   ierr = MatSetFromOptions(_mat);
   LIBMESH_CHKERR(ierr);
  
   this->zero ();
 }

◆ init() [3/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 231 of file petsc_matrix.C.

 {
   // So compilers don't warn when !LIBMESH_ENABLE_BLOCKED_STORAGE
   libmesh_ignore(blocksize_in);
  
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
  
   this->_is_initialized = true;
  
   // 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);
  
   PetscErrorCode ierr = 0;
   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);
  
   ierr = MatCreate(this->comm().get(), &_mat);
   LIBMESH_CHKERR(ierr);
   ierr = MatSetSizes(_mat, m_local, n_local, m_global, n_global);
   LIBMESH_CHKERR(ierr);
   PetscInt blocksize  = static_cast<PetscInt>(blocksize_in);
   ierr = MatSetBlockSize(_mat,blocksize);
   LIBMESH_CHKERR(ierr);
  
 #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);
  
       ierr = MatSetType(_mat, MATBAIJ); // Automatically chooses seqbaij or mpibaij
       LIBMESH_CHKERR(ierr);
  
       // 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);
  
       ierr = MatSeqBAIJSetPreallocation (_mat,
                                          blocksize,
                                          0,
                                          numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data()));
       LIBMESH_CHKERR(ierr);
  
       ierr = MatMPIBAIJSetPreallocation (_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()));
       LIBMESH_CHKERR(ierr);
     }
   else
 #endif
     {
       switch (_mat_type) {
         case AIJ:
           ierr = MatSetType(_mat, MATAIJ); // Automatically chooses seqaij or mpiaij
           LIBMESH_CHKERR(ierr);
           ierr = MatSeqAIJSetPreallocation (_mat,
                                             0,
                                             numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()));
           LIBMESH_CHKERR(ierr);
           ierr = MatMPIAIJSetPreallocation (_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
           ierr = MatSetType(_mat, MATHYPRE);
           LIBMESH_CHKERR(ierr);
           ierr = MatHYPRESetPreallocation (_mat,
                                            0,
                                            numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
                                            0,
                                            numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data()));
           LIBMESH_CHKERR(ierr);
 #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");
       }
  
     }
  
   // Make it an error for PETSc to allocate new nonzero entries during assembly
 #if PETSC_VERSION_LESS_THAN(3,0,0)
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR);
 #else
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
 #endif
   LIBMESH_CHKERR(ierr);
  
   // Is prefix information available somewhere? Perhaps pass in the system name?
   ierr = MatSetOptionsPrefix(_mat, "");
   LIBMESH_CHKERR(ierr);
   ierr = MatSetFromOptions(_mat);
   LIBMESH_CHKERR(ierr);
  
  
   this->zero();
 }

◆ initialized()

template<typename T>

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

inlinevirtualinherited

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

Definition at line 103 of file sparse_matrix.h.

103 { return _is_initialized; }

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

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

 {
   libmesh_assert (this->initialized());
  
   semiparallel_only();
  
   PetscErrorCode ierr=0;
   PetscReal petsc_value;
   Real value;
  
   libmesh_assert (this->closed());
  
   ierr = MatNorm(_mat, NORM_1, &petsc_value);
   LIBMESH_CHKERR(ierr);
  
   value = static_cast<Real>(petsc_value);
  
   return value;
 }

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

 {
   libmesh_assert (this->initialized());
  
   semiparallel_only();
  
   PetscErrorCode ierr=0;
   PetscReal petsc_value;
   Real value;
  
   libmesh_assert (this->closed());
  
   ierr = MatNorm(_mat, NORM_INFINITY, &petsc_value);
   LIBMESH_CHKERR(ierr);
  
   value = static_cast<Real>(petsc_value);
  
   return value;
 }

◆ local_m()

template<typename T >

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

finalvirtual

Get the number of rows owned by this process.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 1038 of file petsc_matrix.C.

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

◆ local_n()

template<typename T >

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

Get the number of columns owned by this process.

Definition at line 1065 of file petsc_matrix.C.

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

◆ m()

template<typename T >

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

overridevirtual

Returns: The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 1024 of file petsc_matrix.C.

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

◆ mat()

template<typename T>

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

inline

Returns: The raw PETSc matrix pointer.

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

Definition at line 281 of file petsc_matrix.h.

281 { libmesh_assert (_mat); return _mat; }

Referenced by libMesh::PetscLinearSolver< Number >::adjoint_solve(), libMesh::PetscPreconditioner< T >::init(), libMesh::PetscLinearSolver< Number >::init(), libMesh::libmesh_petsc_DMCreateInterpolation(), libMesh::libmesh_petsc_DMCreateRestriction(), libMesh::PetscDiffSolver::solve(), libMesh::TaoOptimizationSolver< T >::solve(), libMesh::PetscNonlinearSolver< Number >::solve(), libMesh::PetscLinearSolver< Number >::solve(), libMesh::SlepcEigenSolver< libMesh::Number >::solve_generalized(), and libMesh::SlepcEigenSolver< libMesh::Number >::solve_standard().

◆ n()

template<typename T >

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

overridevirtual

Returns: The column-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 1051 of file petsc_matrix.C.

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

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

84 { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

◆ need_full_sparsity_pattern()

template<typename T>

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

inlinevirtualinherited

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

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

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

Definition at line 120 of file sparse_matrix.h.

121 { return false; }

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

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

 {
   libmesh_assert (this->initialized());
  
   // PETSc 2.2.1 & newer
   const PetscScalar * petsc_row;
   const PetscInt    * petsc_cols;
  
   // If the entry is not in the sparse matrix, it is 0.
   T value=0.;
  
   PetscErrorCode
     ierr=0;
   PetscInt
     ncols=0,
     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());
  
   ierr = MatGetRow(_mat, i_val, &ncols, &petsc_cols, &petsc_row);
   LIBMESH_CHKERR(ierr);
  
   // Perform a binary search to find the contiguous index in
   // petsc_cols (resp. petsc_row) corresponding to global index j_val
   std::pair<const PetscInt *, const PetscInt *> p =
     std::equal_range (petsc_cols, petsc_cols + ncols, j_val);
  
   // Found an entry for j_val
   if (p.first != p.second)
     {
       // The entry in the contiguous row corresponding
       // to the j_val column of interest
       const std::size_t j =
         std::distance (const_cast<PetscInt *>(petsc_cols),
                        const_cast<PetscInt *>(p.first));
  
       libmesh_assert_less (j, ncols);
       libmesh_assert_equal_to (petsc_cols[j], j_val);
  
       value = static_cast<T> (petsc_row[j]);
     }
  
   ierr  = MatRestoreRow(_mat, i_val,
                         &ncols, &petsc_cols, &petsc_row);
   LIBMESH_CHKERR(ierr);
  
   return value;
 }

◆ operator=() [1/2]

template<typename T>

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

delete

◆ operator=() [2/2]

template<typename T>

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

delete

◆ print() [1/2]

template<>

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

inherited

Definition at line 96 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 : IntRange<numeric_index_type>(0, this->m()))
     {
       for (auto j : IntRange<numeric_index_type>(0, this->n()))
         os << std::setw(8) << (*this)(i,j).real() << " ";
       os << std::endl;
     }
  
   os << std::endl << "Imaginary part:" << std::endl;
   for (auto i : IntRange<numeric_index_type>(0, this->m()))
     {
       for (auto j : IntRange<numeric_index_type>(0, this->n()))
         os << std::setw(8) << (*this)(i,j).imag() << " ";
       os << std::endl;
     }
 }

◆ print() [2/2]

template<typename T >

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

inherited

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

Definition at line 200 of file sparse_matrix.C.

 {
   parallel_object_only();
  
   libmesh_assert (this->initialized());
  
   if (!this->_dof_map)
     libmesh_error_msg("Error!  Trying to print a matrix with no dof_map set!");
  
   // We'll print the matrix from processor 0 to make sure
   // it's serialized properly
   if (this->processor_id() == 0)
     {
       libmesh_assert_equal_to (this->_dof_map->first_dof(), 0);
       for (numeric_index_type i=this->_dof_map->first_dof();
            i!=this->_dof_map->end_dof(); ++i)
         {
           if (sparse)
             {
               for (auto j : IntRange<numeric_index_type>(0, this->n()))
                 {
                   T c = (*this)(i,j);
                   if (c != static_cast<T>(0.0))
                     {
                       os << i << " " << j << " " << c << std::endl;
                     }
                 }
             }
           else
             {
               for (auto j : IntRange<numeric_index_type>(0, this->n()))
                 os << (*this)(i,j) << " ";
               os << std::endl;
             }
         }
  
       std::vector<numeric_index_type> ibuf, jbuf;
       std::vector<T> cbuf;
       numeric_index_type currenti = this->_dof_map->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 : IntRange<numeric_index_type>(0, 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=this->_dof_map->first_dof();
            i!=this->_dof_map->end_dof(); ++i)
         {
           for (auto j : IntRange<numeric_index_type>(0, 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);
     }
 }

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

◆ print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

◆ print_matlab()

template<typename T >

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

Create an ASCII file containing the matrix if a filename was provided.

Otherwise the matrix will be dumped to the screen.

Destroy the viewer.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 624 of file petsc_matrix.C.

 {
   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();
     }
  
   PetscErrorCode ierr=0;
   PetscViewer petsc_viewer;
  
  
   ierr = PetscViewerCreate (this->comm().get(),
                             &petsc_viewer);
   LIBMESH_CHKERR(ierr);
  
   if (name != "")
     {
       ierr = PetscViewerASCIIOpen( this->comm().get(),
                                    name.c_str(),
                                    &petsc_viewer);
       LIBMESH_CHKERR(ierr);
  
 #if PETSC_VERSION_LESS_THAN(3,7,0)
       ierr = PetscViewerSetFormat (petsc_viewer,
                                    PETSC_VIEWER_ASCII_MATLAB);
 #else
       ierr = PetscViewerPushFormat (petsc_viewer,
                                     PETSC_VIEWER_ASCII_MATLAB);
 #endif
  
       LIBMESH_CHKERR(ierr);
  
       ierr = MatView (_mat, petsc_viewer);
       LIBMESH_CHKERR(ierr);
     }
  
   else
     {
 #if PETSC_VERSION_LESS_THAN(3,7,0)
       ierr = PetscViewerSetFormat (PETSC_VIEWER_STDOUT_WORLD,
                                    PETSC_VIEWER_ASCII_MATLAB);
 #else
       ierr = PetscViewerPushFormat (PETSC_VIEWER_STDOUT_WORLD,
                                     PETSC_VIEWER_ASCII_MATLAB);
 #endif
  
       LIBMESH_CHKERR(ierr);
  
       ierr = MatView (_mat, PETSC_VIEWER_STDOUT_WORLD);
       LIBMESH_CHKERR(ierr);
     }
  
  
   ierr = LibMeshPetscViewerDestroy (&petsc_viewer);
   LIBMESH_CHKERR(ierr);
 }

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

 {
   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();
     }
  
   PetscErrorCode ierr=0;
  
   // Print to screen if ostream is stdout
   if (os.rdbuf() == std::cout.rdbuf())
     {
       ierr = MatView(_mat, PETSC_VIEWER_STDOUT_SELF);
       LIBMESH_CHKERR(ierr);
     }
  
   // 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.
             if (fd == -1)
               libmesh_error_msg("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.
       ierr = PetscViewerASCIIOpen( this->comm().get(),
                                    temp_filename.c_str(),
                                    &petsc_viewer);
       LIBMESH_CHKERR(ierr);
  
       // 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
       ierr = MatView (_mat, petsc_viewer);
       LIBMESH_CHKERR(ierr);
  
       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());
         }
     }
 }

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

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

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

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

 {
 #if !PETSC_VERSION_LESS_THAN(3,9,0)
   libmesh_assert (this->initialized());
  
   auto ierr = MatResetPreallocation(_mat);
   LIBMESH_CHKERR(ierr);
 #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
 }

◆ row_start()

template<typename T >

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

overridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 1093 of file petsc_matrix.C.

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

◆ row_stop()

template<typename T >

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

overridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 1109 of file petsc_matrix.C.

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

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

 {
   libmesh_assert (this->initialized());
  
   PetscErrorCode ierr=0;
   PetscInt i_val=i, j_val=j;
  
   PetscScalar petsc_value = static_cast<PetscScalar>(value);
   ierr = MatSetValues(_mat, 1, &i_val, 1, &j_val,
                       &petsc_value, INSERT_VALUES);
   LIBMESH_CHKERR(ierr);
 }

◆ set_destroy_mat_on_exit()

template<typename T >

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

virtual

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

Definition at line 1331 of file petsc_matrix.C.

 {
   this->_destroy_mat_on_exit = destroy;
 }

◆ set_matrix_type()

template<typename T >

void libMesh::PetscMatrix< T >::set_matrix_type ( PetscMatrixType mat_type )

Definition at line 123 of file petsc_matrix.C.

 {
   _mat_type = mat_type;
 }

◆ swap()

template<typename T>

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

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

Definition at line 1338 of file petsc_matrix.C.

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

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian().

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

128 {}

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

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

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

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

◆ zero()

template<typename T >

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

overridevirtual

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 507 of file petsc_matrix.C.

 {
   libmesh_assert (this->initialized());
  
   semiparallel_only();
  
   PetscErrorCode ierr=0;
  
   PetscInt m_l, n_l;
  
   ierr = MatGetLocalSize(_mat,&m_l,&n_l);
   LIBMESH_CHKERR(ierr);
  
   if (n_l)
     {
       ierr = MatZeroEntries(_mat);
       LIBMESH_CHKERR(ierr);
     }
 }

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

 {
   libmesh_assert (this->initialized());
  
   semiparallel_only();
  
   PetscErrorCode ierr=0;
  
 #if PETSC_RELEASE_LESS_THAN(3,1,1)
   if (!rows.empty())
     ierr = MatZeroRows(_mat, rows.size(),
                        numeric_petsc_cast(rows.data()), diag_value);
   else
     ierr = MatZeroRows(_mat, 0, NULL, diag_value);
 #else
   // 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())
     ierr = MatZeroRows(_mat, cast_int<PetscInt>(rows.size()),
                        numeric_petsc_cast(rows.data()), PS(diag_value),
                        NULL, NULL);
   else
     ierr = MatZeroRows(_mat, 0, NULL, PS(diag_value), NULL,
                        NULL);
 #endif
  
   LIBMESH_CHKERR(ierr);
 }

Member Data Documentation

◆ _communicator

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

protectedinherited

Definition at line 112 of file parallel_object.h.

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

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _destroy_mat_on_exit

template<typename T>

bool libMesh::PetscMatrix< T >::_destroy_mat_on_exit

private

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

Definition at line 314 of file petsc_matrix.h.

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

◆ _dof_map

template<typename T>

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

protectedinherited

The DofMap object associated with this object.

Definition at line 443 of file sparse_matrix.h.

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

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

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

◆ _mat

template<typename T>

Mat libMesh::PetscMatrix< T >::_mat

private

PETSc matrix datatype to store values.

Definition at line 308 of file petsc_matrix.h.

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), libMesh::PetscMatrix< libMesh::Number >::add(), libMesh::PetscMatrix< libMesh::Number >::get_transpose(), libMesh::PetscMatrix< libMesh::Number >::mat(), and libMesh::PetscMatrix< libMesh::Number >::swap().

◆ _mat_type

template<typename T>

PetscMatrixType libMesh::PetscMatrix< T >::_mat_type

private

Definition at line 316 of file petsc_matrix.h.

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 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 130 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 319 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 321 of file petsc_matrix.h.

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 Attributes

Detailed Description

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

Member Typedef Documentation

◆ Counts

Constructor & Destructor Documentation

◆ PetscMatrix() [1/4]

◆ PetscMatrix() [2/4]

◆ PetscMatrix() [3/4]

◆ PetscMatrix() [4/4]

◆ ~PetscMatrix()

Member Function Documentation

◆ _get_submatrix()

◆ add() [1/2]

◆ add() [2/2]

◆ add_block_matrix() [1/2]

◆ add_block_matrix() [2/2]

◆ add_matrix() [1/2]

◆ add_matrix() [2/2]

◆ attach_dof_map()

◆ build()

◆ clear()

◆ close()

◆ closed()

◆ comm()

◆ create_submatrix()

◆ disable_print_counter_info()

◆ enable_print_counter_info()

◆ flush()

◆ get_diagonal()

◆ get_info()

◆ get_local_size()

◆ get_row()

◆ get_transpose()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ init() [1/3]

◆ init() [2/3]

◆ init() [3/3]

◆ initialized()

◆ l1_norm()

◆ linfty_norm()

◆ local_m()

◆ local_n()

◆ m()

◆ mat()

◆ n()

◆ n_objects()

◆ n_processors()

◆ need_full_sparsity_pattern()

◆ operator()()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ print() [1/2]

◆ print() [2/2]

◆ print_info()

◆ print_matlab()

◆ print_personal()

◆ processor_id()

◆ reinit_submatrix()

◆ reset_preallocation()

◆ row_start()

◆ row_stop()

◆ set()

◆ set_destroy_mat_on_exit()

◆ set_matrix_type()

◆ swap()

◆ update_preallocation_and_zero()

◆ update_sparsity_pattern()

◆ vector_mult()

◆ vector_mult_add()

◆ zero()

◆ zero_rows()

Member Data Documentation

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