EigenSparseMatrix 类包装了来自 Eigen 库的稀疏矩阵对象。更多...

#include <eigen_sparse_matrix.h>

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

Public 类型
typedef EigenSM	DataType
	便捷的类型定义。更多...

typedef Eigen::Triplet< T, eigen_idx_type >	TripletType

Public 成员函数
	EigenSparseMatrix (const Parallel::Communicator &comm)
	构造函数；初始化矩阵为空，没有任何结构，即矩阵无法使用。更多...

	EigenSparseMatrix (EigenSparseMatrix &&)=default
	五个特殊函数对于这个类可以默认，因为它本身不管理任何内存。更多...

	EigenSparseMatrix (const EigenSparseMatrix &)=default

EigenSparseMatrix &	operator= (const EigenSparseMatrix &)=default

EigenSparseMatrix &	operator= (EigenSparseMatrix &&)=default

virtual	~EigenSparseMatrix ()=default

virtual void	init (const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1) override
	使用指定的大小初始化 SparseMatrix。更多...

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

virtual void	clear () override
	恢复 `SparseMatrix<T>` 到原始状态。更多...

virtual void	zero () override
	将所有条目设置为 0。更多...

virtual std::unique_ptr < SparseMatrix< T > >	zero_clone () const override

virtual std::unique_ptr < SparseMatrix< T > >	clone () const override

virtual void	close () override
	调用 SparseMatrix 的内部装配例程，确保值在处理器之间保持一致。更多...

virtual numeric_index_type	m () const override

virtual numeric_index_type	n () const override

virtual numeric_index_type	row_start () const override

virtual numeric_index_type	row_stop () const override

virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value) override
	设置元素 (i,j) 为 `value` . 更多...

virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value) override
	将 `value` 添加到元素 (i,j) . 更多...

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
	将完整矩阵 `dm` 添加到 SparseMatrix。这对于在装配时添加元素矩阵很有用。更多...

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
	与 `add_matrix` 相同，但假定行和列映射相同。因此矩阵 `dm` 必须是方阵。更多...

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

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

virtual Real	l1_norm () const override
	获取矩阵的 $\ell_1$ -范数，即最大列和： $\|M\|_1 = \max_{j} \sum_{i} \|M_{ij}\|$ 更多...

virtual Real	linfty_norm () const override
	获取矩阵的 $\ell_{\infty}$ -范数，即最大行和：更多...

virtual bool	closed () const override

virtual void	print_personal (std::ostream &os=libMesh::out) const override
	以个性化的风格（如果可用）将矩阵的内容打印到屏幕上。更多...

virtual void	get_diagonal (NumericVector< T > &dest) const override
	复制矩阵的对角线部分到 `dest。` 更多...

virtual void	get_transpose (SparseMatrix< T > &dest) const override
	将矩阵的转置复制到 `dest` 中，`dest` 可能是 *this。更多...

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>` 实现不需要此数据时，只需不覆盖此方法。更多...

virtual void	zero_rows (std::vector< numeric_index_type > &rows, T diag_value=0.0)
	将所有行条目设置为 0，然后将 `diag_value` 放在对角线条目。更多...

virtual void	flush ()
	对于 PETSc 矩阵，此函数类似于 close，但不收缩内存。当我们希望在 ADD_VALUES 和 INSERT_VALUES 之间切换时，这很有用。在使用矩阵之前应该调用 close。更多...

virtual numeric_index_type	local_m () const
	获取此进程拥有的行数。更多...

virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)
	将完整矩阵 `dm` 添加到 SparseMatrix。这对于在装配时添加元素矩阵很有用。矩阵被假定为块矩阵，`brow、bcol 对应于块行和列索引。` 更多...

virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices)
	与 `add_block_matrix()` 相同，但假定行和列映射相同。因此矩阵 `dm` 必须是方阵。更多...

virtual void	matrix_matrix_mult (SparseMatrix< T > &, SparseMatrix< T > &, bool)
	计算 Y = A*X，其中 `X` 为矩阵。更多...

virtual void	add_sparse_matrix (const SparseMatrix< T > &, const std::map< numeric_index_type, numeric_index_type > &, const std::map< numeric_index_type, numeric_index_type > &, const T)
	将 `scalar` `spm` 添加到此矩阵的行和列中： A(rows[i], cols[j]) += scalar spm(i,j) 更多...

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

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

virtual void	print_matlab (const std::string &="") const
	以 Matlab 的稀疏矩阵格式打印矩阵的内容。可选择将矩阵打印到名为 `name` 的文件中。如果未指定 `name` ,则将其转储到屏幕上。更多...

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	create_submatrix_nosort (SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &) const
	与上述函数类似，此函数创建由 `rows` 和 `cols` 向量中的索引定义的 `submatrix。` 注意：`rows` 和 `cols` 可以是无序的；如果索引已排序，则对于效率更高的操作，请使用上面的函数； `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` 中。更多...

virtual void	get_row (numeric_index_type, std::vector< numeric_index_type > &, std::vector< T > &) const
	从矩阵获取一行。更多...

静态 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 > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
	创建子矩阵和 reinit_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 属性
DataType	_mat
	实际的 Eigen::SparseMatrix<> 对象。更多...

bool	_closed
	指示矩阵是否已关闭的标志。更多...

友元
class	EigenSparseVector< T >
	使其他 Eigen 数据类型成为友元类。更多...

class	EigenSparseLinearSolver< T >

详细描述

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

EigenSparseMatrix 类包装了来自 Eigen 库的稀疏矩阵对象。

该类是一个模板类，处理不同数据类型 T 的情况。继承自 SparseMatrix<T>。

作者: Benjamin S. Kirk

日期: 2013

在文件 eigen_sparse_matrix.h 第 54 行定义.

成员类型定义说明

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>

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

便捷的类型定义。

在文件 eigen_sparse_matrix.h 第 82 行定义.

template<typename T>

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

在文件 eigen_sparse_matrix.h 第 83 行定义.

构造及析构函数说明

template<typename T >

libMesh::EigenSparseMatrix< T >::EigenSparseMatrix ( const Parallel::Communicator & comm )

构造函数；初始化矩阵为空，没有任何结构，即矩阵无法使用。

因此，该构造函数仅对作为类成员的矩阵有用。所有其他矩阵应在数据流的某个点创建，在那里所有必要的信息都是可用的。

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

参数

comm	通信器对象，指定通信环境。

在文件 eigen_sparse_matrix.C 第 163 行定义.

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

template<typename T>

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

default

五个特殊函数对于这个类可以默认，因为它本身不管理任何内存。

template<typename T>

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

default

template<typename T>

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

virtualdefault

成员函数说明

template<typename T>

virtual void libMesh::SparseMatrix< T >::_get_submatrix	(	SparseMatrix< T > &	,
		const std::vector< numeric_index_type > &	,
		const std::vector< numeric_index_type > &	,
		const bool
	)		const

inlineprotectedvirtualinherited

创建子矩阵和 reinit_submatrix 例程的受保护实现。

注解: 派生类必须在此函数中覆盖，以使其正常工作！

被 libMesh::PetscMatrix< T > 重载.

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

参考自 libMesh::SparseMatrix< T >::create_submatrix() , 以及 libMesh::SparseMatrix< T >::reinit_submatrix().

   {
     libmesh_not_implemented();
   }

template<typename T >

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

overridevirtual

将 value 添加到元素 (i,j) .

如果条目不存在，则抛出错误。可以将零值“添加”到不存在的条目中。

参数

i	矩阵行索引
j	矩阵列索引
value	元素的值

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 272 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->m());
   libmesh_assert_less (j, this->n());
 
   _mat.coeffRef(i,j) += value;
 }

template<typename T >

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

overridevirtual

计算 $A \leftarrow A + a*X$ ，其中 a 为标量，X 为矩阵。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 295 行定义.

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (this->m(), X_in.m());
   libmesh_assert_equal_to (this->n(), X_in.n());
 
   const EigenSparseMatrix<T> & X =
     cast_ref<const EigenSparseMatrix<T> &> (X_in);
 
   _mat += X._mat*a_in;
 }

template<typename T >

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

virtualinherited

将完整矩阵 dm 添加到 SparseMatrix。这对于在装配时添加元素矩阵很有用。矩阵被假定为块矩阵，brow、bcol 对应于*块*行和列索引。

被 libMesh::PetscMatrix< T > 重载.

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

参考 libMesh::DenseMatrixBase< T >::m() , 以及 libMesh::DenseMatrixBase< T >::n().

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

 {
   libmesh_assert_equal_to (dm.m() / brows.size(), dm.n() / bcols.size());
 
   const numeric_index_type blocksize = cast_int<numeric_index_type>
     (dm.m() / brows.size());
 
   libmesh_assert_equal_to (dm.m()%blocksize, 0);
   libmesh_assert_equal_to (dm.n()%blocksize, 0);
 
   std::vector<numeric_index_type> rows, cols;
 
   rows.reserve(blocksize*brows.size());
   cols.reserve(blocksize*bcols.size());
 
   for (auto & row : brows)
     {
       numeric_index_type i = row * blocksize;
 
       for (unsigned int v=0; v<blocksize; v++)
         rows.push_back(i++);
     }
 
   for (auto & col : bcols)
     {
       numeric_index_type j = col * blocksize;
 
       for (unsigned int v=0; v<blocksize; v++)
         cols.push_back(j++);
     }
 
   this->add_matrix (dm, rows, cols);
 }

template<typename T>

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

inlinevirtualinherited

与 add_block_matrix() 相同，但假定行和列映射相同。因此矩阵 dm 必须是方阵。

被 libMesh::PetscMatrix< T > 重载.

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

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

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

libMesh::SparseMatrix::add_block_matrix

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

将完整矩阵 dm 添加到 SparseMatrix。这对于在装配时添加元素矩阵很有用。矩阵被假定为块矩阵，brow、bcol 对应于*块*行和列索引。

Definition: sparse_matrix.C:77

template<typename T >

void libMesh::EigenSparseMatrix< T >::add_matrix	(	const DenseMatrix< T > &	dm,
		const std::vector< numeric_index_type > &	rows,
		const std::vector< numeric_index_type > &	cols
	)

overridevirtual

将完整矩阵 dm 添加到 SparseMatrix。这对于在装配时添加元素矩阵很有用。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 123 行定义.

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

 {
   libmesh_assert (this->initialized());
   unsigned int n_rows = cast_int<unsigned int>(rows.size());
   unsigned int n_cols = cast_int<unsigned int>(cols.size());
   libmesh_assert_equal_to (dm.m(), n_rows);
   libmesh_assert_equal_to (dm.n(), n_cols);
 
 
   for (unsigned int i=0; i<n_rows; i++)
     for (unsigned int j=0; j<n_cols; j++)
       this->add(rows[i],cols[j],dm(i,j));
 }

template<typename T >

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

overridevirtual

与 add_matrix 相同，但假定行和列映射相同。因此矩阵 dm 必须是方阵。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 286 行定义.

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

template<typename T>

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

inlinevirtualinherited

将 scalar* spm 添加到此矩阵的行和列中： A(rows[i], cols[j]) += scalar * spm(i,j)

被 libMesh::PetscMatrix< T > 重载.

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

301 { libmesh_not_implemented(); }

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::EigenSparseMatrix< T >::clear ( )

overridevirtual

恢复 SparseMatrix<T> 到原始状态。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 172 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized.

 {
   _mat.resize(0,0);
 
   _closed = false;
   this->_is_initialized = false;
 }

template<typename T >

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

overridevirtual

返回: 此矩阵的副本的智能指针。

注解: 这必须在派生类中覆盖。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 214 行定义.

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

template<typename T>

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

inlineoverridevirtual

调用 SparseMatrix 的内部装配例程，确保值在处理器之间保持一致。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.h 第 103 行定义.

参考 libMesh::EigenSparseMatrix< T >::_closed.

103 { this->_closed = true; }

libMesh::EigenSparseMatrix::_closed

bool _closed

指示矩阵是否已关闭的标志。

Definition: eigen_sparse_matrix.h:155

template<typename T>

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

inlineoverridevirtual

返回: 如果矩阵已经组装，则为 true。

实现了 libMesh::SparseMatrix< T >.

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

参考 libMesh::EigenSparseMatrix< T >::_closed.

137 { return _closed; }

libMesh::EigenSparseMatrix::_closed

bool _closed

指示矩阵是否已关闭的标志。

Definition: eigen_sparse_matrix.h:155

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>

virtual void libMesh::SparseMatrix< T >::create_submatrix_nosort	(	SparseMatrix< T > &	,
		const std::vector< numeric_index_type > &	,
		const std::vector< numeric_index_type > &
	)		const

inlinevirtualinherited

与上述函数类似，此函数创建由 rows 和 cols 向量中的索引定义的 submatrix。 注意：rows 和 cols 可以是无序的；如果索引已排序，则对于效率更高的操作，请使用上面的函数； rows 和 cols 可以包含由其他处理器拥有的索引。

被 libMesh::PetscMatrix< T > 重载.

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

   {
     libmesh_not_implemented();
   }

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>

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

inlinevirtualinherited

对于 PETSc 矩阵，此函数类似于 close，但不收缩内存。当我们希望在 ADD_VALUES 和 INSERT_VALUES 之间切换时，这很有用。在使用矩阵之前应该调用 close。

被 libMesh::PetscMatrix< T > 重载.

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

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

202 { close(); }

libMesh::SparseMatrix::close

virtual void close()=0

调用 SparseMatrix 的内部装配例程，确保值在处理器之间保持一致。

template<typename T >

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

overridevirtual

复制矩阵的对角线部分到 dest。

参数

dest	存储对角线的目标 NumericVector。

注解: 此函数将矩阵的对角线部分复制到 NumericVector dest 中。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 143 行定义.

参考 libMesh::EigenSparseVector< T >::_vec.

 {
   EigenSparseVector<T> & dest = cast_ref<EigenSparseVector<T> &>(dest_in);
 
   dest._vec = _mat.diagonal();
 }

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>

virtual void libMesh::SparseMatrix< T >::get_row	(	numeric_index_type	,
		std::vector< numeric_index_type > &	,
		std::vector< T > &
	)		const

inlinevirtualinherited

从矩阵获取一行。

参数

i	要获取的矩阵行
indices	将填充为与（可能）非零值对应的列索引的容器
values	包含列值的容器

注解: 此函数检索矩阵的一行，并将提供的容器填充为列索引和值。

被 libMesh::PetscMatrix< T > 重载.

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

   {
     libmesh_not_implemented();
   }

template<typename T >

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

overridevirtual

将矩阵的转置复制到 dest 中，dest 可能是 *this。

参数

dest	存储转置的目标 SparseMatrix。

注解: 此函数将矩阵的转置复制到 SparseMatrix dest 中。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 153 行定义.

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

 {
   EigenSparseMatrix<T> & dest = cast_ref<EigenSparseMatrix<T> &>(dest_in);
 
   dest._mat = _mat.transpose();
 }

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>

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

overridevirtual

使用指定的大小初始化 SparseMatrix。

参数

m	全局行数。
n	全局列数。
m_l	本地行数。
n_l	本地列数。
nnz	每行的对角线非零元素数（默认为 30）。
noz	每行的非对角线非零元素数（默认为 10）。
blocksize	用于具有多个相同类型变量的系统的稠密耦合块的可选值。

实现了 libMesh::SparseMatrix< T >.

template<typename T >

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

overridevirtual

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

参数

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

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

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 65 行定义.

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

 {
   // Ignore calls on initialized objects
   if (this->initialized())
     return;
 
   // We need the DofMap for this!
   libmesh_assert(this->_dof_map);
 
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
 
   const numeric_index_type n_rows   = this->_dof_map->n_dofs();
   const numeric_index_type n_cols   = n_rows;
 
 #ifndef NDEBUG
   // The following variables are only used for assertions,
   // so avoid declaring them when asserts are inactive.
   const numeric_index_type n_l = this->_dof_map->n_dofs_on_processor(0);
   const numeric_index_type m_l = n_l;
 #endif
 
   // Laspack Matrices only work for uniprocessor cases
   libmesh_assert_equal_to (n_rows, n_cols);
   libmesh_assert_equal_to (m_l, n_rows);
   libmesh_assert_equal_to (n_l, n_cols);
 
   const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();
 
 #ifndef NDEBUG
   // The following variables are only used for assertions,
   // so avoid declaring them when asserts are inactive.
   const std::vector<numeric_index_type> & n_oz = this->_sp->get_n_oz();
 #endif
 
   // Make sure the sparsity pattern isn't empty
   libmesh_assert_equal_to (n_nz.size(), n_l);
   libmesh_assert_equal_to (n_oz.size(), n_l);
 
   if (n_rows==0)
     {
       _mat.resize(0,0);
       return;
     }
 
   _mat.resize(n_rows,n_cols);
   _mat.reserve(n_nz);
 
   this->_is_initialized = true;
 
   libmesh_assert_equal_to (n_rows, this->m());
   libmesh_assert_equal_to (n_cols, this->n());
 }

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::EigenSparseMatrix< T >::l1_norm ( ) const

overridevirtual

获取矩阵的 $\ell_1$ -范数，即最大列和： $|M|_1 = \max_{j} \sum_{i} |M_{ij}|$

这是与向量的 $\ell_1$ -范数兼容的自然矩阵范数，即 $|Mv|_1 \leq |M|_1 |v|_1$ 。（参见 Haemmerlin-Hoffmann：Numerische Mathematik）

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 324 行定义.

参考 std::abs().

 {
   // There does not seem to be a straightforward way to iterate over
   // the columns of an EigenSparseMatrix.  So we use some extra
   // storage and keep track of the column sums while going over the
   // row entries...
   std::vector<Real> abs_col_sums(this->n());
 
   // For a row-major Eigen SparseMatrix like we're using, the
   // InnerIterator iterates over the non-zero entries of rows.
   for (auto row : make_range(this->m()))
     {
       EigenSM::InnerIterator it(_mat, row);
       for (; it; ++it)
         abs_col_sums[it.col()] += std::abs(it.value());
     }
 
   return *(std::max_element(abs_col_sums.begin(), abs_col_sums.end()));
 }

template<typename T >

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

overridevirtual

获取矩阵的 $\ell_{\infty}$ -范数，即最大行和：

$|M|_{\infty} = \max_{i} \sum_{j} |M_{ij}|$

这是与向量的 $\ell_{\infty}$ -范数兼容的自然矩阵范数，即 $|Mv|_{\infty} \leq |M|_{\infty} |v|_{\infty}$ 。（参见 Haemmerlin-Hoffmann：Numerische Mathematik）

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 347 行定义.

参考 std::abs() , 以及 libMesh::Real.

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

template<typename T>

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

inlinevirtualinherited

获取此进程拥有的行数。

被 libMesh::PetscMatrix< T > 重载.

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

参考 libMesh::SparseMatrix< T >::row_start() , 以及 libMesh::SparseMatrix< T >::row_stop().

212 { return row_stop() - row_start(); }

libMesh::SparseMatrix::row_stop

virtual numeric_index_type row_stop() const =0

libMesh::SparseMatrix::row_start

virtual numeric_index_type row_start() const =0

template<typename T >

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

overridevirtual

返回: 矩阵的行维度。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 222 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return cast_int<numeric_index_type>(_mat.rows());
 }

template<typename T>

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

inlinevirtualinherited

计算 Y = A*X，其中 X 为矩阵。

被 libMesh::PetscMatrix< T > 重载.

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

291 { libmesh_not_implemented(); }

template<typename T >

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

overridevirtual

返回: 矩阵的列维度。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 232 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return cast_int<numeric_index_type>(_mat.cols());
 }

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::EigenSparseMatrix< T >::operator()	(	const numeric_index_type	i,
		const numeric_index_type	j
	)		const

overridevirtual

返回: 矩阵条目 (i,j) 的副本。

注解: 这可能是一个昂贵的操作，您应该谨慎调用此函数。

参数

i	行索引。
j	列索引。

返回: 位于位置 (i,j) 的矩阵条目的副本。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 311 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->m());
   libmesh_assert_less (j, this->n());
 
   return _mat.coeff(i,j);
 }

template<typename T>

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

default

template<typename T>

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

default

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>

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

inlinevirtualinherited

以 Matlab 的稀疏矩阵格式打印矩阵的内容。可选择将矩阵打印到名为 name 的文件中。如果未指定 name ,则将其转储到屏幕上。

被 libMesh::PetscMatrix< T > 重载.

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

   {
     libmesh_not_implemented();
   }

template<typename T>

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

inlineoverridevirtual

以个性化的风格（如果可用）将矩阵的内容打印到屏幕上。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.h 第 139 行定义.

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

139 { this->print(os); }

libMesh::SparseMatrix::print

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

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

Definition: sparse_matrix.C:225

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 >

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

overridevirtual

返回: 存储在此处理器上的第一个矩阵行的索引。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 242 行定义.

 {
   return 0;
 }

template<typename T >

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

overridevirtual

返回: 存储在此处理器上的最后一个矩阵行（+1）的索引。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 250 行定义.

 {
   return this->m();
 }

template<typename T >

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

overridevirtual

设置元素 (i,j) 为 value .

如果条目不存在,则抛出错误。可以将零值“存储”在不存在的字段中。

参数

i	矩阵行索引
j	矩阵列索引
value	元素的值

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 258 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->m());
   libmesh_assert_less (j, this->n());
 
   _mat.coeffRef(i,j) = value;
 }

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::EigenSparseMatrix< T >::zero ( )

overridevirtual

将所有条目设置为 0。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 183 行定义.

 {
   // This doesn't just zero, it clears the entire non-zero structure!
   _mat.setZero();
 
   if (this->_sp)
   {
     // Re-reserve our non-zero structure
     const std::vector<numeric_index_type> & n_nz = this->_sp->get_n_nz();
     _mat.reserve(n_nz);
   }
 }

template<typename T >

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

overridevirtual

返回: 具有相同类型、大小和分区的此矩阵的零条目的副本的智能指针。

注解: 这必须在派生类中覆盖。

实现了 libMesh::SparseMatrix< T >.

在文件 eigen_sparse_matrix.C 第 199 行定义.

 {
   // TODO: If there is a more efficient way to make a zeroed-out copy
   // of an EigenSM, we should call that instead.
   auto ret = std::make_unique<EigenSparseMatrix<T>>(*this);
   ret->zero();
 
   // Work around an issue on older compilers.  We are able to simply
   // "return ret;" on newer compilers
   return std::unique_ptr<SparseMatrix<T>>(ret.release());
 }

template<typename T >

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

virtualinherited

将所有行条目设置为 0，然后将 diag_value 放在对角线条目。

被 libMesh::DiagonalMatrix< T > , 以及 libMesh::PetscMatrix< T > 重载.

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

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

友元及相关函数文档

template<typename T>

friend class EigenSparseLinearSolver< T >

friend

在文件 eigen_sparse_matrix.h 第 161 行定义.

template<typename T>

friend class EigenSparseVector< T >

friend

使其他 Eigen 数据类型成为友元类。

在文件 eigen_sparse_matrix.h 第 160 行定义.

类成员变量说明

template<typename T>

bool libMesh::EigenSparseMatrix< T >::_closed

private

指示矩阵是否已关闭的标志。

在文件 eigen_sparse_matrix.h 第 155 行定义.

参考自 libMesh::EigenSparseMatrix< T >::close() , 以及 libMesh::EigenSparseMatrix< T >::closed().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

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

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

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>

DataType libMesh::EigenSparseMatrix< T >::_mat

private

实际的 Eigen::SparseMatrix<> 对象。

在文件 eigen_sparse_matrix.h 第 150 行定义.

参考自 libMesh::EigenSparseMatrix< T >::add() , 以及 libMesh::EigenSparseMatrix< T >::get_transpose().

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>

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

protectedinherited

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

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

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

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

Public 类型

Public 成员函数

静态 Public 成员函数

Protected 类型

Protected 成员函数

Protected 属性

静态 Protected 属性

Private 属性

友元

详细描述

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

成员类型定义说明

构造及析构函数说明

成员函数说明

友元及相关函数文档

类成员变量说明

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