这个类提供了一个方便的接口，用于操作并行稀疏矩阵的 PETSc C 库数据结构。所有覆盖的虚拟函数都在 sparse_matrix.h 中有详细的文档说明。更多...

#include <petsc_matrix.h>

类 libMesh::PetscMatrix< T > 继承关系图:

Public 成员函数
	PetscMatrix (const Parallel::Communicator &comm_in)
	构造函数：将矩阵初始化为空，没有任何结构。这个构造函数只适用于类的成员矩阵。所有其他矩阵应该在所有必要信息都可用的数据流中的某一点创建。更多...

	PetscMatrix (Mat m, const Parallel::Communicator &comm_in)
	构造函数：创建一个 PetscMatrix，假设您已经有一个有效的 Mat 对象。在这种情况下，矩阵 m 不会在 PetscMatrix 析构函数中销毁，这允许 m 的所有权保留给原始创建者，并为 PetscMatrix 提供额外的功能。更多...

	PetscMatrix (PetscMatrix &&)=delete
	删除默认生成的复制和移动函数，以及默认析构函数，因为此类手动管理 C 风格的 Mat 结构。更多...

	PetscMatrix (const PetscMatrix &)=delete

PetscMatrix &	operator= (const PetscMatrix &)=delete

PetscMatrix &	operator= (PetscMatrix &&)=delete

virtual	~PetscMatrix ()
	析构函数，释放矩阵资源。更多...

void	set_matrix_type (PetscMatrixType mat_type)
	设置矩阵的类型（如稀疏矩阵类型）。更多...

virtual void	init (const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1) override
	初始化 PETSc 矩阵。更多...

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)
	初始化 PETSc 矩阵。更多...

virtual void	init (ParallelType=PARALLEL) override
	使用由 `dof_map` 计算的稀疏性结构初始化此矩阵。更多...

void	update_preallocation_and_zero ()
	更新基于 `dof_map` 的稀疏模式，并将矩阵置零。这在稀疏模式在计算过程中发生变化的情况下很有用。更多...

void	reset_preallocation ()
	重置矩阵以使用用户提供的原始非零模式。更多...

virtual void	clear () noexceptoverride
	clear() 在析构函数中调用，因此它不应该抛出异常。更多...

virtual void	zero () override
	将矩阵所有元素置为零。更多...

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
	将指定行的所有元素置为零，并在对角线位置放置一个指定值。更多...

virtual void	close () override
	完成任何挂起的插入或添加操作。更多...

virtual void	flush () override
	刷新矩阵的内部缓冲区，确保所有操作都已完成。更多...

virtual numeric_index_type	m () const override
	获取矩阵的行数。更多...

virtual numeric_index_type	local_m () const final
	获取由该进程拥有的矩阵行数。更多...

virtual numeric_index_type	n () const override
	获取矩阵的列数。更多...

numeric_index_type	local_n () const
	获取由该进程拥有的矩阵列数。更多...

void	get_local_size (numeric_index_type &m, numeric_index_type &n) const
	获取由该进程拥有的矩阵行数和列数。更多...

virtual numeric_index_type	row_start () const override
	获取本地处理的行的起始索引。更多...

virtual numeric_index_type	row_stop () const override
	获取本地处理的行的结束索引。更多...

virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value) override
	设置矩阵中特定位置的值。更多...

virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value) override
	在矩阵的特定位置添加值。更多...

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
	将稠密矩阵添加到此稀疏矩阵的指定行和列。更多...

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
	将稠密矩阵添加到此稀疏矩阵的指定位置。更多...

virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols) override
	将稠密块矩阵添加到此稀疏矩阵的指定块行和块列。更多...

virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
	将稠密块矩阵添加到此稀疏矩阵的指定位置。更多...

virtual void	add (const T a, const SparseMatrix< T > &X) override
	计算 A += a*X，其中 a 是标量，X 是矩阵。更多...

virtual void	matrix_matrix_mult (SparseMatrix< T > &X, SparseMatrix< T > &Y, bool reuse=false) override
	计算 Y = A*X，其中 A 是当前矩阵，X 是另一个矩阵。更多...

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
	将标量乘以稀疏矩阵 spm 添加到此矩阵的指定行和列。更多...

virtual T	operator() (const numeric_index_type i, const numeric_index_type j) const override
	获取矩阵中特定位置的值。更多...

virtual Real	l1_norm () const override
	计算矩阵的 L1 范数。更多...

virtual Real	linfty_norm () const override
	计算矩阵的无穷范数。更多...

virtual bool	closed () const override
	检查矩阵是否已经关闭，即所有的插入和添加操作是否已经完成。更多...

virtual void	set_destroy_mat_on_exit (bool destroy=true)
	设置析构时是否删除 Mat 对象。如果设置为 false，则允许 PETSc 管理它。更多...

virtual void	print_personal (std::ostream &os=libMesh::out) const override
	使用 PETSc 查看器将矩阵的内容打印到屏幕。由于我们限制了一个 PETSc 实现，所以此函数仅允许打印到标准输出。更多...

virtual void	print_matlab (const std::string &name="") const override
	将矩阵内容以 MATLAB 格式打印出来。更多...

virtual void	get_diagonal (NumericVector< T > &dest) const override
	获取矩阵的对角线并将其存储在给定的向量中。更多...

virtual void	get_transpose (SparseMatrix< T > &dest) const override
	获取矩阵的转置。更多...

void	swap (PetscMatrix< T > &)
	交换两个 PetscMatrix 的内部数据指针，不交换实际值。更多...

Mat	mat ()
	返回原始的 PETSc 矩阵指针。更多...

virtual void	get_row (numeric_index_type i, std::vector< numeric_index_type > &indices, std::vector< T > &values) const override
	获取矩阵中指定行的索引和值。更多...

virtual void	create_submatrix_nosort (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const override
	根据给定的 `rows` 和 `cols` 向量中的索引创建一个子矩阵，类似于 `create_submatrix` 函数。更多...

virtual bool	initialized () const

void	attach_dof_map (const DofMap &dof_map)
	设置要使用的 `DofMap` 的指针。如果不使用单独的稀疏性模式，则使用来自 DofMap 的模式。更多...

void	attach_sparsity_pattern (const SparsityPattern::Build &sp)
	设置要使用的稀疏性模式的指针。在矩阵需要比系统中的大（或更小以提高效率）的模式，或者在 DofMap 未计算系统稀疏性模式的情况下使用。更多...

virtual bool	need_full_sparsity_pattern () const

virtual void	update_sparsity_pattern (const SparsityPattern::Graph &)
	更新矩阵的稀疏性模式。当您的 `SparseMatrix<T>` 实现不需要此数据时，只需不覆盖此方法。更多...

void	print (std::ostream &os=libMesh::out, const bool sparse=false) const
	将矩阵的内容以统一的样式打印到屏幕上，而不考虑正在使用的矩阵/求解器包。更多...

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

virtual void	create_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const
	此函数创建一个名为 "submatrix" 的矩阵，其定义由 "rows" 和 "cols" 条目中的行和列索引给定。目前，此操作仅对 PetscMatrix 类型定义。注意：`rows` 和 `cols` 向量需要排序；如果 `rows` 和 `cols` 向量未排序，则使用下面的 nosort 版本； `rows` 和 `cols` 仅包含由此处理器拥有的索引。更多...

virtual void	reinit_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const
	此函数与上述函数类似，但允许您重用 "submatrix" 的现有稀疏性模式，而不是再次分配它。如果经常提取相同大小的子矩阵，这应该更有效。更多...

void	vector_mult (NumericVector< T > &dest, const NumericVector< T > &arg) const
	将矩阵乘以 NumericVector `arg` 并将结果存储在 NumericVector `dest` 中。更多...

void	vector_mult_add (NumericVector< T > &dest, const NumericVector< T > &arg) const
	将矩阵乘以 NumericVector `arg` ,并将结果添加到 NumericVector `dest` 中。更多...

静态 Public 成员函数
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)
	使用由 `solver_package` 指定的线性求解器包构建一个 `SparseMatrix<T>。` 更多...

static std::string	get_info ()
	Gets a string containing the reference information. 更多...

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`. 更多...

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

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

static void	disable_print_counter_info ()

Protected 类型
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information. 更多...

Protected 成员函数
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
	创建或重新初始化一个由 `rows` 和 `cols` 向量中给出的索引定义的矩阵 `submatrix。` 更多...

void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter. 更多...

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter. 更多...

Protected 属性
DofMap const *	_dof_map
	与此对象关联的 `DofMap` 对象。可以查询其在处理器上的自由度计数。更多...

SparsityPattern::Build const *	_sp
	与此对象关联的 `sparsity` pattern。在需要时，应查询其入口计数（或使用 need_full_sparsity_pattern，模式）。更多...

bool	_is_initialized
	标志，指示矩阵是否已初始化。更多...

静态 Protected 属性
static Counts	_counts
	Actually holds the data. 更多...

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

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

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

Private 属性
Mat	_mat
	用于存储值的 PETSc 矩阵数据类型。更多...

bool	_destroy_mat_on_exit
	此布尔值仅应在接受 PETSc Mat 对象的构造函数中设置为 `false。` 更多...

PetscMatrixType	_mat_type
	存储 PETSc 矩阵的类型。更多...

std::mutex	_petsc_matrix_mutex
	用于线程安全的互斥锁（C++11 线程）。更多...

Threads::spin_mutex	_petsc_matrix_mutex
	用于线程安全的旋转锁。更多...

详细描述

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

这个类提供了一个方便的接口，用于操作并行稀疏矩阵的 PETSc C 库数据结构。所有覆盖的虚拟函数都在 sparse_matrix.h 中有详细的文档说明。

作者: Benjamin S. Kirk

日期: 2002 SparseMatrix interface to PETSc Mat.

在文件 petsc_matrix.h 第 92 行定义.

成员类型定义说明

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.

在文件 reference_counter.h 第 119 行定义.

构造及析构函数说明

template<typename T >

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

explicit

构造函数：将矩阵初始化为空，没有任何结构。这个构造函数只适用于类的成员矩阵。所有其他矩阵应该在所有必要信息都可用的数据流中的某一点创建。

在使用之前，您必须使用 init(...) 初始化矩阵。

参数

comm_in 通信器，指定了矩阵的并行性质。

在文件 petsc_matrix.C 第 83 行定义.

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

template<typename T >

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

explicit

构造函数：创建一个 PetscMatrix，假设您已经有一个有效的 Mat 对象。在这种情况下，矩阵 m 不会在 PetscMatrix 析构函数中销毁，这允许 m 的所有权保留给原始创建者，并为 PetscMatrix 提供额外的功能。

参数

m	已有的 Mat 对象。
comm_in	通信器，指定了矩阵的并行性质。

在文件 petsc_matrix.C 第 95 行定义.

参考 libMesh::SparseMatrix< T >::_is_initialized , 以及 libMesh::PetscMatrix< T >::_mat.

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

template<typename T>

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

delete

删除默认生成的复制和移动函数，以及默认析构函数，因为此类手动管理 C 风格的 Mat 结构。

template<typename T>

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

delete

template<typename T >

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

virtual

析构函数，释放矩阵资源。

在文件 petsc_matrix.C 第 109 行定义.

 {
   this->clear();
 }

成员函数说明

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

创建或重新初始化一个由 rows 和 cols 向量中给出的索引定义的矩阵 submatrix。

参数

submatrix	要创建或重新初始化的子矩阵。
rows	定义子矩阵的行索引。
cols	定义子矩阵的列索引。
reuse_submatrix	确定 PETSc 是否将 `submatrix` 视为已使用过（已分配内存）的矩阵，还是新矩阵。

注解: 此函数基于 MatGetSubMatrix() 实现。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 812 行定义.

参考 libMesh::SparseMatrix< T >::_is_initialized, libMesh::PetscMatrix< T >::_mat, libMesh::SparseMatrix< T >::clear(), libMesh::PetscMatrix< T >::close(), libMesh::closed(), libMesh::WrappedPetsc< T >::get(), libMesh::SparseMatrix< T >::initialized() , 以及 libMesh::numeric_petsc_cast().

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

template<typename T >

void libMesh::PetscMatrix< T >::add	(	const numeric_index_type	i,
		const numeric_index_type	j,
		const T	value
	)

overridevirtual

在矩阵的特定位置添加值。

参数

i	行索引。
j	列索引。
value	要添加的值。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1127 行定义.

参考 libMesh::initialized().

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

template<typename T >

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

overridevirtual

计算 A += a*X，其中 a 是标量，X 是矩阵。

参数

a	标量值。
X	要添加的矩阵。

注解: 矩阵 A 和 X 需要有相同的非零模式，否则会引起 PETSc 崩溃。; 建议在添加非零值到 X 时，不仅分配适当的内存，而且也显式地将 this 置零。; X 将在执行任何操作前被关闭，如果它尚未关闭的话。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1158 行定义.

参考 libMesh::PetscMatrix< T >::_mat, libMesh::PetscMatrix< T >::closed(), libMesh::initialized(), libMesh::SparseMatrix< T >::m() , 以及 libMesh::SparseMatrix< T >::n().

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

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

将稠密块矩阵添加到此稀疏矩阵的指定块行和块列。

参数

dm	要添加的稠密块矩阵。
brows	稀疏矩阵中的块行索引。
bcols	稀疏矩阵中的块列索引。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 768 行定义.

参考 libMesh::DenseMatrix< T >::get_values(), libMesh::initialized(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::numeric_petsc_cast() , 以及 libMesh::pPS().

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

template<typename T>

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

overridevirtual

将稠密块矩阵添加到此稀疏矩阵的指定位置。

参数

dm	要添加的稠密块矩阵。
dof_indices	稀疏矩阵中的行和列索引。

重载 libMesh::SparseMatrix< T > .

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

将稠密矩阵添加到此稀疏矩阵的指定行和列。

参数

dm	要添加的稠密矩阵。
rows	稀疏矩阵中的行索引。
cols	稀疏矩阵中的列索引。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 741 行定义.

参考 libMesh::DenseMatrix< T >::get_values(), libMesh::initialized(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::numeric_petsc_cast() , 以及 libMesh::pPS().

 {
   libmesh_assert (this->initialized());
 
   const numeric_index_type n_rows = dm.m();
   const numeric_index_type n_cols = dm.n();
 
   libmesh_assert_equal_to (rows.size(), n_rows);
   libmesh_assert_equal_to (cols.size(), n_cols);
 
   PetscErrorCode ierr=0;
   ierr = MatSetValues(_mat,
                       n_rows, numeric_petsc_cast(rows.data()),
                       n_cols, numeric_petsc_cast(cols.data()),
                       pPS(const_cast<T*>(dm.get_values().data())),
                       ADD_VALUES);
   LIBMESH_CHKERR(ierr);
 }

template<typename T >

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

overridevirtual

将稠密矩阵添加到此稀疏矩阵的指定位置。

参数

dm	要添加的稠密矩阵。
dof_indices	稀疏矩阵中的行和列索引。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1145 行定义.

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

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

将标量乘以稀疏矩阵 spm 添加到此矩阵的指定行和列。

参数

spm	要添加的稀疏矩阵。
row_ltog	行的本地到全局索引映射。
col_ltog	列的本地到全局索引映射。
scalar	乘以 spm 的标量值。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 1221 行定义.

参考 libMesh::closed(), libMesh::SparseMatrix< T >::m(), libMesh::SparseMatrix< T >::n() , 以及 libMesh::PS().

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

template<typename T >

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

inherited

设置要使用的 DofMap 的指针。如果不使用单独的稀疏性模式，则使用来自 DofMap 的模式。

dof_map 的生命周期必须超过 this 的生命周期。

在文件 sparse_matrix.C 第 58 行定义.

参考 libMesh::DofMap::get_sparsity_pattern().

参考自 libMesh::DofMap::update_sparsity_pattern().

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

template<typename T >

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

inherited

设置要使用的稀疏性模式的指针。在矩阵需要比系统中的大（或更小以提高效率）的模式，或者在 DofMap 未计算系统稀疏性模式的情况下使用。

sp 的生命周期必须超过 this 的生命周期。

在文件 sparse_matrix.C 第 68 行定义.

参考自 libMesh::DofMap::update_sparsity_pattern().

 {
   _sp = &sp;
 }

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

使用由 solver_package 指定的线性求解器包构建一个 SparseMatrix<T>。

在文件 sparse_matrix.C 第 151 行定义.

参考 libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS, libMesh::libmesh_ignore() , 以及 libMesh::TRILINOS_SOLVERS.

参考自 libMesh::DofMap::process_mesh_constraint_rows().

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

template<typename T >

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

overridevirtualnoexcept

clear() 在析构函数中调用，因此它不应该抛出异常。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 503 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized , 以及 libMesh::initialized().

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

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::PetscMatrix< T >::clone ( ) const

overridevirtual

克隆当前矩阵。

返回: 返回当前矩阵的唯一指针副本。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 483 行定义.

参考 libMesh::closed().

 {
   libmesh_error_msg_if(!this->closed(), "Matrix must be closed before it can be cloned!");
 
   // Copy the nonzero pattern and numerical values
   Mat copy;
   PetscErrorCode ierr = MatDuplicate(_mat, MAT_COPY_VALUES, &copy);
   LIBMESH_CHKERR(ierr);
 
   // Call wrapping PetscMatrix constructor, have it take over
   // ownership.
   auto ret = std::make_unique<PetscMatrix<T>>(copy, this->comm());
   ret->set_destroy_mat_on_exit(true);
 
   // Work around an issue on older compilers.  We are able to simply
   // "return ret;" on newer compilers
   return std::unique_ptr<SparseMatrix<T>>(ret.release());
 }

template<typename T >

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

overridevirtual

完成任何挂起的插入或添加操作。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 983 行定义.

参考自 libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::PetscMatrix< T >::create_submatrix_nosort() , 以及 libMesh::PetscMatrix< T >::get_transpose().

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

template<typename T >

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

overridevirtual

检查矩阵是否已经关闭，即所有的插入和添加操作是否已经完成。

返回: 如果矩阵已经关闭，则返回 true；否则返回 false。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1390 行定义.

参考 libMesh::initialized().

参考自 libMesh::PetscMatrix< T >::add().

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

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

此函数创建一个名为 "submatrix" 的矩阵，其定义由 "rows" 和 "cols" 条目中的行和列索引给定。目前，此操作仅对 PetscMatrix 类型定义。注意：rows 和 cols 向量需要排序；如果 rows 和 cols 向量未排序，则使用下面的 nosort 版本； rows 和 cols 仅包含由此处理器拥有的索引。

在文件 sparse_matrix.h 第 388 行定义.

参考 libMesh::SparseMatrix< T >::_get_submatrix().

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

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

根据给定的 rows 和 cols 向量中的索引创建一个子矩阵，类似于 create_submatrix 函数。

参数

submatrix	存储创建的子矩阵。
rows	定义子矩阵的行索引。
cols	定义子矩阵的列索引。

注解: rows 和 cols 可以是未排序的；如果你的索引是排序的，使用上面的函数可以获得更好的效率； rows 和 cols 可以包含由其他处理器拥有的索引。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 863 行定义.

参考 libMesh::SparseMatrix< T >::_is_initialized, libMesh::PetscMatrix< T >::_mat, libMesh::PetscMatrix< T >::close() , 以及 libMesh::closed().

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

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

在文件 reference_counter.C 第 100 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = false;
   return;
 }

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

在文件 reference_counter.C 第 94 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

template<typename T >

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

overridevirtual

刷新矩阵的内部缓冲区，确保所有操作都已完成。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 998 行定义.

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

template<typename T >

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

overridevirtual

获取矩阵的对角线并将其存储在给定的向量中。

参数

dest 存储对角线的向量。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 937 行定义.

参考 libMesh::PetscVector< T >::vec().

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

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

staticinherited

Gets a string containing the reference information.

在文件 reference_counter.C 第 47 行定义.

参考 libMesh::ReferenceCounter::_counts.

参考自 libMesh::ReferenceCounter::print_info().

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & [name, cd] : _counts)
     oss << "| " << name << " reference count information:\n"
         << "|  Creations:    " << cd.first    << '\n'
         << "|  Destructions: " << cd.second << '\n';
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

template<typename T >

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

获取由该进程拥有的矩阵行数和列数。

参数

m	行大小。
n	列大小。

在文件 petsc_matrix.C 第 1062 行定义.

参考 libMesh::initialized().

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

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

获取矩阵中指定行的索引和值。

参数

i	行索引。
indices	存储该行中非零元素的列索引的向量。
values	存储该行中非零元素的值的向量。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 1333 行定义.

参考 libMesh::closed() , 以及 libMesh::initialized().

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

template<typename T >

void libMesh::PetscMatrix< T >::get_transpose ( SparseMatrix< T > & dest ) const

overridevirtual

获取矩阵的转置。

参数

dest	存储转置矩阵的对象。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 950 行定义.

参考 libMesh::SparseMatrix< T >::_is_initialized, libMesh::PetscMatrix< T >::_mat, libMesh::SparseMatrix< T >::clear() , 以及 libMesh::PetscMatrix< T >::close().

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

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.

在文件 reference_counter.h 第 183 行定义.

参考 libMesh::err.

参考自 libMesh::ReferenceCountedObject< SparseMatrix< T > >::ReferenceCountedObject().

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

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.

在文件 reference_counter.h 第 207 行定义.

参考 libMesh::err.

参考自 libMesh::ReferenceCountedObject< SparseMatrix< T > >::~ReferenceCountedObject().

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

template<typename T >

void libMesh::PetscMatrix< T >::init	(	const numeric_index_type	m,
		const numeric_index_type	n,
		const numeric_index_type	m_l,
		const numeric_index_type	n_l,
		const numeric_index_type	nnz = `30`,
		const numeric_index_type	noz = `10`,
		const numeric_index_type	blocksize = `1`
	)

overridevirtual

初始化 PETSc 矩阵。

参数

m	全局行数。
n	全局列数。
m_l	本地行数。
n_l	本地列数。
nnz	对角线部分本地子矩阵中每行的非零元素数。
noz	非对角线部分本地子矩阵中每行的非零元素数。
blocksize	多个相同类型变量的系统中，用于指示密集耦合块的可选值。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 121 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized, libMesh::AIJ, libMesh::HYPRE, libMesh::initialized(), libMesh::libmesh_ignore() , 以及 libMesh::zero.

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

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

初始化 PETSc 矩阵。

参数

m	全局行数。
n	全局列数。
m_l	本地行数。
n_l	本地列数。
n_nz	包含本地子矩阵对角线部分每行的非零元素数的数组。
n_oz	包含本地子矩阵非对角线部分每行的非零元素数的数组。
blocksize	多个相同类型变量的系统中，用于指示密集耦合块的可选值。

在文件 petsc_matrix.C 第 237 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized, libMesh::AIJ, libMesh::HYPRE, libMesh::initialized(), libMesh::libmesh_ignore(), libMesh::numeric_petsc_cast() , 以及 libMesh::zero.

 {
   // So compilers don't warn when !LIBMESH_ENABLE_BLOCKED_STORAGE
   libmesh_ignore(blocksize_in);
 
   PetscInt blocksize  = static_cast<PetscInt>(blocksize_in);
 
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
 
   this->_is_initialized = true;
 
   // Make sure the sparsity pattern isn't empty unless the matrix is 0x0
   libmesh_assert_equal_to (n_nz.size(), m_l);
   libmesh_assert_equal_to (n_oz.size(), m_l);
 
   PetscErrorCode ierr = 0;
   PetscInt m_global   = static_cast<PetscInt>(m_in);
   PetscInt n_global   = static_cast<PetscInt>(n_in);
   PetscInt m_local    = static_cast<PetscInt>(m_l);
   PetscInt n_local    = static_cast<PetscInt>(n_l);
 
   ierr = MatCreate(this->comm().get(), &_mat);
   LIBMESH_CHKERR(ierr);
   ierr = MatSetSizes(_mat, m_local, n_local, m_global, n_global);
   LIBMESH_CHKERR(ierr);
   ierr = MatSetBlockSize(_mat,blocksize);
   LIBMESH_CHKERR(ierr);
 
 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
   if (blocksize > 1)
     {
       // specified blocksize, bs>1.
       // double check sizes.
       libmesh_assert_equal_to (m_local  % blocksize, 0);
       libmesh_assert_equal_to (n_local  % blocksize, 0);
       libmesh_assert_equal_to (m_global % blocksize, 0);
       libmesh_assert_equal_to (n_global % blocksize, 0);
 
       ierr = MatSetType(_mat, MATBAIJ); // Automatically chooses seqbaij or mpibaij
       LIBMESH_CHKERR(ierr);
 
       // MatSetFromOptions needs to happen before Preallocation routines
       // since MatSetFromOptions can change matrix type and remove incompatible
       // preallocation
       LIBMESH_CHKERR(ierr);
       ierr = MatSetOptionsPrefix(_mat, "");
       LIBMESH_CHKERR(ierr);
       ierr = MatSetFromOptions(_mat);
       LIBMESH_CHKERR(ierr);
       // transform the per-entry n_nz and n_oz arrays into their block counterparts.
       std::vector<numeric_index_type> b_n_nz, b_n_oz;
 
       transform_preallocation_arrays (blocksize,
                                       n_nz, n_oz,
                                       b_n_nz, b_n_oz);
 
       ierr = MatSeqBAIJSetPreallocation (_mat,
                                          blocksize,
                                          0,
                                          numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data()));
       LIBMESH_CHKERR(ierr);
 
       ierr = MatMPIBAIJSetPreallocation (_mat,
                                          blocksize,
                                          0,
                                          numeric_petsc_cast(b_n_nz.empty() ? nullptr : b_n_nz.data()),
                                          0,
                                          numeric_petsc_cast(b_n_oz.empty() ? nullptr : b_n_oz.data()));
       LIBMESH_CHKERR(ierr);
     }
   else
 #endif
     {
       switch (_mat_type) {
         case AIJ:
           ierr = MatSetType(_mat, MATAIJ); // Automatically chooses seqaij or mpiaij
           LIBMESH_CHKERR(ierr);
 
           // MatSetFromOptions needs to happen before Preallocation routines
           // since MatSetFromOptions can change matrix type and remove incompatible
           // preallocation
           LIBMESH_CHKERR(ierr);
           ierr = MatSetOptionsPrefix(_mat, "");
           LIBMESH_CHKERR(ierr);
           ierr = MatSetFromOptions(_mat);
           LIBMESH_CHKERR(ierr);
           ierr = MatSeqAIJSetPreallocation (_mat,
                                             0,
                                             numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()));
           LIBMESH_CHKERR(ierr);
           ierr = MatMPIAIJSetPreallocation (_mat,
                                             0,
                                             numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
                                             0,
                                             numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data()));
           break;
 
         case HYPRE:
 #if !PETSC_VERSION_LESS_THAN(3,9,4) && LIBMESH_HAVE_PETSC_HYPRE
           ierr = MatSetType(_mat, MATHYPRE);
           LIBMESH_CHKERR(ierr);
 
           // MatSetFromOptions needs to happen before Preallocation routines
           // since MatSetFromOptions can change matrix type and remove incompatible
           // preallocation
           LIBMESH_CHKERR(ierr);
           ierr = MatSetOptionsPrefix(_mat, "");
           LIBMESH_CHKERR(ierr);
           ierr = MatSetFromOptions(_mat);
           LIBMESH_CHKERR(ierr);
           ierr = MatHYPRESetPreallocation (_mat,
                                            0,
                                            numeric_petsc_cast(n_nz.empty() ? nullptr : n_nz.data()),
                                            0,
                                            numeric_petsc_cast(n_oz.empty() ? nullptr : n_oz.data()));
           LIBMESH_CHKERR(ierr);
 #else
           libmesh_error_msg("PETSc 3.9.4 or higher with hypre is required for MatHypre");
 #endif
           break;
 
         default: libmesh_error_msg("Unsupported petsc matrix type");
       }
 
     }
 
   // Make it an error for PETSc to allocate new nonzero entries during assembly
   ierr = MatSetOption(_mat, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
   LIBMESH_CHKERR(ierr);
   this->zero();
 }

template<typename T >

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

overridevirtual

使用由 dof_map 计算的稀疏性结构初始化此矩阵。

参数

type	矩阵的串行/并行/幽灵类型

注解: 此函数使用由 dof_map 计算的稀疏性结构初始化矩阵。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 379 行定义.

 {
   libmesh_assert(this->_dof_map);
 
   const numeric_index_type m_in = this->_dof_map->n_dofs();
   const numeric_index_type m_l  = this->_dof_map->n_dofs_on_processor(this->processor_id());
 
   const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();
   const std::vector<numeric_index_type> & n_oz = this->_sp->get_n_oz();
 
   PetscInt blocksize  = static_cast<PetscInt>(this->_dof_map->block_size());
 
   this->init(m_in, m_in, m_l, m_l, n_nz, n_oz, blocksize);
 }

template<typename T>

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

inlinevirtualinherited

返回: 如果矩阵已初始化，则为 true，否则为 false。

在文件 sparse_matrix.h 第 102 行定义.

参考 libMesh::SparseMatrix< T >::_is_initialized.

参考自 libMesh::PetscMatrix< T >::_get_submatrix().

102 { return _is_initialized; }

libMesh::SparseMatrix::_is_initialized

bool _is_initialized

标志，指示矩阵是否已初始化。

Definition: sparse_matrix.h:505

template<typename T >

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

overridevirtual

计算矩阵的 L1 范数。

返回: 返回矩阵的 L1 范数。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 522 行定义.

参考 libMesh::closed(), libMesh::initialized() , 以及 libMesh::Real.

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

template<typename T >

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

overridevirtual

计算矩阵的无穷范数。

返回: 返回矩阵的无穷范数。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 545 行定义.

参考 libMesh::closed(), libMesh::initialized() , 以及 libMesh::Real.

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

template<typename T >

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

finalvirtual

获取由该进程拥有的矩阵行数。

返回: 返回由该进程拥有的矩阵行数。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 1022 行定义.

参考 libMesh::initialized().

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

template<typename T >

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

获取由该进程拥有的矩阵列数。

返回: 返回由该进程拥有的矩阵列数。

在文件 petsc_matrix.C 第 1049 行定义.

参考 libMesh::initialized().

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

template<typename T >

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

overridevirtual

获取矩阵的行数。

返回: 返回矩阵的行数。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1008 行定义.

参考 libMesh::initialized().

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

template<typename T>

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

inline

返回原始的 PETSc 矩阵指针。

返回: 返回 PETSc 矩阵的原始指针。

注解: 这通常在用户级别的代码中不是必需的。; 不要做任何疯狂的事情，比如在它上面调用 MatDestroy()，否则可能会发生非常糟糕的事情！

在文件 petsc_matrix.h 第 455 行定义.

参考 libMesh::PetscMatrix< T >::_mat.

455 { libmesh_assert (_mat); return _mat; }

libMesh::PetscMatrix::_mat

Mat _mat

用于存储值的 PETSc 矩阵数据类型。

Definition: petsc_matrix.h:503

template<typename T >

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

overridevirtual

计算 Y = A*X，其中 A 是当前矩阵，X 是另一个矩阵。

参数

X	输入矩阵。
Y	结果矩阵。
reuse	如果 this->_mat 和 X 有相同的非零模式，并且 Y 是从之前对此函数的调用中获得的，则设置为 true。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 1185 行定义.

参考 libMesh::initialized() , 以及 libMesh::SparseMatrix< T >::m().

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

template<typename T >

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

overridevirtual

获取矩阵的列数。

返回: 返回矩阵的列数。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1035 行定义.

参考 libMesh::initialized().

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

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

inlinestaticinherited

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

在文件 reference_counter.h 第 85 行定义.

参考 libMesh::ReferenceCounter::_n_objects.

参考自 libMesh::LibMeshInit::~LibMeshInit().

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:132

template<typename T>

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

inlinevirtualinherited

返回: 如果此稀疏矩阵格式需要提供稀疏矩阵的图形，则为 true。

这对于 LaspackMatrix 是 true，但对于 PetscMatrix 是 false。在不需要完整图形的情况下，我们可以有效地近似它以提供对稀疏矩阵所需大小的良好估计。

被 libMesh::EpetraMatrix< T > , 以及 libMesh::LaspackMatrix< T > 重载.

在文件 sparse_matrix.h 第 126 行定义.

参考自 libMesh::DofMap::attach_matrix() , 以及 libMesh::DofMap::update_sparsity_pattern().

127 { return false; }

template<typename T >

T libMesh::PetscMatrix< T >::operator()	(	const numeric_index_type	i,
		const numeric_index_type	j
	)		const

overridevirtual

获取矩阵中特定位置的值。

参数

i	行索引。
j	列索引。

返回: 返回矩阵中 (i, j) 位置的值。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1276 行定义.

参考 libMesh::closed() , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   // PETSc 2.2.1 & newer
   const PetscScalar * petsc_row;
   const PetscInt    * petsc_cols;
 
   // If the entry is not in the sparse matrix, it is 0.
   T value=0.;
 
   PetscErrorCode
     ierr=0;
   PetscInt
     ncols=0,
     i_val=static_cast<PetscInt>(i_in),
     j_val=static_cast<PetscInt>(j_in);
 
 
   // the matrix needs to be closed for this to work
   // this->close();
   // but closing it is a semiparallel operation; we want operator()
   // to run on one processor.
   libmesh_assert(this->closed());
 
   ierr = MatGetRow(_mat, i_val, &ncols, &petsc_cols, &petsc_row);
   LIBMESH_CHKERR(ierr);
 
   // Perform a binary search to find the contiguous index in
   // petsc_cols (resp. petsc_row) corresponding to global index j_val
   std::pair<const PetscInt *, const PetscInt *> p =
     std::equal_range (petsc_cols, petsc_cols + ncols, j_val);
 
   // Found an entry for j_val
   if (p.first != p.second)
     {
       // The entry in the contiguous row corresponding
       // to the j_val column of interest
       const std::size_t j =
         std::distance (const_cast<PetscInt *>(petsc_cols),
                        const_cast<PetscInt *>(p.first));
 
       libmesh_assert_less (j, ncols);
       libmesh_assert_equal_to (petsc_cols[j], j_val);
 
       value = static_cast<T> (petsc_row[j]);
     }
 
   ierr  = MatRestoreRow(_mat, i_val,
                         &ncols, &petsc_cols, &petsc_row);
   LIBMESH_CHKERR(ierr);
 
   return value;
 }

template<typename T>

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

delete

template<typename T>

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

delete

template<>

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

inherited

在文件 sparse_matrix.C 第 117 行定义.

参考 std::imag() , 以及 std::real().

 {
   // std::complex<>::operator<<() is defined, but use this form
 
   if (sparse)
     {
       libmesh_not_implemented();
     }
 
   os << "Real part:" << std::endl;
   for (auto i : make_range(this->m()))
     {
       for (auto j : make_range(this->n()))
         os << std::setw(8) << (*this)(i,j).real() << " ";
       os << std::endl;
     }
 
   os << std::endl << "Imaginary part:" << std::endl;
   for (auto i : make_range(this->m()))
     {
       for (auto j : make_range(this->n()))
         os << std::setw(8) << (*this)(i,j).imag() << " ";
       os << std::endl;
     }
 }

template<typename T >

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

inherited

将矩阵的内容以统一的样式打印到屏幕上，而不考虑正在使用的矩阵/求解器包。

在文件 sparse_matrix.C 第 225 行定义.

参考 libMesh::initialized().

参考自 libMesh::EigenSparseMatrix< T >::print_personal() , 以及 libMesh::LaspackMatrix< T >::print_personal().

 {
   parallel_object_only();
 
   libmesh_assert (this->initialized());
 
   libmesh_error_msg_if(!this->_dof_map, "Error!  Trying to print a matrix with no dof_map set!");
 
   // We'll print the matrix from processor 0 to make sure
   // it's serialized properly
   if (this->processor_id() == 0)
     {
       libmesh_assert_equal_to (this->_dof_map->first_dof(), 0);
       for (numeric_index_type i=this->_dof_map->first_dof();
            i!=this->_dof_map->end_dof(); ++i)
         {
           if (sparse)
             {
               for (auto j : make_range(this->n()))
                 {
                   T c = (*this)(i,j);
                   if (c != static_cast<T>(0.0))
                     {
                       os << i << " " << j << " " << c << std::endl;
                     }
                 }
             }
           else
             {
               for (auto j : make_range(this->n()))
                 os << (*this)(i,j) << " ";
               os << std::endl;
             }
         }
 
       std::vector<numeric_index_type> ibuf, jbuf;
       std::vector<T> cbuf;
       numeric_index_type currenti = this->_dof_map->end_dof();
       for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
         {
           this->comm().receive(p, ibuf);
           this->comm().receive(p, jbuf);
           this->comm().receive(p, cbuf);
           libmesh_assert_equal_to (ibuf.size(), jbuf.size());
           libmesh_assert_equal_to (ibuf.size(), cbuf.size());
 
           if (ibuf.empty())
             continue;
           libmesh_assert_greater_equal (ibuf.front(), currenti);
           libmesh_assert_greater_equal (ibuf.back(), ibuf.front());
 
           std::size_t currentb = 0;
           for (;currenti <= ibuf.back(); ++currenti)
             {
               if (sparse)
                 {
                   for (numeric_index_type j=0; j<this->n(); j++)
                     {
                       if (currentb < ibuf.size() &&
                           ibuf[currentb] == currenti &&
                           jbuf[currentb] == j)
                         {
                           os << currenti << " " << j << " " << cbuf[currentb] << std::endl;
                           currentb++;
                         }
                     }
                 }
               else
                 {
                   for (auto j : make_range(this->n()))
                     {
                       if (currentb < ibuf.size() &&
                           ibuf[currentb] == currenti &&
                           jbuf[currentb] == j)
                         {
                           os << cbuf[currentb] << " ";
                           currentb++;
                         }
                       else
                         os << static_cast<T>(0.0) << " ";
                     }
                   os << std::endl;
                 }
             }
         }
       if (!sparse)
         {
           for (; currenti != this->m(); ++currenti)
             {
               for (numeric_index_type j=0; j<this->n(); j++)
                 os << static_cast<T>(0.0) << " ";
               os << std::endl;
             }
         }
     }
   else
     {
       std::vector<numeric_index_type> ibuf, jbuf;
       std::vector<T> cbuf;
 
       // We'll assume each processor has access to entire
       // matrix rows, so (*this)(i,j) is valid if i is a local index.
       for (numeric_index_type i=this->_dof_map->first_dof();
            i!=this->_dof_map->end_dof(); ++i)
         {
           for (auto j : make_range(this->n()))
             {
               T c = (*this)(i,j);
               if (c != static_cast<T>(0.0))
                 {
                   ibuf.push_back(i);
                   jbuf.push_back(j);
                   cbuf.push_back(c);
                 }
             }
         }
       this->comm().send(0,ibuf);
       this->comm().send(0,jbuf);
       this->comm().send(0,cbuf);
     }
 }

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

staticinherited

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

在文件 reference_counter.C 第 81 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter , 以及 libMesh::ReferenceCounter::get_info().

参考自 libMesh::LibMeshInit::~LibMeshInit().

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

template<typename T >

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

overridevirtual

将矩阵内容以 MATLAB 格式打印出来。

参数

name	输出的矩阵名称，默认为空字符串。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 568 行定义.

参考 libMesh::closed(), libMesh::WrappedPetsc< T >::get() , 以及 libMesh::initialized().

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

template<typename T >

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

overridevirtual

使用 PETSc 查看器将矩阵的内容打印到屏幕。由于我们限制了一个 PETSc 实现，所以此函数仅允许打印到标准输出。

参数

os	要写入的输出流，默认为 libMesh::out。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 635 行定义.

参考 libMesh::closed(), libMesh::initialized() , 以及 mkstemp().

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

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

此函数与上述函数类似，但允许您重用 "submatrix" 的现有稀疏性模式，而不是再次分配它。如果经常提取相同大小的子矩阵，这应该更有效。

在文件 sparse_matrix.h 第 415 行定义.

参考 libMesh::SparseMatrix< T >::_get_submatrix().

   {
     this->_get_submatrix(submatrix,
                          rows,
                          cols,
                          true); // true 表示重用 submatrix
   }

template<typename T >

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

重置矩阵以使用用户提供的原始非零模式。

在文件 petsc_matrix.C 第 402 行定义.

参考 libMesh::initialized().

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

template<typename T >

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

overridevirtual

获取本地处理的行的起始索引。

返回: 返回本地处理的行的起始索引。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1077 行定义.

参考 libMesh::initialized() , 以及 libMesh::MacroFunctions::stop().

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

template<typename T >

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

overridevirtual

获取本地处理的行的结束索引。

返回: 返回本地处理的行的结束索引。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1093 行定义.

参考 libMesh::initialized() , 以及 libMesh::MacroFunctions::stop().

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

template<typename T >

void libMesh::PetscMatrix< T >::set	(	const numeric_index_type	i,
		const numeric_index_type	j,
		const T	value
	)

overridevirtual

设置矩阵中特定位置的值。

参数

i	行索引。
j	列索引。
value	要设置的值。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 1109 行定义.

参考 libMesh::initialized().

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

template<typename T >

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

virtual

设置析构时是否删除 Mat 对象。如果设置为 false，则允许 PETSc 管理它。

参数

destroy 如果为 true，则析构时删除 Mat 对象；如果为 false，则不删除。

在文件 petsc_matrix.C 第 1404 行定义.

 {
   this->_destroy_mat_on_exit = destroy;
 }

template<typename T >

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

设置矩阵的类型（如稀疏矩阵类型）。

参数

mat_type 矩阵的类型。

在文件 petsc_matrix.C 第 115 行定义.

 {
   _mat_type = mat_type;
 }

template<typename T >

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

交换两个 PetscMatrix 的内部数据指针，不交换实际值。

参数

matrix 要交换的另一个 PetscMatrix 对象。

在文件 petsc_matrix.C 第 1411 行定义.

参考 libMesh::PetscMatrix< T >::_destroy_mat_on_exit , 以及 libMesh::PetscMatrix< T >::_mat.

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

template<typename T >

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

更新基于 dof_map 的稀疏模式，并将矩阵置零。这在稀疏模式在计算过程中发生变化的情况下很有用。

在文件 petsc_matrix.C 第 396 行定义.

 {
   libmesh_not_implemented();
 }

template<typename T>

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

inlinevirtualinherited

更新矩阵的稀疏性模式。当您的 SparseMatrix<T> 实现不需要此数据时，只需不覆盖此方法。

被 libMesh::EpetraMatrix< T > , 以及 libMesh::LaspackMatrix< T > 重载.

在文件 sparse_matrix.h 第 133 行定义.

参考自 libMesh::DofMap::update_sparsity_pattern().

133 {}

template<typename T >

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

inherited

将矩阵乘以 NumericVector arg 并将结果存储在 NumericVector dest 中。

参数

dest	存储结果的目标 NumericVector。
arg	乘法的源 NumericVector。

注解: 此函数将矩阵乘以 NumericVector arg 并将结果存储在 dest 中。

在文件 sparse_matrix.C 第 195 行定义.

参考 libMesh::NumericVector< T >::zero().

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

template<typename T >

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

inherited

将矩阵乘以 NumericVector arg ,并将结果添加到 NumericVector dest 中。

在文件 sparse_matrix.C 第 205 行定义.

参考 libMesh::NumericVector< T >::add_vector().

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

template<typename T >

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

overridevirtual

将矩阵所有元素置为零。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 417 行定义.

参考 libMesh::initialized().

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

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::PetscMatrix< T >::zero_clone ( ) const

overridevirtual

创建一个新的空矩阵，并将其所有元素置为零。

返回: 返回新创建的空矩阵的唯一指针。

实现了 libMesh::SparseMatrix< T >.

在文件 petsc_matrix.C 第 461 行定义.

参考 libMesh::closed().

 {
   libmesh_error_msg_if(!this->closed(), "Matrix must be closed before it can be cloned!");
 
   // Copy the nonzero pattern only
   Mat copy;
   PetscErrorCode ierr = MatDuplicate(_mat, MAT_DO_NOT_COPY_VALUES, &copy);
   LIBMESH_CHKERR(ierr);
 
   // Call wrapping PetscMatrix constructor, have it take over
   // ownership.
   auto ret = std::make_unique<PetscMatrix<T>>(copy, this->comm());
   ret->set_destroy_mat_on_exit(true);
 
   // Work around an issue on older compilers.  We are able to simply
   // "return ret;" on newer compilers
   return std::unique_ptr<SparseMatrix<T>>(ret.release());
 }

template<typename T >

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

overridevirtual

将指定行的所有元素置为零，并在对角线位置放置一个指定值。

参数

rows	要置零的行的索引。
diag_value	对角线上要放置的值，默认为 0.0。

重载 libMesh::SparseMatrix< T > .

在文件 petsc_matrix.C 第 438 行定义.

参考 libMesh::initialized(), libMesh::numeric_petsc_cast() , 以及 libMesh::PS().

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

类成员变量说明

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

在文件 reference_counter.h 第 124 行定义.

参考自 libMesh::ReferenceCounter::get_info().

template<typename T>

bool libMesh::PetscMatrix< T >::_destroy_mat_on_exit

private

此布尔值仅应在接受 PETSc Mat 对象的构造函数中设置为 false。

在文件 petsc_matrix.h 第 508 行定义.

参考自 libMesh::PetscMatrix< T >::swap().

template<typename T>

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

protectedinherited

与此对象关联的 DofMap 对象。可以查询其在处理器上的自由度计数。

在文件 sparse_matrix.h 第 494 行定义.

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

在文件 reference_counter.h 第 143 行定义.

参考自 libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info() , 以及 libMesh::ReferenceCounter::print_info().

template<typename T>

bool libMesh::SparseMatrix< T >::_is_initialized

protectedinherited

标志，指示矩阵是否已初始化。

在文件 sparse_matrix.h 第 505 行定义.

参考自 libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), libMesh::EpetraMatrix< T >::EpetraMatrix(), libMesh::PetscMatrix< T >::get_transpose(), libMesh::SparseMatrix< T >::initialized() , 以及 libMesh::PetscMatrix< T >::PetscMatrix().

template<typename T>

Mat libMesh::PetscMatrix< T >::_mat

private

用于存储值的 PETSc 矩阵数据类型。

在文件 petsc_matrix.h 第 503 行定义.

参考自 libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::PetscMatrix< T >::add(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), libMesh::PetscMatrix< T >::get_transpose(), libMesh::PetscMatrix< T >::mat(), libMesh::PetscMatrix< T >::PetscMatrix() , 以及 libMesh::PetscMatrix< T >::swap().

template<typename T>

PetscMatrixType libMesh::PetscMatrix< T >::_mat_type

private

存储 PETSc 矩阵的类型。

在文件 petsc_matrix.h 第 513 行定义.

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

在文件 reference_counter.h 第 137 行定义.

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

staticprotectedinherited

The number of objects.

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

在文件 reference_counter.h 第 132 行定义.

参考自 libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter() , 以及 libMesh::ReferenceCounter::~ReferenceCounter().

template<typename T>

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

mutableprivate

用于线程安全的互斥锁（C++11 线程）。

在文件 petsc_matrix.h 第 519 行定义.

template<typename T>

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

mutableprivate

用于线程安全的旋转锁。

在文件 petsc_matrix.h 第 524 行定义.

template<typename T>

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

protectedinherited

与此对象关联的 sparsity pattern。在需要时，应查询其入口计数（或使用 need_full_sparsity_pattern，模式）。

在文件 sparse_matrix.h 第 500 行定义.

该类的文档由以下文件生成:

/home/lwz/libmesh/include/numerics/petsc_matrix.h
/home/lwz/libmesh/src/numerics/petsc_matrix.C

Public 成员函数

静态 Public 成员函数

Protected 类型

Protected 成员函数

Protected 属性

静态 Protected 属性

Private 属性

详细描述

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

成员类型定义说明

构造及析构函数说明

成员函数说明

类成员变量说明

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