NumericVector interface to PETSc Vec. More...

#include <petsc_vector.h>

Inheritance diagram for libMesh::PetscVector< T >:

[legend]

Public Member Functions
	PetscVector (const Parallel::Communicator &comm_in, const ParallelType type=AUTOMATIC)

	PetscVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const ParallelType type=AUTOMATIC)

	PetscVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const numeric_index_type n_local, const ParallelType type=AUTOMATIC)

	PetscVector (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 type=AUTOMATIC)

	PetscVector (Vec v, const Parallel::Communicator &comm_in)

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

	PetscVector (PetscVector &&)=delete

	PetscVector (const PetscVector &)=delete

PetscVector &	operator= (PetscVector &&)=delete

virtual	~PetscVector ()

virtual void	close () override

virtual void	clear () override

virtual void	zero () override

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 type=AUTOMATIC) override

virtual void	init (const numeric_index_type N, const bool fast=false, const ParallelType type=AUTOMATIC) override

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

virtual void	init (const NumericVector< T > &other, const bool fast=false) override

virtual NumericVector< T > &	operator= (const T s) override

virtual NumericVector< T > &	operator= (const NumericVector< T > &v) override

virtual NumericVector< T > &	operator= (const std::vector< T > &v) override

virtual Real	min () const override

virtual Real	max () const override

virtual T	sum () const override

virtual Real	l1_norm () const override

virtual Real	l2_norm () const override

virtual Real	linfty_norm () const override

virtual numeric_index_type	size () const override

virtual numeric_index_type	local_size () const override

virtual numeric_index_type	first_local_index () const override

virtual numeric_index_type	last_local_index () const override

numeric_index_type	map_global_to_local_index (const numeric_index_type i) const

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

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

PetscScalar *	get_array ()

const PetscScalar *	get_array_read () const

void	restore_array ()

virtual NumericVector< T > &	operator+= (const NumericVector< T > &v) override

virtual NumericVector< T > &	operator-= (const NumericVector< T > &v) override

virtual void	reciprocal () override

virtual void	conjugate () override

virtual void	set (const numeric_index_type i, const T value) override

virtual void	add (const numeric_index_type i, const T value) override

virtual void	add (const T s) override

virtual void	add (const NumericVector< T > &v) override

virtual void	add (const T a, const NumericVector< T > &v) override

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

virtual void	add_vector (const NumericVector< T > &v, const SparseMatrix< T > &A) override

virtual void	add_vector_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A) override

void	add_vector_conjugate_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A)

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

virtual void	scale (const T factor) override

virtual NumericVector< T > &	operator/= (const NumericVector< T > &v) override

virtual void	abs () override

virtual T	dot (const NumericVector< T > &v) const override

T	indefinite_dot (const NumericVector< T > &v) const

virtual void	localize (std::vector< T > &v_local) const override

virtual void	localize (NumericVector< T > &v_local) const override

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

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

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

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

virtual void	pointwise_mult (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override

virtual void	print_matlab (const std::string &name="") const override

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

virtual void	swap (NumericVector< T > &v) override

Vec	vec ()

template<>
void	localize_to_one (std::vector< Real > &v_local, const processor_id_type pid) const

template<>
void	localize_to_one (std::vector< Complex > &v_local, const processor_id_type pid) 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

virtual Real	subset_l2_norm (const std::set< numeric_index_type > &indices) const

virtual Real	subset_linfty_norm (const std::set< numeric_index_type > &indices) const

virtual T	el (const numeric_index_type i) const

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual int	global_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const

virtual void	print (std::ostream &os=libMesh::out) const

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

virtual void	print_global (std::ostream &os=libMesh::out) const

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< NumericVector< T > >	build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())

static std::string	get_info ()

static void	print_info (std::ostream &out=libMesh::out)

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

Protected Member Functions
void	increment_constructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

Protected Attributes
bool	_is_closed

bool	_is_initialized

ParallelType	_type

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter = true

Private Types
typedef std::unordered_map< numeric_index_type, numeric_index_type >	GlobalToLocalMap

Private Member Functions
void	_get_array (bool read_only) const

void	_restore_array () const

Private Attributes
Vec	_vec

std::atomic< bool >	_array_is_present

bool	_array_is_present

numeric_index_type	_first

numeric_index_type	_last

numeric_index_type	_local_size

Vec	_local_form

const PetscScalar *	_read_only_values

PetscScalar *	_values

std::mutex	_petsc_vector_mutex

Threads::spin_mutex	_petsc_vector_mutex

GlobalToLocalMap	_global_to_local_map

bool	_destroy_vec_on_exit

bool	_values_manually_retrieved

bool	_values_read_only

Detailed Description

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

NumericVector interface to PETSc Vec.

This class provides a nice interface to PETSc's Vec object. All overridden virtual functions are documented in numeric_vector.h.

Author: Benjamin S. Kirk

Date: 2002

Definition at line 64 of file petsc_vector.h.

Member Typedef Documentation

◆ Counts

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.

Definition at line 117 of file reference_counter.h.

◆ GlobalToLocalMap

template<typename T>

typedef std::unordered_map<numeric_index_type,numeric_index_type> libMesh::PetscVector< T >::GlobalToLocalMap

private

Type for map that maps global to local ghost cells.

Definition at line 421 of file petsc_vector.h.

Constructor & Destructor Documentation

◆ PetscVector() [1/7]

template<typename T >

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

inlineexplicit

Dummy-Constructor. Dimension=0

Definition at line 454 of file petsc_vector.h.

References libMesh::NumericVector< T >::_type.

                                                                                            :
   NumericVector<T>(comm_in, ptype),
   _array_is_present(false),
   _first(0),
   _last(0),
   _local_form(nullptr),
   _values(nullptr),
   _global_to_local_map(),
   _destroy_vec_on_exit(true),
   _values_manually_retrieved(false),
   _values_read_only(false)
 {
   this->_type = ptype;
 }

◆ PetscVector() [2/7]

template<typename T >

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

inlineexplicit

Constructor. Set dimension to n and initialize all elements with zero.

Definition at line 473 of file petsc_vector.h.

References libMesh::PetscVector< T >::init().

                                                        :
   NumericVector<T>(comm_in, ptype),
   _array_is_present(false),
   _local_form(nullptr),
   _values(nullptr),
   _global_to_local_map(),
   _destroy_vec_on_exit(true),
   _values_manually_retrieved(false),
   _values_read_only(false)
 {
   this->init(n, n, false, ptype);
 }

◆ PetscVector() [3/7]

template<typename T >

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

inline

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

Definition at line 492 of file petsc_vector.h.

References libMesh::PetscVector< T >::init().

                                                        :
   NumericVector<T>(comm_in, ptype),
   _array_is_present(false),
   _local_form(nullptr),
   _values(nullptr),
   _global_to_local_map(),
   _destroy_vec_on_exit(true),
   _values_manually_retrieved(false),
   _values_read_only(false)
 {
   this->init(n, n_local, false, ptype);
 }

◆ PetscVector() [4/7]

template<typename T >

libMesh::PetscVector< T >::PetscVector	(	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	type = `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.

Definition at line 512 of file petsc_vector.h.

References libMesh::PetscVector< T >::init().

                                                        :
   NumericVector<T>(comm_in, ptype),
   _array_is_present(false),
   _local_form(nullptr),
   _values(nullptr),
   _global_to_local_map(),
   _destroy_vec_on_exit(true),
   _values_manually_retrieved(false),
   _values_read_only(false)
 {
   this->init(n, n_local, ghost, false, ptype);
 }

◆ PetscVector() [5/7]

template<typename T >

libMesh::PetscVector< T >::PetscVector	(	Vec	v,
		const Parallel::Communicator &	comm_in
	)

inline

Constructor. Creates a PetscVector assuming you already have a valid PETSc Vec object. In this case, v is NOT destroyed by the PetscVector constructor when this object goes out of scope. This allows ownership of v to remain with the original creator, and to simply provide additional functionality with the PetscVector.

Definition at line 535 of file petsc_vector.h.

References libMesh::PetscVector< T >::_global_to_local_map, libMesh::NumericVector< T >::_is_closed, libMesh::NumericVector< T >::_is_initialized, libMesh::NumericVector< T >::_type, libMesh::PetscVector< T >::_vec, libMesh::GHOSTED, ierr, libMesh::PARALLEL, and libMesh::SERIAL.

                                                                    :
   NumericVector<T>(comm_in, AUTOMATIC),
   _array_is_present(false),
   _local_form(nullptr),
   _values(nullptr),
   _global_to_local_map(),
   _destroy_vec_on_exit(false),
   _values_manually_retrieved(false),
   _values_read_only(false)
 {
   this->_vec = v;
   this->_is_closed = true;
   this->_is_initialized = true;
 
   /* We need to ask PETSc about the (local to global) ghost value
      mapping and create the inverse mapping out of it.  */
   PetscErrorCode ierr=0;
   PetscInt petsc_local_size=0;
   ierr = VecGetLocalSize(_vec, &petsc_local_size);
   LIBMESH_CHKERR(ierr);
 
   // Get the vector type from PETSc.
   // As of PETSc 3.0.0, the VecType #define lost its const-ness, so we
   // need to have it in the code
 #if PETSC_VERSION_LESS_THAN(3,0,0) || !PETSC_VERSION_LESS_THAN(3,4,0)
   // Pre-3.0 and petsc-dev (as of October 2012) use non-const versions
   VecType ptype;
 #else
   const VecType ptype;
 #endif
   ierr = VecGetType(_vec, &ptype);
   LIBMESH_CHKERR(ierr);
 
   if ((std::strcmp(ptype,VECSHARED) == 0) || (std::strcmp(ptype,VECMPI) == 0))
     {
 #if PETSC_RELEASE_LESS_THAN(3,1,1)
       ISLocalToGlobalMapping mapping = _vec->mapping;
 #else
       ISLocalToGlobalMapping mapping;
       ierr = VecGetLocalToGlobalMapping(_vec, &mapping);
       LIBMESH_CHKERR(ierr);
 #endif
 
       // If is a sparsely stored vector, set up our new mapping
       if (mapping)
         {
           const numeric_index_type my_local_size = static_cast<numeric_index_type>(petsc_local_size);
           const numeric_index_type ghost_begin = static_cast<numeric_index_type>(petsc_local_size);
 #if PETSC_RELEASE_LESS_THAN(3,4,0)
           const numeric_index_type ghost_end = static_cast<numeric_index_type>(mapping->n);
 #else
           PetscInt n;
           ierr = ISLocalToGlobalMappingGetSize(mapping, &n);
           LIBMESH_CHKERR(ierr);
           const numeric_index_type ghost_end = static_cast<numeric_index_type>(n);
 #endif
 #if PETSC_RELEASE_LESS_THAN(3,1,1)
           const PetscInt * indices = mapping->indices;
 #else
           const PetscInt * indices;
           ierr = ISLocalToGlobalMappingGetIndices(mapping,&indices);
           LIBMESH_CHKERR(ierr);
 #endif
           for (numeric_index_type i=ghost_begin; i<ghost_end; i++)
             _global_to_local_map[indices[i]] = i-my_local_size;
           this->_type = GHOSTED;
 #if !PETSC_RELEASE_LESS_THAN(3,1,1)
           ierr = ISLocalToGlobalMappingRestoreIndices(mapping, &indices);
           LIBMESH_CHKERR(ierr);
 #endif
         }
       else
         this->_type = PARALLEL;
     }
   else
     this->_type = SERIAL;
 }

◆ PetscVector() [6/7]

template<typename T>

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

delete

This class manages a C-style struct (Vec) manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor.

◆ PetscVector() [7/7]

template<typename T>

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

delete

◆ ~PetscVector()

template<typename T >

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

inlinevirtual

Definition at line 619 of file petsc_vector.h.

 {
   this->clear ();
 }

Member Function Documentation

◆ _get_array()

template<typename T >

void libMesh::PetscVector< T >::_get_array ( bool read_only ) const

private

Queries the array (and the local form if the vector is ghosted) from PETSc.

Parameters

read_only Whether or not a read only copy of the raw data

Definition at line 1348 of file petsc_vector.C.

References libMesh::GHOSTED, ierr, and libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
 #ifdef LIBMESH_HAVE_CXX11_THREAD
   std::atomic_thread_fence(std::memory_order_acquire);
 #else
   Threads::spin_mutex::scoped_lock lock(_petsc_vector_mutex);
 #endif
 
   // 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 (_array_is_present && !read_only && _values_read_only)
     _restore_array();
 
   // 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 (_array_is_present && read_only && !_values_read_only)
     _read_only_values = _values;
 
   if (!_array_is_present)
     {
 #ifdef LIBMESH_HAVE_CXX11_THREAD
       std::lock_guard<std::mutex> lock(_petsc_vector_mutex);
 #endif
       if (!_array_is_present)
         {
           PetscErrorCode ierr=0;
           if (this->type() != GHOSTED)
             {
 #if PETSC_VERSION_LESS_THAN(3,2,0)
               // Vec{Get,Restore}ArrayRead were introduced in PETSc 3.2.0.  If you
               // have an older PETSc than that, we'll do an ugly
               // const_cast and call VecGetArray() instead.
               ierr = VecGetArray(_vec, const_cast<PetscScalar **>(&_values));
               _values_read_only = false;
 #else
               if (read_only)
                 {
                   ierr = VecGetArrayRead(_vec, &_read_only_values);
                   _values_read_only = true;
                 }
               else
                 {
                   ierr = VecGetArray(_vec, &_values);
                   _values_read_only = false;
                 }
 #endif
               LIBMESH_CHKERR(ierr);
               _local_size = this->local_size();
             }
           else
             {
               ierr = VecGhostGetLocalForm (_vec,&_local_form);
               LIBMESH_CHKERR(ierr);
 
 #if PETSC_VERSION_LESS_THAN(3,2,0)
               // Vec{Get,Restore}ArrayRead were introduced in PETSc 3.2.0.  If you
               // have an older PETSc than that, we'll do an ugly
               // const_cast and call VecGetArray() instead.
               ierr = VecGetArray(_local_form, const_cast<PetscScalar **>(&_values));
               _values_read_only = false;
 #else
               if (read_only)
                 {
                   ierr = VecGetArrayRead(_local_form, &_read_only_values);
                   _values_read_only = true;
                 }
               else
                 {
                   ierr = VecGetArray(_local_form, &_values);
                   _values_read_only = false;
                 }
 #endif
               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);
           }
 #ifdef LIBMESH_HAVE_CXX11_THREAD
           std::atomic_thread_fence(std::memory_order_release);
           _array_is_present.store(true, std::memory_order_relaxed);
 #else
           _array_is_present = true;
 #endif
         }
     }
 }

◆ _restore_array()

template<typename T >

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

private

Restores the array (and the local form if the vector is ghosted) to PETSc.

Definition at line 1452 of file petsc_vector.C.

References libMesh::GHOSTED, ierr, and libMesh::initialized().

Referenced by libMesh::PetscVector< T >::add(), libMesh::PetscVector< T >::create_subvector(), libMesh::PetscVector< T >::init(), and libMesh::PetscVector< T >::operator=().

 {
   if (_values_manually_retrieved)
     libmesh_error_msg("PetscVector values were manually retrieved but are being automatically restored!");
 
 #ifdef LIBMESH_HAVE_CXX11_THREAD
   std::atomic_thread_fence(std::memory_order_acquire);
 #else
   Threads::spin_mutex::scoped_lock lock(_petsc_vector_mutex);
 #endif
 
   libmesh_assert (this->initialized());
   if (_array_is_present)
     {
 #ifdef LIBMESH_HAVE_CXX11_THREAD
       std::lock_guard<std::mutex> lock(_petsc_vector_mutex);
 #endif
 
       if (_array_is_present)
         {
           PetscErrorCode ierr=0;
           if (this->type() != GHOSTED)
             {
 #if PETSC_VERSION_LESS_THAN(3,2,0)
               // Vec{Get,Restore}ArrayRead were introduced in PETSc 3.2.0.  If you
               // have an older PETSc than that, we'll do an ugly
               // const_cast and call VecRestoreArray() instead.
               ierr = VecRestoreArray (_vec, const_cast<PetscScalar **>(&_values));
 #else
               if (_values_read_only)
                 ierr = VecRestoreArrayRead (_vec, &_read_only_values);
               else
                 ierr = VecRestoreArray (_vec, &_values);
 #endif
 
               LIBMESH_CHKERR(ierr);
               _values = nullptr;
             }
           else
             {
 #if PETSC_VERSION_LESS_THAN(3,2,0)
               // Vec{Get,Restore}ArrayRead were introduced in PETSc 3.2.0.  If you
               // have an older PETSc than that, we'll do an ugly
               // const_cast and call VecRestoreArray() instead.
               ierr = VecRestoreArray (_local_form, const_cast<PetscScalar **>(&_values));
 #else
               if (_values_read_only)
                 ierr = VecRestoreArrayRead (_local_form, &_read_only_values);
               else
                 ierr = VecRestoreArray (_local_form, &_values);
 #endif
               LIBMESH_CHKERR(ierr);
               _values = nullptr;
               ierr = VecGhostRestoreLocalForm (_vec,&_local_form);
               LIBMESH_CHKERR(ierr);
               _local_form = nullptr;
               _local_size = 0;
             }
 #ifdef LIBMESH_HAVE_CXX11_THREAD
           std::atomic_thread_fence(std::memory_order_release);
           _array_is_present.store(false, std::memory_order_relaxed);
 #else
           _array_is_present = false;
 #endif
         }
     }
 }

◆ abs()

template<typename T >

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

overridevirtual

Sets $u_i \leftarrow |u_i|$ for each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 440 of file petsc_vector.C.

References libMesh::GHOSTED, and ierr.

 {
   this->_restore_array();
 
   PetscErrorCode ierr = 0;
 
   if (this->type() != GHOSTED)
     {
       ierr = VecAbs(_vec);
       LIBMESH_CHKERR(ierr);
     }
   else
     {
       Vec loc_vec;
       ierr = VecGhostGetLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecAbs(loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
     }
 }

◆ add() [1/4]

template<typename T >

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

overridevirtual

Adds value to each entry of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 180 of file petsc_vector.C.

References ierr, and value.

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

◆ add() [2/4]

template<typename T >

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

overridevirtual

Adds s to each entry of the vector, $u_i \leftarrow u_i + s$

Implements libMesh::NumericVector< T >.

Definition at line 321 of file petsc_vector.C.

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

◆ add() [3/4]

template<typename T >

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

overridevirtual

Adds v to this, $\vec{u} \leftarrow \vec{u} + \vec{v}$ . Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 332 of file petsc_vector.C.

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

◆ add() [4/4]

template<typename T >

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

overridevirtual

Vector addition with a scalar multiple, $\vec{u} \leftarrow \vec{u} + a\vec{v}$ . Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 340 of file petsc_vector.C.

References libMesh::PetscVector< T >::_restore_array(), libMesh::PetscVector< T >::_vec, libMesh::GHOSTED, ierr, and libMesh::PetscVector< T >::size().

 {
   this->_restore_array();
 
   PetscErrorCode ierr = 0;
   PetscScalar a = static_cast<PetscScalar>(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());
 
   if (this->type() != GHOSTED)
     {
       ierr = VecAXPY(_vec, a, v->_vec);
       LIBMESH_CHKERR(ierr);
     }
   else
     {
       Vec loc_vec;
       Vec v_loc_vec;
       ierr = VecGhostGetLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostGetLocalForm (v->_vec,&v_loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecAXPY(loc_vec, a, v_loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecGhostRestoreLocalForm (v->_vec,&v_loc_vec);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
     }
 }

◆ add_vector() [1/6]

template<typename T >

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

overridevirtual

Computes $\vec{u} \leftarrow \vec{u} + \vec{v}$ , where v is a pointer and each dof_indices[i] specifies where to add value v[i]. This should be overridden in subclasses for efficiency.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 198 of file petsc_vector.C.

References ierr.

 {
   // 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 = static_cast<const PetscScalar *>(v);
 
   ierr = VecSetValues (_vec, cast_int<PetscInt>(dof_indices.size()),
                        i_val, petsc_value, ADD_VALUES);
   LIBMESH_CHKERR(ierr);
 
   this->_is_closed = false;
 }

◆ add_vector() [2/6]

template<typename T >

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

overridevirtual

Computes $\vec{u} \leftarrow \vec{u} + A \vec{v}$ , i.e. adds the product of a SparseMatrix A and a NumericVector v to this.

Implements libMesh::NumericVector< T >.

Definition at line 221 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, A, and ierr.

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

◆ add_vector() [3/6]

template<typename T>

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

inlineinherited

Computes $\vec{u} \leftarrow \vec{u} + \vec{v}$ , where v is a std::vector and each dof_indices[i] specifies where to add value v[i].

Definition at line 835 of file numeric_vector.h.

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

◆ add_vector() [4/6]

template<typename T>

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

virtualinherited

Computes $\vec{u} \leftarrow \vec{u} + \vec{v}$ , where v is a NumericVector and each dof_indices[i] specifies where to add value v(i).

Definition at line 372 of file numeric_vector.C.

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

◆ add_vector() [5/6]

template<typename T>

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

inlineinherited

Computes $\vec{u} \leftarrow \vec{u} + \vec{v}$ , where v is a DenseVector and each dof_indices[i] specifies where to add value v(i).

Definition at line 847 of file numeric_vector.h.

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

◆ add_vector() [6/6]

template<typename T>

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

inherited

Computes $\vec{u} \leftarrow \vec{u} + A \vec{v}$ , i.e. adds the product of a ShellMatrix A and a NumericVector v to this.

Definition at line 384 of file numeric_vector.C.

 {
   a.vector_mult_add(*this,v);
 }

◆ add_vector_conjugate_transpose()

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$ .

Adds the product of the conjugate-transpose of SparseMatrix A and a NumericVector v to this.

Definition at line 277 of file petsc_vector.C.

 {
   libmesh_error_msg("MatMultHermitianTranspose was introduced in PETSc 3.1.0," \
                     << "No one has made it backwards compatible with older " \
                     << "versions of PETSc so far.");
 }

◆ add_vector_transpose()

template<typename T >

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

overridevirtual

Computes $\vec{u} \leftarrow \vec{u} + A^T \vec{v}$ , i.e. adds the product of the transpose of a SparseMatrix A and a NumericVector v to this.

Implements libMesh::NumericVector< T >.

Definition at line 249 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, A, and ierr.

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

◆ build()

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

Builds a NumericVector on the processors in communicator comm using the linear solver package specified by solver_package

Definition at line 48 of file numeric_vector.C.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::add_vector(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), and libMesh::CondensedEigenSystem::get_eigenpair().

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

◆ clear()

template<typename T >

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

inlineoverridevirtual

Restores the NumericVector<T> to a pristine state.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 838 of file petsc_vector.h.

References libMesh::libMeshPrivateData::_is_initialized, ierr, and libMesh::initialized().

 {
   parallel_object_only();
 
   if (this->initialized())
     this->_restore_array();
 
   if ((this->initialized()) && (this->_destroy_vec_on_exit))
     {
       PetscErrorCode ierr=0;
 
       ierr = LibMeshVecDestroy(&_vec);
       LIBMESH_CHKERR(ierr);
     }
 
   this->_is_closed = this->_is_initialized = false;
 
   _global_to_local_map.clear();
 }

◆ clone()

template<typename T >

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

inlineoverridevirtual

Returns: A copy of this vector wrapped in a smart pointer.

Note: This must be overridden in the derived classes.

Implements libMesh::NumericVector< T >.

Definition at line 910 of file petsc_vector.h.

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

◆ close()

template<typename T >

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

inlineoverridevirtual

Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across processors.

Implements libMesh::NumericVector< T >.

Definition at line 810 of file petsc_vector.h.

References libMesh::GHOSTED, and ierr.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::SlepcEigenSolver< T >::get_eigenpair(), libMesh::PetscVector< T >::localize(), and libMesh::PetscLinearSolver< T >::solve().

 {
   parallel_object_only();
 
   this->_restore_array();
 
   PetscErrorCode ierr=0;
 
   ierr = VecAssemblyBegin(_vec);
   LIBMESH_CHKERR(ierr);
   ierr = VecAssemblyEnd(_vec);
   LIBMESH_CHKERR(ierr);
 
   if (this->type() == GHOSTED)
     {
       ierr = VecGhostUpdateBegin(_vec,INSERT_VALUES,SCATTER_FORWARD);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostUpdateEnd(_vec,INSERT_VALUES,SCATTER_FORWARD);
       LIBMESH_CHKERR(ierr);
     }
 
   this->_is_closed = true;
 }

◆ closed()

template<typename T>

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

inlinevirtualinherited

Returns: true if the vector is closed and ready for computation, false otherwise.

Definition at line 165 of file numeric_vector.h.

Referenced by libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::max_constraint_error(), libMesh::EigenSparseVector< T >::operator=(), libMesh::LaspackVector< T >::operator=(), and libMesh::PetscVector< T >::operator=().

165 { return _is_closed; }

libMesh::NumericVector::_is_closed

bool _is_closed

Definition: numeric_vector.h:712

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns: A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

90 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ compare()

template<typename T>

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

virtualinherited

Returns: -1 when this is equivalent to other_vector (up to the given threshold), or the first index where abs(a[i]-b[i]) exceeds the threshold.

Definition at line 104 of file numeric_vector.C.

 {
   libmesh_assert (this->initialized());
   libmesh_assert (other_vector.initialized());
   libmesh_assert_equal_to (this->first_local_index(), other_vector.first_local_index());
   libmesh_assert_equal_to (this->last_local_index(), other_vector.last_local_index());
 
   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)
         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;
 }

◆ conjugate()

template<typename T >

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

overridevirtual

Negates the imaginary component of each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 168 of file petsc_vector.C.

References ierr.

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

◆ create_subvector()

template<typename T >

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

overridevirtual

Fills in subvector from this vector using the indices in rows. Similar to the create_submatrix() routine for the SparseMatrix class, it is currently only implemented for PetscVectors.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1259 of file petsc_vector.C.

References libMesh::NumericVector< T >::_is_initialized, libMesh::PetscVector< T >::_restore_array(), libMesh::PetscVector< T >::_vec, libMesh::MeshTools::Generation::Private::idx(), ierr, libMesh::NumericVector< T >::initialized(), libMesh::Utility::iota(), libMesh::numeric_petsc_cast(), and PETSC_USE_POINTER.

 {
   this->_restore_array();
 
   // PETSc data structures
   IS parent_is, subvector_is;
   VecScatter scatter;
   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
   ierr = ISCreateLibMesh(this->comm().get(),
                          cast_int<PetscInt>(rows.size()),
                          numeric_petsc_cast(rows.data()),
                          PETSC_USE_POINTER,
                          &parent_is);
   LIBMESH_CHKERR(ierr);
 
   ierr = ISCreateLibMesh(this->comm().get(),
                          cast_int<PetscInt>(rows.size()),
                          idx.data(),
                          PETSC_USE_POINTER,
                          &subvector_is);
   LIBMESH_CHKERR(ierr);
 
   // Construct the scatter object
   ierr = LibMeshVecScatterCreate(this->_vec,
                           parent_is,
                           petsc_subvector->_vec,
                           subvector_is,
                           &scatter); LIBMESH_CHKERR(ierr);
 
   // Actually perform the scatter
   ierr = VecScatterBegin(scatter,
                          this->_vec,
                          petsc_subvector->_vec,
                          INSERT_VALUES,
                          SCATTER_FORWARD); LIBMESH_CHKERR(ierr);
 
   ierr = VecScatterEnd(scatter,
                        this->_vec,
                        petsc_subvector->_vec,
                        INSERT_VALUES,
                        SCATTER_FORWARD); LIBMESH_CHKERR(ierr);
 
   // Clean up
   ierr = LibMeshISDestroy(&parent_is);       LIBMESH_CHKERR(ierr);
   ierr = LibMeshISDestroy(&subvector_is);    LIBMESH_CHKERR(ierr);
   ierr = LibMeshVecScatterDestroy(&scatter); LIBMESH_CHKERR(ierr);
 }

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit().

 {
   _enable_print_counter = false;
   return;
 }

◆ dot()

template<typename T >

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

overridevirtual

Returns: $\vec{u} \cdot \vec{v}$ , the dot product of (*this) with the vector v.

Uses the complex-conjugate of v in the complex-valued case.

Implements libMesh::NumericVector< T >.

Definition at line 466 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, ierr, and value.

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

◆ el()

template<typename T>

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

inlinevirtualinherited

Returns: (*this)(i).

Definition at line 346 of file numeric_vector.h.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

◆ first_local_index()

template<typename T >

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

inlineoverridevirtual

Returns: The index of the first vector element actually stored on this processor.

Note: The minimum for this index is 0.

Implements libMesh::NumericVector< T >.

Definition at line 959 of file petsc_vector.h.

References ierr, and libMesh::initialized().

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

◆ get() [1/2]

template<typename T >

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

inlineoverridevirtual

Access multiple components at once. values will not be reallocated; it should already have enough space. The default implementation calls operator() for each index, but some implementations may supply faster methods here.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1087 of file petsc_vector.h.

References libMesh::GHOSTED.

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

◆ get() [2/2]

template<typename T>

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

inlineinherited

Access multiple components at once. values will be resized, if necessary, and filled. The default implementation calls operator() for each index, but some implementations may supply faster methods here.

Definition at line 820 of file numeric_vector.h.

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

◆ get_array()

template<typename T >

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

inline

Get read/write access to the raw PETSc Vector data array.

Note: This is an advanced interface. In general you should avoid using it unless you know what you are doing!

Definition at line 1110 of file petsc_vector.h.

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

◆ get_array_read()

template<typename T >

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

inline

Get read only access to the raw PETSc Vector data array.

Note: This is an advanced interface. In general you should avoid using it unless you know what you are doing!

Definition at line 1121 of file petsc_vector.h.

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

◆ get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by 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 & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

◆ global_relative_compare()

template<typename T>

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

virtualinherited

Returns: -1 when this is equivalent to other_vector (up to the given global relative threshold), or the first index where abs(a[i]-b[i])/max_j(a[j],b[j]) exceeds the threshold.

Definition at line 169 of file numeric_vector.C.

 {
   libmesh_assert (this->initialized());
   libmesh_assert (other_vector.initialized());
   libmesh_assert_equal_to (this->first_local_index(), other_vector.first_local_index());
   libmesh_assert_equal_to (this->last_local_index(), other_vector.last_local_index());
 
   int first_different_i = std::numeric_limits<int>::max();
   numeric_index_type i = first_local_index();
 
   const Real my_norm = this->linfty_norm();
   const Real other_norm = other_vector.linfty_norm();
   const Real abs_threshold = std::max(my_norm, other_norm) * threshold;
 
   do
     {
       if (std::abs((*this)(i) - other_vector(i) ) > abs_threshold)
         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;
 }

◆ increment_constructor_count()

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

inlineprotectedinherited

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

Definition at line 181 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

◆ increment_destructor_count()

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

inlineprotectedinherited

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

Definition at line 194 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

◆ indefinite_dot()

template<typename T >

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

Returns: The dot product of (*this) with the vector v.

Note: Does not use the complex-conjugate of v in the complex-valued case.

Definition at line 487 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, ierr, and value.

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

◆ init() [1/4]

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	ptype = `AUTOMATIC`
	)

inlineoverridevirtual

Change the dimension of the vector to n. The reserved memory for this vector remains unchanged if possible. If n==0, all memory is freed. Therefore, if you want to resize the vector and release the memory not needed, you have to first call init(0) and then init(n). This behaviour is analogous to that of the STL containers.

On fast==false, the vector is filled by zeros.

Implements libMesh::NumericVector< T >.

Definition at line 628 of file petsc_vector.h.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::AUTOMATIC, ierr, libMesh::initialized(), libMesh::PARALLEL, libMesh::SERIAL, and libMesh::zero.

Referenced by libMesh::PetscVector< T >::localize(), and libMesh::PetscVector< T >::PetscVector().

 {
   parallel_object_only();
 
   PetscErrorCode ierr=0;
   PetscInt petsc_n=static_cast<PetscInt>(n);
   PetscInt petsc_n_local=static_cast<PetscInt>(n_local);
 
 
   // 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 = VecCreateSeq (PETSC_COMM_SELF, petsc_n, &_vec);
       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
       libmesh_assert_less_equal (n_local, n);
       ierr = VecCreateMPI (this->comm().get(), petsc_n_local, petsc_n,
                            &_vec);
       LIBMESH_CHKERR(ierr);
 #else
       libmesh_assert_equal_to (n_local, n);
       ierr = VecCreateSeq (PETSC_COMM_SELF, petsc_n, &_vec);
       CHKERRABORT(PETSC_COMM_SELF,ierr);
 #endif
 
       ierr = VecSetFromOptions (_vec);
       LIBMESH_CHKERR(ierr);
     }
   else
     libmesh_error_msg("Unsupported type " << this->_type);
 
   this->_is_initialized = true;
   this->_is_closed = true;
 
 
   if (fast == false)
     this->zero ();
 }

◆ init() [2/4]

template<typename T >

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

inlineoverridevirtual

Call init() with n_local = N.

Implements libMesh::NumericVector< T >.

Definition at line 698 of file petsc_vector.h.

References libMesh::TriangleWrapper::init().

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

◆ init() [3/4]

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	ptype = `AUTOMATIC`
	)

overridevirtual

Create a vector that holds tha local indices plus those specified in the ghost argument.

Implements libMesh::NumericVector< T >.

◆ init() [4/4]

template<typename T >

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

inlineoverridevirtual

Creates a vector that has the same dimension and storage type as other, including ghost dofs.

Implements libMesh::NumericVector< T >.

Definition at line 771 of file petsc_vector.h.

References libMesh::PetscVector< T >::_global_to_local_map, libMesh::libMeshPrivateData::_is_initialized, libMesh::PetscVector< T >::_restore_array(), libMesh::NumericVector< T >::_type, libMesh::PetscVector< T >::_vec, ierr, libMesh::NumericVector< T >::initialized(), libMesh::initialized(), and libMesh::zero.

 {
   parallel_object_only();
 
   // Clear initialized vectors
   if (this->initialized())
     this->clear();
 
   const PetscVector<T> & v = cast_ref<const PetscVector<T> &>(other);
 
   // Other vector should restore array.
   if (v.initialized())
     {
       v._restore_array();
     }
 
   this->_global_to_local_map = v._global_to_local_map;
 
   // Even if we're initializing sizes based on an uninitialized or
   // unclosed vector, *this* vector is being initialized now and is
   // initially closed.
   this->_is_closed      = true; // v._is_closed;
   this->_is_initialized = true; // v._is_initialized;
 
   this->_type = v._type;
 
   // We want to have a valid Vec, even if it's initially of size zero
   PetscErrorCode ierr = VecDuplicate (v._vec, &this->_vec);
   LIBMESH_CHKERR(ierr);
 
   if (fast == false)
     this->zero ();
 }

◆ initialized()

template<typename T>

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

inlinevirtualinherited

Returns: true if the vector has been initialized, false otherwise.

Definition at line 149 of file numeric_vector.h.

Referenced by libMesh::ImplicitSystem::assemble(), libMesh::NumericVector< Number >::compare(), libMesh::PetscVector< T >::create_subvector(), libMesh::NumericVector< Number >::global_relative_compare(), libMesh::PetscVector< T >::init(), and libMesh::NumericVector< Number >::local_relative_compare().

149 { return _is_initialized; }

libMesh::NumericVector::_is_initialized

bool _is_initialized

Definition: numeric_vector.h:717

◆ insert() [1/5]

template<typename T >

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

overridevirtual

Inserts the entries of v in *this at the locations specified by v.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 380 of file petsc_vector.C.

References ierr, and libMesh::numeric_petsc_cast().

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

◆ insert() [2/5]

template<typename T>

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

inlineinherited

Inserts the entries of v in *this at the locations specified by v.

Definition at line 859 of file numeric_vector.h.

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

◆ insert() [3/5]

template<typename T>

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

virtualinherited

Inserts the entries of v in *this at the locations specified by v.

Definition at line 92 of file numeric_vector.C.

 {
   libmesh_assert_equal_to (V.size(), dof_indices.size());
 
   for (numeric_index_type i=0; i<dof_indices.size(); i++)
     this->set (dof_indices[i], V(i));
 }

◆ insert() [4/5]

template<typename T>

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

inlineinherited

Inserts the entries of v in *this at the locations specified by v.

Definition at line 871 of file numeric_vector.h.

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

◆ insert() [5/5]

template<typename T>

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

inlineinherited

Inserts the entries of v in *this at the locations specified by v.

Definition at line 883 of file numeric_vector.h.

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

◆ l1_norm()

template<typename T >

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

overridevirtual

Returns: The $\ell_1$ -norm of the vector, i.e. the sum of the absolute values of the entries.

Implements libMesh::NumericVector< T >.

Definition at line 57 of file petsc_vector.C.

References libMesh::closed(), ierr, libMesh::Real, and value.

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

◆ l2_norm()

template<typename T >

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

overridevirtual

Returns: The $\ell_2$ -norm of the vector, i.e. the square root of the sum of the squares of the entries.

Implements libMesh::NumericVector< T >.

Definition at line 74 of file petsc_vector.C.

References libMesh::closed(), ierr, libMesh::Real, and value.

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

◆ last_local_index()

template<typename T >

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

inlineoverridevirtual

Returns: The index+1 of the last vector element actually stored on this processor.

Note: The maximum for this index is size().

Implements libMesh::NumericVector< T >.

Definition at line 983 of file petsc_vector.h.

References ierr, and libMesh::initialized().

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

◆ linfty_norm()

template<typename T >

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

overridevirtual

Returns: The $\ell_{\infty}$ -norm of the vector, i.e. the maximum absolute value of the entries of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 92 of file petsc_vector.C.

References libMesh::closed(), ierr, libMesh::Real, and value.

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

◆ local_relative_compare()

template<typename T>

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

virtualinherited

Returns: -1 when this is equivalent to other_vector, (up to the given local relative threshold), or the first index where abs(a[i]-b[i])/max(a[i],b[i]) exceeds the threshold.

Definition at line 136 of file numeric_vector.C.

 {
   libmesh_assert (this->initialized());
   libmesh_assert (other_vector.initialized());
   libmesh_assert_equal_to (this->first_local_index(), other_vector.first_local_index());
   libmesh_assert_equal_to (this->last_local_index(), other_vector.last_local_index());
 
   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;
 }

◆ local_size()

template<typename T >

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

inlineoverridevirtual

Returns: The local size of the vector, i.e. index_stop - index_start.

Implements libMesh::NumericVector< T >.

Definition at line 942 of file petsc_vector.h.

References ierr, and libMesh::initialized().

Referenced by 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);
 }

◆ localize() [1/5]

template<typename T >

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

overridevirtual

Creates a copy of the global vector in the local vector v_local.

Implements libMesh::NumericVector< T >.

Definition at line 926 of file petsc_vector.C.

References ierr.

Referenced by libMesh::PetscVector< T >::localize().

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

◆ localize() [2/5]

template<typename T >

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

overridevirtual

Same, but fills a NumericVector<T> instead of a std::vector.

Implements libMesh::NumericVector< T >.

Definition at line 660 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, libMesh::PetscVector< T >::close(), libMesh::GHOSTED, libMesh::MeshTools::Generation::Private::idx(), ierr, libMesh::Utility::iota(), PETSC_USE_POINTER, libMesh::PetscVector< T >::size(), and libMesh::NumericVector< T >::type().

 {
   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());
 
   PetscErrorCode ierr = 0;
   const PetscInt n = this->size();
 
   IS is;
   VecScatter scatter;
 
   // Create idx, idx[i] = i;
   std::vector<PetscInt> idx(n);
   std::iota (idx.begin(), idx.end(), 0);
 
   // Create the index set & scatter object
   ierr = ISCreateLibMesh(this->comm().get(), n, idx.data(), PETSC_USE_POINTER, &is);
   LIBMESH_CHKERR(ierr);
 
   ierr = LibMeshVecScatterCreate(_vec,          is,
                           v_local->_vec, is,
                           &scatter);
   LIBMESH_CHKERR(ierr);
 
   // Perform the scatter
   ierr = VecScatterBegin(scatter, _vec, v_local->_vec,
                          INSERT_VALUES, SCATTER_FORWARD);
   LIBMESH_CHKERR(ierr);
 
   ierr = VecScatterEnd  (scatter, _vec, v_local->_vec,
                          INSERT_VALUES, SCATTER_FORWARD);
   LIBMESH_CHKERR(ierr);
 
   // Clean up
   ierr = LibMeshISDestroy (&is);
   LIBMESH_CHKERR(ierr);
 
   ierr = LibMeshVecScatterDestroy(&scatter);
   LIBMESH_CHKERR(ierr);
 
   // Make sure ghost dofs are up to date
   if (v_local->type() == GHOSTED)
     v_local->close();
 }

◆ localize() [3/5]

template<typename T >

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

overridevirtual

Creates a local vector v_local containing only information relevant to this processor, as defined by the send_list.

Implements libMesh::NumericVector< T >.

Definition at line 713 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, libMesh::PetscVector< T >::close(), libMesh::GHOSTED, libMesh::MeshTools::Generation::Private::idx(), ierr, libMesh::PARALLEL, PETSC_USE_POINTER, libMesh::PetscVector< T >::size(), and libMesh::NumericVector< T >::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());
 
   IS is;
   VecScatter scatter;
 
   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 (numeric_index_type i = 0; i != this->local_size(); ++i)
     idx[n_sl+i] = i + this->first_local_index();
 
   // Create the index set & scatter object
   PetscInt * idxptr = idx.empty() ? nullptr : idx.data();
   ierr = ISCreateLibMesh(this->comm().get(), n_sl+this->local_size(),
                          idxptr, PETSC_USE_POINTER, &is);
   LIBMESH_CHKERR(ierr);
 
   ierr = LibMeshVecScatterCreate(_vec,          is,
                           v_local->_vec, is,
                           &scatter);
   LIBMESH_CHKERR(ierr);
 
 
   // Perform the scatter
   ierr = VecScatterBegin(scatter, _vec, v_local->_vec,
                          INSERT_VALUES, SCATTER_FORWARD);
   LIBMESH_CHKERR(ierr);
 
   ierr = VecScatterEnd  (scatter, _vec, v_local->_vec,
                          INSERT_VALUES, SCATTER_FORWARD);
   LIBMESH_CHKERR(ierr);
 
   // Clean up
   ierr = LibMeshISDestroy (&is);
   LIBMESH_CHKERR(ierr);
 
   ierr = LibMeshVecScatterDestroy(&scatter);
   LIBMESH_CHKERR(ierr);
 
   // Make sure ghost dofs are up to date
   if (v_local->type() == GHOSTED)
     v_local->close();
 }

◆ localize() [4/5]

template<typename T >

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

overridevirtual

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

Note: The indices can be different on every processor, and the same index can be localized to more than one processor. The resulting v_local can be shorter than the original, and the entries will be in the order specified by indices.

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

This function is useful in parallel I/O routines, when you have a parallel vector of solution values which you want to write a subset of.

Implements libMesh::NumericVector< T >.

Definition at line 787 of file petsc_vector.C.

References ierr, libMesh::numeric_petsc_cast(), and PETSC_USE_POINTER.

 {
   // Error code used to check the status of all PETSc function calls.
   PetscErrorCode ierr = 0;
 
   // Create a sequential destination Vec with the right number of entries on each proc.
   Vec dest;
   ierr = VecCreateSeq(PETSC_COMM_SELF, cast_int<PetscInt>(indices.size()), &dest);
   LIBMESH_CHKERR(ierr);
 
   // Create an IS using the libmesh routine.  PETSc does not own the
   // IS memory in this case, it is automatically cleaned up by the
   // std::vector destructor.
   PetscInt * idxptr =
     indices.empty() ? nullptr : numeric_petsc_cast(indices.data());
   IS is;
   ierr = ISCreateLibMesh(this->comm().get(), cast_int<PetscInt>(indices.size()), idxptr,
                          PETSC_USE_POINTER, &is);
   LIBMESH_CHKERR(ierr);
 
   // Create the VecScatter object. "PETSC_NULL" means "use the identity IS".
   VecScatter scatter;
   ierr = LibMeshVecScatterCreate(_vec,
                           /*src is=*/is,
                           /*dest vec=*/dest,
                           /*dest is=*/PETSC_NULL,
                           &scatter);
   LIBMESH_CHKERR(ierr);
 
   // Do the scatter
   ierr = VecScatterBegin(scatter, _vec, dest, INSERT_VALUES, SCATTER_FORWARD);
   LIBMESH_CHKERR(ierr);
 
   ierr = VecScatterEnd(scatter, _vec, dest, INSERT_VALUES, SCATTER_FORWARD);
   LIBMESH_CHKERR(ierr);
 
   // Get access to the values stored in dest.
   PetscScalar * values;
   ierr = VecGetArray (dest, &values);
   LIBMESH_CHKERR(ierr);
 
   // Store values into the provided v_local. Make sure there is enough
   // space reserved and then clear out any existing entries before
   // inserting.
   v_local.reserve(indices.size());
   v_local.clear();
   v_local.insert(v_local.begin(), values, values+indices.size());
 
   // We are done using it, so restore the array.
   ierr = VecRestoreArray (dest, &values);
   LIBMESH_CHKERR(ierr);
 
   // Clean up PETSc data structures.
   ierr = LibMeshVecScatterDestroy(&scatter);
   LIBMESH_CHKERR(ierr);
 
   ierr = LibMeshISDestroy (&is);
   LIBMESH_CHKERR(ierr);
 
   ierr = LibMeshVecDestroy(&dest);
   LIBMESH_CHKERR(ierr);
 }

◆ localize() [5/5]

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

Updates a local vector with selected values from neighboring processors, as defined by send_list.

Implements libMesh::NumericVector< T >.

Definition at line 854 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, libMesh::PetscVector< T >::close(), libMesh::MeshTools::Generation::Private::idx(), ierr, libMesh::PetscVector< T >::init(), libMesh::Utility::iota(), libMesh::PetscVector< T >::localize(), libMesh::PARALLEL, and PETSC_USE_POINTER.

 {
   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 - first_local_idx + 1);
   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
   {
     IS is;
     VecScatter scatter;
 
     // 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 object
     ierr = ISCreateLibMesh(this->comm().get(), my_local_size,
                            my_local_size ? idx.data() : nullptr, PETSC_USE_POINTER, &is);
     LIBMESH_CHKERR(ierr);
 
     ierr = LibMeshVecScatterCreate(_vec,              is,
                             parallel_vec._vec, is,
                             &scatter);
     LIBMESH_CHKERR(ierr);
 
     ierr = VecScatterBegin(scatter, _vec, parallel_vec._vec,
                            INSERT_VALUES, SCATTER_FORWARD);
     LIBMESH_CHKERR(ierr);
 
     ierr = VecScatterEnd  (scatter, _vec, parallel_vec._vec,
                            INSERT_VALUES, SCATTER_FORWARD);
     LIBMESH_CHKERR(ierr);
 
     // Clean up
     ierr = LibMeshISDestroy (&is);
     LIBMESH_CHKERR(ierr);
 
     ierr = LibMeshVecScatterDestroy(&scatter);
     LIBMESH_CHKERR(ierr);
   }
 
   // localize like normal
   parallel_vec.close();
   parallel_vec.localize (*this, send_list);
   this->close();
 }

◆ localize_to_one() [1/3]

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

Creates a local copy of the global vector in v_local only on processor proc_id. By default the data is sent to processor 0. This method is useful for outputting data from one processor.

Implements libMesh::NumericVector< T >.

◆ localize_to_one() [2/3]

template<>

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

Definition at line 961 of file petsc_vector.C.

References ierr.

 {
   this->_restore_array();
 
   PetscErrorCode ierr=0;
   const PetscInt n  = size();
   const PetscInt nl = local_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
   else
     {
       if (pid == 0) // optimized version for localizing to 0
         {
           Vec vout;
           VecScatter ctx;
 
           ierr = VecScatterCreateToZero(_vec, &ctx, &vout);
           LIBMESH_CHKERR(ierr);
 
           ierr = VecScatterBegin(ctx, _vec, vout, INSERT_VALUES, SCATTER_FORWARD);
           LIBMESH_CHKERR(ierr);
           ierr = VecScatterEnd(ctx, _vec, vout, INSERT_VALUES, SCATTER_FORWARD);
           LIBMESH_CHKERR(ierr);
 
           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);
             }
 
           ierr = LibMeshVecScatterDestroy(&ctx);
           LIBMESH_CHKERR(ierr);
           ierr = LibMeshVecDestroy(&vout);
           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);
 
             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, MPI_REAL, MPI_SUM,
                       pid, this->comm().get());
         }
     }
 }

◆ localize_to_one() [3/3]

template<>

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

Definition at line 1055 of file petsc_vector.C.

References ierr.

 {
   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,
                   MPI_REAL, MPI_SUM,
                   pid, this->comm().get());
 
       MPI_Reduce (imag_local_values.data(),
                   imag_v_local.data(), n,
                   MPI_REAL, MPI_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]);
     }
 }

◆ map_global_to_local_index()

template<typename T >

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

inline

Returns: The local index corresponding to global index i.

If the index is not a ghost cell, this is done by subtraction the number of the first local index. If it is a ghost cell, it has to be looked up in the map.

Definition at line 1007 of file petsc_vector.h.

References end, ierr, and libMesh::initialized().

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

◆ max()

template<typename T >

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

inlineoverridevirtual

Returns: The maximum entry in the vector, or the maximum real part in the case of complex numbers.

Implements libMesh::NumericVector< T >.

Definition at line 1162 of file petsc_vector.h.

References ierr, and 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);
 }

◆ min()

template<typename T >

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

inlineoverridevirtual

Returns: The minimum entry in the vector, or the minimum real part in the case of complex numbers.

Implements libMesh::NumericVector< T >.

Definition at line 1141 of file petsc_vector.h.

References ierr, and 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);
 }

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:130

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 95 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

96 { return cast_int<processor_id_type>(_communicator.size()); }

libMesh::Parallel::Communicator::size

processor_id_type size() const

Definition: communicator.h:175

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ operator()()

template<typename T >

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

inlineoverridevirtual

Returns: A copy of the ith entry of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 1067 of file petsc_vector.h.

References libMesh::GHOSTED.

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

◆ operator*=()

template<typename T>

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

inlineinherited

Scales the vector by a, $\vec{u} \leftarrow a\vec{u}$ . Equivalent to u.scale(a)

Returns: A reference to *this.

Definition at line 391 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

◆ operator+=()

template<typename T >

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

overridevirtual

Adds v to *this, $\vec{u} \leftarrow \vec{u} + \vec{v}$ . Equivalent to u.add(1, v).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 111 of file petsc_vector.C.

References libMesh::closed().

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

◆ operator-=()

template<typename T >

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

overridevirtual

Subtracts v from *this, $\vec{u} \leftarrow \vec{u} - \vec{v}$ . Equivalent to u.add(-1, v).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 125 of file petsc_vector.C.

References libMesh::closed().

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

◆ operator/=() [1/2]

template<typename T >

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

overridevirtual

Computes the pointwise division of this vector's entries by another's, $u_i \leftarrow \frac{u_i}{v_i} \, \forall i$

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 427 of file petsc_vector.C.

References libMesh::PetscVector< T >::_vec, and ierr.

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

◆ operator/=() [2/2]

template<typename T>

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

inlineinherited

Scales the vector by 1/a, $\vec{u} \leftarrow \frac{1}{a}\vec{u}$ . Equivalent to u.scale(1./a)

Returns: A reference to *this.

Definition at line 400 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

◆ operator=() [1/5]

template<typename T >

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

Copy assignment operator. Calls VecCopy after performing various checks.

Returns: A reference to *this as the derived type.

Definition at line 560 of file petsc_vector.C.

References libMesh::PetscVector< T >::_restore_array(), libMesh::NumericVector< T >::_type, libMesh::PetscVector< T >::_vec, libMesh::NumericVector< T >::closed(), libMesh::GHOSTED, ierr, libMesh::PetscVector< T >::local_size(), libMesh::PARALLEL, libMesh::SERIAL, libMesh::PetscVector< T >::size(), and libMesh::NumericVector< T >::type().

 {
   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;
 
   if (((this->type()==PARALLEL) && (v.type()==GHOSTED)) ||
       ((this->type()==GHOSTED) && (v.type()==PARALLEL)) ||
       ((this->type()==GHOSTED) && (v.type()==SERIAL))   ||
       ((this->type()==SERIAL) && (v.type()==GHOSTED)))
     {
       /* Allow assignment of a ghosted to a parallel vector since this
          causes no difficulty.  See discussion in libmesh-devel of
          June 24, 2010.  */
       ierr = VecCopy (v._vec, this->_vec);
       LIBMESH_CHKERR(ierr);
     }
   else
     {
       /* In all other cases, we assert that both vectors are of equal
          type.  */
       libmesh_assert_equal_to (this->_type, v._type);
 
       if (v.size() != 0)
         {
           if (this->type() != GHOSTED)
             {
               ierr = VecCopy (v._vec, this->_vec);
               LIBMESH_CHKERR(ierr);
             }
           else
             {
               Vec loc_vec;
               Vec v_loc_vec;
               ierr = VecGhostGetLocalForm (_vec,&loc_vec);
               LIBMESH_CHKERR(ierr);
               ierr = VecGhostGetLocalForm (v._vec,&v_loc_vec);
               LIBMESH_CHKERR(ierr);
 
               ierr = VecCopy (v_loc_vec, loc_vec);
               LIBMESH_CHKERR(ierr);
 
               ierr = VecGhostRestoreLocalForm (v._vec,&v_loc_vec);
               LIBMESH_CHKERR(ierr);
               ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
               LIBMESH_CHKERR(ierr);
             }
         }
     }
 
   close();
 
   return *this;
 }

◆ operator=() [2/5]

template<typename T>

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

delete

◆ operator=() [3/5]

template<typename T >

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

overridevirtual

Sets all entries of the vector to the value s.

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 510 of file petsc_vector.C.

References libMesh::closed(), libMesh::GHOSTED, and ierr.

 {
   this->_restore_array();
   libmesh_assert(this->closed());
 
   PetscErrorCode ierr = 0;
   PetscScalar s = static_cast<PetscScalar>(s_in);
 
   if (this->size() != 0)
     {
       if (this->type() != GHOSTED)
         {
           ierr = VecSet(_vec, s);
           LIBMESH_CHKERR(ierr);
         }
       else
         {
           Vec loc_vec;
           ierr = VecGhostGetLocalForm (_vec,&loc_vec);
           LIBMESH_CHKERR(ierr);
 
           ierr = VecSet(loc_vec, s);
           LIBMESH_CHKERR(ierr);
 
           ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
           LIBMESH_CHKERR(ierr);
         }
     }
 
   return *this;
 }

◆ operator=() [4/5]

template<typename T >

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

overridevirtual

This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual. This function should be overridden in derived classes so that they can be copied correctly via references to the base class. This design usually isn't a good idea in general, but in this context it works because we usually don't have a mix of different kinds of NumericVectors active in the library at a single time.

Returns: A reference to *this as the base type.

Implements libMesh::NumericVector< T >.

Definition at line 546 of file petsc_vector.C.

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

◆ operator=() [5/5]

template<typename T >

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

overridevirtual

Sets (*this)(i) = v(i) for each entry of the vector.

Returns: A reference to *this as the base type.

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.

Implements libMesh::NumericVector< T >.

Definition at line 624 of file petsc_vector.C.

References libMesh::GHOSTED.

 {
   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] =  static_cast<PetscScalar>(v[first + i]);
     }
 
   else
     {
       for (numeric_index_type i=0; i<_local_size; i++)
         _values[i] = static_cast<PetscScalar>(v[i]);
     }
 
   // Make sure ghost dofs are up to date
   if (this->type() == GHOSTED)
     this->close();
 
   return *this;
 }

◆ pointwise_mult()

template<typename T >

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

overridevirtual

Computes $u_i \leftarrow u_i v_i$ (summation not implied) i.e. the pointwise (component-wise) product of vec1 and vec2, and stores the result in *this.

Implements libMesh::NumericVector< T >.

Definition at line 1141 of file petsc_vector.C.

References libMesh::GHOSTED, and ierr.

 {
   this->_restore_array();
 
   PetscErrorCode ierr = 0;
 
   // 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.
 
   if (this->type() != GHOSTED)
     {
       ierr = VecPointwiseMult(this->vec(),
                               const_cast<PetscVector<T> *>(vec1_petsc)->vec(),
                               const_cast<PetscVector<T> *>(vec2_petsc)->vec());
       LIBMESH_CHKERR(ierr);
     }
   else
     {
       Vec loc_vec;
       Vec v1_loc_vec;
       Vec v2_loc_vec;
       ierr = VecGhostGetLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostGetLocalForm (const_cast<PetscVector<T> *>(vec1_petsc)->vec(),&v1_loc_vec);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostGetLocalForm (const_cast<PetscVector<T> *>(vec2_petsc)->vec(),&v2_loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecPointwiseMult(loc_vec,v1_loc_vec,v2_loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecGhostRestoreLocalForm (const_cast<PetscVector<T> *>(vec1_petsc)->vec(),&v1_loc_vec);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostRestoreLocalForm (const_cast<PetscVector<T> *>(vec2_petsc)->vec(),&v2_loc_vec);
       LIBMESH_CHKERR(ierr);
       ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
     }
 }

◆ print() [1/2]

template<typename T >

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

inlinevirtualinherited

Prints the local contents of the vector, by default to libMesh::out

Definition at line 916 of file numeric_vector.h.

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

◆ print() [2/2]

template<>

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

inlineinherited

Definition at line 898 of file numeric_vector.h.

 {
   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 (numeric_index_type i=this->first_local_index(); i<this->last_local_index(); i++)
     os << i << "\t"
        << (*this)(i).real() << "\t\t"
        << (*this)(i).imag() << std::endl;
 }

◆ print_global() [1/2]

template<typename T >

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

inlinevirtualinherited

Prints the global contents of the vector, by default to libMesh::out

Definition at line 953 of file numeric_vector.h.

 {
   libmesh_assert (this->initialized());
 
   std::vector<T> v(this->size());
   this->localize(v);
 
   // Right now we only want one copy of the output
   if (this->processor_id())
     return;
 
   os << "Size\tglobal =  " << this->size() << std::endl;
   os << "#\tValue" << std::endl;
   for (numeric_index_type i=0; i!=v.size(); i++)
     os << i << "\t" << v[i] << std::endl;
 }

◆ print_global() [2/2]

template<>

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

inlineinherited

Definition at line 931 of file numeric_vector.h.

 {
   libmesh_assert (this->initialized());
 
   std::vector<Complex> v(this->size());
   this->localize(v);
 
   // Right now we only want one copy of the output
   if (this->processor_id())
     return;
 
   os << "Size\tglobal =  " << this->size() << std::endl;
   os << "#\tReal part\t\tImaginary part" << std::endl;
   for (numeric_index_type i=0; i!=v.size(); i++)
     os << i << "\t"
        << v[i].real() << "\t\t"
        << v[i].imag() << std::endl;
 }

◆ print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

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

◆ print_matlab()

template<typename T >

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

overridevirtual

Print the contents of the vector in Matlab's sparse matrix format. Optionally prints the vector to the file named name. If name is not specified it is dumped to the screen.

Create an ASCII file containing the matrix if a filename was provided.

Otherwise the matrix will be dumped to the screen.

Destroy the viewer.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1188 of file petsc_vector.C.

References libMesh::closed(), ierr, and libMesh::Quality::name().

 {
   this->_restore_array();
   libmesh_assert (this->closed());
 
   PetscErrorCode ierr=0;
   PetscViewer petsc_viewer;
 
 
   ierr = PetscViewerCreate (this->comm().get(),
                             &petsc_viewer);
   LIBMESH_CHKERR(ierr);
 
   if (name != "")
     {
       ierr = PetscViewerASCIIOpen( this->comm().get(),
                                    name.c_str(),
                                    &petsc_viewer);
       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);
     }
 
   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);
     }
 
 
   ierr = LibMeshPetscViewerDestroy (&petsc_viewer);
   LIBMESH_CHKERR(ierr);
 }

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

102 { return cast_int<processor_id_type>(_communicator.rank()); }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

Definition: communicator.h:173

◆ reciprocal()

template<typename T >

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

overridevirtual

Computes the pointwise reciprocal, $u_i \leftarrow \frac{1}{u_i} \, \forall i$

Implements libMesh::NumericVector< T >.

Definition at line 156 of file petsc_vector.C.

References ierr.

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

◆ restore_array()

template<typename T >

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

inline

Restore the data array.

Note: This MUST be called after get_array() or get_array_read() and before using any other interface functions on PetscVector.

Definition at line 1131 of file petsc_vector.h.

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

◆ scale()

template<typename T >

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

overridevirtual

Scale each element of the vector by the given factor.

Implements libMesh::NumericVector< T >.

Definition at line 400 of file petsc_vector.C.

References libMesh::GHOSTED, and ierr.

 {
   this->_restore_array();
 
   PetscErrorCode ierr = 0;
   PetscScalar factor = static_cast<PetscScalar>(factor_in);
 
   if (this->type() != GHOSTED)
     {
       ierr = VecScale(_vec, factor);
       LIBMESH_CHKERR(ierr);
     }
   else
     {
       Vec loc_vec;
       ierr = VecGhostGetLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecScale(loc_vec, factor);
       LIBMESH_CHKERR(ierr);
 
       ierr = VecGhostRestoreLocalForm (_vec,&loc_vec);
       LIBMESH_CHKERR(ierr);
     }
 }

◆ set()

template<typename T >

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

overridevirtual

Sets v(i) = value.

Implements libMesh::NumericVector< T >.

Definition at line 138 of file petsc_vector.C.

References ierr, and value.

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

◆ size()

template<typename T >

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

inlineoverridevirtual

Returns: The size of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 922 of file petsc_vector.h.

References ierr, and libMesh::initialized().

Referenced by libMesh::PetscVector< T >::add(), libMesh::PetscVector< T >::localize(), and 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);
 }

◆ subset_l1_norm()

template<class T >

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

virtualinherited

Returns: The $\ell_1$ -norm of the vector, i.e. the sum of the absolute values for the specified entries in the vector.

Note: The indices must necessarily live on this processor.

Definition at line 311 of file numeric_vector.C.

Referenced by libMesh::System::discrete_var_norm().

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

◆ subset_l2_norm()

template<class T >

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

virtualinherited

Returns: The $\ell_2$ -norm of the vector, i.e. the square root of the sum of the squares of the elements for the specified entries in the vector.

Note: The indices must necessarily live on this processor.

Definition at line 326 of file numeric_vector.C.

Referenced by libMesh::System::discrete_var_norm().

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

◆ subset_linfty_norm()

template<class T >

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

virtualinherited

Returns: The maximum absolute value of the specified entries of this vector, which is the $\ell_{\infty}$ -norm of a vector.

Note: The indices must necessarily live on this processor.

Definition at line 341 of file numeric_vector.C.

Referenced by libMesh::System::discrete_var_norm().

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

◆ sum()

template<typename T >

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

overridevirtual

Returns: The sum of all values in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 41 of file petsc_vector.C.

References libMesh::closed(), ierr, and value.

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

◆ swap()

template<typename T >

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

inlineoverridevirtual

Swaps the contents of this with v. There should be enough indirection in subclasses to make this an O(1) header-swap operation.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1183 of file petsc_vector.h.

References 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, swap(), and libMesh::NumericVector< T >::swap().

Referenced by libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), DMlibMeshFunction(), DMlibMeshJacobian(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_postcheck(), and libMesh::libmesh_petsc_snes_residual_helper().

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

◆ type() [1/2]

template<typename T>

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

inlineinherited

Returns: The type (SERIAL, PARALLEL, GHOSTED) of the vector.

Definition at line 154 of file numeric_vector.h.

Referenced by libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::LaspackVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::localize(), libMesh::PetscVector< T >::operator=(), and libMesh::System::read_serialized_vector().

154 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

Definition: numeric_vector.h:722

◆ type() [2/2]

template<typename T>

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

inlineinherited

Returns: The type (SERIAL, PARALLEL, GHOSTED) of the vector.

Definition at line 159 of file numeric_vector.h.

159 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

Definition: numeric_vector.h:722

◆ vec()

template<typename T>

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

inline

Returns: The raw PETSc Vec pointer.

Note: This is generally not required in user-level code.; Don't do anything crazy like calling LibMeshVecDestroy() on it, or very bad things will likely happen!

Definition at line 325 of file petsc_vector.h.

References libMesh::PetscVector< T >::_vec.

Referenced by libMesh::PetscPreconditioner< T >::apply(), libMesh::SlepcEigenSolver< T >::attach_deflation_space(), libMesh::PetscNonlinearSolver< Number >::build_mat_null_space(), DMCreateGlobalVector_libMesh(), libMesh::PetscMatrix< T >::get_diagonal(), libMesh::TaoOptimizationSolver< T >::get_dual_variables(), libMesh::SlepcEigenSolver< T >::get_eigenpair(), libMesh::SlepcEigenSolver< T >::set_initial_space(), libMesh::PetscDiffSolver::solve(), and libMesh::PetscLinearSolver< T >::solve().

325 { libmesh_assert (_vec); return _vec; }

libMesh::PetscVector::_vec

Vec _vec

Definition: petsc_vector.h:333

◆ zero()

template<typename T >

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

inlineoverridevirtual

Set all entries to zero. Equivalent to v = 0, but more obvious and faster.

Implements libMesh::NumericVector< T >.

Definition at line 862 of file petsc_vector.h.

References libMesh::closed(), libMesh::GHOSTED, and ierr.

Referenced by libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_residual(), and libMesh::TaoOptimizationSolver< T >::solve().

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

◆ zero_clone()

template<typename T >

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

inlineoverridevirtual

Returns: A smart pointer to a copy of this vector with the same type, size, and partitioning, but with all zero entries.

Note: This must be overridden in the derived classes.

Implements libMesh::NumericVector< T >.

Definition at line 899 of file petsc_vector.h.

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

Member Data Documentation

◆ _array_is_present [1/2]

template<typename T>

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

mutableprivate

If true, the actual PETSc array of the values of the vector is currently accessible. That means that the members _local_form and _values are valid.

Definition at line 342 of file petsc_vector.h.

Referenced by libMesh::PetscVector< T >::swap().

◆ _array_is_present [2/2]

template<typename T>

bool libMesh::PetscVector< T >::_array_is_present

mutableprivate

Definition at line 344 of file petsc_vector.h.

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 107 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _destroy_vec_on_exit

template<typename T>

bool libMesh::PetscVector< T >::_destroy_vec_on_exit

private

This boolean value should only be set to false for the constructor which takes a PETSc Vec object.

Definition at line 433 of file petsc_vector.h.

Referenced by libMesh::PetscVector< T >::swap().

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 141 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

◆ _first

template<typename T>

numeric_index_type libMesh::PetscVector< T >::_first

mutableprivate

First local index.

Only valid when _array_is_present

Definition at line 352 of file petsc_vector.h.

◆ _global_to_local_map

template<typename T>

GlobalToLocalMap libMesh::PetscVector< T >::_global_to_local_map

private

Map that maps global to local ghost cells (will be empty if not in ghost cell mode).

Definition at line 427 of file petsc_vector.h.

Referenced by libMesh::PetscVector< T >::init(), libMesh::PetscVector< T >::PetscVector(), and libMesh::PetscVector< T >::swap().

◆ _is_closed

template<typename T>

bool libMesh::NumericVector< T >::_is_closed

protectedinherited

Flag which tracks whether the vector's values are consistent on all processors after insertion or addition of values has occurred on some or all processors.

Definition at line 712 of file numeric_vector.h.

Referenced by libMesh::NumericVector< Number >::closed(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::PetscVector< T >::PetscVector().

◆ _is_initialized

template<typename T>

bool libMesh::NumericVector< T >::_is_initialized

protectedinherited

true once init() has been called.

Definition at line 717 of file numeric_vector.h.

Referenced by libMesh::PetscVector< T >::create_subvector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::NumericVector< Number >::initialized(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::PetscVector< T >::PetscVector().

◆ _last

template<typename T>

numeric_index_type libMesh::PetscVector< T >::_last

mutableprivate

Last local index.

Only valid when _array_is_present

Definition at line 359 of file petsc_vector.h.

◆ _local_form

template<typename T>

Vec libMesh::PetscVector< T >::_local_form

mutableprivate

PETSc vector datatype to hold the local form of a ghosted vector. The contents of this field are only valid if the vector is ghosted and _array_is_present is true.

Definition at line 371 of file petsc_vector.h.

Referenced by libMesh::PetscVector< T >::swap().

◆ _local_size

template<typename T>

numeric_index_type libMesh::PetscVector< T >::_local_size

mutableprivate

Size of the local values from _get_array()

Definition at line 364 of file petsc_vector.h.

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _petsc_vector_mutex [1/2]

template<typename T>

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

mutableprivate

Mutex for _get_array and _restore_array. This is part of the object to keep down thread contention when reading frmo multiple PetscVectors simultaneously

Definition at line 399 of file petsc_vector.h.

◆ _petsc_vector_mutex [2/2]

template<typename T>

Threads::spin_mutex libMesh::PetscVector< T >::_petsc_vector_mutex

mutableprivate

Definition at line 401 of file petsc_vector.h.

◆ _read_only_values

template<typename T>

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

mutableprivate

Pointer to the actual PETSc array of the values of the vector. This pointer is only valid if _array_is_present is true. We're using PETSc's VecGetArrayRead() function, which requires a constant PetscScalar *, but _get_array and _restore_array are const member functions, so _values also needs to be mutable (otherwise it is a "const PetscScalar * const" in that context).

Definition at line 381 of file petsc_vector.h.

◆ _type

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

Type of vector.

Definition at line 722 of file numeric_vector.h.

Referenced by libMesh::DistributedVector< T >::DistributedVector(), libMesh::EigenSparseVector< T >::EigenSparseVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::PetscVector< T >::init(), libMesh::LaspackVector< T >::LaspackVector(), libMesh::PetscVector< T >::operator=(), libMesh::PetscVector< T >::PetscVector(), and libMesh::NumericVector< Number >::type().

◆ _values

template<typename T>

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

mutableprivate

Pointer to the actual PETSc array of the values of the vector. This pointer is only valid if _array_is_present is true. We're using PETSc's VecGetArrayRead() function, which requires a constant PetscScalar *, but _get_array and _restore_array are const member functions, so _values also needs to be mutable (otherwise it is a "const PetscScalar * const" in that context).

Definition at line 391 of file petsc_vector.h.

Referenced by libMesh::PetscVector< T >::swap().

◆ _values_manually_retrieved

template<typename T>

bool libMesh::PetscVector< T >::_values_manually_retrieved

mutableprivate

Whether or not the data array has been manually retrieved using get_array() or get_array_read()

Definition at line 439 of file petsc_vector.h.

◆ _values_read_only

template<typename T>

bool libMesh::PetscVector< T >::_values_read_only

mutableprivate

Whether or not the data array is for read only access

Definition at line 444 of file petsc_vector.h.

◆ _vec

template<typename T>

Vec libMesh::PetscVector< T >::_vec

private

Actual PETSc vector datatype to hold vector entries.

Definition at line 333 of file petsc_vector.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

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

Member Typedef Documentation

◆ Counts

◆ GlobalToLocalMap

Constructor & Destructor Documentation

◆ PetscVector() [1/7]

◆ PetscVector() [2/7]

◆ PetscVector() [3/7]

◆ PetscVector() [4/7]

◆ PetscVector() [5/7]

◆ PetscVector() [6/7]

◆ PetscVector() [7/7]

◆ ~PetscVector()

Member Function Documentation

◆ _get_array()

◆ _restore_array()

◆ abs()

◆ add() [1/4]

◆ add() [2/4]

◆ add() [3/4]

◆ add() [4/4]

◆ add_vector() [1/6]

◆ add_vector() [2/6]

◆ add_vector() [3/6]

◆ add_vector() [4/6]

◆ add_vector() [5/6]

◆ add_vector() [6/6]

◆ add_vector_conjugate_transpose()

◆ add_vector_transpose()

◆ build()

◆ clear()

◆ clone()

◆ close()

◆ closed()

◆ comm()

◆ compare()

◆ conjugate()

◆ create_subvector()

◆ disable_print_counter_info()

◆ dot()

◆ el()

◆ enable_print_counter_info()

◆ first_local_index()

◆ get() [1/2]

◆ get() [2/2]

◆ get_array()

◆ get_array_read()

◆ get_info()

◆ global_relative_compare()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ indefinite_dot()

◆ init() [1/4]

◆ init() [2/4]

◆ init() [3/4]

◆ init() [4/4]

◆ initialized()

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ l1_norm()

◆ l2_norm()

◆ last_local_index()

◆ linfty_norm()

◆ local_relative_compare()

◆ local_size()

◆ localize() [1/5]

◆ localize() [2/5]

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