libmesh解析: libMesh::PetscVector< T

 {
   libmesh_assert (this->initialized());
 
   bool initially_array_is_present = _array_is_present.load(std::memory_order_acquire);
 
   // If we already have a read/write array - and we're trying
   // to get a read only array - let's just use the read write
   if (initially_array_is_present && read_only && !_values_read_only)
     _read_only_values = _values;
 
   // If the values have already been retrieved and we're currently
   // trying to get a non-read only view (ie read/write) and the
   // values are currently read only... then we need to restore
   // the array first... and then retrieve it again.
   if (initially_array_is_present && !read_only && _values_read_only)
     {
       _restore_array();
       initially_array_is_present = false;
     }
 
   if (!initially_array_is_present)
     {
       std::scoped_lock lock(_petsc_get_restore_array_mutex);
       if (!_array_is_present.load(std::memory_order_relaxed))
         {
           PetscErrorCode ierr=0;
           if (this->type() != GHOSTED)
             {
               if (read_only)
                 {
                   ierr = VecGetArrayRead(_vec, &_read_only_values);
                   _values_read_only = true;
                 }
               else
                 {
                   ierr = VecGetArray(_vec, &_values);
                   _values_read_only = false;
                 }
               LIBMESH_CHKERR(ierr);
               _local_size = this->local_size();
             }
           else
             {
               ierr = VecGhostGetLocalForm (_vec,&_local_form);
               LIBMESH_CHKERR(ierr);
 
               if (read_only)
                 {
                   ierr = VecGetArrayRead(_local_form, &_read_only_values);
                   _values_read_only = true;
                 }
               else
                 {
                   ierr = VecGetArray(_local_form, &_values);
                   _values_read_only = false;
                 }
               LIBMESH_CHKERR(ierr);
 
               PetscInt my_local_size = 0;
               ierr = VecGetLocalSize(_local_form, &my_local_size);
               LIBMESH_CHKERR(ierr);
               _local_size = static_cast<numeric_index_type>(my_local_size);
             }
 
           { // cache ownership range
             PetscInt petsc_first=0, petsc_last=0;
             ierr = VecGetOwnershipRange (_vec, &petsc_first, &petsc_last);
             LIBMESH_CHKERR(ierr);
             _first = static_cast<numeric_index_type>(petsc_first);
             _last = static_cast<numeric_index_type>(petsc_last);
           }
           _array_is_present.store(true, std::memory_order_release);
         }
     }
 }

template<typename T >

void libMesh::PetscVector< T >::_restore_array ( ) const

private

将数组（如果向量是幽灵的，则还包括本地形式）恢复到 PETSc。

在文件 petsc_vector.C 第 1346 行定义.

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

 {
   libmesh_error_msg_if(_values_manually_retrieved,
                        "PetscVector values were manually retrieved but are being automatically restored!");
 
   libmesh_assert (this->initialized());
   if (_array_is_present.load(std::memory_order_acquire))
     {
       std::scoped_lock lock(_petsc_get_restore_array_mutex);
       if (_array_is_present.load(std::memory_order_relaxed))
         {
           PetscErrorCode ierr=0;
           if (this->type() != GHOSTED)
             {
               if (_values_read_only)
                 ierr = VecRestoreArrayRead (_vec, &_read_only_values);
               else
                 ierr = VecRestoreArray (_vec, &_values);
 
               LIBMESH_CHKERR(ierr);
               _values = nullptr;
             }
           else
             {
               if (_values_read_only)
                 ierr = VecRestoreArrayRead (_local_form, &_read_only_values);
               else
                 ierr = VecRestoreArray (_local_form, &_values);
 
               LIBMESH_CHKERR(ierr);
               _values = nullptr;
               ierr = VecGhostRestoreLocalForm (_vec,&_local_form);
               LIBMESH_CHKERR(ierr);
               _local_form = nullptr;
               _local_size = 0;
             }
           _array_is_present.store(false, std::memory_order_release);
         }
     }
 }

template<typename T >

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

overridevirtual

对当前向量的所有元素取绝对值。

在文件 petsc_vector.C 第 459 行定义.

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscErrorCode ierr = VecAbs(_vec);
   LIBMESH_CHKERR(ierr);
 
   libmesh_assert(this->comm().verify(int(this->type())));
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 }

template<typename T >

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

overridevirtual

将索引为 i 的元素值增加 value。

参数

i	数值索引。
value	要增加的值。

在文件 petsc_vector.C 第 196 行定义.

参考 libMesh::PS().

 {
   this->_restore_array();
   libmesh_assert_less (i, size());
 
   PetscErrorCode ierr=0;
   PetscInt i_val = static_cast<PetscInt>(i);
   PetscScalar petsc_value = PS(value);
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   ierr = VecSetValues (_vec, 1, &i_val, &petsc_value, ADD_VALUES);
   LIBMESH_CHKERR(ierr);
 
   this->_is_closed = false;
 }

template<typename T >

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

overridevirtual

将 NumericVector 中的所有元素加上标量值 s。

参数

s 要加上的标量值。

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

 {
   this->_get_array(false);
 
   for (numeric_index_type i=0; i<_local_size; i++)
     _values[i] += PetscScalar(v_in);
 }

template<typename T >

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

overridevirtual

将当前 NumericVector 与另一个 NumericVector v 相加。

参数

v	另一个 NumericVector 对象。

在文件 petsc_vector.C 第 345 行定义.

 {
   parallel_object_only();
 
   this->add (1., v);
 }

template<typename T >

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

overridevirtual

将当前 NumericVector 与另一个 NumericVector v 相加，并乘以标量值 a。

参数

a	标量值。
v	另一个 NumericVector 对象。

在文件 petsc_vector.C 第 355 行定义.

参考 libMesh::PetscVector< T >::_restore_array(), libMesh::PS(), libMesh::PetscVector< T >::size() , 以及 libMesh::PetscVector< T >::vec().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // VecAXPY doesn't support &x==&y
   if (this == &v_in)
     {
       this->scale(a_in+1);
       return;
     }
 
   PetscScalar a = PS(a_in);
 
   // Make sure the NumericVector passed in is really a PetscVector
   const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
   v->_restore_array();
 
   libmesh_assert_equal_to (this->size(), v->size());
 
   PetscErrorCode ierr = VecAXPY(_vec, a, v->vec());
   LIBMESH_CHKERR(ierr);
 
   libmesh_assert(this->comm().verify(int(this->type())));
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
   this->_is_closed = true;
 }

template<typename T >

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

overridevirtual

向指定索引数组的元素中添加向量 v 的元素。

参数

v	向量 v。
dof_indices	指定的索引数组。

在文件 petsc_vector.C 第 215 行定义.

参考 libMesh::pPS().

 {
   // If we aren't adding anything just return
   if (dof_indices.empty())
     return;
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   const PetscInt * i_val = reinterpret_cast<const PetscInt *>(dof_indices.data());
   const PetscScalar * petsc_value = pPS(v);
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   ierr = VecSetValues (_vec, cast_int<PetscInt>(dof_indices.size()),
                        i_val, petsc_value, ADD_VALUES);
   LIBMESH_CHKERR(ierr);
 
   this->_is_closed = false;
 }

template<typename T >

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

overridevirtual

使用 SparseMatrix A 对向量 v 进行矩阵乘法，并将结果添加到当前向量。

参数

v	向量 v。
A	稀疏矩阵 A。

在文件 petsc_vector.C 第 239 行定义.

 {
   parallel_object_only();
 
   this->_restore_array();
   // Make sure the data passed in are really of Petsc types
   const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
   const PetscMatrix<T> * A = cast_ptr<const PetscMatrix<T> *>(&A_in);
 
   PetscErrorCode ierr=0;
 
   // We shouldn't close() the matrix for you, as that would potentially modify the state of a const object.
   if (!A->closed())
     {
       libmesh_warning("Matrix A must be assembled before calling PetscVector::add_vector(v, A).\n"
                       "Please update your code, as this warning will become an error in a future release.");
       libmesh_deprecated();
       const_cast<PetscMatrix<T> *>(A)->close();
     }
 
   // The const_cast<> is not elegant, but it is required since PETSc
   // expects a non-const Mat.
   ierr = MatMultAdd(const_cast<PetscMatrix<T> *>(A)->mat(), v->_vec, _vec, _vec);
   LIBMESH_CHKERR(ierr);
 }

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::PetscVector< T >::add_vector_conjugate_transpose	(	const NumericVector< T > &	v,
		const SparseMatrix< T > &	A
	)

$U \leftarrow U + A^H v$ .

将共轭转置的 SparseMatrix A 与 NumericVector v 的乘积添加到当前向量。

参数

v	向量 v。
A	稀疏矩阵 A。

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

 {
   parallel_object_only();
 
   this->_restore_array();
   // Make sure the data passed in are really of Petsc types
   const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
   const PetscMatrix<T> * A = cast_ptr<const PetscMatrix<T> *>(&A_in);
 
   // We shouldn't close() the matrix for you, as that would potentially modify the state of a const object.
   if (!A->closed())
     {
       libmesh_warning("Matrix A must be assembled before calling PetscVector::add_vector_conjugate_transpose(v, A).\n"
                       "Please update your code, as this warning will become an error in a future release.");
       libmesh_deprecated();
       const_cast<PetscMatrix<T> *>(A)->close();
     }
 
   // Store a temporary copy since MatMultHermitianTransposeAdd doesn't seem to work
   // TODO: Find out why MatMultHermitianTransposeAdd doesn't work, might be a PETSc bug?
   std::unique_ptr<NumericVector<Number>> this_clone = this->clone();
 
   // The const_cast<> is not elegant, but it is required since PETSc
   // expects a non-const Mat.
   PetscErrorCode ierr = MatMultHermitianTranspose(const_cast<PetscMatrix<T> *>(A)->mat(), v->_vec, _vec);
   LIBMESH_CHKERR(ierr);
 
   // Add the temporary copy to the matvec result
   this->add(1., *this_clone);
 }

template<typename T >

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

overridevirtual

使用 SparseMatrix A 的共轭转置与向量 v 进行矩阵乘法，并将结果添加到当前向量。

参数

v	向量 v。
A	稀疏矩阵 A。

在文件 petsc_vector.C 第 269 行定义.

参考自 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().

 {
   parallel_object_only();
 
   this->_restore_array();
   // Make sure the data passed in are really of Petsc types
   const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
   const PetscMatrix<T> * A = cast_ptr<const PetscMatrix<T> *>(&A_in);
 
   PetscErrorCode ierr=0;
 
   // We shouldn't close() the matrix for you, as that would potentially modify the state of a const object.
   if (!A->closed())
     {
       libmesh_warning("Matrix A must be assembled before calling PetscVector::add_vector_transpose(v, A).\n"
                       "Please update your code, as this warning will become an error in a future release.");
       libmesh_deprecated();
       const_cast<PetscMatrix<T> *>(A)->close();
     }
 
   // The const_cast<> is not elegant, but it is required since PETSc
   // expects a non-const Mat.
   ierr = MatMultTransposeAdd(const_cast<PetscMatrix<T> *>(A)->mat(), v->_vec, _vec, _vec);
   LIBMESH_CHKERR(ierr);
 }

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.

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

inlineoverridevirtualnoexcept

从析构函数中调用 clear()，所以它不应引发异常。

在文件 petsc_vector.h 第 1153 行定义.

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

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

template<typename T >

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

inlineoverridevirtual

克隆该 NumericVector 的独立副本。

返回: 返回一个指向克隆副本的 std::unique_ptr<NumericVector<T>>。

在文件 petsc_vector.h 第 1226 行定义.

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

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

template<typename T >

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

inlineoverridevirtual

关闭 PetscVector。

参考自 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=().

在文件 petsc_vector.h 第 1135 行定义.

参考自 libMesh::PetscVector< T >::localize().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   VecAssemblyBeginEnd(this->comm(), _vec);
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
   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.

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::PetscVector< T >::conjugate ( )

overridevirtual

对 NumericVector 中的所有元素取共轭。

在文件 petsc_vector.C 第 182 行定义.

 {
   parallel_object_only();
 
   PetscErrorCode ierr = 0;
 
   // We just call the PETSc VecConjugate
   ierr = VecConjugate(_vec);
   LIBMESH_CHKERR(ierr);
 }

template<typename T >

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

overridevirtual

创建当前向量的子向量，并将其赋值给 subvector。

参数

subvector	用于存储子向量的 NumericVector。
rows	子向量的行索引数组。

在文件 petsc_vector.C 第 1189 行定义.

参考 libMesh::NumericVector< T >::_is_initialized, libMesh::PetscVector< T >::_restore_array(), libMesh::PetscVector< T >::_vec, libMesh::WrappedPetsc< T >::get(), libMesh::NumericVector< T >::initialized() , 以及 libMesh::numeric_petsc_cast().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // PETSc data structures
   PetscErrorCode ierr = 0;
 
   // Make sure the passed in subvector is really a PetscVector
   PetscVector<T> * petsc_subvector = cast_ptr<PetscVector<T> *>(&subvector);
 
   // If the petsc_subvector is already initialized, we assume that the
   // user has already allocated the *correct* amount of space for it.
   // If not, we use the appropriate PETSc routines to initialize it.
   if (!petsc_subvector->initialized())
     {
       // Initialize the petsc_subvector to have enough space to hold
       // the entries which will be scattered into it.  Note: such an
       // init() function (where we let PETSc decide the number of local
       // entries) is not currently offered by the PetscVector
       // class.  Should we differentiate here between sequential and
       // parallel vector creation based on this->n_processors() ?
       ierr = VecCreateMPI(this->comm().get(),
                           PETSC_DECIDE,                    // n_local
                           cast_int<PetscInt>(rows.size()), // n_global
                           &(petsc_subvector->_vec));
       LIBMESH_CHKERR(ierr);
 
       ierr = VecSetFromOptions (petsc_subvector->_vec);
       LIBMESH_CHKERR(ierr);
 
       // Mark the subvector as initialized
       petsc_subvector->_is_initialized = true;
     }
   else
     {
       petsc_subvector->_restore_array();
     }
 
   // Use iota to fill an array with entries [0,1,2,3,4,...rows.size()]
   std::vector<PetscInt> idx(rows.size());
   std::iota (idx.begin(), idx.end(), 0);
 
   // Construct index sets
   WrappedPetsc<IS> parent_is;
   ierr = ISCreateGeneral(this->comm().get(),
                          cast_int<PetscInt>(rows.size()),
                          numeric_petsc_cast(rows.data()),
                          PETSC_USE_POINTER,
                          parent_is.get());
   LIBMESH_CHKERR(ierr);
 
   WrappedPetsc<IS> subvector_is;
   ierr = ISCreateGeneral(this->comm().get(),
                          cast_int<PetscInt>(rows.size()),
                          idx.data(),
                          PETSC_USE_POINTER,
                          subvector_is.get());
   LIBMESH_CHKERR(ierr);
 
   // Construct the scatter object
   WrappedPetsc<VecScatter> scatter;
   ierr = VecScatterCreate(this->_vec,
                           parent_is,
                           petsc_subvector->_vec,
                           subvector_is,
                           scatter.get()); LIBMESH_CHKERR(ierr);
 
   // Actually perform the scatter
   VecScatterBeginEnd(this->comm(), scatter, this->_vec, petsc_subvector->_vec, INSERT_VALUES, SCATTER_FORWARD);
 }

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::PetscVector< T >::dot ( const NumericVector< T > & v ) const

overridevirtual

计算当前向量与向量 v 的点积。

参数

v	另一个 NumericVector 对象。

返回: 返回点积结果。

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

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // Error flag
   PetscErrorCode ierr = 0;
 
   // Return value
   PetscScalar value=0.;
 
   // Make sure the NumericVector passed in is really a PetscVector
   const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
 
   // 2.3.x (at least) style.  Untested for previous versions.
   ierr = VecDot(this->_vec, v->_vec, &value);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<T>(value);
 }

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::PetscVector< T >::first_local_index ( ) const

inlineoverridevirtual

获取 NumericVector 的第一个本地索引。

返回: 返回 NumericVector 的第一个本地索引。

在文件 petsc_vector.h 第 1275 行定义.

 {
   libmesh_assert (this->initialized());
 
   numeric_index_type first = 0;
 
   if (_array_is_present) // Can we use cached values?
     first = _first;
   else
     {
       PetscErrorCode ierr=0;
       PetscInt petsc_first=0, petsc_last=0;
       ierr = VecGetOwnershipRange (_vec, &petsc_first, &petsc_last);
       LIBMESH_CHKERR(ierr);
       first = static_cast<numeric_index_type>(petsc_first);
     }
 
   return first;
 }

template<typename T >

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

inlineoverridevirtual

获取指定索引的元素值。

参数

index	索引数组。
values	用于存储值的数组。

在文件 petsc_vector.h 第 1403 行定义.

 {
   this->_get_array(true);
 
   const std::size_t num = index.size();
 
   for (std::size_t i=0; i<num; i++)
     {
       const numeric_index_type local_index = this->map_global_to_local_index(index[i]);
 #ifndef NDEBUG
       if (this->type() == GHOSTED)
         {
           libmesh_assert_less (local_index, _local_size);
         }
 #endif
       values[i] = static_cast<T>(_read_only_values[local_index]);
     }
 }

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());
 }

template<typename T >

PetscScalar * libMesh::PetscVector< T >::get_array ( )

inline

获取对 PETSc Vector 数据数组的读/写访问权限。

注解: 这是一个高级接口。通常情况下，除非你知道自己在做什么，否则应避免使用它！

在文件 petsc_vector.h 第 1426 行定义.

 {
   _get_array(false);
   _values_manually_retrieved = true;
 
   return _values;
 }

template<typename T >

const PetscScalar * libMesh::PetscVector< T >::get_array_read ( ) const

inline

获取对 PETSc Vector 数据数组的只读访问权限。

注解: 这是一个高级接口。通常情况下，除非你知道自己在做什么，否则应避免使用它！

在文件 petsc_vector.h 第 1437 行定义.

 {
   _get_array(true);
   _values_manually_retrieved = true;
 
   return _read_only_values;
 }

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 >

T libMesh::PetscVector< T >::indefinite_dot ( const NumericVector< T > & v ) const

计算 (*this) 与向量 v 的点积，不使用复数值的共轭。

参数

v	另一个 NumericVector 对象。

返回: 返回点积结果。

在文件 petsc_vector.C 第 498 行定义.

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // Error flag
   PetscErrorCode ierr = 0;
 
   // Return value
   PetscScalar value=0.;
 
   // Make sure the NumericVector passed in is really a PetscVector
   const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
 
   // 2.3.x (at least) style.  Untested for previous versions.
   ierr = VecTDot(this->_vec, v->_vec, &value);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<T>(value);
 }

template<typename T >

void libMesh::PetscVector< T >::init	(	const numeric_index_type	N,
		const numeric_index_type	n_local,
		const bool	fast = `false`,
		const ParallelType	type = `AUTOMATIC`
	)

inlineoverridevirtual

初始化 NumericVector 对象。

参数

N	全局维度。
n_local	本地维度。
fast	是否启用快速初始化，默认为 false。
type	并行类型，默认为 AUTOMATIC。

在文件 petsc_vector.h 第 959 行定义.

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

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

 {
   parallel_object_only();
 
   PetscErrorCode ierr=0;
   PetscInt petsc_n=static_cast<PetscInt>(n);
 
   // Clear initialized vectors
   if (this->initialized())
     this->clear();
 
   if (ptype == AUTOMATIC)
     {
       if (n == n_local)
         this->_type = SERIAL;
       else
         this->_type = PARALLEL;
     }
   else
     this->_type = ptype;
 
   libmesh_assert ((this->_type==SERIAL && n==n_local) ||
                   this->_type==PARALLEL);
 
   // create a sequential vector if on only 1 processor
   if (this->_type == SERIAL)
     {
       ierr = VecCreate(PETSC_COMM_SELF, &_vec);CHKERRABORT(PETSC_COMM_SELF,ierr);
       ierr = VecSetSizes(_vec, petsc_n, petsc_n); CHKERRABORT(PETSC_COMM_SELF,ierr);
       ierr = VecSetFromOptions (_vec);
       CHKERRABORT(PETSC_COMM_SELF,ierr);
     }
   // otherwise create an MPI-enabled vector
   else if (this->_type == PARALLEL)
     {
 #ifdef LIBMESH_HAVE_MPI
       PetscInt petsc_n_local=cast_int<PetscInt>(n_local);
       libmesh_assert_less_equal (n_local, n);
       // Use more generic function instead of VecCreateSeq/MPI
       ierr = VecCreate(this->comm().get(), &_vec);LIBMESH_CHKERR(ierr);
       ierr = VecSetSizes(_vec, petsc_n_local, petsc_n); LIBMESH_CHKERR(ierr);
 #else
       libmesh_assert_equal_to (n_local, n);
       ierr = VecCreate(PETSC_COMM_SELF, &_vec);CHKERRABORT(PETSC_COMM_SELF,ierr);
       ierr = VecSetSizes(_vec, petsc_n, petsc_n); CHKERRABORT(PETSC_COMM_SELF,ierr);
 #endif
       ierr = VecSetFromOptions (_vec);
       LIBMESH_CHKERR(ierr);
     }
   else
     libmesh_error_msg("Unsupported type " << Utility::enum_to_string(this->_type));
 
   this->_is_initialized = true;
   this->_is_closed = true;
 
 
   if (fast == false)
     this->zero ();
 }

template<typename T >

void libMesh::PetscVector< T >::init	(	const numeric_index_type	N,
		const bool	fast = `false`,
		const ParallelType	type = `AUTOMATIC`
	)

inlineoverridevirtual

初始化 NumericVector 对象。

参数

N	全局维度。
fast	是否启用快速初始化，默认为 false。
type	并行类型，默认为 AUTOMATIC。

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

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

template<typename T>

virtual void libMesh::PetscVector< 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	= `AUTOMATIC`
	)

overridevirtual

初始化 NumericVector 对象。

参数

N	全局维度。
n_local	本地维度。
ghost	指定要保留内存的索引。
fast	是否启用快速初始化，默认为 false。
type	并行类型，默认为 AUTOMATIC。

template<typename T >

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

inlineoverridevirtual

使用另一个 NumericVector 对象初始化当前对象。

参数

other	另一个 NumericVector 对象。
fast	是否启用快速初始化，默认为 false。

参考 libMesh::PetscVector< T >::_global_to_local_map, libMesh::libMeshPrivateData::_is_initialized, libMesh::PetscVector< T >::_restore_array(), libMesh::NumericVector< T >::_type, libMesh::PetscVector< T >::_vec, libMesh::NumericVector< T >::initialized(), libMesh::initialized() , 以及 libMesh::zero.

在文件 petsc_vector.h 第 1098 行定义.

 {
   parallel_object_only();
 
   // 清除已初始化的向量
   if (this->initialized())
     this->clear();
 
   const PetscVector<T> & v = cast_ref<const PetscVector<T> &>(other);
 
   // 其他向量应该恢复数组。
   if (v.initialized())
     {
       v._restore_array();
     }
 
   this->_global_to_local_map = v._global_to_local_map;
 
   // 即使我们基于一个未初始化或未关闭的向量来初始化大小，*这个*向量现在正在初始化，最初是关闭的。
   this->_is_closed      = true; // v._is_closed;
   this->_is_initialized = true; // v._is_initialized;
 
   this->_type = v._type;
 
   // 我们希望有一个有效的 Vec，即使它最初的大小为零
   PetscErrorCode ierr = VecDuplicate (v._vec, &this->_vec);
   LIBMESH_CHKERR(ierr);
 
   if (fast == false)
     this->zero ();
 }

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::PetscVector< T >::insert	(	const T *	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

overridevirtual

将指定索引数组的元素设置为向量 v 的元素。

参数

v	向量 v。
dof_indices	指定的索引数组。

在文件 petsc_vector.C 第 390 行定义.

参考 libMesh::numeric_petsc_cast() , 以及 libMesh::pPS().

 {
   if (dof_indices.empty())
     return;
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   PetscInt * idx_values = numeric_petsc_cast(dof_indices.data());
   std::scoped_lock lock(this->_numeric_vector_mutex);
   ierr = VecSetValues (_vec, cast_int<PetscInt>(dof_indices.size()),
                        idx_values, pPS(v), INSERT_VALUES);
   LIBMESH_CHKERR(ierr);
 
   this->_is_closed = false;
 }

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

overridevirtual

计算 NumericVector 的 L1 范数。

返回: 返回 L1 范数。

在文件 petsc_vector.C 第 60 行定义.

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

 {
   this->_restore_array();
   libmesh_assert(this->closed());
 
   PetscErrorCode ierr=0;
   PetscReal value=0.;
 
   ierr = VecNorm (_vec, NORM_1, &value);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<Real>(value);
 }

template<typename T >

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

overridevirtual

计算 NumericVector 的 L2 范数。

返回: 返回 L2 范数。

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

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

 {
   parallel_object_only();
 
   this->_restore_array();
   libmesh_assert(this->closed());
 
   PetscErrorCode ierr=0;
   PetscReal value=0.;
 
   ierr = VecNorm (_vec, NORM_2, &value);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<Real>(value);
 }

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::PetscVector< T >::last_local_index ( ) const

inlineoverridevirtual

获取 NumericVector 的最后一个本地索引。

返回: 返回 NumericVector 的最后一个本地索引。

在文件 petsc_vector.h 第 1299 行定义.

 {
   libmesh_assert (this->initialized());
 
   numeric_index_type last = 0;
 
   if (_array_is_present) // Can we use cached values?
     last = _last;
   else
     {
       PetscErrorCode ierr=0;
       PetscInt petsc_first=0, petsc_last=0;
       ierr = VecGetOwnershipRange (_vec, &petsc_first, &petsc_last);
       LIBMESH_CHKERR(ierr);
       last = static_cast<numeric_index_type>(petsc_last);
     }
 
   return last;
 }

template<typename T >

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

overridevirtual

计算 NumericVector 的 Linf 范数。

返回: 返回 Linf 范数。

在文件 petsc_vector.C 第 97 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
   libmesh_assert(this->closed());
 
   PetscErrorCode ierr=0;
   PetscReal value=0.;
 
   ierr = VecNorm (_vec, NORM_INFINITY, &value);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<Real>(value);
 }

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::PetscVector< T >::local_size ( ) const

inlineoverridevirtual

获取 NumericVector 的本地大小（本地维度）。

返回: 返回 NumericVector 的本地大小（本地维度）。

在文件 petsc_vector.h 第 1258 行定义.

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

 {
   libmesh_assert (this->initialized());
 
   PetscErrorCode ierr=0;
   PetscInt petsc_size=0;
 
   ierr = VecGetLocalSize(_vec, &petsc_size);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<numeric_index_type>(petsc_size);
 }

template<typename T >

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

overridevirtual

将当前向量的数据本地化到 std::vector v_local 中。

参数

v_local 用于存储本地数据的 std::vector。

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

参考自 libMesh::PetscVector< T >::localize().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // This function must be run on all processors at once
   parallel_object_only();
 
   PetscErrorCode ierr=0;
   const PetscInt n = this->size();
   const PetscInt nl = this->local_size();
   PetscScalar * values;
 
   v_local.clear();
   v_local.resize(n, 0.);
 
   ierr = VecGetArray (_vec, &values);
   LIBMESH_CHKERR(ierr);
 
   numeric_index_type ioff = first_local_index();
 
   for (PetscInt i=0; i<nl; i++)
     v_local[i+ioff] = static_cast<T>(values[i]);
 
   ierr = VecRestoreArray (_vec, &values);
   LIBMESH_CHKERR(ierr);
 
   this->comm().sum(v_local);
 }

template<typename T >

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

overridevirtual

将当前向量的数据本地化到 NumericVector v_local 中。

参数

v_local 用于存储本地数据的 NumericVector。

在文件 petsc_vector.C 第 634 行定义.

参考 libMesh::PetscVector< T >::_vec, libMesh::NumericVector< T >::closed(), libMesh::WrappedPetsc< T >::get(), libMesh::PetscVector< T >::local_size(), libMesh::PetscVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // Make sure the NumericVector passed in is really a PetscVector
   PetscVector<T> * v_local = cast_ptr<PetscVector<T> *>(&v_local_in);
 
   libmesh_assert(v_local);
   // v_local_in should be closed
   libmesh_assert(v_local->closed());
   libmesh_assert_equal_to (v_local->size(), this->size());
   // 1) v_local_in is a large vector to hold the whole world
   // 2) v_local_in is a ghosted vector
   // 3) v_local_in is a parallel vector
   // Cases 2) and 3) should be scalable
   libmesh_assert(this->size()==v_local->local_size() || this->local_size()==v_local->local_size());
 
   PetscErrorCode ierr = 0;
 
   if (v_local->type() == SERIAL && this->size() == v_local->local_size())
   {
     WrappedPetsc<VecScatter> scatter;
     ierr = VecScatterCreateToAll(_vec, scatter.get(), nullptr);
     LIBMESH_CHKERR(ierr);
     VecScatterBeginEnd(this->comm(), scatter, _vec, v_local->_vec, INSERT_VALUES, SCATTER_FORWARD);
   }
   // Two vectors have the same size, and we should just do a simple copy.
   // v_local could be either a parallel or ghosted vector
   else if (this->local_size() == v_local->local_size())
   {
     ierr = VecCopy(_vec,v_local->_vec);
     LIBMESH_CHKERR(ierr);
   }
   else
   {
     libmesh_error_msg("Vectors are inconsistent");
   }
 
   // Make sure ghost dofs are up to date
   // We do not call "close" here to save a global reduction
   if (v_local->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), v_local->_vec, INSERT_VALUES, SCATTER_FORWARD);
 }

template<typename T >

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

overridevirtual

将当前向量的数据本地化到 NumericVector v_local 中，只包括指定的索引。

参数

v_local	用于存储本地数据的 NumericVector。
indices	指定的索引数组。

在文件 petsc_vector.C 第 683 行定义.

参考 libMesh::PetscVector< T >::_vec, libMesh::PetscVector< T >::close(), libMesh::WrappedPetsc< T >::get(), libMesh::PetscVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

 {
   parallel_object_only();
 
   libmesh_assert(this->comm().verify(int(this->type())));
   libmesh_assert(this->comm().verify(int(v_local_in.type())));
 
   // FIXME: Workaround for a strange bug at large-scale.
   // If we have ghosting, PETSc lets us just copy the solution, and
   // doing so avoids a segfault?
   if (v_local_in.type() == GHOSTED &&
       this->type() == PARALLEL)
     {
       v_local_in = *this;
       return;
     }
 
   // Normal code path begins here
 
   this->_restore_array();
 
   // Make sure the NumericVector passed in is really a PetscVector
   PetscVector<T> * v_local = cast_ptr<PetscVector<T> *>(&v_local_in);
 
   libmesh_assert(v_local);
   libmesh_assert_equal_to (v_local->size(), this->size());
   libmesh_assert_less_equal (send_list.size(), v_local->size());
 
   PetscErrorCode ierr=0;
   const numeric_index_type n_sl =
     cast_int<numeric_index_type>(send_list.size());
 
   std::vector<PetscInt> idx(n_sl + this->local_size());
   for (numeric_index_type i=0; i<n_sl; i++)
     idx[i] = static_cast<PetscInt>(send_list[i]);
   for (auto i : make_range(this->local_size()))
     idx[n_sl+i] = i + this->first_local_index();
 
   // Create the index set & scatter objects
   WrappedPetsc<IS> is;
   PetscInt * idxptr = idx.empty() ? nullptr : idx.data();
   ierr = ISCreateGeneral(this->comm().get(), n_sl+this->local_size(),
                          idxptr, PETSC_USE_POINTER, is.get());
   LIBMESH_CHKERR(ierr);
 
   WrappedPetsc<VecScatter> scatter;
   ierr = VecScatterCreate(_vec,          is,
                           v_local->_vec, is,
                           scatter.get());
   LIBMESH_CHKERR(ierr);
 
 
   // Perform the scatter
   VecScatterBeginEnd(this->comm(), scatter, _vec, v_local->_vec, INSERT_VALUES, SCATTER_FORWARD);
 
   // Make sure ghost dofs are up to date
   if (v_local->type() == GHOSTED)
     v_local->close();
 }

template<typename T >

void libMesh::PetscVector< 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

本地化当前向量的数据，并将其发送给指定的进程。

参数

first_local_idx	第一个本地索引。
last_local_idx	最后一个本地索引。
send_list	要发送给的进程列表。

在文件 petsc_vector.C 第 802 行定义.

参考 libMesh::PetscVector< T >::_vec, libMesh::PetscVector< T >::close(), libMesh::WrappedPetsc< T >::get(), libMesh::PetscVector< T >::init() , 以及 libMesh::PetscVector< T >::localize().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   libmesh_assert_less_equal (send_list.size(), this->size());
   libmesh_assert_less_equal (last_local_idx+1, this->size());
 
   const numeric_index_type my_size       = this->size();
   const numeric_index_type my_local_size = (last_local_idx + 1 - first_local_idx);
   PetscErrorCode ierr=0;
 
   // Don't bother for serial cases
   //  if ((first_local_idx == 0) &&
   //      (my_local_size == my_size))
   // But we do need to stay in sync for degenerate cases
   if (this->n_processors() == 1)
     return;
 
 
   // Build a parallel vector, initialize it with the local
   // parts of (*this)
   PetscVector<T> parallel_vec(this->comm(), PARALLEL);
 
   parallel_vec.init (my_size, my_local_size, true, PARALLEL);
 
 
   // Copy part of *this into the parallel_vec
   {
     // Create idx, idx[i] = i+first_local_idx;
     std::vector<PetscInt> idx(my_local_size);
     std::iota (idx.begin(), idx.end(), first_local_idx);
 
     // Create the index set & scatter objects
     WrappedPetsc<IS> is;
     ierr = ISCreateGeneral(this->comm().get(), my_local_size,
                            my_local_size ? idx.data() : nullptr, PETSC_USE_POINTER, is.get());
     LIBMESH_CHKERR(ierr);
 
     WrappedPetsc<VecScatter> scatter;
     ierr = VecScatterCreate(_vec,              is,
                             parallel_vec._vec, is,
                             scatter.get());
     LIBMESH_CHKERR(ierr);
 
     // Perform the scatter
     VecScatterBeginEnd(this->comm(), scatter, _vec, parallel_vec._vec, INSERT_VALUES, SCATTER_FORWARD);
   }
 
   // localize like normal
   parallel_vec.close();
   parallel_vec.localize (*this, send_list);
   this->close();
 }

template<typename T>

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

pure virtualinherited

用全局索引中给定的值填充本地 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::EpetraVector< T >, libMesh::LaspackVector< T >, libMesh::EigenSparseVector< T > , 以及 libMesh::DistributedVector< T > 内被实现.

template<typename T>

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

overridevirtual

将当前向量的数据本地化到 std::vector v_local 中，只包括一个进程的数据。

参数

v_local	用于存储本地数据的 std::vector。
proc_id	进程 ID。

template<>

void libMesh::PetscVector< Real >::localize_to_one	(	std::vector< Real > &	v_local,
		const processor_id_type	timpi_mpi_varpid
	)		const

在文件 petsc_vector.C 第 900 行定义.

参考 libMesh::WrappedPetsc< T >::get().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   const PetscInt n  = size();
   PetscScalar * values;
 
   // only one processor
   if (n_processors() == 1)
     {
       v_local.resize(n);
 
       ierr = VecGetArray (_vec, &values);
       LIBMESH_CHKERR(ierr);
 
       for (PetscInt i=0; i<n; i++)
         v_local[i] = static_cast<Real>(values[i]);
 
       ierr = VecRestoreArray (_vec, &values);
       LIBMESH_CHKERR(ierr);
     }
 
   // otherwise multiple processors
 #ifdef LIBMESH_HAVE_MPI
   else
     {
       if (pid == 0) // optimized version for localizing to 0
         {
           WrappedPetsc<Vec> vout;
           WrappedPetsc<VecScatter> ctx;
 
           ierr = VecScatterCreateToZero(_vec, ctx.get(), vout.get());
           LIBMESH_CHKERR(ierr);
 
           VecScatterBeginEnd(this->comm(), ctx, _vec, vout, INSERT_VALUES, SCATTER_FORWARD);
 
           if (processor_id() == 0)
             {
               v_local.resize(n);
 
               ierr = VecGetArray (vout, &values);
               LIBMESH_CHKERR(ierr);
 
               for (PetscInt i=0; i<n; i++)
                 v_local[i] = static_cast<Real>(values[i]);
 
               ierr = VecRestoreArray (vout, &values);
               LIBMESH_CHKERR(ierr);
             }
         }
       else
         {
           v_local.resize(n);
 
           numeric_index_type ioff = this->first_local_index();
           std::vector<Real> local_values (n, 0.);
 
           {
             ierr = VecGetArray (_vec, &values);
             LIBMESH_CHKERR(ierr);
 
             const PetscInt nl = local_size();
             for (PetscInt i=0; i<nl; i++)
               local_values[i+ioff] = static_cast<Real>(values[i]);
 
             ierr = VecRestoreArray (_vec, &values);
             LIBMESH_CHKERR(ierr);
           }
 
 
           MPI_Reduce (local_values.data(), v_local.data(), n,
                       Parallel::StandardType<Real>(),
                       Parallel::OpFunction<Real>::sum(), pid,
                       this->comm().get());
         }
     }
 #endif // LIBMESH_HAVE_MPI
 }

template<>

void libMesh::PetscVector< Complex >::localize_to_one	(	std::vector< Complex > &	v_local,
		const processor_id_type	pid
	)		const

在文件 petsc_vector.C 第 991 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   const PetscInt n  = size();
   const PetscInt nl = local_size();
   PetscScalar * values;
 
 
   v_local.resize(n);
 
 
   for (PetscInt i=0; i<n; i++)
     v_local[i] = 0.;
 
   // only one processor
   if (n_processors() == 1)
     {
       ierr = VecGetArray (_vec, &values);
       LIBMESH_CHKERR(ierr);
 
       for (PetscInt i=0; i<n; i++)
         v_local[i] = static_cast<Complex>(values[i]);
 
       ierr = VecRestoreArray (_vec, &values);
       LIBMESH_CHKERR(ierr);
     }
 
   // otherwise multiple processors
   else
     {
       numeric_index_type ioff = this->first_local_index();
 
       /* in here the local values are stored, acting as send buffer for MPI
        * initialize to zero, since we collect using MPI_SUM
        */
       std::vector<Real> real_local_values(n, 0.);
       std::vector<Real> imag_local_values(n, 0.);
 
       {
         ierr = VecGetArray (_vec, &values);
         LIBMESH_CHKERR(ierr);
 
         // provide my local share to the real and imag buffers
         for (PetscInt i=0; i<nl; i++)
           {
             real_local_values[i+ioff] = static_cast<Complex>(values[i]).real();
             imag_local_values[i+ioff] = static_cast<Complex>(values[i]).imag();
           }
 
         ierr = VecRestoreArray (_vec, &values);
         LIBMESH_CHKERR(ierr);
       }
 
       /* have buffers of the real and imaginary part of v_local.
        * Once MPI_Reduce() collected all the real and imaginary
        * parts in these std::vector<Real>, the values can be
        * copied to v_local
        */
       std::vector<Real> real_v_local(n);
       std::vector<Real> imag_v_local(n);
 
       // collect entries from other proc's in real_v_local, imag_v_local
       MPI_Reduce (real_local_values.data(),
                   real_v_local.data(), n,
                   Parallel::StandardType<Real>(),
                   Parallel::OpFunction<Real>::sum(),
                   pid, this->comm().get());
 
       MPI_Reduce (imag_local_values.data(),
                   imag_v_local.data(), n,
                   Parallel::StandardType<Real>(),
                   Parallel::OpFunction<Real>::sum(),
                   pid, this->comm().get());
 
       // copy real_v_local and imag_v_local to v_local
       for (PetscInt i=0; i<n; i++)
         v_local[i] = Complex(real_v_local[i], imag_v_local[i]);
     }
 }

template<typename T >

numeric_index_type libMesh::PetscVector< T >::map_global_to_local_index ( const numeric_index_type i ) const

inline

返回: 全局索引 i 对应的本地索引。

如果索引不是幽灵单元，那么通过减去第一个本地索引的数量来实现。如果它是幽灵单元，需要在映射中查找。

在文件 petsc_vector.h 第 1323 行定义.

 {
   libmesh_assert (this->initialized());
 
   numeric_index_type first=0;
   numeric_index_type last=0;
 
   if (_array_is_present) // Can we use cached values?
     {
       first = _first;
       last = _last;
     }
   else
     {
       PetscErrorCode ierr=0;
       PetscInt petsc_first=0, petsc_last=0;
       ierr = VecGetOwnershipRange (_vec, &petsc_first, &petsc_last);
       LIBMESH_CHKERR(ierr);
       first = static_cast<numeric_index_type>(petsc_first);
       last = static_cast<numeric_index_type>(petsc_last);
     }
 
 
   if ((i>=first) && (i<last))
     {
       return i-first;
     }
 
   GlobalToLocalMap::const_iterator it = _global_to_local_map.find(i);
 #ifndef NDEBUG
   const GlobalToLocalMap::const_iterator end = _global_to_local_map.end();
   if (it == end)
     {
       std::ostringstream error_message;
       error_message << "No index " << i << " in ghosted vector.\n"
                     << "Vector contains [" << first << ',' << last << ")\n";
       GlobalToLocalMap::const_iterator b = _global_to_local_map.begin();
       if (b == end)
         {
           error_message << "And empty ghost array.\n";
         }
       else
         {
           error_message << "And ghost array {" << b->first;
           for (++b; b != end; ++b)
             error_message << ',' << b->first;
           error_message << "}\n";
         }
 
       libmesh_error_msg(error_message.str());
     }
   libmesh_assert (it != _global_to_local_map.end());
 #endif
   return it->second+last-first;
 }

template<typename T >

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

inlineoverridevirtual

获取 NumericVector 中的最大值。

返回: 返回 NumericVector 中的最大值。

在文件 petsc_vector.h 第 1478 行定义.

参考 libMesh::Real.

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   PetscInt index=0;
   PetscReal returnval=0.;
 
   ierr = VecMax (_vec, &index, &returnval);
   LIBMESH_CHKERR(ierr);
 
   // this return value is correct: VecMax returns a PetscReal
   return static_cast<Real>(returnval);
 }

template<typename T >

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

inlineoverridevirtual

获取当前向量允许的最大 ID。

返回: 返回允许的最大 ID。

在文件 petsc_vector.h 第 1526 行定义.

 {
   // The PetscInt type is used for indexing, it may be either a signed
   // 4-byte or 8-byte integer depending on how PETSc is configured.
   return std::numeric_limits<PetscInt>::max();
 }

template<typename T >

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

inlineoverridevirtual

获取 NumericVector 中的最小值。

返回: 返回 NumericVector 中的最小值。

libMesh::ReferenceCounter::_n_objects

在文件 petsc_vector.h 第 1457 行定义.

参考 libMesh::Real.

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   PetscInt index=0;
   PetscReal returnval=0.;
 
   ierr = VecMin (_vec, &index, &returnval);
   LIBMESH_CHKERR(ierr);
 
   // this return value is correct: VecMin returns a PetscReal
   return static_cast<Real>(returnval);
 }

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

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:132

template<typename T >

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

inlineoverridevirtual

访问 NumericVector 对象的元素。

参数

i 数值索引。

返回: 返回索引为 i 的元素值。

libMesh::NumericVector::scale

在文件 petsc_vector.h 第 1383 行定义.

 {
   this->_get_array(true);
 
   const numeric_index_type local_index = this->map_global_to_local_index(i);
 
 #ifndef NDEBUG
   if (this->type() == GHOSTED)
     {
       libmesh_assert_less (local_index, _local_size);
     }
 #endif
 
   return static_cast<T>(_read_only_values[local_index]);
 }

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

virtual void scale(const T factor)=0

缩放向量的每个元素。

template<typename T >

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

overridevirtual

将当前向量与另一个 NumericVector v 逐元素相乘并赋值给当前向量。

参数

v	另一个 NumericVector 对象。

在文件 petsc_vector.C 第 429 行定义.

 {
   parallel_object_only();
 
   PetscErrorCode ierr = 0;
 
   const PetscVector<T> * v_vec = cast_ptr<const PetscVector<T> *>(&v);
 
   ierr = VecPointwiseMult(_vec, _vec, v_vec->_vec);
   LIBMESH_CHKERR(ierr);
 
   return *this;
 }

template<typename T >

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

overridevirtual

将当前 NumericVector 与另一个 NumericVector v 相加。

参数

v	另一个 NumericVector 对象。

返回: 返回 *this 的引用。

在文件 petsc_vector.C 第 118 行定义.

参考 libMesh::closed().

 {
   parallel_object_only();
 
   this->_restore_array();
   libmesh_assert(this->closed());
 
   this->add(1., v);
 
   return *this;
 }

template<typename T >

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

overridevirtual

将当前 NumericVector 与另一个 NumericVector v 相减。

参数

v	另一个 NumericVector 对象。

返回: 返回 *this 的引用。

libMesh::NumericVector::scale

在文件 petsc_vector.C 第 134 行定义.

参考 libMesh::closed().

 {
   parallel_object_only();
 
   this->_restore_array();
   libmesh_assert(this->closed());
 
   this->add(-1., v);
 
   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; }

virtual void scale(const T factor)=0

缩放向量的每个元素。

template<typename T >

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

overridevirtual

将当前向量与另一个 NumericVector v 逐元素相除并赋值给当前向量。

参数

v	另一个 NumericVector 对象。

在文件 petsc_vector.C 第 444 行定义.

 {
   parallel_object_only();
 
   PetscErrorCode ierr = 0;
 
   const PetscVector<T> * v_vec = cast_ptr<const PetscVector<T> *>(&v);
 
   ierr = VecPointwiseDivide(_vec, _vec, v_vec->_vec);
   LIBMESH_CHKERR(ierr);
 
   return *this;
 }

template<typename T >

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

复制赋值运算符。在执行各种检查后调用 VecCopy。

返回: 派生类型 *this 的引用。

参数

v	要复制的 PetscVector 对象。

在文件 petsc_vector.C 第 566 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
   v._restore_array();
 
   libmesh_assert_equal_to (this->size(), v.size());
   libmesh_assert_equal_to (this->local_size(), v.local_size());
   libmesh_assert (v.closed());
 
   PetscErrorCode ierr = 0;
 
   ierr = VecCopy (v._vec, this->_vec);
   LIBMESH_CHKERR(ierr);
 
   libmesh_assert(this->comm().verify(int(this->type())));
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
   this->_is_closed = true;
 
   return *this;
 }

template<typename T>

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

delete

template<typename T >

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

overridevirtual

将 NumericVector 中的所有元素设置为标量值 s。

参数

s	要赋给所有元素的标量值。

返回: 返回 *this 的引用。

在文件 petsc_vector.C 第 523 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
   libmesh_assert(this->closed());
 
   PetscScalar s = PS(s_in);
 
   if (this->size() != 0)
     {
       PetscErrorCode ierr = VecSet(_vec, s);
       LIBMESH_CHKERR(ierr);
 
       libmesh_assert(this->comm().verify(int(this->type())));
 
       if (this->type() == GHOSTED)
         VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
     }
 
   return *this;
 }

template<typename T >

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

overridevirtual

将当前 NumericVector 的内容复制为另一个 NumericVector v。

参数

v	另一个 NumericVector 对象。

返回: 返回 *this 的引用。

在文件 petsc_vector.C 第 550 行定义.

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

template<typename T >

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

overridevirtual

将当前 NumericVector 的内容复制为一个标量值向量 v。

参数

v 标量值向量。

返回: 返回 *this 的引用。

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

Case 2: The vector is the same size as our local piece. Insert directly to the local piece.

在文件 petsc_vector.C 第 596 行定义.

参考 libMesh::PS().

 {
   parallel_object_only();
 
   this->_get_array(false);
 
   if (this->size() == v.size())
     {
       numeric_index_type first = first_local_index();
       numeric_index_type last = last_local_index();
       for (numeric_index_type i=0; i<last-first; i++)
         _values[i] = PS(v[first + i]);
     }
 
   else
     {
       for (numeric_index_type i=0; i<_local_size; i++)
         _values[i] = PS(v[i]);
     }
 
   // Make sure ghost dofs are up to date
   if (this->type() == GHOSTED)
     this->close();
 
   return *this;
 }

template<typename T >

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

overridevirtual

逐元素将当前向量与 vec1 相除，结果存储在当前向量中。

参数

vec1	另一个 NumericVector 对象。

在文件 petsc_vector.C 第 1105 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // Convert arguments to PetscVector*.
   const PetscVector<T> * const vec1_petsc = cast_ptr<const PetscVector<T> *>(&vec1);
   const PetscVector<T> * const vec2_petsc = cast_ptr<const PetscVector<T> *>(&vec2);
 
   // Call PETSc function.
   PetscErrorCode ierr = VecPointwiseDivide(_vec, vec1_petsc->vec(), vec2_petsc->vec());
   LIBMESH_CHKERR(ierr);
 
   libmesh_assert(this->comm().verify(int(this->type())));
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
   this->_is_closed = true;
 }

template<typename T >

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

overridevirtual

逐元素将当前向量与 vec1 相乘，结果存储在当前向量中。

参数

vec1	另一个 NumericVector 对象。

在文件 petsc_vector.C 第 1081 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
 
   // Convert arguments to PetscVector*.
   const PetscVector<T> * vec1_petsc = cast_ptr<const PetscVector<T> *>(&vec1);
   const PetscVector<T> * vec2_petsc = cast_ptr<const PetscVector<T> *>(&vec2);
 
   // Call PETSc function.
   PetscErrorCode ierr = VecPointwiseMult(_vec, vec1_petsc->vec(), vec2_petsc->vec());
   LIBMESH_CHKERR(ierr);
 
   libmesh_assert(this->comm().verify(int(this->type())));
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
   this->_is_closed = true;
 }

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

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

overridevirtual

将当前向量的数据以 MATLAB 格式打印输出。

参数

name 输出的名称。

在文件 petsc_vector.C 第 1129 行定义.

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

 {
   parallel_object_only();
 
   this->_restore_array();
   libmesh_assert (this->closed());
 
   PetscErrorCode ierr = 0;
 
   WrappedPetsc<PetscViewer> petsc_viewer;
   ierr = PetscViewerCreate (this->comm().get(), petsc_viewer.get());
   LIBMESH_CHKERR(ierr);
 
   // Create an ASCII file containing the matrix
   // if a filename was provided.
   if (name != "")
     {
       ierr = PetscViewerASCIIOpen( this->comm().get(),
                                    name.c_str(),
                                    petsc_viewer.get());
       LIBMESH_CHKERR(ierr);
 
 #if PETSC_VERSION_LESS_THAN(3,7,0)
       ierr = PetscViewerSetFormat (petsc_viewer,
                                    PETSC_VIEWER_ASCII_MATLAB);
 #else
       ierr = PetscViewerPushFormat (petsc_viewer,
                                     PETSC_VIEWER_ASCII_MATLAB);
 #endif
 
       LIBMESH_CHKERR(ierr);
 
       ierr = VecView (_vec, petsc_viewer);
       LIBMESH_CHKERR(ierr);
     }
 
   // Otherwise the matrix will be dumped to the screen.
   else
     {
 
 #if PETSC_VERSION_LESS_THAN(3,7,0)
       ierr = PetscViewerSetFormat (PETSC_VIEWER_STDOUT_WORLD,
                                    PETSC_VIEWER_ASCII_MATLAB);
 #else
       ierr = PetscViewerPushFormat (PETSC_VIEWER_STDOUT_WORLD,
                                     PETSC_VIEWER_ASCII_MATLAB);
 #endif
 
       LIBMESH_CHKERR(ierr);
 
       ierr = VecView (_vec, PETSC_VIEWER_STDOUT_WORLD);
       LIBMESH_CHKERR(ierr);
     }
 }

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::PetscVector< T >::reciprocal ( )

overridevirtual

对 NumericVector 中的所有元素取倒数。

在文件 petsc_vector.C 第 168 行定义.

 {
   parallel_object_only();
 
   PetscErrorCode ierr = 0;
 
   // VecReciprocal has been in PETSc since at least 2.3.3 days
   ierr = VecReciprocal(_vec);
   LIBMESH_CHKERR(ierr);
 }

template<typename T >

void libMesh::PetscVector< T >::restore_array ( )

inline

恢复数据数组。

注解: 在使用 get_array() 或 get_array_read() 获取数组后，必须调用此函数，然后才能使用 PetscVector 上的其他接口函数。

在文件 petsc_vector.h 第 1447 行定义.

 {
   // \note \p _values_manually_retrieved needs to be set to \p false
   // \e before calling \p _restore_array()!
   _values_manually_retrieved = false;
   _restore_array();
 }

template<typename T >

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

overridevirtual

缩放当前向量的所有元素。

参数

factor 缩放因子。

在文件 petsc_vector.C 第 411 行定义.

参考 libMesh::PS().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscScalar factor = PS(factor_in);
 
   PetscErrorCode ierr = VecScale(_vec, factor);
   LIBMESH_CHKERR(ierr);
 
   libmesh_assert(this->comm().verify(int(this->type())));
 
   if (this->type() == GHOSTED)
     VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 }

template<typename T >

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

overridevirtual

设置索引为 i 的元素值为 value。

参数

i	数值索引。
value	要设置的值。

在文件 petsc_vector.C 第 149 行定义.

参考 libMesh::PS().

 {
   this->_restore_array();
   libmesh_assert_less (i, size());
 
   PetscErrorCode ierr=0;
   PetscInt i_val = static_cast<PetscInt>(i);
   PetscScalar petsc_value = PS(value);
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   ierr = VecSetValues (_vec, 1, &i_val, &petsc_value, INSERT_VALUES);
   LIBMESH_CHKERR(ierr);
 
   this->_is_closed = false;
 }

template<typename T >

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

inlineoverridevirtual

获取 NumericVector 的大小（维度）。

返回: 返回 NumericVector 的大小（维度）。

在文件 petsc_vector.h 第 1238 行定义.

参考自 libMesh::PetscVector< T >::add(), libMesh::PetscVector< T >::localize() , 以及 libMesh::PetscVector< T >::operator=().

 {
   libmesh_assert (this->initialized());
 
   PetscErrorCode ierr=0;
   PetscInt petsc_size=0;
 
   if (!this->initialized())
     return 0;
 
   ierr = VecGetSize(_vec, &petsc_size);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<numeric_index_type>(petsc_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::PetscVector< T >::sum ( ) const

overridevirtual

计算 NumericVector 中的元素之和。

返回: 返回 NumericVector 中的元素之和。

在文件 petsc_vector.C 第 44 行定义.

参考 libMesh::closed().

 {
   this->_restore_array();
   libmesh_assert(this->closed());
 
   PetscErrorCode ierr=0;
   PetscScalar value=0.;
 
   ierr = VecSum (_vec, &value);
   LIBMESH_CHKERR(ierr);
 
   return static_cast<T>(value);
 }

template<typename T >

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

inlineoverridevirtual

交换当前向量与另一个 NumericVector v 的数据。

参数

v	另一个 NumericVector 对象。

参考 libMesh::PetscVector< T >::_array_is_present, libMesh::PetscVector< T >::_destroy_vec_on_exit, libMesh::PetscVector< T >::_global_to_local_map, libMesh::PetscVector< T >::_local_form, libMesh::PetscVector< T >::_values, libMesh::PetscVector< T >::_vec , 以及 libMesh::NumericVector< T >::swap().

在文件 petsc_vector.h 第 1499 行定义.

 {
   parallel_object_only();
 
   NumericVector<T>::swap(other);
 
   PetscVector<T> & v = cast_ref<PetscVector<T> &>(other);
 
   std::swap(_vec, v._vec);
   std::swap(_destroy_vec_on_exit, v._destroy_vec_on_exit);
   std::swap(_global_to_local_map, v._global_to_local_map);
 
 #ifdef LIBMESH_HAVE_CXX11_THREAD
   // Only truly atomic for v... but swap() doesn't really need to be thread safe!
   _array_is_present = v._array_is_present.exchange(_array_is_present);
 #else
   std::swap(_array_is_present, v._array_is_present);
 #endif
 
   std::swap(_local_form, v._local_form);
   std::swap(_values, v._values);
 }

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>

Vec libMesh::PetscVector< T >::vec ( )

inline

获取当前向量的原始 PETSc Vec 指针。

注解: 通常在用户级代码中不需要使用此函数。; 不要尝试像调用 VecDestroy() 这样的操作，否则可能会发生严重问题！

返回: 返回原始 PETSc Vec 指针。

在文件 petsc_vector.h 第 641 行定义.

参考自 libMesh::PetscVector< T >::add(), libMesh::PetscShellMatrix< T >::get_diagonal(), libMesh::PetscMatrix< T >::get_diagonal(), libMesh::PetscVector< T >::pointwise_divide(), libMesh::PetscVector< T >::pointwise_mult(), libMesh::PetscShellMatrix< T >::vector_mult() , 以及 libMesh::PetscShellMatrix< T >::vector_mult_add().

641 { libmesh_assert (_vec); return _vec; }

libMesh::PetscVector::_vec

Vec _vec

用于保存向量元素的实际 PETSc 向量数据类型。

Definition: petsc_vector.h:659

template<typename T>

Vec libMesh::PetscVector< T >::vec ( ) const

inline

获取当前向量的原始 PETSc Vec 指针（const 版本）。

注解: 通常在用户级代码中不需要使用此函数。; 不要尝试像调用 VecDestroy() 这样的操作，否则可能会发生严重问题！

返回: 返回原始 PETSc Vec 指针。

在文件 petsc_vector.h 第 652 行定义.

libMesh::PetscVector::_vec

652 { libmesh_assert (_vec); return _vec; }

Vec _vec

用于保存向量元素的实际 PETSc 向量数据类型。

Definition: petsc_vector.h:659

template<typename T >

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

inlineoverridevirtual

将 PetscVector 的所有元素设置为零。

在文件 petsc_vector.h 第 1178 行定义.

参考 libMesh::closed().

 {
   parallel_object_only();
 
   libmesh_assert(this->closed());
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
 
   PetscScalar z=0.;
 
   if (this->type() != GHOSTED)
     {
       ierr = VecSet (_vec, z);
       LIBMESH_CHKERR(ierr);
     }
   else
     {
       /* Vectors that include ghost values require a special
          handling.  */
       Vec loc_vec;
       ierr = VecGhostGetLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecSet (loc_vec, z);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
     }
 }

template<typename T >

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

inlineoverridevirtual

获取一个零副本的独立指针。

返回: 返回一个指向零副本的 std::unique_ptr<NumericVector<T>>。

在文件 petsc_vector.h 第 1215 行定义.

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

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

类成员变量说明

template<typename T>

std::atomic<bool> libMesh::PetscVector< T >::_array_is_present

mutableprivate

如果为 true，则当前 PETSc 向量值的实际数组当前可访问。这意味着成员 _local_form 和 _values 有效。

在文件 petsc_vector.h 第 666 行定义.

template<typename T>

bool libMesh::PetscVector< T >::_array_is_present

mutableprivate

在文件 petsc_vector.h 第 668 行定义.

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

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

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

template<typename T>

bool libMesh::PetscVector< T >::_destroy_vec_on_exit

private

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

在文件 petsc_vector.h 第 736 行定义.

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>

numeric_index_type libMesh::PetscVector< T >::_first

mutableprivate

第一个本地索引。

仅当 _array_is_present 为真时有效。

在文件 petsc_vector.h 第 676 行定义.

template<typename T>

GlobalToLocalMap libMesh::PetscVector< T >::_global_to_local_map

private

用于将全局幽灵单元格映射到本地单元格的映射（如果不是幽灵单元格模式，则为空）。

在文件 petsc_vector.h 第 731 行定义.

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

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

template<typename T>

numeric_index_type libMesh::PetscVector< T >::_last

mutableprivate

最后一个本地索引。

仅当 _array_is_present 为真时有效。

在文件 petsc_vector.h 第 683 行定义.

template<typename T>

Vec libMesh::PetscVector< T >::_local_form

mutableprivate

用于保存幽灵向量的本地形式的 PETSc 向量数据类型。仅当向量是幽灵的且 _array_is_present 为真时，此字段的内容才有效。

在文件 petsc_vector.h 第 693 行定义.

参考自 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>

numeric_index_type libMesh::PetscVector< T >::_local_size

mutableprivate

从 _get_array() 获取本地值的大小。

在文件 petsc_vector.h 第 688 行定义.

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>

std::mutex libMesh::PetscVector< T >::_petsc_get_restore_array_mutex

mutableprivate

用于 _get_array 和 _restore_array 的互斥锁。这是对象的一部分，以减少从多个 PetscVectors 同时读取时的线程争用。

在文件 petsc_vector.h 第 709 行定义.

template<typename T>

const PetscScalar* libMesh::PetscVector< T >::_read_only_values

mutableprivate

指向当前 PETSc 向量值的实际数组的指针。仅当 _array_is_present 为真时，此指针才有效。

在文件 petsc_vector.h 第 698 行定义.

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

向量的类型。

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

template<typename T>

PetscScalar* libMesh::PetscVector< T >::_values

mutableprivate

指向当前 PETSc 向量值的实际数组的指针。仅当 _array_is_present 为真时，此指针才有效。我们使用了 PETSc 的 VecGetArrayRead() 函数，它需要一个常量 PetscScalar *，但是 _get_array 和 _restore_array 是 const 成员函数，因此 _values 也需要是可变的（否则在那个上下文中它是 "const PetscScalar * const"）。

在文件 petsc_vector.h 第 704 行定义.