This class provides a nice interface to the Eigen C++-based data structures for serial vectors. 更多...

#include <eigen_sparse_matrix.h>

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

Public 类型
typedef EigenSV	DataType
	Convenient typedefs. 更多...

Public 成员函数
	EigenSparseVector (const Parallel::Communicator &comm_in, const ParallelType=AUTOMATIC)
	Dummy-Constructor. 更多...

	EigenSparseVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const ParallelType=AUTOMATIC)
	Constructor. 更多...

	EigenSparseVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const numeric_index_type n_local, const ParallelType=AUTOMATIC)
	Constructor. 更多...

	EigenSparseVector (const Parallel::Communicator &comm_in, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType=AUTOMATIC)
	Constructor. 更多...

EigenSparseVector< T > &	operator= (const EigenSparseVector< T > &v)
	Copy assignment operator. 更多...

	EigenSparseVector (EigenSparseVector &&)=default
	The 5 special functions can be defaulted for this class, as it does not manage any memory itself. 更多...

	EigenSparseVector (const EigenSparseVector &)=default

EigenSparseVector &	operator= (EigenSparseVector &&)=default

virtual	~EigenSparseVector ()=default

virtual void	close () override
	调用 NumericVector 的内部组装函数，确保值在处理器之间一致。更多...

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

virtual void	zero () override
	将所有条目设置为零。等同于 `v` = 0，但更明显且更快。更多...

virtual std::unique_ptr < NumericVector< T > >	zero_clone () const override
	返回一个智能指针，指向具有相同类型、大小和分区的此向量的副本，但所有条目都为零。更多...

virtual std::unique_ptr < NumericVector< T > >	clone () const override
	返回一个包装了此向量副本的智能指针。更多...

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
	更改向量的维度为 `n` 。如果可能的话，该向量的保留内存保持不变。如果 `n==0` ，所有内存都将被释放。因此，如果要调整向量的大小并释放不需要的内存，必须首先调用 `init(0)` ，然后调用 `init(n)` 。这种行为类似于 STL 容器。更多...

virtual void	init (const numeric_index_type N, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
	调用 `init()` ，其中 n_local = N。更多...

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const bool fast=false, const ParallelType=AUTOMATIC) override
	创建一个包含本地索引以及在 `ghost` 参数中指定的索引的向量。更多...

virtual void	init (const NumericVector< T > &other, const bool fast=false) override
	创建一个具有与 `other` 相同维度和存储类型的向量，包括 ghost dofs。更多...

virtual NumericVector< T > &	operator= (const T s) override
	设置向量的所有条目为值 `s。` 更多...

virtual NumericVector< T > &	operator= (const NumericVector< T > &v) override
	一个复制赋值运算符更多...

virtual NumericVector< T > &	operator= (const std::vector< T > &v) override
	设置 (*this)(i) = v(i) 对于向量的每个条目。更多...

virtual Real	min () const override
	获取向量中的最小值，或者在复数情况下获取最小的实部。更多...

virtual Real	max () const override
	获取向量中的最大值，或者在复数情况下获取最大的实部。更多...

virtual T	sum () const override
	获取向量中所有值的总和。更多...

virtual Real	l1_norm () const override
	获取向量的 $\ell_1$ -范数，即条目的绝对值之和。更多...

virtual Real	l2_norm () const override
	获取向量的 $\ell_2$ -范数，即条目平方和的平方根。更多...

virtual Real	linfty_norm () const override
	获取向量的 $\ell_{\infty}$ -范数，即向量的最大绝对值。更多...

virtual numeric_index_type	size () const override
	获取向量的大小。更多...

virtual numeric_index_type	local_size () const override
	获取向量的本地大小，即 `index_stop` - `index_start。` 更多...

virtual numeric_index_type	first_local_index () const override
	获取实际存储在该处理器上的第一个向量元素的索引。更多...

virtual numeric_index_type	last_local_index () const override
	获取实际存储在该处理器上的最后一个向量元素的索引+1。更多...

virtual T	operator() (const numeric_index_type i) const override
	获取向量的第 i 个条目的副本。更多...

virtual NumericVector< T > &	operator+= (const NumericVector< T > &v) override
	将向量加上 `v` ， $\vec{u} \leftarrow \vec{u} + \vec{v}$ 。等价于 `u.add(1, v)。` 更多...

virtual NumericVector< T > &	operator-= (const NumericVector< T > &v) override
	将 `v` 从 *this 减去， $\vec{u} \leftarrow \vec{u} - \vec{v}$ 。等价于 `u.add`(-1, v)。更多...

virtual NumericVector< T > &	operator*= (const NumericVector< T > &v_in) override
	计算此向量条目与另一个向量的条目之间的分量乘法， $u_i \leftarrow u_i v_i \, \forall i$ 。更多...

virtual NumericVector< T > &	operator/= (const NumericVector< T > &v_in) override
	计算此向量条目与另一个向量的分量除法， $u_i \leftarrow \frac{u_i}{v_i} \, \forall i$ 。更多...

virtual void	reciprocal () override
	计算每个向量条目的分量倒数， $u_i \leftarrow \frac{1}{u_i} \, \forall i$ 。更多...

virtual void	conjugate () override
	反转向量中每个条目的虚部。更多...

virtual void	set (const numeric_index_type i, const T value) override
	设置 `v(i)` = `value` 。请注意，此方法的库实现是线程安全的，例如，将在写入向量之前锁定 `_numeric_vector_mutex` 。更多...

virtual void	add (const numeric_index_type i, const T value) override
	将 `value` 添加到由 `i` 指定的向量条目。请注意，此方法的库实现是线程安全的，例如，将在写入向量之前锁定 `_numeric_vector_mutex` 。更多...

virtual void	add (const T s) override
	将 `s` 添加到向量的每个条目， $u_i \leftarrow u_i + s$ 更多...

virtual void	add (const NumericVector< T > &v) override
	将 `v` 添加到 *this， $\vec{u} \leftarrow \vec{u} + \vec{v}$ 。等效于调用 `operator+=()。` 更多...

virtual void	add (const T a, const NumericVector< T > &v) override
	带有标量倍数的向量相加， $\vec{u} \leftarrow \vec{u} + a\vec{v}$ 。等效于调用 `operator+=()。` 更多...

virtual void	add_vector (const NumericVector< T > &v, const SparseMatrix< T > &A) override
	计算 $\vec{u} \leftarrow \vec{u} + A \vec{v}$ ，即将 `SparseMatrix` `A` 和 `NumericVector` `v` 的乘积添加到 `this。` 更多...

virtual void	add_vector_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A) override
	计算 $\vec{u} \leftarrow \vec{u} + A^T \vec{v}$ ，即将矩阵 `A` 的转置与 `NumericVector` `v` 的乘积添加到 `this。` 更多...

virtual void	scale (const T factor) override
	缩放向量的每个元素。更多...

virtual void	abs () override
	设置 $u_i \leftarrow \|u_i\|$ ，对向量中的每个条目进行绝对值操作。更多...

virtual T	dot (const NumericVector< T > &v) const override
	计算 $\vec{u} \cdot \vec{v}$ ，即 (*this) 与向量 `v` 的点积。更多...

virtual void	localize (std::vector< T > &v_local) const override
	创建全局向量的副本并存储在本地向量 `v_local` 中。更多...

virtual void	localize (NumericVector< T > &v_local) const override
	创建全局向量的副本并存储在本地向量 `v_local` 中，而不是 std::vector。更多...

virtual void	localize (NumericVector< T > &v_local, const std::vector< numeric_index_type > &send_list) const override
	创建本地向量 `v_local` ，其中仅包含与此处理器相关的信息，由 `send_list` 定义。更多...

virtual void	localize (std::vector< T > &v_local, const std::vector< numeric_index_type > &indices) const override
	用全局索引中给定的值填充本地 std::vector "v_local"。更多...

virtual void	localize (const numeric_index_type first_local_idx, const numeric_index_type last_local_idx, const std::vector< numeric_index_type > &send_list) override
	使用由 `send_list` 指定的值从相邻处理器中选择的值更新本地向量。更多...

virtual void	localize_to_one (std::vector< T > &v_local, const processor_id_type proc_id=0) const override
	在处理器 `proc_id` 上创建全局向量的本地副本。默认情况下，数据发送到处理器 0。此方法对于从一个处理器输出数据非常有用。更多...

virtual void	pointwise_mult (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
	比较该向量与另一个向量的全局相对差异。更多...

virtual void	pointwise_divide (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
	计算该向量与另一个向量的逐点除法。更多...

virtual void	swap (NumericVector< T > &v) override
	交换该向量的内容与向量 `v` 的内容。子类应提供足够的间接性以使此操作成为 O(1) 的头部交换操作。更多...

virtual std::size_t	max_allowed_id () const override
	返回 NumericVector 可以包含的最大条目数（在所有处理器上）。更多...

DataType &	vec ()
	References to the underlying Eigen data types. 更多...

const DataType &	vec () const

virtual bool	initialized () const
	检查向量是否已经初始化。更多...

ParallelType	type () const
	获取向量的类型。更多...

ParallelType &	type ()
	获取向量的类型。更多...

virtual bool	closed () const
	检查向量是否已经关闭并准备好进行计算。更多...

virtual Real	subset_l1_norm (const std::set< numeric_index_type > &indices) const
	获取指定条目的向量的 $\ell_1$ -范数，即指定条目的绝对值之和。更多...

virtual Real	subset_l2_norm (const std::set< numeric_index_type > &indices) const
	获取指定条目的向量的 $\ell_2$ -范数，即指定条目平方和的平方根。更多...

virtual Real	subset_linfty_norm (const std::set< numeric_index_type > &indices) const
	获取指定条目的向量的最大绝对值，即指定条目的 $\ell_{\infty}$ -范数。更多...

Real	l2_norm_diff (const NumericVector< T > &other_vec) const
	获取 $\ell_2$ -范数的向量差值 $\vec{u} - \vec{v}$ ，其中 $\vec{u}$ 是 `this。` 更多...

virtual T	el (const numeric_index_type i) const
	获取向量的第 i 个条目。更多...

virtual void	get (const std::vector< numeric_index_type > &index, T *values) const
	一次访问多个组件。 `values` 将不会重新分配空间；它应该已经具有足够的空间。默认实现对每个索引调用 `operator()` ，但某些实现可能在此处提供更快的方法。更多...

void	get (const std::vector< numeric_index_type > &index, std::vector< T > &values) const
	一次访问多个组件。 `values` 将被调整大小，如果需要，将被填充。默认实现对每个索引调用 `operator()` ，但某些实现可能在此处提供更快的方法。更多...

NumericVector< T > &	operator*= (const T a)
	将向量缩放为 `a` ， $\vec{u} \leftarrow a\vec{u}$ 。等价于 `u.scale(a)。` 更多...

NumericVector< T > &	operator/= (const T a)
	将向量缩放为 `1/a` ， $\vec{u} \leftarrow \frac{1}{a}\vec{u}$ 。等价于 `u.scale`(1. 更多...

virtual void	add_vector (const T *v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个指针，每个 `dof_indices`[i] 指定了要添加的值 `v`[i] 的位置。这应该在子类中进行重写以提高效率。请注意，此方法的库实现是线程安全的。更多...

void	add_vector (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个 std::vector，每个 `dof_indices`[i] 指定了要添加的值 `v`[i] 的位置默认实现对每个索引调用 `operator()` ，但某些实现可能在此处提供更快的方法。请注意，此方法的库实现是线程安全的。更多...

void	add_vector (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个 NumericVector，每个 `dof_indices`[i] 指定了要添加的值 `v(i)` 的位置。此方法是线程安全的。更多...

void	add_vector (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个 DenseVector，每个 `dof_indices`[i] 指定了要添加的值 `v(i)` 的位置。此方法是线程安全的。更多...

void	add_vector (const NumericVector< T > &v, const ShellMatrix< T > &A)
	计算 $\vec{u} \leftarrow \vec{u} + A \vec{v}$ ，即将 `ShellMatrix` `A` 和 `NumericVector` `v` 的乘积添加到 `this。` 更多...

virtual void	insert (const T *v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `dof_indices` 指定。请注意，此方法的库实现是线程安全的。更多...

void	insert (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `v` 指定。只要使用 `NumericVector` 的库实现，此方法是线程安全的。更多...

void	insert (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `v` 指定。只要使用 `NumericVector` 的库实现，此方法是线程安全的。更多...

void	insert (const DenseSubVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `v` 指定。只要使用 `NumericVector` 的库实现，此方法是线程安全的。更多...

virtual int	compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
	比较 `this` 与 `other_vector` 的等效性，（在给定的 `threshold` 内）如果等效则返回 `-1` ，或者返回第一个索引，其中 `abs`(a[i]-b[i]) 超过阈值。更多...

virtual int	local_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
	比较该向量与另一个向量的局部相对差异。更多...

virtual void	print (std::ostream &os=libMesh::out) const
	打印本地向量的内容，默认输出到 libMesh::out 流。更多...

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

virtual void	print_global (std::ostream &os=libMesh::out) const
	打印全局向量的内容，默认输出到 libMesh::out 流。更多...

template<>
void	print_global (std::ostream &os) const

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

virtual void	create_subvector (NumericVector< T > &subvector, const std::vector< numeric_index_type > &rows) const
	使用 `rows` 中的索引从该向量中填充 `subvector。类似于` SparseMatrix 类的 `create_submatrix()` 函数，当前仅对 PetscVectors 实现了此功能。更多...

bool	readable () const
	检查该向量是否能够用于全局操作。更多...

bool	compatible (const NumericVector< T > &v) const
	检查该向量和向量 `v` 是否能够一起用于全局操作。更多...

静态 Public 成员函数
static std::unique_ptr < NumericVector< T > >	build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
	构建一个 NumericVector 对象。更多...

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 成员函数
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 属性
bool	_is_closed
	用于跟踪向量的值在在一些或全部处理器上进行插入或添加值操作后是否在所有处理器上保持一致的标志。更多...

bool	_is_initialized
	在调用 init() 后设置为 true。更多...

ParallelType	_type
	向量的类型。更多...

std::mutex	_numeric_vector_mutex
	用于执行线程安全操作的互斥锁。更多...

静态 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	_vec
	Actual Eigen::SparseVector<> we are wrapping. 更多...

友元
class	EigenSparseMatrix< T >
	Make other Eigen datatypes friends. 更多...

class	EigenSparseLinearSolver< T >

详细描述

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

This class provides a nice interface to the Eigen C++-based data structures for serial vectors.

All overridden virtual functions are documented in numeric_vector.h.

作者: Benjamin S. Kirk

日期: 2002

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

成员类型定义说明

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 EigenSV libMesh::EigenSparseVector< T >::DataType

Convenient typedefs.

在文件 eigen_sparse_vector.h 第 113 行定义.

构造及析构函数说明

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector	(	const Parallel::Communicator &	comm_in,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineexplicit

Dummy-Constructor.

Dimension=0

在文件 eigen_sparse_vector.h 第 266 行定义.

参考 libMesh::NumericVector< T >::_type.

   : NumericVector<T>(comm_in, ptype)
 {
   this->_type = ptype;
 }

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector	(	const Parallel::Communicator &	comm_in,
		const numeric_index_type	n,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineexplicit

Constructor.

Set dimension to n and initialize all elements with zero.

在文件 eigen_sparse_vector.h 第 277 行定义.

参考 libMesh::EigenSparseVector< T >::init().

   : NumericVector<T>(comm_in, ptype)
 {
   this->init(n, n, false, ptype);
 }

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector	(	const Parallel::Communicator &	comm_in,
		const numeric_index_type	n,
		const numeric_index_type	n_local,
		const ParallelType	ptype = `AUTOMATIC`
	)

inline

Constructor.

Set local dimension to n_local, the global dimension to n, and initialize all elements with zero.

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

参考 libMesh::EigenSparseVector< T >::init().

   : NumericVector<T>(comm_in, ptype)
 {
   this->init(n, n_local, false, ptype);
 }

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector	(	const Parallel::Communicator &	comm_in,
		const numeric_index_type	N,
		const numeric_index_type	n_local,
		const std::vector< numeric_index_type > &	ghost,
		const ParallelType	ptype = `AUTOMATIC`
	)

inline

Constructor.

Set local dimension to n_local, the global dimension to n, but additionally reserve memory for the indices specified by the ghost argument.

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

参考 libMesh::EigenSparseVector< T >::init().

   : NumericVector<T>(comm_in, ptype)
 {
   this->init(N, n_local, ghost, false, ptype);
 }

template<typename T>

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

default

The 5 special functions can be defaulted for this class, as it does not manage any memory itself.

template<typename T>

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

default

template<typename T>

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

virtualdefault

成员函数说明

template<typename T >

void libMesh::EigenSparseVector< T >::abs ( )

overridevirtual

设置 $u_i \leftarrow |u_i|$ ，对向量中的每个条目进行绝对值操作。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 240 行定义.

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

 {
   libmesh_assert (this->initialized());
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i!=n; ++i)
     this->set(i,std::abs((*this)(i)));
 }

template<typename T >

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

inlineoverridevirtual

将 value 添加到由 i 指定的向量条目。请注意，此方法的库实现是线程安全的，例如，将在写入向量之前锁定 _numeric_vector_mutex 。

参数

i	要添加到的条目的索引。
value	要添加的值。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 498 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->size());
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   _vec[static_cast<eigen_idx_type>(i)] += value;
 
   this->_is_closed = false;
 }

template<typename T >

void libMesh::EigenSparseVector< T >::add ( const T s )

overridevirtual

将 s 添加到向量的每个条目， $u_i \leftarrow u_i + s$

参数

s 要添加的值。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 165 行定义.

 {
   _vec += EigenSV::Constant(this->size(), v);
 }

template<typename T >

void libMesh::EigenSparseVector< T >::add ( const NumericVector< T > & v )

overridevirtual

将 v 添加到 *this， $\vec{u} \leftarrow \vec{u} + \vec{v}$ 。等效于调用 operator+=()。

参数

v 另一个数值向量。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 174 行定义.

参考 libMesh::EigenSparseVector< T >::_vec , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
   _vec += v._vec;
 }

template<typename T >

void libMesh::EigenSparseVector< T >::add	(	const T	a,
		const NumericVector< T > &	v
	)

overridevirtual

带有标量倍数的向量相加， $\vec{u} \leftarrow \vec{u} + a\vec{v}$ 。等效于调用 operator+=()。

参数

a	缩放因子。
v	另一个数值向量。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 186 行定义.

参考 libMesh::EigenSparseVector< T >::_vec , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
   _vec += v._vec*a;
 }

template<typename T >

void libMesh::EigenSparseVector< T >::add_vector	(	const NumericVector< T > &	v,
		const SparseMatrix< T > &	A
	)

overridevirtual

计算 $\vec{u} \leftarrow \vec{u} + A \vec{v}$ ，即将 SparseMatrix A 和 NumericVector v 的乘积添加到 this。

参数

v	另一个数值向量。
A	稀疏矩阵。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 198 行定义.

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

 {
   // Make sure the data passed in are really in Eigen types
   const EigenSparseVector<T> * e_vec = cast_ptr<const EigenSparseVector<T> *>(&vec_in);
   const EigenSparseMatrix<T> * mat = cast_ptr<const EigenSparseMatrix<T> *>(&mat_in);
 
   libmesh_assert(e_vec);
   libmesh_assert(mat);
 
   _vec += mat->_mat*e_vec->_vec;
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const T *	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

virtualinherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个指针，每个 dof_indices[i] 指定了要添加的值 v[i] 的位置。这应该在子类中进行重写以提高效率。请注意，此方法的库实现是线程安全的。

参数

v	一个指向值的指针。
dof_indices	每个要添加值的位置的索引集合。

被 libMesh::PetscVector< T > , 以及 libMesh::EpetraVector< T > 重载.

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

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

 {
   libmesh_assert(v);
 
   for (auto i : index_range(dof_indices))
     this->add (dof_indices[i], v[i]);
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const std::vector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个 std::vector，每个 dof_indices[i] 指定了要添加的值 v[i] 的位置默认实现对每个索引调用 operator() ，但某些实现可能在此处提供更快的方法。请注意，此方法的库实现是线程安全的。

参数

v	包含要添加的值的 std::vector。
dof_indices	每个要添加值的位置的索引集合。

在文件 numeric_vector.h 第 1041 行定义.

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->add_vector(v.data(), dof_indices);
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const NumericVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个 NumericVector，每个 dof_indices[i] 指定了要添加的值 v(i) 的位置。此方法是线程安全的。

参数

v	另一个数值向量。
dof_indices	每个要添加值的位置的索引集合。

在文件 numeric_vector.C 第 391 行定义.

参考 libMesh::NumericVector< T >::readable() , 以及 libMesh::NumericVector< T >::size().

 {
   libmesh_assert(v.readable());
 
   const std::size_t n = dof_indices.size();
   libmesh_assert_equal_to(v.size(), n);
   for (numeric_index_type i=0; i != n; i++)
     this->add (dof_indices[i], v(i));
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const DenseVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个 DenseVector，每个 dof_indices[i] 指定了要添加的值 v(i) 的位置。此方法是线程安全的。

参数

v	另一个数值向量。
dof_indices	每个要添加值的位置的索引集合。

在文件 numeric_vector.h 第 1053 行定义.

参考 libMesh::DenseVector< T >::empty() , 以及 libMesh::DenseVector< T >::size().

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->add_vector(&v(0), dof_indices);
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const NumericVector< T > &	v,
		const ShellMatrix< T > &	A
	)

inherited

计算 $\vec{u} \leftarrow \vec{u} + A \vec{v}$ ，即将 ShellMatrix A 和 NumericVector v 的乘积添加到 this。

参数

v	另一个数值向量。
A	Shell 矩阵。

在文件 numeric_vector.C 第 405 行定义.

参考 libMesh::ShellMatrix< T >::vector_mult_add().

 {
   libmesh_assert(this->compatible(v));
 
   a.vector_mult_add(*this,v);
 }

template<typename T >

void libMesh::EigenSparseVector< T >::add_vector_transpose	(	const NumericVector< T > &	v,
		const SparseMatrix< T > &	A
	)

overridevirtual

计算 $\vec{u} \leftarrow \vec{u} + A^T \vec{v}$ ，即将矩阵 A 的转置与 NumericVector v 的乘积添加到 this。

参数

v	另一个数值向量。
A	稀疏矩阵。

实现了 libMesh::NumericVector< T >.

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

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

 {
   // Make sure the data passed in are really in Eigen types
   const EigenSparseVector<T> * e_vec = cast_ptr<const EigenSparseVector<T> *>(&vec_in);
   const EigenSparseMatrix<T> * mat = cast_ptr<const EigenSparseMatrix<T> *>(&mat_in);
 
   libmesh_assert(e_vec);
   libmesh_assert(mat);
 
   _vec += mat->_mat.transpose()*e_vec->_vec;
 }

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::NumericVector< T >::build	(	const Parallel::Communicator &	comm,
		const SolverPackage	solver_package = `libMesh::default_solver_package()`
	)

staticinherited

构建一个 NumericVector 对象。

参数

comm	通信器对象，表示通信方式。
solver_package	线性求解器包的类型。

返回: 指向构建的 NumericVector 对象的 unique_ptr。

在文件 numeric_vector.C 第 50 行定义.

参考 libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS , 以及 libMesh::TRILINOS_SOLVERS.

参考自 libMesh::DiagonalMatrix< T >::DiagonalMatrix(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::enforce_constraints_on_residual() , 以及 libMesh::DofMap::process_mesh_constraint_rows().

 {
   // Build the appropriate vector
   switch (solver_package)
     {
 
 #ifdef LIBMESH_HAVE_LASPACK
     case LASPACK_SOLVERS:
       return std::make_unique<LaspackVector<T>>(comm, AUTOMATIC);
 #endif
 
 #ifdef LIBMESH_HAVE_PETSC
     case PETSC_SOLVERS:
       return std::make_unique<PetscVector<T>>(comm, AUTOMATIC);
 #endif
 
 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
     case TRILINOS_SOLVERS:
       return std::make_unique<EpetraVector<T>>(comm, AUTOMATIC);
 #endif
 
 #ifdef LIBMESH_HAVE_EIGEN
     case EIGEN_SOLVERS:
       return std::make_unique<EigenSparseVector<T>>(comm, AUTOMATIC);
 #endif
 
     default:
       return std::make_unique<DistributedVector<T>>(comm, AUTOMATIC);
     }
 }

template<typename T >

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

inlineoverridevirtual

将 NumericVector<T> 恢复到原始状态。

重载 libMesh::NumericVector< T > .

在文件 eigen_sparse_vector.h 第 393 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized.

 {
   _vec.resize(0);
 
   this->_is_initialized = false;
   this->_is_closed = false;
 }

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::EigenSparseVector< T >::clone ( ) const

inlineoverridevirtual

返回一个包装了此向量副本的智能指针。

注解: 派生类必须重写此方法。

返回: 指向新向量副本的 unique_ptr。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 427 行定义.

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

 {
   NumericVector<T> * cloned_vector = new EigenSparseVector<T>(this->comm());
   cloned_vector->init(*this, true);
   *cloned_vector = *this;
   return std::unique_ptr<NumericVector<T>>(cloned_vector);
 }

template<typename T >

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

inlineoverridevirtual

调用 NumericVector 的内部组装函数，确保值在处理器之间一致。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 382 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   this->_is_closed = true;
 }

template<typename T>

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

inlinevirtualinherited

检查向量是否已经关闭并准备好进行计算。

返回: 如果向量已经关闭并准备好进行计算，则返回 true；否则返回 false。

在文件 numeric_vector.h 第 180 行定义.

参考 libMesh::NumericVector< T >::_is_closed.

参考自 libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::PetscVector< T >::localize(), libMesh::DofMap::max_constraint_error(), libMesh::EigenSparseVector< T >::operator=(), libMesh::LaspackVector< T >::operator=() , 以及 libMesh::PetscVector< T >::operator=().

180 { return _is_closed; }

libMesh::NumericVector::_is_closed

bool _is_closed

用于跟踪向量的值在在一些或全部处理器上进行插入或添加值操作后是否在所有处理器上保持一致的标志。

Definition: numeric_vector.h:913

template<typename T >

int libMesh::NumericVector< T >::compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtualinherited

比较 this 与 other_vector 的等效性，（在给定的 threshold 内）如果等效则返回 -1 ，或者返回第一个索引，其中 abs(a[i]-b[i]) 超过阈值。

注解: "等效" 表示两个向量非常相似或几乎相同，其差异小于或等于给定的阈值。这个阈值通常用于考虑浮点数精度问题，因为在计算机中，浮点数运算可能会导致微小的数值差异。当两个向量被认为等效时，它们的差异小于或等于阈值。具体来说，这是通过计算两个向量的每个元素之间的差异并将其与阈值进行比较来确定的。如果两个向量的差异小于阈值，就可以说它们是等效的。否则，如果差异大于阈值，就可以说它们不等效。

参数

other_vector	另一个数值向量。
threshold	阈值。

返回: 如果向量等效则返回 -1 ，否则返回第一个不等效的索引。

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

参考 std::abs().

 {
   libmesh_assert(this->compatible(other_vector));
 
   int first_different_i = std::numeric_limits<int>::max();
   numeric_index_type i = first_local_index();
 
   while (first_different_i==std::numeric_limits<int>::max()
          && i<last_local_index())
   {
     if (std::abs((*this)(i) - other_vector(i)) > threshold)
       first_different_i = i;
     else
       i++;
   }
 
   // Find the correct first differing index in parallel
   this->comm().min(first_different_i);
 
   if (first_different_i == std::numeric_limits<int>::max())
     return -1;
 
   return first_different_i;
 }

template<typename T >

bool libMesh::NumericVector< T >::compatible ( const NumericVector< T > & v ) const

inherited

检查该向量和向量 v 是否能够一起用于全局操作。

参数

v	要比较的另一个向量。

返回: 如果这两个向量可以一起用于全局操作，则返回 true，否则返回 false。

在文件 numeric_vector.C 第 423 行定义.

参考 libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::last_local_index(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::readable() , 以及 libMesh::NumericVector< T >::size().

 {
   return this->readable() && v.readable() &&
          this->size() == v.size() &&
          this->local_size() == v.local_size() &&
          this->first_local_index() == v.first_local_index() &&
          this->last_local_index() == v.last_local_index();
 }

template<typename T >

void libMesh::EigenSparseVector< T >::conjugate ( )

overridevirtual

反转向量中每个条目的虚部。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 157 行定义.

 {
   _vec = _vec.conjugate();
 }

template<typename T>

virtual void libMesh::NumericVector< T >::create_subvector	(	NumericVector< T > &	subvector,
		const std::vector< numeric_index_type > &	rows
	)		const

inlinevirtualinherited

使用 rows 中的索引从该向量中填充 subvector。类似于 SparseMatrix 类的 create_submatrix() 函数，当前仅对 PetscVectors 实现了此功能。

参数

subvector	要填充的子向量。
rows	包含用于选择要填充到子向量的索引的向量。

被 libMesh::PetscVector< T > , 以及 libMesh::EpetraVector< T > 重载.

在文件 numeric_vector.h 第 871 行定义.

   {
     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;
 }

template<typename T >

T libMesh::EigenSparseVector< T >::dot ( const NumericVector< T > & v ) const

overridevirtual

计算 $\vec{u} \cdot \vec{v}$ ，即 (*this) 与向量 v 的点积。

在复数值情况下，使用 v 的复共轭。

参数

v 另一个数值向量。

返回: 点积的结果。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 253 行定义.

参考 libMesh::EigenSparseVector< T >::_vec , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   // Make sure the NumericVector passed in is really a EigenSparseVector
   const EigenSparseVector<T> * v = cast_ptr<const EigenSparseVector<T> *>(&v_in);
   libmesh_assert(v);
 
   return _vec.dot(v->_vec);
 }

template<typename T>

virtual T libMesh::NumericVector< T >::el ( const numeric_index_type i ) const

inlinevirtualinherited

获取向量的第 i 个条目。

参数

i	要获取的条目的索引。

返回: 第 i 个条目的值。

在文件 numeric_vector.h 第 416 行定义.

416 { return (*this)(i); }

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 >

numeric_index_type libMesh::EigenSparseVector< T >::first_local_index ( ) const

inlineoverridevirtual

获取实际存储在该处理器上的第一个向量元素的索引。

注解: 此索引的最小值为 0。

返回: 第一个本地索引。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 461 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return 0;
 }

template<typename T >

void libMesh::NumericVector< T >::get	(	const std::vector< numeric_index_type > &	index,
		T *	values
	)		const

inlinevirtualinherited

一次访问多个组件。 values 将 *不会* 重新分配空间；它应该已经具有足够的空间。默认实现对每个索引调用 operator() ，但某些实现可能在此处提供更快的方法。

参数

index	要获取的索引集合。
values	存储获取值的数组。

被 libMesh::PetscVector< T > 重载.

在文件 numeric_vector.h 第 1012 行定义.

参考自 libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::enforce_constraints_on_residual() , 以及 libMesh::DofMap::max_constraint_error().

 {
   const std::size_t num = index.size();
   for (std::size_t i=0; i<num; i++)
     {
       values[i] = (*this)(index[i]);
     }
 }

template<typename T >

void libMesh::NumericVector< T >::get	(	const std::vector< numeric_index_type > &	index,
		std::vector< T > &	values
	)		const

inlineinherited

一次访问多个组件。 values 将被调整大小，如果需要，将被填充。默认实现对每个索引调用 operator() ，但某些实现可能在此处提供更快的方法。

参数

index	要获取的索引集合。
values	存储获取值的向量。

在文件 numeric_vector.h 第 1026 行定义.

 {
   const std::size_t num = index.size();
   values.resize(num);
   if (!num)
     return;
 
   this->get(index, values.data());
 }

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
 }

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

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

参考 libMesh::err.

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

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

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

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

参考 libMesh::err.

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

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

template<typename T >

void libMesh::EigenSparseVector< T >::init	(	const numeric_index_type	n,
		const numeric_index_type	n_local,
		const bool	fast = `false`,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineoverridevirtual

更改向量的维度为 n 。如果可能的话，该向量的保留内存保持不变。如果 n==0 ，所有内存都将被释放。因此，如果要调整向量的大小并释放不需要的内存，必须首先调用 init(0) ，然后调用 init(n) 。这种行为类似于 STL 容器。

参数

n	新的全局维度。
n_local	新的本地维度。
fast	如果为 false，则向量将被填充为零。
ptype	平行类型，表示数值向量的类型。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 316 行定义.

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

参考自 libMesh::EigenSparseVector< T >::EigenSparseVector().

 {
   // Eigen vectors only for serial cases,
   // but can provide a "parallel" vector on one processor.
   libmesh_error_msg_if(n != n_local, "Error: EigenSparseVectors can only be used in serial!");
 
   this->_type = SERIAL;
 
   // Clear initialized vectors
   if (this->initialized())
     this->clear();
 
   _vec.resize(n);
 
   this->_is_initialized = true;
   this->_is_closed = true;
 
   // Optionally zero out all components
   if (fast == false)
     this->zero ();
 
   return;
 }

template<typename T >

void libMesh::EigenSparseVector< T >::init	(	const numeric_index_type	n,
		const bool	fast = `false`,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineoverridevirtual

调用 init() ，其中 n_local = N。

参数

n	新的全局维度。
fast	如果为 false，则向量将被填充为零。
ptype	平行类型，表示数值向量的类型。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 347 行定义.

 {
   this->init(n,n,fast,ptype);
 }

template<typename T>

virtual void libMesh::EigenSparseVector< T >::init	(	const numeric_index_type	n,
		const numeric_index_type	n_local,
		const std::vector< numeric_index_type > &	ghost,
		const bool	fast = `false`,
		const ParallelType	ptype = `AUTOMATIC`
	)

overridevirtual

创建一个包含本地索引以及在 ghost 参数中指定的索引的向量。

参数

n	新的全局维度。
n_local	新的本地维度。
ghost	指定的索引。
fast	如果为 false，则向量将被填充为零。
ptype	平行类型，表示数值向量的类型。

实现了 libMesh::NumericVector< T >.

template<class T >

void libMesh::EigenSparseVector< T >::init	(	const NumericVector< T > &	other,
		const bool	fast = `false`
	)

overridevirtual

创建一个具有与 other 相同维度和存储类型的向量，包括 ghost dofs。

参数

other	另一个数值向量。
fast	如果为 false，则向量将被填充为零。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 372 行定义.

参考 libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

 {
   this->init(other.size(),other.local_size(),fast,other.type());
 }

template<typename T>

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

inlinevirtualinherited

检查向量是否已经初始化。

返回: 如果向量已经初始化，则返回 true；否则返回 false。

在文件 numeric_vector.h 第 159 行定义.

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

参考自 libMesh::PetscVector< T >::create_subvector() , 以及 libMesh::PetscVector< T >::init().

159 { return _is_initialized; }

libMesh::NumericVector::_is_initialized

bool _is_initialized

在调用 init() 后设置为 true。

Definition: numeric_vector.h:918

template<typename T >

void libMesh::NumericVector< T >::insert	(	const T *	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

virtualinherited

将 v 的条目插入到 *this 中，位置由 dof_indices 指定。请注意，此方法的库实现是线程安全的。

参数

v	一个指向值的指针。
dof_indices	每个要插入值的位置的索引集合。

被 libMesh::PetscVector< T > , 以及 libMesh::EpetraVector< T > 重载.

在文件 numeric_vector.C 第 84 行定义.

 {
   libmesh_assert (v);
 
   for (auto i : index_range(dof_indices))
     this->set (dof_indices[i], v[i]);
 }

template<typename T >

void libMesh::NumericVector< T >::insert	(	const NumericVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inherited

将 v 的条目插入到 *this 中，位置由 v 指定。只要使用 NumericVector 的库实现，此方法是线程安全的。

参数

v	一个数值向量。
dof_indices	每个要插入值的位置的索引集合。

在文件 numeric_vector.C 第 96 行定义.

参考 libMesh::NumericVector< T >::readable() , 以及 libMesh::NumericVector< T >::size().

 {
   libmesh_assert_equal_to (V.size(), dof_indices.size());
   libmesh_assert (V.readable());
 
   for (auto i : index_range(dof_indices))
     this->set (dof_indices[i], V(i));
 }

template<typename T >

void libMesh::NumericVector< T >::insert	(	const DenseVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

将 v 的条目插入到 *this 中，位置由 v 指定。只要使用 NumericVector 的库实现，此方法是线程安全的。

参数

v	一个 DenseVector。
dof_indices	每个要插入值的位置的索引集合。

在文件 numeric_vector.h 第 1077 行定义.

参考 libMesh::DenseVector< T >::empty() , 以及 libMesh::DenseVector< T >::size().

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->insert(&v(0), dof_indices);
 }

template<typename T >

void libMesh::NumericVector< T >::insert	(	const DenseSubVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

将 v 的条目插入到 *this 中，位置由 v 指定。只要使用 NumericVector 的库实现，此方法是线程安全的。

参数

v	一个 DenseSubVector。
dof_indices	每个要插入值的位置的索引集合。

在文件 numeric_vector.h 第 1089 行定义.

参考 libMesh::DenseSubVector< T >::empty() , 以及 libMesh::DenseSubVector< T >::size().

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->insert(&v(0), dof_indices);
 }

template<typename T >

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

overridevirtual

获取向量的 $\ell_1$ -范数，即条目的绝对值之和。

返回: 向量的 $\ell_1$ -范数。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 48 行定义.

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

 {
   libmesh_assert (this->closed());
   libmesh_assert (this->initialized());
 
   return _vec.lpNorm<1>();
 }

template<typename T >

Real libMesh::EigenSparseVector< T >::l2_norm ( ) const

overridevirtual

获取向量的 $\ell_2$ -范数，即条目平方和的平方根。

返回: 向量的 $\ell_2$ -范数。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 59 行定义.

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

 {
   libmesh_assert (this->closed());
   libmesh_assert (this->initialized());
 
   return _vec.lpNorm<2>();
 }

template<class T >

Real libMesh::NumericVector< T >::l2_norm_diff ( const NumericVector< T > & other_vec ) const

inherited

获取 $\ell_2$ -范数的向量差值 $\vec{u} - \vec{v}$ ，其中 $\vec{u}$ 是 this。

参数

other_vec 另一个数值向量。

返回: $\ell_2$ -范数的向量差值。

在文件 numeric_vector.C 第 363 行定义.

参考 std::norm(), libMesh::TensorTools::norm_sq(), libMesh::Real , 以及 std::sqrt().

 {
   libmesh_assert(this->compatible(v));
 
   Real norm = 0;
   for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
     norm += TensorTools::norm_sq((*this)(i) - v(i));
 
   this->comm().sum(norm);
 
   return std::sqrt(norm);
 }

template<typename T >

numeric_index_type libMesh::EigenSparseVector< T >::last_local_index ( ) const

inlineoverridevirtual

获取实际存储在该处理器上的最后一个向量元素的索引+1。

注解: 此索引的最大值为 size()。

返回: 最后一个本地索引+1。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 472 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return this->size();
 }

template<typename T >

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

overridevirtual

获取向量的 $\ell_{\infty}$ -范数，即向量的最大绝对值。

返回: 向量的 $\ell_{\infty}$ -范数。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 70 行定义.

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

 {
   libmesh_assert (this->closed());
   libmesh_assert (this->initialized());
 
   return _vec.lpNorm<Eigen::Infinity>();
 }

template<typename T >

int libMesh::NumericVector< T >::local_relative_compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtualinherited

比较该向量与另一个向量的局部相对差异。

如果两个向量在给定的局部相对阈值 abs(a[i]-b[i])/max(a[i],b[i]) 下等效，则返回-1，否则返回首个不等效的索引。

参数

other_vector	要比较的另一个向量。
threshold	允许的局部相对差异阈值（可选，默认值为 TOLERANCE）。

返回: -1 表示等效，否则返回不等效的索引。

在文件 numeric_vector.C 第 137 行定义.

参考 std::abs().

 {
   libmesh_assert(this->compatible(other_vector));
 
   int first_different_i = std::numeric_limits<int>::max();
   numeric_index_type i = first_local_index();
 
   do
     {
       if (std::abs((*this)(i) - other_vector(i)) > threshold *
           std::max(std::abs((*this)(i)), std::abs(other_vector(i))))
         first_different_i = i;
       else
         i++;
     }
   while (first_different_i==std::numeric_limits<int>::max()
          && i<last_local_index());
 
   // Find the correct first differing index in parallel
   this->comm().min(first_different_i);
 
   if (first_different_i == std::numeric_limits<int>::max())
     return -1;
 
   return first_different_i;
 }

template<typename T >

numeric_index_type libMesh::EigenSparseVector< T >::local_size ( ) const

inlineoverridevirtual

获取向量的本地大小，即 index_stop - index_start。

返回: 向量的本地大小。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 450 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return this->size();
 }

template<typename T >

void libMesh::EigenSparseVector< T >::localize ( std::vector< T > & v_local ) const

overridevirtual

创建全局向量的副本并存储在本地向量 v_local 中。

参数

v_local 用于存储本地向量的 std::vector。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 392 行定义.

 {
   v_local.resize(this->size());
 
   for (auto i : index_range(v_local))
     v_local[i] = (*this)(i);
 }

template<typename T >

void libMesh::EigenSparseVector< T >::localize ( NumericVector< T > & v_local ) const

overridevirtual

创建全局向量的副本并存储在本地向量 v_local 中，而不是 std::vector。

参数

v_local 用于存储本地向量的 NumericVector<T>。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 334 行定义.

 {
   // Make sure the NumericVector passed in is really a EigenSparseVector
   EigenSparseVector<T> * v_local =
     cast_ptr<EigenSparseVector<T> *>(&v_local_in);
 
   libmesh_assert(v_local);
 
   *v_local = *this;
 }

template<typename T>

virtual void libMesh::EigenSparseVector< T >::localize	(	NumericVector< T > &	v_local,
		const std::vector< numeric_index_type > &	send_list
	)		const

overridevirtual

创建本地向量 v_local ，其中仅包含与此处理器相关的信息，由 send_list 定义。

参数

v_local	用于存储本地向量的 NumericVector<T>。
send_list	指定要包含在本地向量中的值的索引列表。

实现了 libMesh::NumericVector< T >.

template<typename T >

void libMesh::EigenSparseVector< T >::localize	(	std::vector< T > &	v_local,
		const std::vector< numeric_index_type > &	indices
	)		const

overridevirtual

用全局索引中给定的值填充本地 std::vector "v_local"。

参数

v_local	用于存储本地向量的 std::vector。
indices	要填充到 v_local 中的全局索引列表。

Fill in the local std::vector "v_local" with the global indices given in "indices".

注解: 每个处理器上的索引可能不同，并且相同的索引可以本地化到多个处理器。生成的v_local可以比原来的v_local短，并且条目将按照索引指定的顺序排列。

Example:

*   On 4 procs *this = {a, b, c, d, e, f, g, h, i} is a parallel vector.
*   On each proc, the indices arrays are set up as:
*   proc0, indices = {1,2,4,5}
*   proc1, indices = {2,5,6,8}
*   proc2, indices = {2,3,6,7}
*   proc3, indices = {0,1,2,3}
*
*   After calling this version of localize, the v_local vectors are:
*   proc0, v_local = {b,c,e,f}
*   proc1, v_local = {c,f,g,i}
*   proc2, v_local = {c,d,g,h}
*   proc3, v_local = {a,b,c,d}
*

这个函数在并行I/0例程中很有用，当你有一个解值的并行向量，你想写一个子集。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 364 行定义.

 {
   // EigenSparseVectors are serial, so we can just copy values
   v_local.resize(indices.size());
 
   for (auto i : index_range(v_local))
     v_local[i] = (*this)(indices[i]);
 }

template<typename T>

virtual void libMesh::EigenSparseVector< T >::localize	(	const numeric_index_type	first_local_idx,
		const numeric_index_type	last_local_idx,
		const std::vector< numeric_index_type > &	send_list
	)

overridevirtual

使用由 send_list 指定的值从相邻处理器中选择的值更新本地向量。

参数

first_local_idx	本地向量的第一个索引。
last_local_idx	本地向量的最后一个索引。
send_list	用于更新本地向量的值的索引列表。

实现了 libMesh::NumericVector< T >.

template<typename T>

void libMesh::EigenSparseVector< T >::localize_to_one	(	std::vector< T > &	v_local,
		const processor_id_type	proc_id = `0`
	)		const

overridevirtual

在处理器 proc_id 上创建全局向量的本地副本。默认情况下，数据发送到处理器 0。此方法对于从一个处理器输出数据非常有用。

参数

v_local	用于存储本地向量的 std::vector。
proc_id	目标处理器的 ID。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 404 行定义.

 {
   libmesh_assert_equal_to (pid, 0);
 
   this->localize (v_local);
 }

template<typename T >

Real libMesh::EigenSparseVector< T >::max ( ) const

overridevirtual

获取向量中的最大值，或者在复数情况下获取最大的实部。

返回: 向量的最大值。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 430 行定义.

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

 {
   libmesh_assert (this->initialized());
   if (!this->size())
     return -std::numeric_limits<Real>::max();
 
 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
   Real the_max = libmesh_real((*this)(0));
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=1; i<n; i++)
     the_max = std::max (the_max, libmesh_real((*this)(i)));
 
   return the_max;
 #else
   return libmesh_real(_vec.maxCoeff());
 #endif
 }

template<typename T >

std::size_t libMesh::EigenSparseVector< T >::max_allowed_id ( ) const

inlineoverridevirtual

返回 NumericVector 可以包含的最大条目数（在所有处理器上）。

尽管我们定义了 numeric_index_type，通常要求 NumericVector 底层实现的索引具有大小等于 sizeof(numeric_index_type) 的大小，但这两种类型仍可能具有不同的符号，这会影响可以存储在 NumericVector 中的最大值数量。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 541 行定义.

 {
   // We use the Eigen::Matrix type which appears to be templated on
   // int for its sizes, see e.g. https://eigen.tuxfamily.org/dox/classEigen_1_1Matrix.html
   return std::numeric_limits<int>::max();
 }

template<typename T >

Real libMesh::EigenSparseVector< T >::min ( ) const

overridevirtual

获取向量中的最小值，或者在复数情况下获取最小的实部。

返回: 向量的最小值。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 453 行定义.

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

 {
   libmesh_assert (this->initialized());
   if (!this->size())
     return std::numeric_limits<Real>::max();
 
 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
   Real the_min = libmesh_real((*this)(0));
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=1; i<n; i++)
     the_min = std::min (the_min, libmesh_real((*this)(i)));
 
   return the_min;
 #else
   return libmesh_real(_vec.minCoeff());
 #endif
 }

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 >

T libMesh::EigenSparseVector< T >::operator() ( const numeric_index_type i ) const

inlineoverridevirtual

获取向量的第 i 个条目的副本。

参数

i	要获取的条目的索引。

返回: 第 i 个条目的副本。

实现了 libMesh::NumericVector< T >.

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

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert ( ((i >= this->first_local_index()) &&
                     (i <  this->last_local_index())) );
 
   return _vec[static_cast<eigen_idx_type>(i)];
 }

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator*= ( const NumericVector< T > & v )

overridevirtual

计算此向量条目与另一个向量的条目之间的分量乘法， $u_i \leftarrow u_i v_i \, \forall i$ 。

参数

v 另一个数值向量。

返回: 对 *this 的引用。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 110 行定义.

参考 libMesh::closed() , 以及 libMesh::NumericVector< T >::size().

 {
   libmesh_assert (this->closed());
   libmesh_assert_equal_to(size(), v_in.size());
 
   const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
   _vec = _vec.cwiseProduct(v._vec);
 
   return *this;
 }

template<typename T>

NumericVector<T>& libMesh::NumericVector< T >::operator*= ( const T a )

inlineinherited

将向量缩放为 a ， $\vec{u} \leftarrow a\vec{u}$ 。等价于 u.scale(a)。

参数

a 缩放因子。

返回: 对 *this 的引用。

在文件 numeric_vector.h 第 463 行定义.

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

463 { this->scale(a); return *this; }

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

缩放向量的每个元素。

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator+= ( const NumericVector< T > & v )

overridevirtual

将向量加上 v ， $\vec{u} \leftarrow \vec{u} + \vec{v}$ 。等价于 u.add(1, v)。

参数

v 另一个数值向量。

返回: 对 *this 的引用。

实现了 libMesh::NumericVector< T >.

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

参考 libMesh::EigenSparseVector< T >::_vec , 以及 libMesh::closed().

 {
   libmesh_assert (this->closed());
 
   const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
   _vec += v._vec;
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator-= ( const NumericVector< T > & v )

overridevirtual

将 v 从 *this 减去， $\vec{u} \leftarrow \vec{u} - \vec{v}$ 。等价于 u.add(-1, v)。

参数

v 另一个数值向量。

返回: 对 *this 的引用。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 96 行定义.

参考 libMesh::EigenSparseVector< T >::_vec , 以及 libMesh::closed().

 {
   libmesh_assert (this->closed());
 
   const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
   _vec -= v._vec;
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator/= ( const NumericVector< T > & v )

overridevirtual

计算此向量条目与另一个向量的分量除法， $u_i \leftarrow \frac{u_i}{v_i} \, \forall i$ 。

参数

v 另一个数值向量。

返回: 对 *this 的引用。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 125 行定义.

参考 libMesh::closed() , 以及 libMesh::NumericVector< T >::size().

 {
   libmesh_assert (this->closed());
   libmesh_assert_equal_to(size(), v_in.size());
 
   const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
   _vec = _vec.cwiseQuotient(v._vec);
 
   return *this;
 }

template<typename T>

NumericVector<T>& libMesh::NumericVector< T >::operator/= ( const T a )

inlineinherited

将向量缩放为 1/a ， $\vec{u} \leftarrow \frac{1}{a}\vec{u}$ 。等价于 u.scale(1.

/a)。

参数

a 缩放因子。

返回: 对 *this 的引用。

在文件 numeric_vector.h 第 481 行定义.

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

481 { this->scale(1./a); return *this; }

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

缩放向量的每个元素。

template<typename T >

EigenSparseVector< T > & libMesh::EigenSparseVector< T >::operator= ( const EigenSparseVector< T > & v )

Copy assignment operator.

Does some state checks before copying the underlying Eigen data type.

返回: A reference to *this as the derived type.

在文件 eigen_sparse_vector.C 第 299 行定义.

参考 libMesh::EigenSparseVector< T >::_vec, libMesh::NumericVector< T >::closed(), libMesh::initialized() , 以及 libMesh::EigenSparseVector< T >::size().

 {
   libmesh_assert (this->initialized());
   libmesh_assert (v.closed());
   libmesh_assert_equal_to (this->size(), v.size());
 
   _vec = v._vec;
 
   this->_is_closed = true;
 
   return *this;
 }

template<typename T>

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

default

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator= ( const T s )

overridevirtual

设置向量的所有条目为值 s。

参数

s 设置的值。

返回: 对 *this 的引用。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 268 行定义.

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert (this->closed());
 
   _vec.fill(s);
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator= ( const NumericVector< T > & v )

overridevirtual

一个复制赋值运算符

参数

v	要复制的 NumericVector 对象。

返回: 作为基础类型的 *this 的引用。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 282 行定义.

 {
   // Make sure the NumericVector passed in is really a EigenSparseVector
   const EigenSparseVector<T> * v =
     cast_ptr<const EigenSparseVector<T> *>(&v_in);
 
   libmesh_assert(v);
 
   *this = *v;
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< T >::operator= ( const std::vector< T > & v )

overridevirtual

设置 (*this)(i) = v(i) 对于向量的每个条目。

参数

v 另一个向量。

返回: 对 *this 的引用。

Case 1: The vector is the same size of The global vector. Only add the local components.

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 316 行定义.

 {
   if (this->size() == v.size())
     for (auto i : index_range(v))
       this->set (i, v[i]);
 
   else
     libmesh_error_msg("this->size() = " << this->size() << " must be equal to v.size() = " << v.size());
 
   return *this;
 }

template<typename T >

void libMesh::EigenSparseVector< T >::pointwise_divide	(	const NumericVector< T > &	vec1,
		const NumericVector< T > &	vec2
	)

overridevirtual

计算该向量与另一个向量的逐点除法。

执行逐点（分量间）除法操作 $u_i \leftarrow \frac{v_{1,i}}{v_{2,i}}$ ，并将结果存储在该向量中。

参数

vec1	被除数的输入向量。
vec2	除数的输入向量。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 422 行定义.

 {
   libmesh_not_implemented();
 }

template<typename T >

void libMesh::EigenSparseVector< T >::pointwise_mult	(	const NumericVector< T > &	vec1,
		const NumericVector< T > &	vec2
	)

overridevirtual

比较该向量与另一个向量的全局相对差异。

如果两个向量在给定的全局相对阈值 threshold 下等效，则返回-1，否则返回首个不等效的索引，其中相对差异定义为 $\frac{|a[i]-b[i]|}{\max_j(a[j],b[j])}$ 。

参数

other_vector	要比较的另一个向量。
threshold	允许的全局相对差异阈值（可选，默认值为 TOLERANCE）。

返回: -1 表示等效，否则返回不等效的索引。计算该向量与另一个向量的逐点乘积。

执行逐点（分量间）乘积操作 $u_i \leftarrow u_i v_i$ ，并将结果存储在该向量中。

参数

vec1	第一个输入向量。
vec2	第二个输入向量。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 415 行定义.

 {
   libmesh_not_implemented();
 }

template<typename T >

void libMesh::NumericVector< T >::print ( std::ostream & os = libMesh::out ) const

inlinevirtualinherited

打印本地向量的内容，默认输出到 libMesh::out 流。

参数

os	输出流，用于指定输出位置（可选，默认为 libMesh::out）。

在文件 numeric_vector.h 第 1121 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   os << "Size\tglobal =  " << this->size()
      << "\t\tlocal =  " << this->local_size() << std::endl;
 
   os << "#\tValue" << std::endl;
   for (auto i : index_range(*this))
     os << i << "\t" << (*this)(i) << std::endl;
 }

template<>

void libMesh::NumericVector< Complex >::print ( std::ostream & os ) const

inlineinherited

在文件 numeric_vector.h 第 1103 行定义.

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

 {
   libmesh_assert (this->initialized());
   os << "Size\tglobal =  " << this->size()
      << "\t\tlocal =  " << this->local_size() << std::endl;
 
   // std::complex<>::operator<<() is defined, but use this form
   os << "#\tReal part\t\tImaginary part" << std::endl;
   for (auto i : index_range(*this))
     os << i << "\t"
        << (*this)(i).real() << "\t\t"
        << (*this)(i).imag() << std::endl;
 }

template<typename T >

void libMesh::NumericVector< T >::print_global ( std::ostream & os = libMesh::out ) const

inlinevirtualinherited

打印全局向量的内容，默认输出到 libMesh::out 流。

参数

os	输出流，用于指定输出位置（可选，默认为 libMesh::out）。

在文件 numeric_vector.h 第 1158 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   std::vector<T> v(this->size());
   this->localize(v);
 
   // 现在我们只需要输出的一个副本
   if (this->processor_id())
     return;
 
   os << "Size\tglobal =  " << this->size() << std::endl;
   os << "#\tValue" << std::endl;
   for (auto i : make_range(v.size()))
     os << i << "\t" << v[i] << std::endl;
 }

template<>

void libMesh::NumericVector< Complex >::print_global ( std::ostream & os ) const

inlineinherited

在文件 numeric_vector.h 第 1136 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   std::vector<Complex> v(this->size());
   this->localize(v);
 
   // 现在我们只需要输出的一个副本
   if (this->processor_id())
     return;
 
   os << "Size\tglobal =  " << this->size() << std::endl;
   os << "#\tReal part\t\tImaginary part" << std::endl;
   for (auto i : make_range(v.size()))
     os << i << "\t"
        << v[i].real() << "\t\t"
        << v[i].imag() << std::endl;
 }

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::NumericVector< T >::print_matlab ( const std::string & = "" ) const

inlinevirtualinherited

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

参数

name	用于指定输出文件名的可选参数（默认为空）。

被 libMesh::PetscVector< T > 重载.

在文件 numeric_vector.h 第 859 行定义.

   {
     libmesh_not_implemented();
   }

template<typename T >

bool libMesh::NumericVector< T >::readable ( ) const

inherited

检查该向量是否能够用于全局操作。

返回: 如果向量可以用于全局操作，则返回 true，否则返回 false。

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

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

参考自 libMesh::NumericVector< T >::add_vector(), libMesh::NumericVector< T >::compatible() , 以及 libMesh::NumericVector< T >::insert().

 {
   return this->initialized() && this->closed();
 }

template<typename T >

void libMesh::EigenSparseVector< T >::reciprocal ( )

overridevirtual

计算每个向量条目的分量倒数， $u_i \leftarrow \frac{1}{u_i} \, \forall i$ 。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 141 行定义.

 {
 #ifndef NDEBUG
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i<n; i++)
     // Don't divide by zero!
     libmesh_assert_not_equal_to ((*this)(i), T(0));
 #endif
 
   _vec = _vec.cwiseInverse();
 }

template<typename T >

void libMesh::EigenSparseVector< T >::scale ( const T factor )

overridevirtual

缩放向量的每个元素。

参数

factor 缩放因子。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 230 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   _vec *= factor;
 }

template<typename T >

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

inlineoverridevirtual

设置 v(i) = value 。请注意，此方法的库实现是线程安全的，例如，将在写入向量之前锁定 _numeric_vector_mutex 。

参数

i	要设置的条目的索引。
value	要设置的值。

实现了 libMesh::NumericVector< T >.

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

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->size());
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   _vec[static_cast<eigen_idx_type>(i)] = value;
 
   this->_is_closed = false;
 }

template<typename T >

numeric_index_type libMesh::EigenSparseVector< T >::size ( ) const

inlineoverridevirtual

获取向量的大小。

返回: 向量的大小。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 439 行定义.

参考 libMesh::initialized().

参考自 libMesh::EigenSparseVector< T >::operator=().

 {
   libmesh_assert (this->initialized());
 
   return static_cast<numeric_index_type>(_vec.size());
 }

template<class T >

Real libMesh::NumericVector< T >::subset_l1_norm ( const std::set< numeric_index_type > & indices ) const

virtualinherited

获取指定条目的向量的 $\ell_1$ -范数，即指定条目的绝对值之和。

参数

indices 指定的索引集合。

返回: 指定条目的向量的 $\ell_1$ -范数。

注解: 索引必须位于此处理器上。

在文件 numeric_vector.C 第 306 行定义.

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

 {
   libmesh_assert (this->readable());
 
   const NumericVector<T> & v = *this;
 
   Real norm = 0;
 
   for (const auto & index : indices)
     norm += std::abs(v(index));
 
   this->comm().sum(norm);
 
   return norm;
 }

template<class T >

Real libMesh::NumericVector< T >::subset_l2_norm ( const std::set< numeric_index_type > & indices ) const

virtualinherited

获取指定条目的向量的 $\ell_2$ -范数，即指定条目平方和的平方根。

参数

indices 指定的索引集合。

返回: 指定条目的向量的 $\ell_2$ -范数。

注解: 索引必须位于此处理器上。

在文件 numeric_vector.C 第 323 行定义.

参考 std::norm(), libMesh::TensorTools::norm_sq(), libMesh::Real , 以及 std::sqrt().

 {
   libmesh_assert (this->readable());
 
   const NumericVector<T> & v = *this;
 
   Real norm = 0;
 
   for (const auto & index : indices)
     norm += TensorTools::norm_sq(v(index));
 
   this->comm().sum(norm);
 
   return std::sqrt(norm);
 }

template<class T >

Real libMesh::NumericVector< T >::subset_linfty_norm ( const std::set< numeric_index_type > & indices ) const

virtualinherited

获取指定条目的向量的最大绝对值，即指定条目的 $\ell_{\infty}$ -范数。

参数

indices 指定的索引集合。

返回: 指定条目的向量的最大绝对值。

注解: 索引必须位于此处理器上。

在文件 numeric_vector.C 第 340 行定义.

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

 {
   libmesh_assert (this->readable());
 
   const NumericVector<T> & v = *this;
 
   Real norm = 0;
 
   for (const auto & index : indices)
     {
       Real value = std::abs(v(index));
       if (value > norm)
         norm = value;
     }
 
   this->comm().max(norm);
 
   return norm;
 }

template<typename T >

T libMesh::EigenSparseVector< T >::sum ( ) const

overridevirtual

获取向量中所有值的总和。

返回: 向量中所有值的总和。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.C 第 37 行定义.

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

 {
   libmesh_assert (this->closed());
   libmesh_assert (this->initialized());
 
   return _vec.sum();
 }

template<typename T >

void libMesh::EigenSparseVector< T >::swap ( NumericVector< T > & v )

inlineoverridevirtual

交换该向量的内容与向量 v 的内容。子类应提供足够的间接性以使此操作成为 O(1) 的头部交换操作。

参数

v 要交换内容的向量。

重载 libMesh::NumericVector< T > .

在文件 eigen_sparse_vector.h 第 526 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized , 以及 libMesh::EigenSparseVector< T >::swap().

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

 {
   EigenSparseVector<T> & v = cast_ref<EigenSparseVector<T> &>(other);
 
   _vec.swap(v._vec);
 
   std::swap (this->_is_closed,      v._is_closed);
   std::swap (this->_is_initialized, v._is_initialized);
   std::swap (this->_type,           v._type);
 }

template<typename T>

ParallelType libMesh::NumericVector< T >::type ( ) const

inlineinherited

获取向量的类型。

返回: 向量的类型（SERIAL、PARALLEL、GHOSTED）。

在文件 numeric_vector.h 第 166 行定义.

参考 libMesh::NumericVector< T >::_type.

参考自 libMesh::DofMap::constrain_element_residual(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::enforce_constraints_on_residual(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DofMap::heterogeneously_constrain_element_jacobian_and_residual(), libMesh::DofMap::heterogeneously_constrain_element_residual(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::LaspackVector< T >::init() , 以及 libMesh::PetscVector< T >::localize().

166 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

向量的类型。

Definition: numeric_vector.h:923

template<typename T>

ParallelType& libMesh::NumericVector< T >::type ( )

inlineinherited

获取向量的类型。

返回: 向量的类型（SERIAL、PARALLEL、GHOSTED）。

在文件 numeric_vector.h 第 173 行定义.

参考 libMesh::NumericVector< T >::_type.

173 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

向量的类型。

Definition: numeric_vector.h:923

template<typename T>

DataType& libMesh::EigenSparseVector< T >::vec ( )

inline

References to the underlying Eigen data types.

注解: This is generally not required in user-level code.

在文件 eigen_sparse_vector.h 第 243 行定义.

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

243 { return _vec; }

libMesh::EigenSparseVector::_vec

DataType _vec

Actual Eigen::SparseVector<> we are wrapping.

Definition: eigen_sparse_vector.h:251

template<typename T>

const DataType& libMesh::EigenSparseVector< T >::vec ( ) const

inline

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

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

244 { return _vec; }

libMesh::EigenSparseVector::_vec

DataType _vec

Actual Eigen::SparseVector<> we are wrapping.

Definition: eigen_sparse_vector.h:251

template<typename T >

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

inlineoverridevirtual

将所有条目设置为零。等同于 v = 0，但更明显且更快。

实现了 libMesh::NumericVector< T >.

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

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert (this->closed());
 
   _vec.setZero();
 }

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::EigenSparseVector< T >::zero_clone ( ) const

inlineoverridevirtual

返回一个智能指针，指向具有相同类型、大小和分区的此向量的副本，但所有条目都为零。

注解: 派生类必须重写此方法。

返回: 指向新向量副本的 unique_ptr。

实现了 libMesh::NumericVector< T >.

在文件 eigen_sparse_vector.h 第 416 行定义.

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

 {
   NumericVector<T> * cloned_vector = new EigenSparseVector<T>(this->comm());
   cloned_vector->init(*this);
   return std::unique_ptr<NumericVector<T>>(cloned_vector);
 }

友元及相关函数文档

template<typename T>

friend class EigenSparseLinearSolver< T >

friend

在文件 eigen_sparse_vector.h 第 257 行定义.

template<typename T>

friend class EigenSparseMatrix< T >

friend

Make other Eigen datatypes friends.

在文件 eigen_sparse_vector.h 第 256 行定义.

类成员变量说明

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

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

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

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::NumericVector< T >::_is_closed

protectedinherited

用于跟踪向量的值在在一些或全部处理器上进行插入或添加值操作后是否在所有处理器上保持一致的标志。

在文件 numeric_vector.h 第 913 行定义.

参考自 libMesh::NumericVector< T >::closed(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=() , 以及 libMesh::PetscVector< T >::PetscVector().

template<typename T>

bool libMesh::NumericVector< T >::_is_initialized

protectedinherited

在调用 init() 后设置为 true。

在文件 numeric_vector.h 第 918 行定义.

参考自 libMesh::PetscVector< T >::create_subvector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::NumericVector< T >::initialized(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=() , 以及 libMesh::PetscVector< T >::PetscVector().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

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

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

staticprotectedinherited

The number of objects.

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

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

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

template<typename T>

std::mutex libMesh::NumericVector< T >::_numeric_vector_mutex

protectedinherited

用于执行线程安全操作的互斥锁。

在文件 numeric_vector.h 第 928 行定义.

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

向量的类型。

在文件 numeric_vector.h 第 923 行定义.

参考自 libMesh::DistributedVector< T >::DistributedVector(), libMesh::EigenSparseVector< T >::EigenSparseVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::PetscVector< T >::init(), libMesh::LaspackVector< T >::LaspackVector(), libMesh::PetscVector< T >::PetscVector() , 以及 libMesh::NumericVector< T >::type().

template<typename T>

DataType libMesh::EigenSparseVector< T >::_vec

private

Actual Eigen::SparseVector<> we are wrapping.

在文件 eigen_sparse_vector.h 第 251 行定义.

参考自 libMesh::EigenSparseVector< T >::add(), libMesh::EigenSparseVector< T >::add_vector(), libMesh::EigenSparseVector< T >::add_vector_transpose(), libMesh::EigenSparseVector< T >::dot(), libMesh::EigenSparseMatrix< T >::get_diagonal(), libMesh::EigenSparseVector< T >::operator+=(), libMesh::EigenSparseVector< T >::operator-=(), libMesh::EigenSparseVector< T >::operator=() , 以及 libMesh::EigenSparseVector< T >::vec().

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

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

Public 类型

Public 成员函数

静态 Public 成员函数

Protected 类型

Protected 成员函数

Protected 属性

静态 Protected 属性

Private 属性

友元

详细描述

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

成员类型定义说明

构造及析构函数说明

成员函数说明

友元及相关函数文档

类成员变量说明

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