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

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 >:
[legend]

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
 
PetscMatrixoperator= (PetscMatrix &&)=delete
 
virtual ~PetscMatrix ()
 
PetscMatrixoperator= (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
 
virtual 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) 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) 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...
 
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...
 
template<>
void print (std::ostream &os, const bool sparse) const
 
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_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::Communicatorcomm () 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 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 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)
 
void finish_initialization ()
 Finish up the initialization process. More...
 
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.

86  :
88 {
89 }
This class provides a nice interface to the PETSc C-based data structures for parallel, sparse matrices.
PetscMatrixType _mat_type
Definition: petsc_matrix.h:349

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

98  :
99  PetscMatrixBase<T>(mat_in, comm_in, destroy_on_exit)
100 {
101  MatType mat_type;
102  LibmeshPetscCall(MatGetType(mat_in, &mat_type));
103  PetscBool is_hypre;
104  LibmeshPetscCall(PetscStrcmp(mat_type, MATHYPRE, &is_hypre));
105  if (is_hypre == PETSC_TRUE)
106  _mat_type = HYPRE;
107  else
108  _mat_type = AIJ;
109 }
This class provides a nice interface to the PETSc C-based data structures for parallel, sparse matrices.
PetscMatrixType _mat_type
Definition: petsc_matrix.h:349

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

122  :
123  PetscMatrixBase<T>(comm_in), _mat_type(AIJ)
124 {
125  this->init(m_in, n_in, m_l, n_l, n_nz, n_oz, blocksize_in);
126 }
This class provides a nice interface to the PETSc C-based data structures for parallel, sparse matrices.
PetscMatrixType _mat_type
Definition: petsc_matrix.h:349
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.
Definition: petsc_matrix.C:214

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

804 {
805  if (!this->closed())
806  {
807  libmesh_deprecated();
808  libmesh_warning("The matrix must be assembled before calling PetscMatrix::create_submatrix().\n"
809  "Please update your code, as this warning will become an error in a future release.");
810  const_cast<PetscMatrix<T> *>(this)->close();
811  }
812 
813  semiparallel_only();
814 
815  // Make sure the SparseMatrix passed in is really a PetscMatrix
816  PetscMatrix<T> * petsc_submatrix = cast_ptr<PetscMatrix<T> *>(&submatrix);
817 
818  // If we're not reusing submatrix and submatrix is already initialized
819  // then we need to clear it, otherwise we get a memory leak.
820  if (!reuse_submatrix && submatrix.initialized())
821  submatrix.clear();
822 
823  // Construct row and column index sets.
824  WrappedPetsc<IS> isrow;
825  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
826  cast_int<PetscInt>(rows.size()),
827  numeric_petsc_cast(rows.data()),
828  PETSC_USE_POINTER,
829  isrow.get()));
830 
831  WrappedPetsc<IS> iscol;
832  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
833  cast_int<PetscInt>(cols.size()),
834  numeric_petsc_cast(cols.data()),
835  PETSC_USE_POINTER,
836  iscol.get()));
837 
838  // Extract submatrix
839  LibmeshPetscCall(LibMeshCreateSubMatrix(this->_mat,
840  isrow,
841  iscol,
842  (reuse_submatrix ? MAT_REUSE_MATRIX : MAT_INITIAL_MATRIX),
843  (&petsc_submatrix->_mat)));
844 
845  // Specify that the new submatrix is initialized and close it.
846  petsc_submatrix->_is_initialized = true;
847  petsc_submatrix->close();
848 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
virtual void clear()=0
Restores the SparseMatrix<T> to a pristine state.
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

◆ _petsc_viewer()

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

Definition at line 663 of file petsc_matrix.C.

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

666 {
667  parallel_object_only();
668 
669  // We'll get matrix sizes from the file, but we need to at least
670  // have a Mat object
671  if (!this->initialized())
672  {
673  LibmeshPetscCall(MatCreate(this->comm().get(), &this->_mat));
674  this->_is_initialized = true;
675  }
676 
677  PetscViewer viewer;
678  LibmeshPetscCall(PetscViewerCreate(this->comm().get(), &viewer));
679  LibmeshPetscCall(PetscViewerSetType(viewer, viewertype));
680  LibmeshPetscCall(PetscViewerSetFromOptions(viewer));
681  LibmeshPetscCall(PetscViewerFileSetMode(viewer, filemode));
682  LibmeshPetscCall(PetscViewerFileSetName(viewer, filename.c_str()));
683  if (filemode == FILE_MODE_READ)
684  LibmeshPetscCall(MatLoad(this->_mat, viewer));
685  else
686  LibmeshPetscCall(MatView(this->_mat, viewer));
687  LibmeshPetscCall(PetscViewerDestroy(&viewer));
688 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
Mat _mat
PETSc matrix datatype to store values.

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

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

Referenced by PetscMatrixTest::testPetscCopyFromHash().

990 {
991  libmesh_assert (this->initialized());
992 
993  PetscInt i_val=i, j_val=j;
994 
995  PetscScalar petsc_value = static_cast<PetscScalar>(value);
996  std::scoped_lock lock(this->_petsc_matrix_mutex);
997  LibmeshPetscCall(MatSetValues(this->_mat, 1, &i_val, 1, &j_val,
998  &petsc_value, ADD_VALUES));
999 }
virtual bool initialized() const
std::mutex _petsc_matrix_mutex
Definition: petsc_matrix.h:353
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
static const bool value
Definition: xdr_io.C:54

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

1018 {
1019  libmesh_assert (this->initialized());
1020 
1021  // sanity check. but this cannot avoid
1022  // crash due to incompatible sparsity structure...
1023  libmesh_assert_equal_to (this->m(), X_in.m());
1024  libmesh_assert_equal_to (this->n(), X_in.n());
1025 
1026  PetscScalar a = static_cast<PetscScalar> (a_in);
1027  const PetscMatrix<T> * X = cast_ptr<const PetscMatrix<T> *> (&X_in);
1028 
1029  libmesh_assert (X);
1030 
1031  // the matrix from which we copy the values has to be assembled/closed
1032  libmesh_assert(X->closed());
1033 
1034  semiparallel_only();
1035 
1036  LibmeshPetscCall(MatAXPY(this->_mat, a, X->_mat, DIFFERENT_NONZERO_PATTERN));
1037 }
virtual numeric_index_type n() const override
virtual bool initialized() const
virtual numeric_index_type m() const override
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

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

762 {
763  libmesh_assert (this->initialized());
764 
765  const numeric_index_type n_brows =
766  cast_int<numeric_index_type>(brows.size());
767  const numeric_index_type n_bcols =
768  cast_int<numeric_index_type>(bcols.size());
769 
770 #ifndef NDEBUG
771  const numeric_index_type n_rows =
772  cast_int<numeric_index_type>(dm.m());
773  const numeric_index_type n_cols =
774  cast_int<numeric_index_type>(dm.n());
775  const numeric_index_type blocksize = n_rows / n_brows;
776 
777  libmesh_assert_equal_to (n_cols / n_bcols, blocksize);
778  libmesh_assert_equal_to (blocksize*n_brows, n_rows);
779  libmesh_assert_equal_to (blocksize*n_bcols, n_cols);
780 
781  PetscInt petsc_blocksize;
782  LibmeshPetscCall(MatGetBlockSize(this->_mat, &petsc_blocksize));
783  libmesh_assert_equal_to (blocksize, static_cast<numeric_index_type>(petsc_blocksize));
784 #endif
785 
786  std::scoped_lock lock(this->_petsc_matrix_mutex);
787  // These casts are required for PETSc <= 2.1.5
788  LibmeshPetscCall(MatSetValuesBlocked(this->_mat,
789  n_brows, numeric_petsc_cast(brows.data()),
790  n_bcols, numeric_petsc_cast(bcols.data()),
791  pPS(const_cast<T*>(dm.get_values().data())),
792  ADD_VALUES));
793 }
virtual bool initialized() const
unsigned int m() const
PetscScalar * pPS(T *ptr)
Definition: petsc_macro.h:174
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
std::mutex _petsc_matrix_mutex
Definition: petsc_matrix.h:353
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
std::vector< T > & get_values()
Definition: dense_matrix.h:382
Mat _mat
PETSc matrix datatype to store values.
unsigned int n() const

◆ 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); }
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:759

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

736 {
737  libmesh_assert (this->initialized());
738 
739  const numeric_index_type n_rows = dm.m();
740  const numeric_index_type n_cols = dm.n();
741 
742  libmesh_assert_equal_to (rows.size(), n_rows);
743  libmesh_assert_equal_to (cols.size(), n_cols);
744 
745  std::scoped_lock lock(this->_petsc_matrix_mutex);
746  LibmeshPetscCall(MatSetValues(this->_mat,
747  n_rows, numeric_petsc_cast(rows.data()),
748  n_cols, numeric_petsc_cast(cols.data()),
749  pPS(const_cast<T*>(dm.get_values().data())),
750  ADD_VALUES));
751 }
virtual bool initialized() const
unsigned int m() const
PetscScalar * pPS(T *ptr)
Definition: petsc_macro.h:174
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
std::mutex _petsc_matrix_mutex
Definition: petsc_matrix.h:353
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
std::vector< T > & get_values()
Definition: dense_matrix.h:382
Mat _mat
PETSc matrix datatype to store values.
unsigned int n() const

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

1006 {
1007  this->add_matrix (dm, dof_indices, dof_indices);
1008 }
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.
Definition: petsc_matrix.C:733

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

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

1075 {
1076  // size of spm is usually greater than row_ltog and col_ltog in parallel as the indices are owned by the processor
1077  // also, we should allow adding certain parts of spm to _mat
1078  libmesh_assert_greater_equal(spm.m(), row_ltog.size());
1079  libmesh_assert_greater_equal(spm.n(), col_ltog.size());
1080 
1081  // make sure matrix has larger size than spm
1082  libmesh_assert_greater_equal(this->m(), spm.m());
1083  libmesh_assert_greater_equal(this->n(), spm.n());
1084 
1085  if (!this->closed())
1086  this->close();
1087 
1088  auto pscm = cast_ptr<const PetscMatrix<T> *>(&spm);
1089 
1090  PetscInt ncols = 0;
1091 
1092  const PetscInt * lcols;
1093  const PetscScalar * vals;
1094 
1095  std::vector<PetscInt> gcols;
1096  std::vector<PetscScalar> values;
1097 
1098  for (auto ltog : row_ltog)
1099  {
1100  PetscInt grow[] = {static_cast<PetscInt>(ltog.second)}; // global row index
1101 
1102  LibmeshPetscCall(MatGetRow(pscm->_mat, static_cast<PetscInt>(ltog.first), &ncols, &lcols, &vals));
1103 
1104  // get global indices (gcols) from lcols, increment values = vals*scalar
1105  gcols.resize(ncols);
1106  values.resize(ncols);
1107  for (auto i : index_range(gcols))
1108  {
1109  gcols[i] = libmesh_map_find(col_ltog, lcols[i]);
1110  values[i] = PS(scalar) * vals[i];
1111  }
1112 
1113  LibmeshPetscCall(MatSetValues(this->_mat, 1, grow, ncols, gcols.data(), values.data(), ADD_VALUES));
1114  LibmeshPetscCall(MatRestoreRow(pscm->_mat, static_cast<PetscInt>(ltog.first), &ncols, &lcols, &vals));
1115  }
1116  // Note: We are not closing the matrix because it is expensive to do so when adding multiple sparse matrices.
1117  // Remember to manually close the matrix once all changes to the matrix have been made.
1118 }
virtual numeric_index_type n() const override
virtual numeric_index_type m() const override
PetscScalar PS(T val)
Definition: petsc_macro.h:168
virtual numeric_index_type m() const =0
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
virtual numeric_index_type n() const =0

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

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

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

◆ attach_sparsity_pattern()

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

Set a pointer to a sparsity pattern to use.

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

The lifetime of sp must exceed the lifetime of this.

Definition at line 82 of file sparse_matrix.C.

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

83 {
84  _sp = &sp;
85 }
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.

◆ build()

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

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

Definition at line 165 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().

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

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

75 {
76  if ((this->initialized()) && (this->_destroy_mat_on_exit))
77  {
78  exceptionless_semiparallel_only();
79 
80  // If we encounter an error here, print a warning but otherwise
81  // keep going since we may be recovering from an exception.
82  PetscErrorCode ierr = MatDestroy (&_mat);
83  if (ierr)
84  libmesh_warning("Warning: MatDestroy returned a non-zero error code which we ignored.");
85 
86  this->_is_initialized = false;
87  }
88 }
virtual bool initialized() const
bool _destroy_mat_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Mat object...
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
Mat _mat
PETSc matrix datatype to store values.

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

455 {
456  libmesh_error_msg_if(!this->closed(), "Matrix must be closed before it can be cloned!");
457 
458  // Copy the nonzero pattern and numerical values
459  Mat copy;
460  LibmeshPetscCall(MatDuplicate(this->_mat, MAT_COPY_VALUES, &copy));
461 
462  // Call wrapping PetscMatrix constructor, have it take over
463  // ownership.
464  auto ret = std::make_unique<PetscMatrix<T>>(copy, this->comm());
465  ret->set_destroy_mat_on_exit(true);
466 
467  return ret;
468 }
const Parallel::Communicator & comm() const
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override

◆ 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(), and libMesh::PetscLinearSolver< Number >::solve_common().

227 {
228  semiparallel_only();
229 
230  // BSK - 1/19/2004
231  // strictly this check should be OK, but it seems to
232  // fail on matrix-free matrices. Do they falsely
233  // state they are assembled? Check with the developers...
234  // if (this->closed())
235  // return;
236 
237  MatAssemblyBeginEnd(this->comm(), this->_mat, MAT_FINAL_ASSEMBLY);
238 }
const Parallel::Communicator & comm() const
Mat _mat
PETSc matrix datatype to store values.

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

242 {
243  libmesh_assert (this->initialized());
244 
245  PetscBool assembled;
246 
247  LibmeshPetscCall(MatAssembled(this->_mat, &assembled));
248 
249  return (assembled == PETSC_TRUE);
250 }
virtual bool initialized() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

203 {
204  libmesh_assert (this->initialized());
205 
206  PetscInt start=0, stop=0;
207 
208  LibmeshPetscCall(MatGetOwnershipRangeColumn(this->_mat, &start, &stop));
209 
210  return static_cast<numeric_index_type>(start);
211 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
void stop(const char *file, int line, const char *date, const char *time)
Mat _mat
PETSc matrix datatype to store values.

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

215 {
216  libmesh_assert (this->initialized());
217 
218  PetscInt start=0, stop=0;
219 
220  LibmeshPetscCall(MatGetOwnershipRangeColumn(this->_mat, &start, &stop));
221 
222  return static_cast<numeric_index_type>(stop);
223 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
void stop(const char *file, int line, const char *date, const char *time)
Mat _mat
PETSc matrix datatype to store values.

◆ comm()

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

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

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

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

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

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

Referenced by PetscMatrixTest::testPetscCopyFromHash().

1281 {
1282  Mat xaij;
1283  libmesh_assert(this->initialized());
1284  libmesh_assert(!this->closed());
1285  LibmeshPetscCall(MatDuplicate(this->_mat, MAT_DO_NOT_COPY_VALUES, &xaij));
1286  LibmeshPetscCall(MatCopyHashToXAIJ(this->_mat, xaij));
1287  return std::make_unique<PetscMatrix<T>>(xaij, this->comm(), /*destroy_on_exit=*/true);
1288 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override

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

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

512  {
513  this->_get_submatrix(submatrix,
514  rows,
515  cols,
516  false); // false means DO NOT REUSE submatrix
517  }
virtual void _get_submatrix(SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
Protected implementation of the create_submatrix and reinit_submatrix routines.

◆ create_submatrix_nosort()

template<typename T >
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 851 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().

854 {
855  if (!this->closed())
856  {
857  libmesh_deprecated();
858  libmesh_warning("The matrix must be assembled before calling PetscMatrix::create_submatrix_nosort().\n"
859  "Please update your code, as this warning will become an error in a future release.");
860  const_cast<PetscMatrix<T> *>(this)->close();
861  }
862 
863  // Make sure the SparseMatrix passed in is really a PetscMatrix
864  PetscMatrix<T> * petsc_submatrix = cast_ptr<PetscMatrix<T> *>(&submatrix);
865 
866  LibmeshPetscCall(MatZeroEntries(petsc_submatrix->_mat));
867 
868  PetscInt pc_ncols = 0;
869  const PetscInt * pc_cols;
870  const PetscScalar * pc_vals;
871 
872  // // data for creating the submatrix
873  std::vector<PetscInt> sub_cols;
874  std::vector<PetscScalar> sub_vals;
875 
876  for (auto i : index_range(rows))
877  {
878  PetscInt sub_rid[] = {static_cast<PetscInt>(i)};
879  PetscInt rid = static_cast<PetscInt>(rows[i]);
880  // only get value from local rows, and set values to the corresponding columns in the submatrix
881  if (rows[i]>= this->row_start() && rows[i]< this->row_stop())
882  {
883  // get one row of data from the original matrix
884  LibmeshPetscCall(MatGetRow(this->_mat, rid, &pc_ncols, &pc_cols, &pc_vals));
885  // extract data from certain cols, save the indices and entries sub_cols and sub_vals
886  for (auto j : index_range(cols))
887  {
888  for (unsigned int idx = 0; idx< static_cast<unsigned int>(pc_ncols); idx++)
889  {
890  if (pc_cols[idx] == static_cast<PetscInt>(cols[j]))
891  {
892  sub_cols.push_back(static_cast<PetscInt>(j));
893  sub_vals.push_back(pc_vals[idx]);
894  }
895  }
896  }
897  // set values
898  LibmeshPetscCall(MatSetValues(petsc_submatrix->_mat,
899  1,
900  sub_rid,
901  static_cast<PetscInt>(sub_vals.size()),
902  sub_cols.data(),
903  sub_vals.data(),
904  INSERT_VALUES));
905  LibmeshPetscCall(MatRestoreRow(this->_mat, rid, &pc_ncols, &pc_cols, &pc_vals));
906  // clear data for this row
907  sub_cols.clear();
908  sub_vals.clear();
909  }
910  }
911  MatAssemblyBeginEnd(petsc_submatrix->comm(), petsc_submatrix->_mat, MAT_FINAL_ASSEMBLY);
912  // Specify that the new submatrix is initialized and close it.
913  petsc_submatrix->_is_initialized = true;
914  petsc_submatrix->close();
915 }
virtual numeric_index_type row_stop() const override
const Parallel::Communicator & comm() const
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
virtual numeric_index_type row_start() const override
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)
A useful inline function which replaces the macros used previously.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ finish_initialization()

template<typename T >
void libMesh::PetscMatrix< T >::finish_initialization ( )
protected

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

330 {
331  // Make it an error for PETSc to allocate new nonzero entries during assembly. For old PETSc
332  // versions this option must be set after preallocation for MPIAIJ matrices
333  LibmeshPetscCall(MatSetOption(this->_mat, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
334  this->_is_initialized = true;
335 }
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
Mat _mat
PETSc matrix datatype to store values.

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

961 {
962  semiparallel_only();
963 
964  MatAssemblyBeginEnd(this->comm(), this->_mat, MAT_FLUSH_ASSEMBLY);
965 }
const Parallel::Communicator & comm() const
Mat _mat
PETSc matrix datatype to store values.

◆ frobenius_norm()

template<typename T >
Real libMesh::PetscMatrix< T >::frobenius_norm ( ) const
virtual

Definition at line 497 of file petsc_matrix.C.

498 {
499  return PetscMatrix<T>::norm<NORM_FROBENIUS>();
500 }
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

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

117 {
118  void * ctx;
119  PetscContainer container;
120  LibmeshPetscCall2(comm, PetscObjectQuery((PetscObject)mat, "PetscMatrixCtx", (PetscObject *)&container));
121  if (!container)
122  return nullptr;
123 
124  LibmeshPetscCall2(comm, PetscContainerGetPointer(container, &ctx));
126  return static_cast<PetscMatrixBase<T> *>(ctx);
127 }
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
void * 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 919 of file petsc_matrix.C.

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

920 {
921  // Make sure the NumericVector passed in is really a PetscVector
922  PetscVector<T> & petsc_dest = cast_ref<PetscVector<T> &>(dest);
923 
924  // Needs a const_cast since PETSc does not work with const.
925  LibmeshPetscCall(MatGetDiagonal(const_cast<PetscMatrix<T> *>(this)->mat(),petsc_dest.vec()));
926 }
This class provides a nice interface to PETSc&#39;s Vec object.
Definition: petsc_vector.h:73
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

◆ get_info()

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

◆ get_row()

template<typename T >
void libMesh::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
iThe matrix row to get
indicesA container that will be filled with the column indices corresponding to (possibly) non-zero values
valuesA container holding the column values

Implements libMesh::SparseMatrix< T >.

Definition at line 1174 of file petsc_matrix.C.

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

1177 {
1178  libmesh_assert (this->initialized());
1179 
1180  const PetscScalar * petsc_row;
1181  const PetscInt * petsc_cols;
1182 
1183  PetscInt
1184  ncols=0,
1185  i_val = static_cast<PetscInt>(i_in);
1186 
1187  // the matrix needs to be closed for this to work
1188  // this->close();
1189  // but closing it is a semiparallel operation; we want operator()
1190  // to run on one processor.
1191  libmesh_assert(this->closed());
1192 
1193  // PETSc makes no effort at being thread safe. Helgrind complains about
1194  // possible data races even just in PetscFunctionBegin (due to things
1195  // like stack counter incrementing). Perhaps we could ignore
1196  // this, but there are legitimate data races for Mat data members like
1197  // mat->getrowactive between MatGetRow and MatRestoreRow. Moreover,
1198  // there could be a write into mat->rowvalues during MatGetRow from
1199  // one thread while we are attempting to read from mat->rowvalues
1200  // (through petsc_cols) during data copy in another thread. So
1201  // the safe thing to do is to lock the whole method
1202 
1203  std::lock_guard<std::mutex> lock(_petsc_matrix_mutex);
1204 
1205  LibmeshPetscCall(MatGetRow(this->_mat, i_val, &ncols, &petsc_cols, &petsc_row));
1206 
1207  // Copy the data
1208  indices.resize(static_cast<std::size_t>(ncols));
1209  values.resize(static_cast<std::size_t>(ncols));
1210 
1211  for (auto i : index_range(indices))
1212  {
1213  indices[i] = static_cast<numeric_index_type>(petsc_cols[i]);
1214  values[i] = static_cast<T>(petsc_row[i]);
1215  }
1216 
1217  LibmeshPetscCall(MatRestoreRow(this->_mat, i_val,
1218  &ncols, &petsc_cols, &petsc_row));
1219 }
virtual bool initialized() const
std::mutex _petsc_matrix_mutex
Definition: petsc_matrix.h:353
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117

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

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

932 {
933  // Make sure the SparseMatrix passed in is really a PetscMatrix
934  PetscMatrix<T> & petsc_dest = cast_ref<PetscMatrix<T> &>(dest);
935 
936  // If we aren't reusing the matrix then need to clear dest,
937  // otherwise we get a memory leak
938  if (&petsc_dest != this)
939  dest.clear();
940 
941  if (&petsc_dest == this)
942  // The MAT_REUSE_MATRIX flag was replaced by MAT_INPLACE_MATRIX
943  // in PETSc 3.7.0
944 #if PETSC_VERSION_LESS_THAN(3,7,0)
945  LibmeshPetscCall(MatTranspose(this->_mat,MAT_REUSE_MATRIX, &petsc_dest._mat));
946 #else
947  LibmeshPetscCall(MatTranspose(this->_mat, MAT_INPLACE_MATRIX, &petsc_dest._mat));
948 #endif
949  else
950  LibmeshPetscCall(MatTranspose(this->_mat,MAT_INITIAL_MATRIX, &petsc_dest._mat));
951 
952  // Specify that the transposed matrix is initialized and close it.
953  petsc_dest._is_initialized = true;
954  petsc_dest.close();
955 }
virtual void clear()=0
Restores the SparseMatrix<T> to a pristine state.
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
Mat _mat
PETSc matrix datatype to store values.
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

◆ increment_constructor_count()

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ init() [1/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
mThe global number of rows.
nThe global number of columns.
m_lThe local number of rows.
n_lThe local number of columns.
n_nzThe number of nonzeros in each row of the DIAGONAL portion of the local submatrix.
n_ozThe number of nonzeros in each row of the OFF-DIAGONAL portion of the local submatrix.
blocksizeOptional 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().

221 {
222  this->init_without_preallocation(m_in, n_in, m_l, n_l, blocksize_in);
223 
224  PetscInt n_nz = static_cast<PetscInt>(nnz);
225  PetscInt n_oz = static_cast<PetscInt>(noz);
226 
227 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
228  if (blocksize > 1)
229  {
230  LibmeshPetscCall(MatSeqBAIJSetPreallocation(this->_mat, blocksize, n_nz/blocksize, NULL));
231  LibmeshPetscCall(MatMPIBAIJSetPreallocation(this->_mat, blocksize,
232  n_nz/blocksize, NULL,
233  n_oz/blocksize, NULL));
234  }
235  else
236 #endif
237  {
238  switch (this->_mat_type) {
239  case AIJ:
240  LibmeshPetscCall(MatSeqAIJSetPreallocation(this->_mat, n_nz, NULL));
241  LibmeshPetscCall(MatMPIAIJSetPreallocation(this->_mat, n_nz, NULL, n_oz, NULL));
242  break;
243 
244  case HYPRE:
245 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
246  LibmeshPetscCall(MatHYPRESetPreallocation(this->_mat, n_nz, NULL, n_oz, NULL));
247 #else
248  libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
249 #endif
250  break;
251 
252  default: libmesh_error_msg("Unsupported petsc matrix type");
253  }
254  }
255 
256  this->finish_initialization();
257 }
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.
Definition: petsc_matrix.C:135
Mat _mat
PETSc matrix datatype to store values.
PetscMatrixType _mat_type
Definition: petsc_matrix.h:349
void finish_initialization()
Finish up the initialization process.
Definition: petsc_matrix.C:329

◆ 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
mThe global number of rows.
nThe global number of columns.
m_lThe local number of rows.
n_lThe local number of columns.
n_nzarray containing the number of nonzeros in each row of the DIAGONAL portion of the local submatrix.
n_ozArray containing the number of nonzeros in each row of the OFF-DIAGONAL portion of the local submatrix.
blocksizeOptional 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().

345 {
346  this->init_without_preallocation(m_in, n_in, m_l, n_l, blocksize_in);
347  this->preallocate(m_l, n_nz, n_oz, blocksize_in);
348 
349  this->finish_initialization();
350 }
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.
Definition: petsc_matrix.C:135
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)
Definition: petsc_matrix.C:260
void finish_initialization()
Finish up the initialization process.
Definition: petsc_matrix.C:329

◆ 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
typeThe 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 
)
protected

Perform matrix initialization steps sans preallocation.

Parameters
mThe global number of rows
nThe global number of columns
m_lThe local number of rows
n_lThe local number of columns
blocksizeThe 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().

140 {
141  // So compilers don't warn when !LIBMESH_ENABLE_BLOCKED_STORAGE
142  libmesh_ignore(blocksize_in);
143 
144  // Clear initialized matrices
145  if (this->initialized())
146  this->clear();
147 
148  PetscInt m_global = static_cast<PetscInt>(m_in);
149  PetscInt n_global = static_cast<PetscInt>(n_in);
150  PetscInt m_local = static_cast<PetscInt>(m_l);
151  PetscInt n_local = static_cast<PetscInt>(n_l);
152 
153  LibmeshPetscCall(MatCreate(this->comm().get(), &this->_mat));
154  LibmeshPetscCall(MatSetSizes(this->_mat, m_local, n_local, m_global, n_global));
155  PetscInt blocksize = static_cast<PetscInt>(blocksize_in);
156  LibmeshPetscCall(MatSetBlockSize(this->_mat,blocksize));
157  LibmeshPetscCall(MatSetOptionsPrefix(this->_mat, ""));
158 
159 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
160  if (blocksize > 1)
161  {
162  // specified blocksize, bs>1.
163  // double check sizes.
164  libmesh_assert_equal_to (m_local % blocksize, 0);
165  libmesh_assert_equal_to (n_local % blocksize, 0);
166  libmesh_assert_equal_to (m_global % blocksize, 0);
167  libmesh_assert_equal_to (n_global % blocksize, 0);
168  libmesh_assert_equal_to (n_nz % blocksize, 0);
169  libmesh_assert_equal_to (n_oz % blocksize, 0);
170 
171  LibmeshPetscCall(MatSetType(this->_mat, MATBAIJ)); // Automatically chooses seqbaij or mpibaij
172 
173  // MatSetFromOptions needs to happen before Preallocation routines
174  // since MatSetFromOptions can change matrix type and remove incompatible
175  // preallocation
176  LibmeshPetscCall(MatSetFromOptions(this->_mat));
177  }
178  else
179 #endif
180  {
181  switch (this->_mat_type) {
182  case AIJ:
183  LibmeshPetscCall(MatSetType(this->_mat, MATAIJ)); // Automatically chooses seqaij or mpiaij
184 
185  // MatSetFromOptions needs to happen before Preallocation routines
186  // since MatSetFromOptions can change matrix type and remove incompatible
187  // preallocation
188  LibmeshPetscCall(MatSetFromOptions(this->_mat));
189  break;
190 
191  case HYPRE:
192 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
193  LibmeshPetscCall(MatSetType(this->_mat, MATHYPRE));
194 
195  // MatSetFromOptions needs to happen before Preallocation routines
196  // since MatSetFromOptions can change matrix type and remove incompatible
197  // preallocation
198  LibmeshPetscCall(MatSetFromOptions(this->_mat));
199 #else
200  libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
201 #endif
202  break;
203 
204  default: libmesh_error_msg("Unsupported petsc matrix type");
205  }
206  }
207 
208  this->set_context ();
209 }
virtual bool initialized() const
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.
const Parallel::Communicator & comm() const
void set_context()
Set the context (ourself) for _mat.
void libmesh_ignore(const Args &...)
Mat _mat
PETSc matrix datatype to store values.
PetscMatrixType _mat_type
Definition: petsc_matrix.h:349

◆ initialized()

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

Reimplemented in libMesh::StaticCondensation.

Definition at line 133 of file sparse_matrix.h.

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

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

◆ l1_norm()

template<typename T >
Real libMesh::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.

493 {
494  return PetscMatrix<T>::norm<NORM_1>();
495 }
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

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

880 {
881  auto diff_mat = this->clone();
882  diff_mat->add(-1.0, other_mat);
883  return diff_mat->l1_norm();
884 }
virtual std::unique_ptr< SparseMatrix< T > > clone() const =0

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

503 {
504  return PetscMatrix<T>::norm<NORM_INFINITY>();
505 }
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

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

143 {
144  libmesh_assert (this->initialized());
145 
146  PetscInt m = 0;
147 
148  LibmeshPetscCall(MatGetLocalSize (this->_mat, &m, NULL));
149 
150  return static_cast<numeric_index_type>(m);
151 }
virtual bool initialized() const
virtual numeric_index_type m() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

167 {
168  libmesh_assert (this->initialized());
169 
170  PetscInt n = 0;
171 
172  LibmeshPetscCall(MatGetLocalSize (this->_mat, NULL, &n));
173 
174  return static_cast<numeric_index_type>(n);
175 }
virtual numeric_index_type n() const override
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

131 {
132  libmesh_assert (this->initialized());
133 
134  PetscInt petsc_m=0, petsc_n=0;
135 
136  LibmeshPetscCall(MatGetSize (this->_mat, &petsc_m, &petsc_n));
137 
138  return static_cast<numeric_index_type>(petsc_m);
139 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

◆ 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::PetscDiffSolver::solve(), libMesh::TaoOptimizationSolver< T >::solve(), libMesh::PetscNonlinearSolver< Number >::solve(), and libMesh::PetscLinearSolver< Number >::solve_common().

120 { libmesh_assert (_mat); return _mat; }
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

◆ 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_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

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

1042 {
1043  libmesh_assert (this->initialized());
1044 
1045  // sanity check
1046  // we do not check the Y_out size here as we will initialize & close it at the end
1047  libmesh_assert_equal_to (this->n(), X_in.m());
1048 
1049  const PetscMatrix<T> * X = cast_ptr<const PetscMatrix<T> *> (&X_in);
1050  PetscMatrix<T> * Y = cast_ptr<PetscMatrix<T> *> (&Y_out);
1051 
1052  // the matrix from which we copy the values has to be assembled/closed
1053  libmesh_assert(X->closed());
1054 
1055  semiparallel_only();
1056 
1057  if (reuse)
1058  LibmeshPetscCall(MatMatMult(this->_mat, X->_mat, MAT_REUSE_MATRIX, PETSC_DEFAULT, &Y->_mat));
1059  else
1060  {
1061  Y->clear();
1062  LibmeshPetscCall(MatMatMult(this->_mat, X->_mat, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &Y->_mat));
1063  }
1064  // Specify that the new matrix is initialized
1065  // We do not close it here as `MatMatMult` ensures Y being closed
1066  Y->_is_initialized = true;
1067 }
virtual numeric_index_type n() const override
virtual bool initialized() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

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

155 {
156  libmesh_assert (this->initialized());
157 
158  PetscInt petsc_m=0, petsc_n=0;
159 
160  LibmeshPetscCall(MatGetSize (this->_mat, &petsc_m, &petsc_n));
161 
162  return static_cast<numeric_index_type>(petsc_n);
163 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

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

239 {
240  if (!_sp)
241  return 0;
242  return _sp->n_nonzeros();
243 }
std::size_t n_nonzeros() const
The total number of nonzeros in the global matrix.
SparsityPattern::Build const * _sp
The sparsity pattern associated with this object.

◆ n_objects()

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

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

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

◆ n_processors()

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

Definition at line 103 of file parallel_object.h.

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

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

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

◆ need_full_sparsity_pattern()

template<typename T>
virtual bool libMesh::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.

475 {
476  libmesh_assert (this->initialized());
477 
478  semiparallel_only();
479 
480  PetscReal petsc_value;
481  Real value;
482 
483  libmesh_assert (this->closed());
484 
485  LibmeshPetscCall(MatNorm(this->_mat, N, &petsc_value));
486 
487  value = static_cast<Real>(petsc_value);
488 
489  return value;
490 }
virtual bool initialized() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
static const bool value
Definition: xdr_io.C:54

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

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

1123 {
1124  libmesh_assert (this->initialized());
1125 
1126  // PETSc 2.2.1 & newer
1127  const PetscScalar * petsc_row;
1128  const PetscInt * petsc_cols;
1129 
1130  // If the entry is not in the sparse matrix, it is 0.
1131  T value=0.;
1132 
1133  PetscInt
1134  ncols=0,
1135  i_val=static_cast<PetscInt>(i_in),
1136  j_val=static_cast<PetscInt>(j_in);
1137 
1138 
1139  // the matrix needs to be closed for this to work
1140  // this->close();
1141  // but closing it is a semiparallel operation; we want operator()
1142  // to run on one processor.
1143  libmesh_assert(this->closed());
1144 
1145  LibmeshPetscCall(MatGetRow(this->_mat, i_val, &ncols, &petsc_cols, &petsc_row));
1146 
1147  // Perform a binary search to find the contiguous index in
1148  // petsc_cols (resp. petsc_row) corresponding to global index j_val
1149  std::pair<const PetscInt *, const PetscInt *> p =
1150  std::equal_range (petsc_cols, petsc_cols + ncols, j_val);
1151 
1152  // Found an entry for j_val
1153  if (p.first != p.second)
1154  {
1155  // The entry in the contiguous row corresponding
1156  // to the j_val column of interest
1157  const std::size_t j =
1158  std::distance (const_cast<PetscInt *>(petsc_cols),
1159  const_cast<PetscInt *>(p.first));
1160 
1161  libmesh_assert_less (j, ncols);
1162  libmesh_assert_equal_to (petsc_cols[j], j_val);
1163 
1164  value = static_cast<T> (petsc_row[j]);
1165  }
1166 
1167  LibmeshPetscCall(MatRestoreRow(this->_mat, i_val,
1168  &ncols, &petsc_cols, &petsc_row));
1169 
1170  return value;
1171 }
virtual bool initialized() const
Real distance(const Point &p)
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
static const bool value
Definition: xdr_io.C:54

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

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

1225 {
1226  semiparallel_only();
1227 
1228  if (this->_mat)
1229  {
1230  PetscBool assembled;
1231  LibmeshPetscCall(MatAssembled(this->_mat, &assembled));
1232 #ifndef NDEBUG
1233  const bool cxx_assembled = (assembled == PETSC_TRUE) ? true : false;
1234  libmesh_assert(this->_communicator.verify(cxx_assembled));
1235 #endif
1236 
1237  if (!assembled)
1238  // MatCopy does not work with an unassembled matrix. We could use MatDuplicate but then we
1239  // would have to destroy the matrix we manage and others might be relying on that data. So
1240  // we just assemble here regardless of the preceding level of matrix fill
1241  this->close();
1242  LibmeshPetscCall(MatCopy(v._mat, this->_mat, DIFFERENT_NONZERO_PATTERN));
1243  }
1244  else
1245  LibmeshPetscCall(MatDuplicate(v._mat, MAT_COPY_VALUES, &this->_mat));
1246 
1247  this->_is_initialized = true;
1248 
1249  return *this;
1250 }
const Parallel::Communicator & _communicator
bool _is_initialized
Flag indicating whether or not the matrix has been initialized.
libmesh_assert(ctx)
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
Mat _mat
PETSc matrix datatype to store values.
timpi_pure bool verify(const T &r) const

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

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

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

264 {
265  // Make sure the sparsity pattern isn't empty unless the matrix is 0x0
266  libmesh_assert_equal_to (n_nz.size(), m_l);
267  libmesh_assert_equal_to (n_oz.size(), m_l);
268  // Avoid unused warnings when not configured with block storage
269  libmesh_ignore(blocksize_in);
270 
271 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
272  PetscInt blocksize = static_cast<PetscInt>(blocksize_in);
273 
274  if (blocksize > 1)
275  {
276  // transform the per-entry n_nz and n_oz arrays into their block counterparts.
277  std::vector<numeric_index_type> b_n_nz, b_n_oz;
278 
279  transform_preallocation_arrays (blocksize,
280  n_nz, n_oz,
281  b_n_nz, b_n_oz);
282 
283  LibmeshPetscCall(MatSeqBAIJSetPreallocation (this->_mat,
284  blocksize,
285  0,
286  numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data())));
287 
288  LibmeshPetscCall(MatMPIBAIJSetPreallocation (this->_mat,
289  blocksize,
290  0,
291  numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data()),
292  0,
293  numeric_petsc_cast(b_n_oz.empty() ? nullptr : b_n_oz.data())));
294  }
295  else
296 #endif
297  {
298  switch (this->_mat_type) {
299  case AIJ:
300  LibmeshPetscCall(MatSeqAIJSetPreallocation (this->_mat,
301  0,
302  numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data())));
303  LibmeshPetscCall(MatMPIAIJSetPreallocation (this->_mat,
304  0,
305  numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
306  0,
307  numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data())));
308  break;
309 
310  case HYPRE:
311 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
312  LibmeshPetscCall(MatHYPRESetPreallocation (this->_mat,
313  0,
314  numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
315  0,
316  numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data())));
317 #else
318  libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
319 #endif
320  break;
321 
322  default: libmesh_error_msg("Unsupported petsc matrix type");
323  }
324 
325  }
326 }
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
void libmesh_ignore(const Args &...)
Mat _mat
PETSc matrix datatype to store values.
PetscMatrixType _mat_type
Definition: petsc_matrix.h:349

◆ print() [1/2]

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

Definition at line 131 of file sparse_matrix.C.

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

◆ print() [2/2]

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

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

Definition at line 247 of file sparse_matrix.C.

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

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

◆ print_info()

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

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_matlab()

template<typename T >
void libMesh::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().

511 {
512  libmesh_assert (this->initialized());
513 
514  semiparallel_only();
515 
516  if (!this->closed())
517  {
518  libmesh_deprecated();
519  libmesh_warning("The matrix must be assembled before calling PetscMatrix::print_matlab().\n"
520  "Please update your code, as this warning will become an error in a future release.");
521  const_cast<PetscMatrix<T> *>(this)->close();
522  }
523 
524  WrappedPetsc<PetscViewer> petsc_viewer;
525  LibmeshPetscCall(PetscViewerCreate (this->comm().get(),
526  petsc_viewer.get()));
527 
528  // Create an ASCII file containing the matrix
529  // if a filename was provided.
530  if (name != "")
531  {
532  LibmeshPetscCall(PetscViewerASCIIOpen( this->comm().get(),
533  name.c_str(),
534  petsc_viewer.get()));
535 
536 #if PETSC_VERSION_LESS_THAN(3,7,0)
537  LibmeshPetscCall(PetscViewerSetFormat (petsc_viewer,
538  PETSC_VIEWER_ASCII_MATLAB));
539 #else
540  LibmeshPetscCall(PetscViewerPushFormat (petsc_viewer,
541  PETSC_VIEWER_ASCII_MATLAB));
542 #endif
543 
544  LibmeshPetscCall(MatView (this->_mat, petsc_viewer));
545  }
546 
547  // Otherwise the matrix will be dumped to the screen.
548  else
549  {
550 #if PETSC_VERSION_LESS_THAN(3,7,0)
551  LibmeshPetscCall(PetscViewerSetFormat (PETSC_VIEWER_STDOUT_WORLD,
552  PETSC_VIEWER_ASCII_MATLAB));
553 #else
554  LibmeshPetscCall(PetscViewerPushFormat (PETSC_VIEWER_STDOUT_WORLD,
555  PETSC_VIEWER_ASCII_MATLAB));
556 #endif
557 
558  LibmeshPetscCall(MatView (this->_mat, PETSC_VIEWER_STDOUT_WORLD));
559  }
560 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
virtual bool initialized() const
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61

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

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

568 {
569  libmesh_assert (this->initialized());
570 
571  // Routine must be called in parallel on parallel matrices
572  // and serial on serial matrices.
573  semiparallel_only();
574 
575  // #ifndef NDEBUG
576  // if (os != std::cout)
577  // libMesh::err << "Warning! PETSc can only print to std::cout!" << std::endl;
578  // #endif
579 
580  // Matrix must be in an assembled state to be printed
581  if (!this->closed())
582  {
583  libmesh_deprecated();
584  libmesh_warning("The matrix must be assembled before calling PetscMatrix::print_personal().\n"
585  "Please update your code, as this warning will become an error in a future release.");
586  const_cast<PetscMatrix<T> *>(this)->close();
587  }
588 
589  // Print to screen if ostream is stdout
590  if (os.rdbuf() == std::cout.rdbuf())
591  LibmeshPetscCall(MatView(this->_mat, NULL));
592 
593  // Otherwise, print to the requested file, in a roundabout way...
594  else
595  {
596  // We will create a temporary filename, and file, for PETSc to
597  // write to.
598  std::string temp_filename;
599 
600  {
601  // Template for temporary filename
602  char c[] = "temp_petsc_matrix.XXXXXX";
603 
604  // Generate temporary, unique filename only on processor 0. We will
605  // use this filename for PetscViewerASCIIOpen, before copying it into
606  // the user's stream
607  if (this->processor_id() == 0)
608  {
609  int fd = mkstemp(c);
610 
611  // Check to see that mkstemp did not fail.
612  libmesh_error_msg_if(fd == -1, "mkstemp failed in PetscMatrix::print_personal()");
613 
614  // mkstemp returns a file descriptor for an open file,
615  // so let's close it before we hand it to PETSc!
616  ::close (fd);
617  }
618 
619  // Store temporary filename as string, makes it easier to broadcast
620  temp_filename = c;
621  }
622 
623  // Now broadcast the filename from processor 0 to all processors.
624  this->comm().broadcast(temp_filename);
625 
626  // PetscViewer object for passing to MatView
627  PetscViewer petsc_viewer;
628 
629  // This PETSc function only takes a string and handles the opening/closing
630  // of the file internally. Since print_personal() takes a reference to
631  // an ostream, we have to do an extra step... print_personal() should probably
632  // have a version that takes a string to get rid of this problem.
633  LibmeshPetscCall(PetscViewerASCIIOpen( this->comm().get(),
634  temp_filename.c_str(),
635  &petsc_viewer));
636 
637  // Probably don't need to set the format if it's default...
638  // ierr = PetscViewerSetFormat (petsc_viewer,
639  // PETSC_VIEWER_DEFAULT);
640  // LIBMESH_CHKERR(ierr);
641 
642  // Finally print the matrix using the viewer
643  LibmeshPetscCall(MatView (this->_mat, petsc_viewer));
644 
645  if (this->processor_id() == 0)
646  {
647  // Now the inefficient bit: open temp_filename as an ostream and copy the contents
648  // into the user's desired ostream. We can't just do a direct file copy, we don't even have the filename!
649  std::ifstream input_stream(temp_filename.c_str());
650  os << input_stream.rdbuf(); // The "most elegant" way to copy one stream into another.
651  // os.close(); // close not defined in ostream
652 
653  // Now remove the temporary file
654  input_stream.close();
655  std::remove(temp_filename.c_str());
656  }
657  }
658 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
int mkstemp(char *tmpl)
Definition: win_mkstemp.h:13
libmesh_assert(ctx)
virtual void close() override
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
This class provides a nice interface to the PETSc C-based AIJ data structures for parallel...
Definition: petsc_matrix.h:61
processor_id_type processor_id() const

◆ print_petsc_binary()

template<typename T >
void libMesh::PetscMatrix< T >::print_petsc_binary ( const std::string &  filename)
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 693 of file petsc_matrix.C.

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

694 {
695  libmesh_assert (this->initialized());
696 
697  this->_petsc_viewer(filename, PETSCVIEWERBINARY, FILE_MODE_WRITE);
698 }
virtual bool initialized() const
libmesh_assert(ctx)
void _petsc_viewer(const std::string &filename, PetscViewerType viewertype, PetscFileMode filemode)
Definition: petsc_matrix.C:663

◆ print_petsc_hdf5()

template<typename T >
void libMesh::PetscMatrix< T >::print_petsc_hdf5 ( const std::string &  filename)
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::initialized(), and libMesh::libmesh_assert().

704 {
705  libmesh_assert (this->initialized());
706 
707  this->_petsc_viewer(filename, PETSCVIEWERHDF5, FILE_MODE_WRITE);
708 }
virtual bool initialized() const
libmesh_assert(ctx)
void _petsc_viewer(const std::string &filename, PetscViewerType viewertype, PetscFileMode filemode)
Definition: petsc_matrix.C:663

◆ processor_id()

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

Definition at line 114 of file parallel_object.h.

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

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

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

◆ read()

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

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

Definition at line 511 of file sparse_matrix.C.

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

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

Referenced by ConstraintOperatorTest::test1DCoarseningNewNodes().

568 {
569  LOG_SCOPE("read_matlab()", "SparseMatrix");
570 
571 #ifndef LIBMESH_HAVE_CXX11_REGEX
572  libmesh_not_implemented(); // What is your compiler?!? Email us!
573  libmesh_ignore(filename);
574 #else
575  parallel_object_only();
576 
577  const bool gzipped_file = (filename.rfind(".gz") == filename.size() - 3);
578 
579  // The sizes we get from the file
580  std::size_t m = 0,
581  n = 0;
582 
583  // If we don't already have this size, we'll need to reinit, and
584  // determine which rows+columns each processor is in charge of.
585  std::vector<numeric_index_type> new_row_starts, new_row_stops,
586  new_col_starts, new_col_stops;
587 
588  numeric_index_type new_row_start, new_row_stop,
589  new_col_start, new_col_stop;
590 
591  // We'll read through the file three times: once to get a reliable
592  // value for the matrix size (so we can divvy it up among
593  // processors), then again to get the sparsity to send to each
594  // processor, then a final time to get the entries to send to each
595  // processor.
596  //
597  // We'll use an istream here; it might be an ifstream if we're
598  // opening a raw ASCII file or a gzstream if we're opening a
599  // compressed one.
600  std::unique_ptr<std::istream> file;
601 
602  // We'll need a temporary structure to cache matrix entries, because
603  // we need to read through the whole file before we know the size
604  // and sparsity structure with which we can init().
605  //
606  // Reading through the file three times via `seekg` doesn't work
607  // with our gzstream wrapper, and seems to take three times as long
608  // even with a plain ifstream. What happened to disk caching!?
609  std::vector<std::tuple<numeric_index_type, numeric_index_type, T>> entries;
610 
611  // First read through the file, saving size and entry data
612  {
613  // We'll read the matrix on processor 0 rather than try to juggle
614  // parallel I/O.
615  if (this->processor_id() == 0)
616  {
617  // We'll be using regular expressions to make ourselves slightly
618  // more robust to formatting.
619  const std::regex start_regex // assignment like "zzz = ["
620  ("\\s*\\w+\\s*=\\s*\\[");
621  const std::regex end_regex // end of assignment
622  ("^[^%]*\\]");
623 
624  if (gzipped_file)
625  {
626 #ifdef LIBMESH_HAVE_GZSTREAM
627  auto inf = std::make_unique<igzstream>();
628  libmesh_assert(inf);
629  inf->open(filename.c_str(), std::ios::in);
630  file = std::move(inf);
631 #else
632  libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
633 #endif
634  }
635  else
636  {
637  auto inf = std::make_unique<std::ifstream>();
638  libmesh_assert(inf);
639 
640  std::string new_name = Utility::unzip_file(filename);
641 
642  inf->open(new_name.c_str(), std::ios::in);
643  file = std::move(inf);
644  }
645 
646  // If we have a matrix with all-zero trailing rows, the only
647  // way to get the size is if it ended up in a comment
648  const std::regex size_regex // comment like "% size = 8 8"
649  ("%\\s*[Ss][Ii][Zz][Ee]\\s*=\\s*(\\d+)\\s+(\\d+)");
650  const std::string whitespace = " \t";
651 
652  bool have_started = false;
653  bool have_ended = false;
654  std::size_t largest_i_seen = 0, largest_j_seen = 0;
655 
656  // Data for the row we're working on
657  // Use 1-based indexing for current_row, as in the file
658  std::size_t current_row = 1;
659 
660  for (std::string line; std::getline(*file, line);)
661  {
662  std::smatch sm;
663 
664  // First, try to match an entry. This is the most common
665  // case so we won't rely on slow std::regex for it.
666  // stringstream is at least an improvement over that.
667 
668  // Look for row/col/val like "1 1 -2.0e-4"
669 
670  std::istringstream l(line);
671 
672  std::size_t i, j;
673  T value;
674 
675  l >> i >> j >> value;
676 
677  if (!l.fail())
678  {
679  libmesh_error_msg_if
680  (!have_started, "Confused by premature entries in matrix file " << filename);
681 
682  entries.emplace_back(cast_int<numeric_index_type>(i),
683  cast_int<numeric_index_type>(j),
684  value);
685 
686  libmesh_error_msg_if
687  (!i || !j, "Expected 1-based indexing in matrix file "
688  << filename);
689 
690  current_row = std::max(current_row, i);
691 
692  libmesh_error_msg_if
693  (i < current_row,
694  "Can't handle out-of-order entries in matrix file "
695  << filename);
696 
697  largest_i_seen = std::max(i, largest_i_seen);
698  largest_j_seen = std::max(j, largest_j_seen);
699  }
700 
701  else if (std::regex_search(line, sm, size_regex))
702  {
703  const std::string msize = sm[1];
704  const std::string nsize = sm[2];
705  m = std::stoull(msize);
706  n = std::stoull(nsize);
707  }
708 
709  else if (std::regex_search(line, start_regex))
710  have_started = true;
711 
712  else if (std::regex_search(line, end_regex))
713  {
714  have_ended = true;
715  break;
716  }
717  }
718 
719  libmesh_error_msg_if
720  (!have_started, "Confused by missing assignment beginning in matrix file " << filename);
721 
722  libmesh_error_msg_if
723  (!have_ended, "Confused by missing assignment ending in matrix file " << filename);
724 
725  libmesh_error_msg_if
726  (m > largest_i_seen, "Confused by missing final row(s) in matrix file " << filename);
727 
728  libmesh_error_msg_if
729  (m > 0 && m < largest_i_seen, "Confused by extra final row(s) in matrix file " << filename);
730 
731  if (!m)
732  m = largest_i_seen;
733 
734  libmesh_error_msg_if
735  (n > largest_j_seen, "Confused by missing final column(s) in matrix file " << filename);
736 
737  libmesh_error_msg_if
738  (n > 0 && n < largest_j_seen, "Confused by extra final column(s) in matrix file " << filename);
739 
740  if (!n)
741  n = largest_j_seen;
742 
743  this->comm().broadcast(m);
744  this->comm().broadcast(n);
745  }
746  else
747  {
748  this->comm().broadcast(m);
749  this->comm().broadcast(n);
750  }
751 
752  if (this->initialized() &&
753  m == this->m() &&
754  n == this->n())
755  {
756  new_row_start = this->row_start(),
757  new_row_stop = this->row_stop();
758 
759  new_col_start = this->col_start(),
760  new_col_stop = this->col_stop();
761  }
762  else
763  {
764  // Determine which rows/columns each processor will be in charge of
765  new_row_start = this->processor_id() * m / this->n_processors(),
766  new_row_stop = (this->processor_id()+1) * m / this->n_processors();
767 
768  new_col_start = this->processor_id() * n / this->n_processors(),
769  new_col_stop = (this->processor_id()+1) * n / this->n_processors();
770  }
771 
772  this->comm().gather(0, new_row_start, new_row_starts);
773  this->comm().gather(0, new_row_stop, new_row_stops);
774  this->comm().gather(0, new_col_start, new_col_starts);
775  this->comm().gather(0, new_col_stop, new_col_stops);
776 
777  } // Done reading entry data and broadcasting matrix size
778 
779  // Calculate the matrix sparsity and initialize it second
780  {
781  // Deduce the sparsity pattern, or at least the maximum number of
782  // on- and off- diagonal non-zeros per row.
783  numeric_index_type on_diagonal_nonzeros =0,
784  off_diagonal_nonzeros =0;
785 
786  if (this->processor_id() == 0)
787  {
788  // Data for the row we're working on
789  // Use 1-based indexing for current_row, as in the file
790  numeric_index_type current_row = 1;
791  processor_id_type current_proc = 0;
792  numeric_index_type current_on_diagonal_nonzeros = 0;
793  numeric_index_type current_off_diagonal_nonzeros = 0;
794 
795  for (auto [i, j, value] : entries)
796  {
797  if (i > current_row)
798  {
799  current_row = i;
800  // +1 for 1-based indexing in file
801  while (current_row >= (new_row_stops[current_proc]+1))
802  ++current_proc;
803  current_on_diagonal_nonzeros = 0;
804  current_off_diagonal_nonzeros = 0;
805  }
806 
807  // +1 for 1-based indexing in file
808  if (j >= (new_col_starts[current_proc]+1) &&
809  j < (new_col_stops[current_proc]+1))
810  {
811  ++current_on_diagonal_nonzeros;
812  on_diagonal_nonzeros =
813  std::max(on_diagonal_nonzeros,
814  current_on_diagonal_nonzeros);
815  }
816  else
817  {
818  ++current_off_diagonal_nonzeros;
819  off_diagonal_nonzeros =
820  std::max(off_diagonal_nonzeros,
821  current_off_diagonal_nonzeros);
822  }
823  }
824  }
825 
826  this->comm().broadcast(on_diagonal_nonzeros);
827  this->comm().broadcast(off_diagonal_nonzeros);
828 
829  this->init(m, n,
830  new_row_stop-new_row_start,
831  new_col_stop-new_col_start,
832  on_diagonal_nonzeros,
833  off_diagonal_nonzeros);
834  }
835 
836  // Set the matrix values last.
837  // Convert from 1-based to 0-based indexing
838  if (this->processor_id() == 0)
839  for (auto [i, j, value] : entries)
840  this->set(i-1, j-1, value);
841 
842  this->close();
843 #endif
844 }
virtual bool initialized() const
void gather(const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
const Parallel::Communicator & comm() const
virtual numeric_index_type row_stop() const =0
uint8_t processor_id_type
processor_id_type n_processors() const
void libmesh_ignore(const Args &...)
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type m() const =0
std::string unzip_file(std::string_view name)
Create an unzipped copy of a bz2 or xz file, returning the name of the now-unzipped file that can be ...
Definition: utility.C:164
libmesh_assert(ctx)
virtual numeric_index_type col_stop() const =0
virtual numeric_index_type col_start() const =0
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
virtual void close()=0
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
virtual numeric_index_type row_start() const =0
static const bool value
Definition: xdr_io.C:54
processor_id_type processor_id() const
virtual numeric_index_type n() const =0
virtual void init(const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1)=0
Initialize SparseMatrix with the specified sizes.

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

714 {
715  LOG_SCOPE("read_petsc_binary()", "PetscMatrix");
716 
717  this->_petsc_viewer(filename, PETSCVIEWERBINARY, FILE_MODE_READ);
718 }
void _petsc_viewer(const std::string &filename, PetscViewerType viewertype, PetscFileMode filemode)
Definition: petsc_matrix.C:663

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

724 {
725  LOG_SCOPE("read_petsc_hdf5()", "PetscMatrix");
726 
727  this->_petsc_viewer(filename, PETSCVIEWERHDF5, FILE_MODE_READ);
728 }
void _petsc_viewer(const std::string &filename, PetscViewerType viewertype, PetscFileMode filemode)
Definition: petsc_matrix.C:663

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

543  {
544  this->_get_submatrix(submatrix,
545  rows,
546  cols,
547  true); // true means REUSE submatrix
548  }
virtual void _get_submatrix(SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
Protected implementation of the create_submatrix and reinit_submatrix routines.

◆ require_sparsity_pattern()

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

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

Definition at line 168 of file sparse_matrix.h.

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

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

386 {
387  semiparallel_only();
388 
389 #if !PETSC_VERSION_LESS_THAN(3,9,0)
390  libmesh_assert (this->initialized());
391 
392  LibmeshPetscCall(MatResetPreallocation(this->_mat));
393 #else
394  libmesh_warning("Your version of PETSc doesn't support resetting of "
395  "preallocation, so we will use your most recent sparsity "
396  "pattern. This may result in a degradation of performance\n");
397 #endif
398 }
virtual bool initialized() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

1294 {
1295  semiparallel_only();
1296 
1297  if (this->_use_hash_table)
1298 #if PETSC_RELEASE_GREATER_EQUALS(3, 23, 0)
1299  // This performs MatReset plus re-establishes the hash table
1300  LibmeshPetscCall(MatResetHash(this->_mat));
1301 #else
1302  libmesh_error_msg("Resetting hash tables not supported until PETSc version 3.23");
1303 #endif
1304  else
1305  this->reset_preallocation();
1306 }
void reset_preallocation()
Reset matrix to use the original nonzero pattern provided by users.
Definition: petsc_matrix.C:385
Mat _mat
PETSc matrix datatype to store values.
bool _use_hash_table
Flag indicating whether the matrix is assembled using a hash table.

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

179 {
180  libmesh_assert (this->initialized());
181 
182  PetscInt start=0, stop=0;
183 
184  LibmeshPetscCall(MatGetOwnershipRange(this->_mat, &start, &stop));
185 
186  return static_cast<numeric_index_type>(start);
187 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
void stop(const char *file, int line, const char *date, const char *time)
Mat _mat
PETSc matrix datatype to store values.

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

191 {
192  libmesh_assert (this->initialized());
193 
194  PetscInt start=0, stop=0;
195 
196  LibmeshPetscCall(MatGetOwnershipRange(this->_mat, &start, &stop));
197 
198  return static_cast<numeric_index_type>(stop);
199 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
void stop(const char *file, int line, const char *date, const char *time)
Mat _mat
PETSc matrix datatype to store values.

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

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

1261 {
1262  libmesh_assert(this->closed());
1263 
1264  LibmeshPetscCall(MatScale(this->_mat, PS(scale)));
1265 }
PetscScalar PS(T val)
Definition: petsc_macro.h:168
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override
virtual void scale(const T scale) override
Scales all elements of this matrix by 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 970 of file petsc_matrix.C.

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

973 {
974  libmesh_assert (this->initialized());
975 
976  PetscInt i_val=i, j_val=j;
977 
978  PetscScalar petsc_value = static_cast<PetscScalar>(value);
979  std::scoped_lock lock(this->_petsc_matrix_mutex);
980  LibmeshPetscCall(MatSetValues(this->_mat, 1, &i_val, 1, &j_val,
981  &petsc_value, INSERT_VALUES));
982 }
virtual bool initialized() const
std::mutex _petsc_matrix_mutex
Definition: petsc_matrix.h:353
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.
static const bool value
Definition: xdr_io.C:54

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

106 {
107  libmesh_assert(this->_mat);
108  PetscContainer container;
109  LibmeshPetscCall(PetscContainerCreate(this->comm().get(), &container));
110  LibmeshPetscCall(PetscContainerSetPointer(container, this));
111  LibmeshPetscCall(PetscObjectCompose((PetscObject)(Mat)this->_mat, "PetscMatrixCtx", (PetscObject)container));
112  LibmeshPetscCall(PetscContainerDestroy(&container));
113 }
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

92 {
94 }
bool _destroy_mat_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Mat object...
void destroy(triangulateio &t, IO_Type)
Frees any memory which has been dynamically allocated by Triangle.

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

108  {
109  return PETSC_SOLVERS;
110  }

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

1269 {
1270 #if PETSC_RELEASE_LESS_THAN(3,19,0)
1271  return false;
1272 #else
1273  return true;
1274 #endif
1275 }

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

99 {
100  std::swap(_mat, m_in._mat);
101  std::swap(_destroy_mat_on_exit, m_in._destroy_mat_on_exit);
102 }
bool _destroy_mat_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Mat object...
Mat _mat
PETSc matrix datatype to store values.

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

380 {
381  libmesh_not_implemented();
382 }

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

Referenced by PetscMatrixTest::testPetscCopyFromHash().

668 {
669  libmesh_error_msg_if(use_hash && !this->supports_hash_table(),
670  "This matrix class does not support hash table assembly");
671  this->_use_hash_table = use_hash;
672 }
bool _use_hash_table
Flag indicating whether the matrix is assembled using a hash table.
virtual bool supports_hash_table() const

◆ use_hash_table() [2/2]

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

Definition at line 609 of file sparse_matrix.h.

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

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

◆ vector_mult()

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

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

Definition at line 209 of file sparse_matrix.C.

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

211 {
212  dest.zero();
213  this->vector_mult_add(dest,arg);
214 }
void vector_mult_add(NumericVector< T > &dest, const NumericVector< T > &arg) const
Multiplies the matrix by the NumericVector arg and adds the result to the NumericVector dest...

◆ vector_mult_add()

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

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

Definition at line 219 of file sparse_matrix.C.

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

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

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

402 {
403  libmesh_assert (this->initialized());
404 
405  semiparallel_only();
406 
407  PetscInt m_l, n_l;
408 
409  LibmeshPetscCall(MatGetLocalSize(this->_mat,&m_l,&n_l));
410 
411  if (n_l)
412  LibmeshPetscCall(MatZeroEntries(this->_mat));
413 }
virtual bool initialized() const
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

436 {
437  libmesh_error_msg_if(!this->closed(), "Matrix must be closed before it can be cloned!");
438 
439  // Copy the nonzero pattern only
440  Mat copy;
441  LibmeshPetscCall(MatDuplicate(this->_mat, MAT_DO_NOT_COPY_VALUES, &copy));
442 
443  // Call wrapping PetscMatrix constructor, have it take over
444  // ownership.
445  auto ret = std::make_unique<PetscMatrix<T>>(copy, this->comm());
446  ret->set_destroy_mat_on_exit(true);
447 
448  return ret;
449 }
const Parallel::Communicator & comm() const
Mat _mat
PETSc matrix datatype to store values.
virtual bool closed() const override

◆ zero_rows()

template<typename T >
void libMesh::PetscMatrix< T >::zero_rows ( std::vector< numeric_index_type > &  rows,
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().

417 {
418  libmesh_assert (this->initialized());
419 
420  semiparallel_only();
421 
422  // As of petsc-dev at the time of 3.1.0, MatZeroRows now takes two additional
423  // optional arguments. The optional arguments (x,b) can be used to specify the
424  // solutions for the zeroed rows (x) and right hand side (b) to update.
425  // Could be useful for setting boundary conditions...
426  if (!rows.empty())
427  LibmeshPetscCall(MatZeroRows(this->_mat, cast_int<PetscInt>(rows.size()),
428  numeric_petsc_cast(rows.data()), PS(diag_value),
429  NULL, NULL));
430  else
431  LibmeshPetscCall(MatZeroRows(this->_mat, 0, NULL, PS(diag_value), NULL, NULL));
432 }
virtual bool initialized() const
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
PetscScalar PS(T val)
Definition: petsc_macro.h:168
libmesh_assert(ctx)
Mat _mat
PETSc matrix datatype to store values.

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

◆ _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 641 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

◆ _mat

template<typename T>
Mat libMesh::PetscMatrixBase< T >::_mat
protectedinherited

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

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


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