libMesh::LaspackMatrix< T > 模板类 参考

LaspackMatrix类封装了Laspack库中的QMatrix对象。 目前，Laspack仅支持实数数据类型，因此这个类是对 SparseMatrix<T> 的全特化，其中 T = Real。 所有重写的虚拟函数在 sparse_matrix.h 中有文档说明。 更多...

#include <laspack_matrix.h>

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

Public 成员函数
	LaspackMatrix (const Parallel::Communicator &comm)
	构造函数；将矩阵初始化为空，没有任何结构，即矩阵无法使用。因此，此构造函数仅适用于类的成员矩阵。 所有其他矩阵应在所有必要信息都可用的数据流的某一点创建。 更多...
	LaspackMatrix (LaspackMatrix &&)=delete
	此类手动管理C风格的结构（QMatrix），因此我们不希望生成任何自动复制/移动函数， 且不能默认析构函数。 更多...
	LaspackMatrix (const LaspackMatrix &)=delete
LaspackMatrix &	operator= (const LaspackMatrix &)=delete
LaspackMatrix &	operator= (LaspackMatrix &&)=delete
virtual	~LaspackMatrix ()
virtual bool	need_full_sparsity_pattern () const override
	LaspackMatrix 需要完整的稀疏性模式。 更多...
virtual void	update_sparsity_pattern (const SparsityPattern::Graph &) override
	更新矩阵的稀疏性模式。这将告诉底层矩阵存储方案如何映射 元素。 更多...
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
	初始化LaspackMatrix对象的属性，包括矩阵的行数、列数、非零元素的预估数量等。这些参数将影响矩阵的内存分配和性能。 更多...
virtual void	init (ParallelType=PARALLEL) override
	初始化LaspackMatrix对象，指定并行类型（默认为PARALLEL）。 这个函数用于指定矩阵的并行计算方式。 更多...
virtual void	clear () override
	清空LaspackMatrix对象，释放分配的内存和资源。 这个函数用于清除矩阵的数据和状态。 更多...
virtual void	zero () override
	将LaspackMatrix对象的所有元素置零。 这个函数用于将矩阵中的所有元素设置为零。 更多...
virtual std::unique_ptr < SparseMatrix< T > >	zero_clone () const override
	创建一个与LaspackMatrix对象具有相同属性但所有元素为零的新矩阵。 这个函数用于创建一个与原矩阵具有相同大小和属性的全零矩阵。 更多...
virtual std::unique_ptr < SparseMatrix< T > >	clone () const override
	克隆LaspackMatrix对象，创建一个具有相同属性和数据的新矩阵。 这个函数用于创建一个与原矩阵具有相同大小、属性和数据的新矩阵。 更多...
virtual void	close () override
	关闭LaspackMatrix对象，标记矩阵已经完成构建，不再修改其结构。 这个函数用于标记矩阵的状态为已完成构建，之后不再修改其结构。 更多...
virtual numeric_index_type	m () const override
	返回LaspackMatrix对象的行数。 这个函数用于获取矩阵的行数。 更多...
virtual numeric_index_type	n () const override
	返回LaspackMatrix对象的列数。 这个函数用于获取矩阵的列数。 更多...
virtual numeric_index_type	row_start () const override
	返回LaspackMatrix对象的行起始位置。 这个函数用于获取矩阵的行起始位置，通常用于稀疏矩阵的索引操作。 更多...
virtual numeric_index_type	row_stop () const override
	返回LaspackMatrix对象的行结束位置。 这个函数用于获取矩阵的行结束位置，通常用于稀疏矩阵的索引操作。 更多...
virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value) override
	设置LaspackMatrix对象的指定位置 处的值为 value。 更多...
virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value) override
	将 处的值增加 value。 更多...
virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
	将一个DenseMatrix对象的元素加到LaspackMatrix对象的指定行和列。 更多...
virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
	将一个DenseMatrix对象的元素加到LaspackMatrix对象的指定自由度索引。 更多...
virtual void	add (const T a, const SparseMatrix< T > &X) override
	计算矩阵 的 ，其中 是标量， 是矩阵。 计算结果存储在LaspackMatrix对象中。 更多...
virtual T	operator() (const numeric_index_type i, const numeric_index_type j) const override
	获取LaspackMatrix对象的指定位置 处的值。 这个函数用于获取矩阵的特定元素的值。 更多...
virtual Real	l1_norm () const override
	返回矩阵的 范数。当前未实现。 更多...
virtual Real	linfty_norm () const override
	返回矩阵的 范数。当前未实现。 更多...
virtual bool	closed () const override
	检查LaspackMatrix对象是否已关闭。 这个函数用于检查矩阵是否已经完成构建并关闭，不再修改其结构。 更多...
virtual void	print_personal (std::ostream &os=libMesh::out) const override
	打印LaspackMatrix对象的信息到指定的输出流（默认为libMesh::out）。 这个函数用于将矩阵的信息输出到指定的输出流中。 更多...
virtual void	get_diagonal (NumericVector< T > &dest) const override
	获取矩阵的对角线元素，并存储到指定的NumericVector对象中。 这个函数用于获取矩阵的对角线元素。 更多...
virtual void	get_transpose (SparseMatrix< T > &dest) const override
	获取矩阵的转置，并存储到指定的SparseMatrix对象中。 这个函数用于获取矩阵的转置矩阵。 更多...
virtual bool	initialized () const
void	attach_dof_map (const DofMap &dof_map)
	设置要使用的 DofMap 的指针。如果不使用单独的稀疏性模式， 则使用来自 DofMap 的模式。 更多...
void	attach_sparsity_pattern (const SparsityPattern::Build &sp)
	设置要使用的稀疏性模式的指针。在矩阵需要比系统中的大（或更小以提高效率）的模式， 或者在 DofMap 未计算系统稀疏性模式的情况下使用。 更多...
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 成员函数
numeric_index_type	pos (const numeric_index_type i, const numeric_index_type j) const

Private 属性
QMatrix	_QMat
	Laspack稀疏矩阵指针。 更多...
std::vector< numeric_index_type >	_csr
	压缩行索引。 更多...
std::vector< std::vector < numeric_index_type > ::const_iterator >	_row_start
	压缩行索引数据结构中每行的起始位置。 更多...
bool	_closed
	指示矩阵是否已关闭的标志。 更多...

友元
class	LaspackVector< T >
	使其他Laspack数据类型成为友元类。 更多...
class	LaspackLinearSolver< T >

详细描述

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

LaspackMatrix类封装了Laspack库中的QMatrix对象。 目前，Laspack仅支持实数数据类型，因此这个类是对 SparseMatrix<T> 的全特化，其中 T = Real。 所有重写的虚拟函数在 sparse_matrix.h 中有文档说明。

作者

Benjamin S. Kirk

日期

2003

<T>的特化版本，其中T为Real类型。该类提供了与SparseMatrix相关的功能，并使用Laspack库进行实际计算。

在文件 laspack_matrix.h 第 56 行定义.

成员类型定义说明

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::LaspackMatrix< T >::LaspackMatrix

(

const Parallel::Communicator &

comm

)

构造函数；将矩阵初始化为空，没有任何结构，即矩阵无法使用。因此，此构造函数仅适用于类的成员矩阵。 所有其他矩阵应在所有必要信息都可用的数据流的某一点创建。

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

参数

comm	通信器，用于并行计算。

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

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

template<typename T >

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

delete

此类手动管理C风格的结构（QMatrix），因此我们不希望生成任何自动复制/移动函数， 且不能默认析构函数。

template<typename T >

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

delete

template<typename T >

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

virtual

在文件 laspack_matrix.C 第 246 行定义.

{
  this->clear ();
}

成员函数说明

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::LaspackMatrix< T >::add ( const numeric_index_type  i, const numeric_index_type  j, const T  value  )

overridevirtual

将 处的值增加 value。

参数

i	指定元素的行索引。
j	指定元素的列索引。
value	要增加的值。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 388 行定义.

参考 libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());

  const numeric_index_type position = this->pos(i,j);

  // Sanity check
  libmesh_assert_equal_to (*(_row_start[i]+position), j);

  Q_AddVal (&_QMat, i+1, position, value);
}

template<typename T >

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

overridevirtual

计算矩阵 的 ，其中 是标量， 是矩阵。 计算结果存储在LaspackMatrix对象中。

参数

a	标量值。
X	要与矩阵相乘的SparseMatrix对象。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 416 行定义.

参考 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 LaspackMatrix<T> * X =
    cast_ptr<const LaspackMatrix<T> *> (&X_in);

  _LPNumber a = static_cast<_LPNumber> (a_in);

  libmesh_assert(X);

  // loops taken from LaspackMatrix<T>::zero ()

  const numeric_index_type n_rows = this->m();

  for (numeric_index_type row=0; row<n_rows; row++)
    {
      auto r_start = _row_start[row];

      const numeric_index_type len = (_row_start[row+1] - _row_start[row]);

      // Make sure we agree on the row length
      libmesh_assert_equal_to (len, Q_GetLen(&_QMat, row+1));
      // compare matrix sparsity structures
      libmesh_assert_equal_to (len, Q_GetLen(&(X->_QMat), row+1));


      for (numeric_index_type l=0; l<len; l++)
        {
          const numeric_index_type j = *(r_start + l);

          // Make sure the data structures are working
          libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, row+1, l));

          const _LPNumber value = a * Q_GetEl(const_cast<QMatrix*>(&(X->_QMat)), row+1, j+1);
          Q_AddVal   (&_QMat, row+1, l, value);
        }
    }
}

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

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

template<typename T >

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

overridevirtual

将一个DenseMatrix对象的元素加到LaspackMatrix对象的指定行和列。

参数

dm	包含要添加的元素的DenseMatrix对象。
rows	要添加的元素所在的行索引。
cols	要添加的元素所在的列索引。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 201 行定义.

参考 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::LaspackMatrix< T >::add_matrix ( const DenseMatrix< T > &  dm, const std::vector< numeric_index_type > &  dof_indices  )

overridevirtual

将一个DenseMatrix对象的元素加到LaspackMatrix对象的指定自由度索引。

参数

dm	包含要添加的元素的DenseMatrix对象。
dof_indices	要添加的元素所在的自由度索引。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 407 行定义.

{
  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 行定义.

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

overridevirtual

清空LaspackMatrix对象，释放分配的内存和资源。 这个函数用于清除矩阵的数据和状态。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 254 行定义.

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

{
  if (this->initialized())
    {
      Q_Destr(&_QMat);
    }

  _csr.clear();
  _row_start.clear();
  _closed = false;
  this->_is_initialized = false;
}

template<typename T >

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

overridevirtual

克隆LaspackMatrix对象，创建一个具有相同属性和数据的新矩阵。 这个函数用于创建一个与原矩阵具有相同大小、属性和数据的新矩阵。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 319 行定义.

{
  // We don't currently have a faster implementation than making a
  // zero clone and then filling in the values.
  auto mat_copy = this->zero_clone();
  mat_copy->add(1., *this);

  // Work around an issue on older compilers.  We are able to simply
  // "return mat_copy;" on newer compilers
  return std::unique_ptr<SparseMatrix<T>>(mat_copy.release());
}

template<typename T >

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

overridevirtual

关闭LaspackMatrix对象，标记矩阵已经完成构建，不再修改其结构。 这个函数用于标记矩阵的状态为已完成构建，之后不再修改其结构。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 499 行定义.

参考 libMesh::initialized().

{
  libmesh_assert(this->initialized());

  this->_closed = true;

  // We've probably changed some entries so we need to tell LASPACK
  // that cached data is now invalid.
  *_QMat.DiagElAlloc = _LPFalse;
  *_QMat.ElSorted = _LPFalse;
  if (*_QMat.ILUExists)
    {
      *_QMat.ILUExists = _LPFalse;
      Q_Destr(_QMat.ILU);
    }
}

template<typename T >

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

inlineoverridevirtual

检查LaspackMatrix对象是否已关闭。 这个函数用于检查矩阵是否已经完成构建并关闭，不再修改其结构。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.h 第 244 行定义.

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

{ return _closed; }

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

{ close(); }

template<typename T >

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

overridevirtual

获取矩阵的对角线元素，并存储到指定的NumericVector对象中。 这个函数用于获取矩阵的对角线元素。

参数

dest	存储矩阵对角线元素的NumericVector对象。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 221 行定义.

{
  libmesh_not_implemented();
}

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::LaspackMatrix< T >::get_transpose ( SparseMatrix< T > &  dest ) const

overridevirtual

获取矩阵的转置，并存储到指定的SparseMatrix对象中。 这个函数用于获取矩阵的转置矩阵。

参数

dest	存储矩阵转置的SparseMatrix对象。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 229 行定义.

{
  libmesh_not_implemented();
}

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::LaspackMatrix< 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

初始化LaspackMatrix对象的属性，包括矩阵的行数、列数、非零元素的预估数量等。这些参数将影响矩阵的内存分配和性能。

参数

m	矩阵的行数。
n	矩阵的列数。
m_l	矩阵的局部行数（仅在并行计算中使用）。
n_l	矩阵的局部列数（仅在并行计算中使用）。
nnz	非零元素的预估数量（默认为30）。
noz	零元素的预估数量（默认为10）。
blocksize	矩阵的块大小（默认为1）。

实现了 libMesh::SparseMatrix< T >.

template<typename T >

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

overridevirtual

初始化LaspackMatrix对象，指定并行类型（默认为PARALLEL）。 这个函数用于指定矩阵的并行计算方式。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 150 行定义.

参考 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();
#ifndef NDEBUG
  // The following variables are only used for assertions,
  // so avoid declaring them when asserts are inactive.
  const numeric_index_type n_cols   = n_rows;
  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);

#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_nz = this->_sp->get_n_nz();
  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)
    return;

  Q_Constr(&_QMat, const_cast<char *>("Mat"), n_rows, _LPFalse, Rowws, Normal, _LPTrue);

  this->_is_initialized = true;

  libmesh_assert_equal_to (n_rows, this->m());
}

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

{ return _is_initialized; }

template<typename T >

virtual Real libMesh::LaspackMatrix< T >::l1_norm ( ) const

inlineoverridevirtual

返回矩阵的 范数。当前未实现。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.h 第 233 行定义.

{ libmesh_not_implemented(); return 0.; }

template<typename T >

virtual Real libMesh::LaspackMatrix< T >::linfty_norm ( ) const

inlineoverridevirtual

返回矩阵的 范数。当前未实现。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.h 第 238 行定义.

{ libmesh_not_implemented(); return 0.; }

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

{ return row_stop() - row_start(); }

template<typename T >

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

overridevirtual

返回LaspackMatrix对象的行数。 这个函数用于获取矩阵的行数。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 332 行定义.

参考 libMesh::initialized().

{
  libmesh_assert (this->initialized());

  return static_cast<numeric_index_type>(Q_GetDim(const_cast<QMatrix*>(&_QMat)));
}

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 行定义.

  { libmesh_not_implemented(); }

template<typename T >

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

overridevirtual

返回LaspackMatrix对象的列数。 这个函数用于获取矩阵的列数。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 342 行定义.

参考 libMesh::initialized().

{
  libmesh_assert (this->initialized());

  return static_cast<numeric_index_type>(Q_GetDim(const_cast<QMatrix*>(&_QMat)));
}

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

  { return _n_objects; }

template<typename T >

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

inlineoverridevirtual

LaspackMatrix 需要完整的稀疏性模式。

重载 libMesh::SparseMatrix< T > .

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

  { return true; }

template<typename T >

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

overridevirtual

获取LaspackMatrix对象的指定位置 处的值。 这个函数用于获取矩阵的特定元素的值。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 462 行定义.

参考 libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());

  return Q_GetEl (const_cast<QMatrix*>(&_QMat), i+1, j+1);
}

template<typename T >

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

delete

template<typename T >

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

delete

template<typename T >

numeric_index_type libMesh::LaspackMatrix< T >::pos ( const numeric_index_type  i, const numeric_index_type  j  ) const

private

返回

压缩行存储方案中 元素的位置。

参数

i	行索引。
j	列索引。

在文件 laspack_matrix.C 第 475 行定义.

{
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());
  libmesh_assert_less (i+1, _row_start.size());
  libmesh_assert (_row_start.back() == _csr.end());

  // note this requires the _csr to be sorted
  auto p = std::equal_range (_row_start[i], _row_start[i+1], j);

  // Make sure the row contains the element j
  libmesh_assert (p.first != p.second);

  // Make sure the values match
  libmesh_assert (*p.first == j);

  // Return the position in the compressed row
  return std::distance (_row_start[i], p.first);
}

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::LaspackMatrix< T >::print_personal ( std::ostream &  os = libMesh::out ) const

inlineoverridevirtual

打印LaspackMatrix对象的信息到指定的输出流（默认为libMesh::out）。 这个函数用于将矩阵的信息输出到指定的输出流中。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.h 第 250 行定义.

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

{ this->print(os); }

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::LaspackMatrix< T >::row_start ( ) const

overridevirtual

返回LaspackMatrix对象的行起始位置。 这个函数用于获取矩阵的行起始位置，通常用于稀疏矩阵的索引操作。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 352 行定义.

{
  return 0;
}

template<typename T >

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

overridevirtual

返回LaspackMatrix对象的行结束位置。 这个函数用于获取矩阵的行结束位置，通常用于稀疏矩阵的索引操作。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 360 行定义.

{
  return this->m();
}

template<typename T >

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

overridevirtual

设置LaspackMatrix对象的指定位置 处的值为 value。

参数

i	指定元素的行索引。
j	指定元素的列索引。
value	要设置的值。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 368 行定义.

参考 libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->m());
  libmesh_assert_less (j, this->n());

  const numeric_index_type position = this->pos(i,j);

  // Sanity check
  libmesh_assert_equal_to (*(_row_start[i]+position), j);
  libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, i+1, position));

  Q_SetEntry (&_QMat, i+1, position, j+1, value);
}

template<typename T >

void libMesh::LaspackMatrix< T >::update_sparsity_pattern ( const SparsityPattern::Graph &  sparsity_pattern )

overridevirtual

更新矩阵的稀疏性模式。这将告诉底层矩阵存储方案如何映射 元素。

参数

graph

稀疏性模式的图形。

重载 libMesh::SparseMatrix< T > .

在文件 laspack_matrix.C 第 42 行定义.

参考 libMesh::initialized().

{
  // clear data, start over
  this->clear ();

  // big trouble if this fails!
  libmesh_assert(this->_dof_map);

  const numeric_index_type n_rows = sparsity_pattern.size();

  // Initialize the _row_start data structure,
  // allocate storage for the _csr array
  {
    std::size_t size = 0;

    for (numeric_index_type row=0; row<n_rows; row++)
      size += sparsity_pattern[row].size();

    _csr.resize       (size);
    _row_start.reserve(n_rows + 1);
  }


  // Initialize the _csr data structure.
  {
    std::vector<numeric_index_type>::iterator position = _csr.begin();

    _row_start.push_back (position);

    for (numeric_index_type row=0; row<n_rows; row++)
      {
        // insert the row indices
        for (const auto & col : sparsity_pattern[row])
          {
            libmesh_assert (position != _csr.end());
            *position = col;
            ++position;
          }

        _row_start.push_back (position);
      }
  }


  // Initialize the matrix
  libmesh_assert (!this->initialized());
  this->init ();
  libmesh_assert (this->initialized());
  //libMesh::out << "n_rows=" << n_rows << std::endl;
  //libMesh::out << "m()=" << m() << std::endl;
  libmesh_assert_equal_to (n_rows, this->m());

  // Tell the matrix about its structure.  Initialize it
  // to zero.
  for (numeric_index_type i=0; i<n_rows; i++)
    {
      auto rs = _row_start[i];

      const numeric_index_type length = _row_start[i+1] - rs;

      Q_SetLen (&_QMat, i+1, length);

      for (numeric_index_type l=0; l<length; l++)
        {
          const numeric_index_type j = *(rs+l);

          // sanity check
          //libMesh::out << "m()=" << m() << std::endl;
          //libMesh::out << "(i,j,l) = (" << i
          //          << "," << j
          //          << "," << l
          //           << ")" << std::endl;
          //libMesh::out << "pos(i,j)=" << pos(i,j)
          //              << std::endl;
          libmesh_assert_equal_to (this->pos(i,j), l);
          Q_SetEntry (&_QMat, i+1, l, j+1, 0.);
        }
    }

  // That's it!
  //libmesh_here();
}

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

overridevirtual

将LaspackMatrix对象的所有元素置零。 这个函数用于将矩阵中的所有元素设置为零。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 270 行定义.

{
  const numeric_index_type n_rows = this->m();

  for (numeric_index_type row=0; row<n_rows; row++)
    {
      auto r_start = _row_start[row];

      const numeric_index_type len = (_row_start[row+1] - _row_start[row]);

      // Make sure we agree on the row length
      libmesh_assert_equal_to (len, Q_GetLen(&_QMat, row+1));

      for (numeric_index_type l=0; l<len; l++)
        {
          const numeric_index_type j = *(r_start + l);

          // Make sure the data structures are working
          libmesh_assert_equal_to ((j+1), Q_GetPos (&_QMat, row+1, l));

          Q_SetEntry (&_QMat, row+1, l, j+1, 0.);
        }
    }

  this->close();
}

template<typename T >

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

overridevirtual

创建一个与LaspackMatrix对象具有相同属性但所有元素为零的新矩阵。 这个函数用于创建一个与原矩阵具有相同大小和属性的全零矩阵。

实现了 libMesh::SparseMatrix< T >.

在文件 laspack_matrix.C 第 300 行定义.

{
  // This function is marked as "not implemented" since it hasn't been
  // tested, the code below might serve as a possible implementation.
  libmesh_not_implemented();

  // Make empty copy with matching comm, initialize, zero, and return.
  auto mat_copy = std::make_unique<LaspackMatrix<T>>(this->comm());
  mat_copy->init();
  mat_copy->zero();

  // Work around an issue on older compilers.  We are able to simply
  // "return mat_copy;" on newer compilers
  return std::unique_ptr<SparseMatrix<T>>(mat_copy.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 LaspackLinearSolver< T >

friend

在文件 laspack_matrix.h 第 308 行定义.

template<typename T >

friend class LaspackVector< T >

friend

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

在文件 laspack_matrix.h 第 307 行定义.

类成员变量说明

template<typename T >

bool libMesh::LaspackMatrix< T >::_closed

private

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

在文件 laspack_matrix.h 第 302 行定义.

参考自 libMesh::LaspackMatrix< T >::closed().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

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

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

template<typename T >

std::vector<numeric_index_type> libMesh::LaspackMatrix< T >::_csr

private

压缩行索引。

这个成员变量存储了LaspackMatrix对象的稀疏矩阵的压缩行索引 压缩行索引是一种数据结构，用于有效地存储矩阵的非零元素的位置信息，以节省内存和提高计算效率。

在文件 laspack_matrix.h 第 289 行定义.

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

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 >

QMatrix libMesh::LaspackMatrix< T >::_QMat

private

Laspack稀疏矩阵指针。

在文件 laspack_matrix.h 第 281 行定义.

template<typename T >

std::vector<std::vector<numeric_index_type>::const_iterator> libMesh::LaspackMatrix< T >::_row_start

private

压缩行索引数据结构中每行的起始位置。

这个成员变量存储了LaspackMatrix对象的稀疏矩阵压缩行索引数据结构中每行的起始位置。 这些起始位置告诉程序在压缩行索引中的哪个位置开始存储每行的非零元素。这有助于高效地访问矩阵的行元素。

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

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/laspack_matrix.h
• /home/lwz/libmesh/src/numerics/laspack_matrix.C