This class provides a nice interface to PETSc's Vec object. More...

#include <petsc_vector.h>

Inheritance diagram for libMesh::PetscVector< T >:

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

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

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

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

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

PetscVector< T > &	operator= (const PetscVector< T > &v)
	Copy assignment operator.

	PetscVector (PetscVector &&)=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 (const PetscVector &)=delete

PetscVector &	operator= (PetscVector &&)=delete

virtual	~PetscVector ()

virtual void	close () override
	Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across processors.

virtual void	clear () noexcept override
	clear() is called from the destructor, so it should not throw.

virtual void	zero () override
	Set all entries to zero.

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
	Change the dimension of the vector to `n`.

virtual void	init (const numeric_index_type N, const bool fast=false, const ParallelType type=AUTOMATIC) override
	Call `init()` with n_local = N.

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const bool fast=false, const ParallelType=AUTOMATIC) override
	Create a vector that holds the local indices plus those specified in the `ghost` argument.

virtual void	init (const NumericVector< T > &other, const bool fast=false) override
	Creates a vector that has the same dimension and storage type as `other`, including ghost dofs.

virtual NumericVector< T > &	operator= (const T s) override
	Sets all entries of the vector to the value `s`.

virtual NumericVector< T > &	operator= (const NumericVector< T > &v) override
	This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual.

virtual NumericVector< T > &	operator= (const std::vector< T > &v) override
	Sets (*this)(i) = v(i) for each entry of the vector.

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
	Access multiple components at once.

PetscScalar *	get_array ()
	Get read/write access to the raw PETSc Vector data array.

const PetscScalar *	get_array_read () const
	Get read only access to the raw PETSc Vector data array.

void	restore_array ()
	Restore the data array.

virtual NumericVector< T > &	operator+= (const NumericVector< T > &v) override
	Adds `v` to *this, \( \vec{u} \leftarrow \vec{u} + \vec{v} \).

virtual NumericVector< T > &	operator-= (const NumericVector< T > &v) override
	Subtracts `v` from *this, \( \vec{u} \leftarrow \vec{u} - \vec{v} \).

virtual void	reciprocal () override
	Computes the component-wise reciprocal, \( u_i \leftarrow \frac{1}{u_i} \, \forall i\).

virtual void	conjugate () override
	Negates the imaginary component of each entry in the vector.

virtual void	set (const numeric_index_type i, const T value) override
	Sets v(i) = `value`.

virtual void	add (const numeric_index_type i, const T value) override
	Adds `value` to the vector entry specified by `i`.

virtual void	add (const T s) override
	Adds `s` to each entry of the vector, \( u_i \leftarrow u_i + s \).

virtual void	add (const NumericVector< T > &v) override
	Adds `v` to `this`, \( \vec{u} \leftarrow \vec{u} + \vec{v} \).

virtual void	add (const T a, const NumericVector< T > &v) override
	Vector addition with a scalar multiple, \( \vec{u} \leftarrow \vec{u} + a\vec{v} \).

virtual void	add_vector (const T *v, const std::vector< numeric_index_type > &dof_indices) override
	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].

virtual void	add_vector (const NumericVector< T > &v, const SparseMatrix< T > &A) override
	Computes \( \vec{u} \leftarrow \vec{u} + A \vec{v} \), i.e.

virtual void	add_vector_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A) override
	Computes \( \vec{u} \leftarrow \vec{u} + A^T \vec{v} \), i.e.

void	add_vector_conjugate_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A)
	\( U \leftarrow U + A^H v \).

virtual void	insert (const T *v, const std::vector< numeric_index_type > &dof_indices) override
	Inserts the entries of `v` in *this at the locations specified by `v`.

virtual void	scale (const T factor) override
	Scale each element of the vector by the given `factor`.

virtual NumericVector< T > &	operator*= (const NumericVector< T > &v) override
	Computes the component-wise multiplication of this vector's entries by another's, \( u_i \leftarrow u_i v_i \, \forall i\).

virtual NumericVector< T > &	operator/= (const NumericVector< T > &v) override
	Computes the component-wise division of this vector's entries by another's, \( u_i \leftarrow \frac{u_i}{v_i} \, \forall i\).

virtual void	abs () override
	Sets \( u_i \leftarrow \|u_i\| \) for each entry in the vector.

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
	Creates a copy of the global vector in the local vector `v_local`.

virtual void	localize (NumericVector< T > &v_local) const override
	Same, but fills a `NumericVector<T>` instead of a `std::vector`.

virtual void	localize (NumericVector< T > &v_local, const std::vector< numeric_index_type > &send_list) const override
	Creates a local vector `v_local` containing only information relevant to this processor, as defined by the `send_list`.

virtual void	localize (std::vector< T > &v_local, const std::vector< numeric_index_type > &indices) const override
	Fill in the local std::vector "v_local" with the global indices given in "indices".

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
	Updates a local vector with selected values from neighboring processors, as defined by `send_list`.

virtual void	localize_to_one (std::vector< T > &v_local, const processor_id_type proc_id=0) const override
	Creates a local copy of the global vector in `v_local` only on processor `proc_id`.

virtual void	pointwise_mult (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
	Computes \( u_i \leftarrow u_i v_i \) (summation not implied) i.e.

virtual void	pointwise_divide (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
	Computes \( u_i \leftarrow \frac{v_{1,i}}{v_{2,i}} \) (summation not implied) i.e.

virtual void	print_matlab (const std::string &name="") const override
	Print the contents of the vector in Matlab's sparse matrix format.

virtual void	create_subvector (NumericVector< T > &subvector, const std::vector< numeric_index_type > &rows, bool supplying_global_rows=true) const override
	Fills in `subvector` from this vector using the indices in `rows`.

virtual void	swap (NumericVector< T > &v) override
	Swaps the contents of this with `v`.

virtual std::size_t	max_allowed_id () const override

Vec	vec ()

Vec	vec () const

virtual std::unique_ptr< NumericVector< T > >	get_subvector (const std::vector< numeric_index_type > &rows) override
	Creates a view into this vector using the indices in `rows`.

virtual void	restore_subvector (std::unique_ptr< NumericVector< T > > subvector, const std::vector< numeric_index_type > &rows) override
	Restores a view into this vector using the indices in `rows`.

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

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

virtual bool	initialized () const

ParallelType	type () const

ParallelType &	type ()

bool	is_effectively_serial () const

bool	is_effectively_ghosted () const

void	set_type (ParallelType t)
	Allow the user to change the ParallelType of the NumericVector under some circumstances.

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

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

Real	l1_norm_diff (const NumericVector< T > &other_vec) const

virtual T	el (const numeric_index_type i) const

void	get (const std::vector< numeric_index_type > &index, std::vector< T > &values) const
	Access multiple components at once.

NumericVector< T > &	operator*= (const T a)
	Scales the vector by `a`, \( \vec{u} \leftarrow a\vec{u} \).

NumericVector< T > &	operator/= (const T a)
	Scales the vector by `1/a`, \( \vec{u} \leftarrow \frac{1}{a}\vec{u} \).

void	add_vector (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	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].

void	add_vector (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	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)`.

void	add_vector (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	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)`.

void	add_vector (const NumericVector< T > &v, const ShellMatrix< T > &A)
	Computes \( \vec{u} \leftarrow \vec{u} + A \vec{v} \), i.e.

void	insert (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Inserts the entries of `v` in *this at the locations specified by `v`.

void	insert (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Inserts the entries of `v` in *this at the locations specified by `v`.

void	insert (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Inserts the entries of `v` in *this at the locations specified by `v`.

void	insert (const DenseSubVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Inserts the entries of `v` in *this at the locations specified by `v`.

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
	Prints the local contents of the vector, by default to libMesh::out.

void	print (std::ostream &os) const

virtual void	print_global (std::ostream &os=libMesh::out) const
	Prints the global contents of the vector, by default to libMesh::out.

void	print_global (std::ostream &os) const

virtual void	read_matlab (const std::string &filename)
	Read the contents of the vector from the Matlab-script format used by PETSc.

bool	readable () const

bool	compatible (const NumericVector< T > &v) 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, SolverPackage solver_package=libMesh::default_solver_package(), ParallelType parallel_type=AUTOMATIC)
	Builds a `NumericVector` on the processors in communicator `comm` using the linear solver package specified by `solver_package`.

static std::string	get_info ()
	Gets a string containing the reference information.

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().

static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information.

Protected Member Functions
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
bool	_is_closed
	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.

bool	_is_initialized
	`true` once init() has been called.

ParallelType	_type
	Type of vector.

std::mutex	_numeric_vector_mutex
	Mutex for performing thread-safe operations.

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Private Types
typedef std::unordered_map< numeric_index_type, numeric_index_type >	GlobalToLocalMap
	Type for map that maps global to local ghost cells.

Private Member Functions
void	_get_array (bool read_only) const
	Queries the array (and the local form if the vector is ghosted) from PETSc.

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

template<NormType N>
Real	norm () const

Private Attributes
Vec	_vec
	Actual PETSc vector datatype to hold vector entries.

std::atomic< bool >	_array_is_present
	If `true`, the actual PETSc array of the values of the vector is currently accessible.

bool	_array_is_present

numeric_index_type	_first
	First local index.

numeric_index_type	_last
	Last local index.

numeric_index_type	_local_size
	Size of the local values from _get_array()

Vec	_local_form
	PETSc vector datatype to hold the local form of a ghosted vector.

const PetscScalar *	_read_only_values
	Pointer to the actual PETSc array of the values of the vector.

PetscScalar *	_values
	Pointer to the actual PETSc array of the values of the vector.

std::mutex	_petsc_get_restore_array_mutex
	Mutex for _get_array and _restore_array.

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

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

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

bool	_values_read_only
	Whether or not the data array is for read only access.

Detailed Description

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

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

NumericVector interface to PETSc Vec.

Definition at line 73 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 119 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 448 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 489 of file petsc_vector.h.

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

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

◆ 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 511 of file petsc_vector.h.

                                                       :
  NumericVector<T>(comm_in, ptype),
  _vec(nullptr),
  _array_is_present(false),
  _first(0),
  _last(0),
  _local_size(0),
  _local_form(nullptr),
  _read_only_values(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);
}

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

◆ 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 535 of file petsc_vector.h.

                                                       :
  NumericVector<T>(comm_in, ptype),
  _vec(nullptr),
  _array_is_present(false),
  _first(0),
  _last(0),
  _local_size(0),
  _local_form(nullptr),
  _read_only_values(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);
}

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

◆ 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 560 of file petsc_vector.h.

                                                       :
  NumericVector<T>(comm_in, ptype),
  _vec(nullptr),
  _array_is_present(false),
  _first(0),
  _last(0),
  _local_size(0),
  _local_form(nullptr),
  _read_only_values(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);
}

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

◆ 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 588 of file petsc_vector.h.

                                                                   :
  NumericVector<T>(comm_in, AUTOMATIC),
  _vec(v),
  _array_is_present(false),
  _first(0),
  _last(0),
  _local_size(0),
  _local_form(nullptr),
  _read_only_values(nullptr),
  _values(nullptr),
  _global_to_local_map(),
  _destroy_vec_on_exit(false),
  _values_manually_retrieved(false),
  _values_read_only(false)
{
  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.  */
  PetscInt petsc_local_size=0;
  LibmeshPetscCall(VecGetLocalSize(_vec, &petsc_local_size));
 
  // Get the vector type from PETSc.
  VecType ptype;
  LibmeshPetscCall(VecGetType(_vec, &ptype));
 
  // PETSc supports some exotic types nowadays.  Just use Vec sizes to
  // determine whether we're SERIAL vs PARALLEL-or-GHOSTED.
  PetscInt petsc_global_size = 0;
  LibmeshPetscCall(VecGetSize(_vec, &petsc_global_size));
 
  // If we have a parallel Vec with all its DoFs on one processor, we
  // might be unable to tell on that processor that it's not a serial
  // vector unless we communicate.
  bool is_serial = (petsc_local_size == petsc_global_size);
  comm_in.min(is_serial);
 
#ifdef DEBUG
  dof_id_type sum_of_local_sizes = petsc_local_size;
  comm_in.sum(sum_of_local_sizes);
  libmesh_assert_equal_to(sum_of_local_sizes,
                          cast_int<dof_id_type>(petsc_global_size));
#endif
 
#if PETSC_RELEASE_GREATER_EQUALS(3, 21, 0)
  // Fande only implemented VecGhostGetGhostIS for VECMPI
  if (std::strcmp(ptype, VECMPI) == 0)
    {
      IS ghostis;
      LibmeshPetscCall(VecGhostGetGhostIS(_vec, &ghostis));
 
      Vec localrep;
      LibmeshPetscCall(VecGhostGetLocalForm(_vec, &localrep));
 
      // If is a sparsely stored vector, set up our new mapping
      // Only checking mapping is not enough to determine if a vec is ghosted
      // We need to check if vec has a local representation
      if (ghostis && localrep)
        {
          PetscInt ghost_size;
          LibmeshPetscCall(ISGetSize(ghostis, &ghost_size));
 
          const PetscInt * indices;
          LibmeshPetscCall(ISGetIndices(ghostis, &indices));
 
          for (const auto i : make_range(ghost_size))
            _global_to_local_map[indices[i]] = i;
          this->_type = GHOSTED;
          LibmeshPetscCall(ISRestoreIndices(ghostis, &indices));
        }
      else
        this->_type = PARALLEL;
    }
  else if (!is_serial)
#else // PETSc < 3.21.0
  if (!is_serial)
#endif
    {
      ISLocalToGlobalMapping mapping = nullptr;
      Vec localrep = nullptr;
 
      // Non-VECMPI types won't even let us call VecGetLocalToGlobalMapping;
      // we'll just assume for now that no such type is ghosted
      if (std::strcmp(ptype, VECMPI) == 0)
        {
          LibmeshPetscCall(VecGetLocalToGlobalMapping(_vec, &mapping));
          LibmeshPetscCall(VecGhostGetLocalForm(_vec,&localrep));
        }
 
      // If is a sparsely stored vector, set up our new mapping
      // Only checking mapping is not enough to determine if a vec is ghosted
      // We need to check if vec has a local representation
      if (mapping && localrep)
        {
          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);
          PetscInt n;
          LibmeshPetscCall(ISLocalToGlobalMappingGetSize(mapping, &n));
 
          const numeric_index_type ghost_end = static_cast<numeric_index_type>(n);
          const PetscInt * indices;
          LibmeshPetscCall(ISLocalToGlobalMappingGetIndices(mapping,&indices));
 
          for (numeric_index_type i=ghost_begin; i<ghost_end; i++)
            _global_to_local_map[indices[i]] = i-my_local_size;
          this->_type = GHOSTED;
          LibmeshPetscCall(ISLocalToGlobalMappingRestoreIndices(mapping, &indices));
        }
      else
        this->_type = PARALLEL;
 
      LibmeshPetscCall(VecGhostRestoreLocalForm(_vec,&localrep));
    }
  else
    this->_type = SERIAL;
}

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, libMesh::make_range(), libMesh::Parallel::Communicator::min(), libMesh::PARALLEL, libMesh::SERIAL, and libMesh::Parallel::Communicator::sum().

◆ 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 712 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 1184 of file petsc_vector.C.

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

References libMesh::initialized(), and libMesh::libmesh_assert().

◆ _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 1258 of file petsc_vector.C.

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

References libMesh::initialized(), and libMesh::libmesh_assert().

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

◆ 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 413 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  LibmeshPetscCall(VecAbs(_vec));
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
}

References libMesh::libmesh_assert().

◆ add() [1/4]

template<typename T >

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

overridevirtual

Adds value to the vector entry specified by i.

Note that library implementations of this method are thread safe, e.g. we will lock _numeric_vector_mutex before writing to the vector

Implements libMesh::NumericVector< T >.

Definition at line 165 of file petsc_vector.C.

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

References libMesh::PS(), and value.

Referenced by main().

◆ add() [2/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 305 of file petsc_vector.C.

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

◆ add() [3/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 315 of file petsc_vector.C.

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

◆ add() [4/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 294 of file petsc_vector.C.

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

◆ add_vector() [1/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).

This method is guaranteed to be thread safe as long as library implementations of NumericVector are used

Definition at line 1008 of file numeric_vector.h.

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

References libMesh::DenseVector< T >::empty(), libMesh::libmesh_assert(), and libMesh::DenseVector< T >::size().

◆ add_vector() [2/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 716 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

◆ add_vector() [3/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 204 of file petsc_vector.C.

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

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

◆ 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
	)

inherited

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

This method is guaranteed to be thread-safe as long as library implementations of NumericVector are used

Definition at line 702 of file numeric_vector.C.

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

◆ add_vector() [5/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].

This method is guaranteed to be thread safe as long as library implementations of NumericVector are used

Definition at line 996 of file numeric_vector.h.

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

References libMesh::libmesh_assert().

◆ add_vector() [6/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. Note that library implementations of this method are thread safe

Reimplemented from libMesh::NumericVector< T >.

Definition at line 182 of file petsc_vector.C.

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

◆ 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 260 of file petsc_vector.C.

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

◆ 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 232 of file petsc_vector.C.

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

◆ build()

template<typename T >

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

staticinherited

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

Definition at line 61 of file numeric_vector.C.

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

References libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS, libMesh::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

◆ clear()

template<typename T >

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

inlineoverridevirtualnoexcept

clear() is called from the destructor, so it should not throw.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 929 of file petsc_vector.h.

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

References libMesh::initialized().

◆ 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 993 of file petsc_vector.h.

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

Referenced by PetscVectorTest::testPetscOperations().

◆ 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 911 of file petsc_vector.h.

{
  parallel_object_only();
 
  this->_restore_array();
 
  VecAssemblyBeginEnd(this->comm(), _vec);
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
  this->_is_closed = true;
}

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::PetscNonlinearSolver< Number >::force_new_preconditioner(), libMesh::SlepcEigenSolver< T >::get_eigenpair(), libMesh::PetscVector< T >::localize(), main(), libMesh::PetscLinearSolver< T >::solve_base(), PetscVectorTest::testGetArray(), and PetscVectorTest::testPetscOperations().

◆ 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 210 of file numeric_vector.h.

210{ return _is_closed; }

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

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

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ 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 153 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

◆ compatible()

template<typename T >

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

inherited

Returns: whether or not this vector and the vector v are able to be read for global operations with one-another

Definition at line 734 of file numeric_vector.C.

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

References libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::last_local_index(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::readable(), and libMesh::NumericVector< T >::size().

◆ 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 153 of file petsc_vector.C.

{
  parallel_object_only();
 
 
  // We just call the PETSc VecConjugate
  LibmeshPetscCall(VecConjugate(_vec));
}

◆ create_subvector()

template<typename T >

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

overridevirtual

Fills in subvector from this vector using the indices in rows.

supplying_global_rows communicates whether the supplied vector of rows corresponds to all the rows that should be used in the subvector's index set, e.g. whether the rows correspond to the global collective. If the rows supplied are only the local indices, then supplying_global_rows should be set to false

This is currently only implemented for PetscVector and EigenSparseVector.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1052 of file petsc_vector.C.

{
  parallel_object_only();
 
  libmesh_error_msg_if(
      subvector.is_effectively_ghosted(),
      "We do not support scattering parallel information to ghosts for subvectors");
 
  this->_restore_array();
 
  // PETSc data structures
 
  // 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())
    {
      if (this->is_effectively_serial())
        {
          libmesh_assert(this->comm().verify(rows.size()));
          LibmeshPetscCall(VecCreateSeq(this->comm().get(), rows.size(), &(petsc_subvector->_vec)));
 
#ifdef LIBMESH_ENABLE_DEPRECATED
          // In the past we always created PARALLEL subvectors from
          // GHOSTED vectors, but this behavior must now be specified
          // downstream when it's desired, by setting the subvector
          // type in advance.
          petsc_subvector->_type = (this->type() == SERIAL) ? SERIAL : PARALLEL;
 
          if (petsc_subvector->type() == AUTOMATIC &&
              this->type() != petsc_subvector->type())
            libmesh_deprecated();
#else
          // If the subvector already had a type, let's not change it.
          // If it was just at the default AUTOMATIC, let's pick the
          // true type from the supervector.
          if (petsc_subvector->type() == AUTOMATIC)
            petsc_subvector->_type = this->type();
#endif
        }
      else
        {
#ifndef LIBMESH_ENABLE_DEPRECATED
          // We're only supporting PARALLEL subvectors in parallel
          // so far, but we want to leave other possible API inputs
          // marked as invalid so we can add support for other
          // subvector types later.
          if (petsc_subvector->type() != PARALLEL &&
              (petsc_subvector->type() != AUTOMATIC ||
               this->type() != PARALLEL))
            libmesh_not_implemented_msg("Cannot yet create non-PARALLEL subvectors in parallel");
#endif
 
          if (supplying_global_rows)
            // 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() ?
            LibmeshPetscCall(VecCreateMPI(this->comm().get(),
                                          PETSC_DECIDE,                    // n_local
                                          cast_int<PetscInt>(rows.size()), // n_global
                                          &(petsc_subvector->_vec)));
          else
            LibmeshPetscCall(VecCreateMPI(this->comm().get(),
                                          cast_int<PetscInt>(rows.size()),
                                          PETSC_DETERMINE,
                                          &(petsc_subvector->_vec)));
 
          // We created a parallel vector
          petsc_subvector->_type = PARALLEL;
        }
 
      LibmeshPetscCall(VecSetFromOptions (petsc_subvector->_vec));
 
 
      // Mark the subvector as initialized
      petsc_subvector->_is_initialized = true;
    }
  else
    {
      petsc_subvector->_restore_array();
    }
 
  std::vector<PetscInt> idx(rows.size());
  if (supplying_global_rows)
    std::iota (idx.begin(), idx.end(), 0);
  else
    {
      PetscInt start;
      LibmeshPetscCall(VecGetOwnershipRange(petsc_subvector->_vec, &start, nullptr));
      std::iota (idx.begin(), idx.end(), start);
    }
 
  // Construct index sets
  WrappedPetsc<IS> parent_is;
  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                   cast_int<PetscInt>(rows.size()),
                                   numeric_petsc_cast(rows.data()),
                                   PETSC_USE_POINTER,
                                   parent_is.get()));
 
  WrappedPetsc<IS> subvector_is;
  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                   cast_int<PetscInt>(rows.size()),
                                   idx.data(),
                                   PETSC_USE_POINTER,
                                   subvector_is.get()));
 
  // Construct the scatter object
  WrappedPetsc<VecScatter> scatter;
  LibmeshPetscCall(VecScatterCreate(this->_vec,
                                    parent_is,
                                    petsc_subvector->_vec,
                                    subvector_is,
                                    scatter.get()));
 
  // Actually perform the scatter
  VecScatterBeginEnd(this->comm(), scatter, this->_vec, petsc_subvector->_vec, INSERT_VALUES, SCATTER_FORWARD);
 
  petsc_subvector->_is_closed = true;
}

References libMesh::NumericVector< T >::_is_closed, libMesh::NumericVector< T >::_is_initialized, libMesh::PetscVector< T >::_restore_array(), libMesh::NumericVector< T >::_type, libMesh::PetscVector< T >::_vec, libMesh::AUTOMATIC, libMesh::WrappedPetsc< T >::get(), libMesh::NumericVector< T >::initialized(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::libmesh_assert(), libMesh::numeric_petsc_cast(), libMesh::PARALLEL, libMesh::SERIAL, and libMesh::NumericVector< T >::type().

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ 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 429 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  // Error flag
 
  // 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.
  LibmeshPetscCall(VecDot(this->_vec, v->_vec, &value));
 
  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 403 of file numeric_vector.h.

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ 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 1039 of file petsc_vector.h.

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

References libMesh::initialized(), and libMesh::libmesh_assert().

Referenced by PetscVectorTest::testPetscOperations().

◆ get() [1/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 981 of file numeric_vector.h.

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

◆ get() [2/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 1159 of file petsc_vector.h.

{
  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->is_effectively_ghosted())
        libmesh_assert_less (local_index, _local_size);
#endif
      values[i] = static_cast<T>(_read_only_values[local_index]);
    }
}

◆ 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 1180 of file petsc_vector.h.

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

Referenced by PetscVectorTest::testGetArray().

◆ 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 1191 of file petsc_vector.h.

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

Referenced by PetscVectorTest::testGetArray().

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

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

Referenced by libMesh::ReferenceCounter::print_info().

◆ get_subvector()

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::PetscVector< T >::get_subvector ( const std::vector< numeric_index_type > & )

overridevirtual

Creates a view into this vector using the indices in rows.

Calls to this API should always be paired with a call to restore_subvector, else any changes made in the subvector will not be reflected in (this) original vector.

This is currently only implemented for PetscVector and EigenSparseVector.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1297 of file petsc_vector.C.

{
  // Construct index set
  WrappedPetsc<IS> parent_is;
  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                   cast_int<PetscInt>(rows.size()),
                                   numeric_petsc_cast(rows.data()),
                                   PETSC_USE_POINTER,
                                   parent_is.get()));
 
  Vec subvec;
  LibmeshPetscCall(VecGetSubVector(_vec, parent_is, &subvec));
 
  this->_is_closed = false;
 
  return std::make_unique<PetscVector<T>>(subvec, this->comm());
}

References libMesh::WrappedPetsc< T >::get(), and libMesh::numeric_petsc_cast().

◆ 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 211 of file numeric_vector.C.

{
  libmesh_assert(this->compatible(other_vector));
 
  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;
}

References libMesh::libmesh_assert(), libMesh::NumericVector< T >::linfty_norm(), and libMesh::Real.

◆ increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

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

◆ increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

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

◆ 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 450 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  // Error flag
 
  // 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.
  LibmeshPetscCall(VecTDot(this->_vec, v->_vec, &value));
 
  return static_cast<T>(value);
}

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

◆ init() [1/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 790 of file petsc_vector.h.

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

◆ init() [2/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 721 of file petsc_vector.h.

{
  parallel_object_only();
 
  PetscInt petsc_n=static_cast<PetscInt>(n);
 
  // Clear initialized vectors
  if (this->initialized())
    this->clear();
 
  if (ptype == AUTOMATIC)
    {
      if (n == n_local)
        this->_type = SERIAL;
      else
        this->_type = PARALLEL;
    }
  else
    this->_type = ptype;
 
  // We should have been given consistent settings
  libmesh_assert ((this->_type==SERIAL && n==n_local) ||
                  (this->n_processors()==1 && n==n_local) ||
                  this->_type==PARALLEL);
 
  // create a sequential vector if on only 1 processor, or if asked
  if (this->_type == SERIAL || (this->n_processors() == 1))
    {
      LibmeshPetscCallA(PETSC_COMM_SELF, VecCreate(PETSC_COMM_SELF, &_vec));
      LibmeshPetscCallA(PETSC_COMM_SELF, VecSetSizes(_vec, petsc_n, petsc_n));
      LibmeshPetscCallA(PETSC_COMM_SELF, VecSetFromOptions (_vec));
    }
  // or create an MPI-enabled PARALLEL vector w/o ghosting if asked
  else if (this->_type == PARALLEL)
    {
#ifdef LIBMESH_HAVE_MPI
      PetscInt petsc_n_local=cast_int<PetscInt>(n_local);
      libmesh_assert_less_equal (n_local, n);
      // Use more generic function instead of VecCreateSeq/MPI
      LibmeshPetscCall(VecCreate(this->comm().get(), &_vec));
      LibmeshPetscCall(VecSetSizes(_vec, petsc_n_local, petsc_n));
#else
      libmesh_assert_equal_to (n_local, n);
      LibmeshPetscCallA(PETSC_COMM_SELF, VecCreate(PETSC_COMM_SELF, &_vec));
      LibmeshPetscCallA(PETSC_COMM_SELF, VecSetSizes(_vec, petsc_n, petsc_n));
#endif
      LibmeshPetscCall(VecSetFromOptions(_vec));
    }
  // or yell because we don't know what to do
  else
    libmesh_error_msg("Unsupported type " <<
                      Utility::enum_to_string(this->_type) <<
                      " for parallel init with no ghost indices supplied");
 
  this->_is_initialized = true;
  this->_is_closed = true;
 
 
  if (fast == false)
    this->zero ();
}

References libMesh::AUTOMATIC, libMesh::Utility::enum_to_string(), libMesh::initialized(), libMesh::libmesh_assert(), libMesh::PARALLEL, libMesh::SERIAL, and libMesh::zero.

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

◆ init() [3/4]

template<typename T >

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`
	)

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 801 of file petsc_vector.h.

{
  parallel_object_only();
 
  if (this->comm().size() == 1)
    {
      libmesh_assert(ghost.empty());
      this->init(n, n_local, fast, ptype);
      return;
    }
 
  PetscInt petsc_n=static_cast<PetscInt>(n);
  PetscInt petsc_n_local=static_cast<PetscInt>(n_local);
  PetscInt petsc_n_ghost=static_cast<PetscInt>(ghost.size());
 
  // If the mesh is not disjoint, every processor will either have
  // all the dofs, none of the dofs, or some non-zero dofs at the
  // boundary between processors.
  //
  // However we can't assert this, because someone might want to
  // construct a GHOSTED vector which doesn't include neighbor element
  // dofs.  Boyce tried to do so in user code, and we're going to want
  // to do so in System::project_vector().
  //
  // libmesh_assert(n_local == 0 || n_local == n || !ghost.empty());
 
  libmesh_assert(sizeof(PetscInt) == sizeof(numeric_index_type));
 
  PetscInt * petsc_ghost = ghost.empty() ? LIBMESH_PETSC_NULLPTR :
    const_cast<PetscInt *>(reinterpret_cast<const PetscInt *>(ghost.data()));
 
  // Clear initialized vectors
  if (this->initialized())
    this->clear();
 
  libmesh_assert(ptype == AUTOMATIC || ptype == GHOSTED);
  this->_type = GHOSTED;
 
  /* Make the global-to-local ghost cell map.  */
  for (auto i : index_range(ghost))
    {
      _global_to_local_map[ghost[i]] = i;
    }
 
  /* Create vector.  */
  LibmeshPetscCall(VecCreateGhost (this->comm().get(), petsc_n_local, petsc_n,
                                   petsc_n_ghost, petsc_ghost,
                                   &_vec));
 
  // Add a prefix so that we can at least distinguish a ghosted vector from a
  // nonghosted vector when using a petsc option.
  // PETSc does not fully support VecGhost on GPU yet. This change allows us to
  // trigger a nonghosted vector to use GPU without bothering the ghosted vectors.
  LibmeshPetscCall(PetscObjectAppendOptionsPrefix((PetscObject)_vec,"ghost_"));
 
  LibmeshPetscCall(VecSetFromOptions (_vec));
 
  this->_is_initialized = true;
  this->_is_closed = true;
 
  if (fast == false)
    this->zero ();
}

References libMesh::AUTOMATIC, libMesh::GHOSTED, libMesh::index_range(), libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::zero.

◆ 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 873 of file petsc_vector.h.

{
  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
  LibmeshPetscCall(VecDuplicate (v._vec, &this->_vec));
 
  if (fast == false)
    this->zero ();
}

References libMesh::PetscVector< T >::_global_to_local_map, libMesh::PetscVector< T >::_restore_array(), libMesh::NumericVector< T >::_type, libMesh::PetscVector< T >::_vec, libMesh::initialized(), libMesh::NumericVector< T >::initialized(), and libMesh::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.

149{ return _is_initialized; }

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

Referenced by libMesh::System::add_vector(), libMesh::ImplicitSystem::assemble(), libMesh::EigenSparseVector< T >::create_subvector(), libMesh::PetscVector< T >::create_subvector(), and libMesh::PetscVector< T >::init().

◆ insert() [1/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.

This method is guaranteed to be thread-safe as long as library implementations of NumericVector are used

Definition at line 1044 of file numeric_vector.h.

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

References libMesh::DenseSubVector< T >::empty(), libMesh::libmesh_assert(), and libMesh::DenseSubVector< T >::size().

◆ insert() [2/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.

This method is guaranteed to be thread-safe as long as library implementations of NumericVector are used

Definition at line 1032 of file numeric_vector.h.

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

References libMesh::DenseVector< T >::empty(), libMesh::libmesh_assert(), and libMesh::DenseVector< T >::size().

◆ insert() [3/5]

template<typename T >

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

inherited

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

This method is guaranteed to be thread-safe as long as library implementations of NumericVector are used

Definition at line 140 of file numeric_vector.C.

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

◆ insert() [4/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.

This method is guaranteed to be thread-safe as long as library implementations of NumericVector are used

Definition at line 1020 of file numeric_vector.h.

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

References libMesh::libmesh_assert().

◆ insert() [5/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.

Note that library implementations of this method are thread safe

Reimplemented from libMesh::NumericVector< T >.

Definition at line 350 of file petsc_vector.C.

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

◆ is_effectively_ghosted()

template<typename T >

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

inlineinherited

Returns: Whether the vector is effectively ghosted, i.e. whether vector operations require handling of ghosted coefficients.

This is true for GHOSTED vectors in parallel, but in serial subclasses may return false here for GHOSTED vectors since every ghosted vector is effectively serial and thus may be able to take advantage of serial-specific code paths.

Definition at line 181 of file numeric_vector.h.

182 { return (this->n_processors()!=1) && (_type == GHOSTED); }

References libMesh::NumericVector< T >::_type, libMesh::GHOSTED, and libMesh::ParallelObject::n_processors().

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

◆ is_effectively_serial()

template<typename T >

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

inlineinherited

Returns: Whether the vector is effectively serial, i.e. whether all vector data is accessible on every processor.

This is true for explicitly SERIAL vectors, but also for vectors on serial (1-processor) communicators.

Definition at line 168 of file numeric_vector.h.

169 { return (this->n_processors()==1) || (_type == SERIAL); }

References libMesh::NumericVector< T >::_type, libMesh::ParallelObject::n_processors(), and libMesh::SERIAL.

Referenced by libMesh::PetscVector< T >::operator=().

◆ 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 74 of file petsc_vector.C.

{
  return PetscVector<T>::norm<NORM_1>();
}

◆ l1_norm_diff()

template<class T >

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

inherited

Returns: The \( \ell_1 \)-norm of \( \vec{u} - \vec{v} \), where \( \vec{u} \) is this.

Definition at line 653 of file numeric_vector.C.

{
  libmesh_assert(this->compatible(v));
 
  struct L1Differ {
    const NumericVector<T> & v1, & v2;
    Real norm;
 
    L1Differ (const NumericVector<T> & v1in,
              const NumericVector<T> & v2in) :
      v1(v1in), v2(v2in), norm(0) {}
 
    L1Differ (L1Differ & other, Threads::split) :
      v1(other.v1), v2(other.v2), norm(0) {}
 
    void operator()(const IntRange<numeric_index_type> & index_range) {
      for (const auto i : index_range)
        norm += libMesh::l1_norm_diff(v1(i), v2(i));
    }
 
    void join(const L1Differ & other) {
      norm += other.norm;
    }
  };
 
  L1Differ differ(*this, v);
 
  Threads::parallel_reduce(make_range(this->first_local_index(), this->last_local_index()), differ);
 
  this->comm().sum(differ.norm);
 
  return differ.norm;
}

References libMesh::index_range(), libMesh::l1_norm_diff(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Threads::parallel_reduce(), and libMesh::Real.

Referenced by libMesh::l1_norm_diff().

◆ 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 79 of file petsc_vector.C.

{
  return PetscVector<T>::norm<NORM_2>();
}

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor().

◆ l2_norm_diff()

template<class T >

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

inherited

Returns: The \( \ell_2 \)-norm of \( \vec{u} - \vec{v} \), where \( \vec{u} \) is this.

Definition at line 616 of file numeric_vector.C.

{
  libmesh_assert(this->compatible(v));
 
  struct L2Differ {
    const NumericVector<T> & v1, & v2;
    Real norm_sq;
 
    L2Differ (const NumericVector<T> & v1in,
              const NumericVector<T> & v2in) :
      v1(v1in), v2(v2in), norm_sq(0) {}
 
    L2Differ (L2Differ & other, Threads::split) :
      v1(other.v1), v2(other.v2), norm_sq(0) {}
 
    void operator()(const IntRange<numeric_index_type> & index_range) {
      for (const auto i : index_range)
        norm_sq += TensorTools::norm_sq(v1(i) - v2(i));
    }
 
    void join(const L2Differ & other) {
      norm_sq += other.norm_sq;
    }
  };
 
  L2Differ differ(*this, v);
 
  Threads::parallel_reduce(make_range(this->first_local_index(), this->last_local_index()), differ);
 
  this->comm().sum(differ.norm_sq);
 
  return std::sqrt(differ.norm_sq);
}

References libMesh::index_range(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Threads::parallel_reduce(), and libMesh::Real.

◆ 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 1061 of file petsc_vector.h.

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

References libMesh::initialized(), and libMesh::libmesh_assert().

Referenced by PetscVectorTest::testPetscOperations().

◆ 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 84 of file petsc_vector.C.

{
  return PetscVector<T>::norm<NORM_INFINITY>();
}

◆ 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 181 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

◆ 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 1024 of file petsc_vector.h.

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

References libMesh::initialized(), and libMesh::libmesh_assert().

Referenced by libMesh::PetscVector< T >::operator=().

◆ localize() [1/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 695 of file petsc_vector.C.

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

References libMesh::PetscVector< T >::_vec, libMesh::PetscVector< T >::close(), libMesh::WrappedPetsc< T >::get(), libMesh::PetscVector< T >::init(), libMesh::is, libMesh::PetscVector< T >::localize(), and libMesh::PARALLEL.

◆ 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 622 of file petsc_vector.C.

{
  parallel_object_only();
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(v_local_in.type())));
 
  v_local_in = *this;
}

References libMesh::libmesh_assert(), and libMesh::NumericVector< T >::type().

◆ 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 637 of file petsc_vector.C.

{
  this->localize(v_local_in);
}

◆ localize() [4/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 753 of file petsc_vector.C.

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

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

◆ localize() [5/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 646 of file petsc_vector.C.

{
  parallel_object_only();
 
  // Error code used to check the status of all PETSc function calls.
 
  // Create a sequential destination Vec with the right number of entries on each proc.
  WrappedPetsc<Vec> dest;
  LibmeshPetscCall(VecCreateSeq(PETSC_COMM_SELF, cast_int<PetscInt>(indices.size()), dest.get()));
 
  // 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());
  WrappedPetsc<IS> is;
  LibmeshPetscCall(ISCreateGeneral(this->comm().get(), cast_int<PetscInt>(indices.size()), idxptr,
                                   PETSC_USE_POINTER, is.get()));
 
  // Create the VecScatter object. "PETSC_NULL" means "use the identity IS".
  WrappedPetsc<VecScatter> scatter;
  LibmeshPetscCall(VecScatterCreate(_vec,
                                    /*src is=*/is,
                                    /*dest vec=*/dest,
                                    /*dest is=*/LIBMESH_PETSC_NULLPTR,
                                    scatter.get()));
 
  // Do the scatter
  VecScatterBeginEnd(this->comm(), scatter, _vec, dest, INSERT_VALUES, SCATTER_FORWARD);
 
  // Get access to the values stored in dest.
  PetscScalar * values;
  LibmeshPetscCall(VecGetArray (dest, &values));
 
  // 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.
  LibmeshPetscCall(VecRestoreArray (dest, &values));
}

References libMesh::WrappedPetsc< T >::get(), libMesh::is, and libMesh::numeric_petsc_cast().

◆ localize_to_one() [1/3]

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

Definition at line 870 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  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)
    {
      LibmeshPetscCall(VecGetArray (_vec, &values));
 
      for (PetscInt i=0; i<n; i++)
        v_local[i] = static_cast<Complex>(values[i]);
 
      LibmeshPetscCall(VecRestoreArray (_vec, &values));
    }
 
  // 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.);
 
      {
        LibmeshPetscCall(VecGetArray (_vec, &values));
 
        // 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();
          }
 
        LibmeshPetscCall(VecRestoreArray (_vec, &values));
      }
 
      /* have buffers of the real and imaginary part of v_local.
       * Once MPI_Reduce() collected all the real and imaginary
       * parts in these std::vector<Real>, the values can be
       * copied to v_local
       */
      std::vector<Real> real_v_local(n);
      std::vector<Real> imag_v_local(n);
 
      // collect entries from other proc's in real_v_local, imag_v_local
      MPI_Reduce (real_local_values.data(),
                  real_v_local.data(), n,
                  Parallel::StandardType<Real>(),
                  Parallel::OpFunction<Real>::sum(),
                  pid, this->comm().get());
 
      MPI_Reduce (imag_local_values.data(),
                  imag_v_local.data(), n,
                  Parallel::StandardType<Real>(),
                  Parallel::OpFunction<Real>::sum(),
                  pid, this->comm().get());
 
      // copy real_v_local and imag_v_local to v_local
      for (PetscInt i=0; i<n; i++)
        v_local[i] = Complex(real_v_local[i], imag_v_local[i]);
    }
}

◆ localize_to_one() [2/3]

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

Definition at line 787 of file petsc_vector.C.

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

References libMesh::ctx, libMesh::WrappedPetsc< T >::get(), and libMesh::Real.

◆ localize_to_one() [3/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 >.

◆ 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 1083 of file petsc_vector.h.

{
  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
    {
      PetscInt petsc_first=0, petsc_last=0;
      LibmeshPetscCall(VecGetOwnershipRange (_vec, &petsc_first, &petsc_last));
      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;
}

References b, libMesh::initialized(), and libMesh::libmesh_assert().

◆ 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 1230 of file petsc_vector.h.

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

References libMesh::Real.

◆ max_allowed_id()

template<typename T >

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

inlineoverridevirtual

Returns: the max number of entries (across all procs) that the NumericVector can have.

Although we define numeric_index_type, and it is typically required that the NumericVector's underlying implementation's indices have size equal to sizeof(numeric_index_type), these two types can still have different signedness, which affects the maximum number of values which can be stored in the NumericVector.

Implements libMesh::NumericVector< T >.

Definition at line 1276 of file petsc_vector.h.

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

◆ 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 1211 of file petsc_vector.h.

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

References libMesh::Real.

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

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

◆ norm()

template<typename T >

template<NormType N>

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

private

Returns: A norm of the vector, where the type of norm to compute is determined by the template parameter N of the PETSc-defined type NormType. The valid template arguments are NORM_1, NORM_2 and NORM_INFINITY, as used to define l1_norm(), l2_norm() and linfty_norm().

Definition at line 60 of file petsc_vector.C.

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

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

◆ 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 1141 of file petsc_vector.h.

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

◆ operator*=() [1/2]

template<typename T >

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

overridevirtual

Computes the component-wise multiplication of this vector's entries by another's, \( u_i \leftarrow u_i v_i \, \forall i\).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 387 of file petsc_vector.C.

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

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

◆ operator*=() [2/2]

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 448 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

Scale each element of the vector by the given factor.

References libMesh::NumericVector< T >::scale().

◆ 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 93 of file petsc_vector.C.

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

References libMesh::closed(), and libMesh::libmesh_assert().

◆ 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 109 of file petsc_vector.C.

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

References libMesh::closed(), and libMesh::libmesh_assert().

◆ operator/=() [1/2]

template<typename T >

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

overridevirtual

Computes the component-wise 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 400 of file petsc_vector.C.

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

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

◆ 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 466 of file numeric_vector.h.

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

References libMesh::NumericVector< T >::scale().

◆ operator=() [1/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 500 of file petsc_vector.C.

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

◆ operator=() [2/5]

template<typename T >

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

Copy assignment operator.

Supported assignments based on ParallelType combination (note that we lump ghosted into parallel for this method documentation):

Assign from parallel to parallel
Assign from serial to serial
Assign from parallel to serial
Returns
A reference to *this as the derived type.

Definition at line 516 of file petsc_vector.C.

{
  enum AssignmentType { ParallelToSerial, SerialToParallel, SameToSame, Error };
 
  parallel_object_only();
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(v.type())));
 
  if (this == &v)
    return *this;
 
  this->_restore_array();
  v._restore_array();
 
  libmesh_assert_equal_to (this->size(), v.size());
  libmesh_assert (v.closed());
 
  AssignmentType assign_type = Error;
  if (this->is_effectively_serial() && !v.is_effectively_serial())
    assign_type = ParallelToSerial;
  else if (!this->is_effectively_serial() && v.is_effectively_serial())
    assign_type = SerialToParallel;
  else if (this->local_size() == v.local_size())
    assign_type = SameToSame;
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<AssignmentType>::type>(assign_type)));
 
  switch (assign_type)
    {
      case ParallelToSerial:
      {
          // scatter from parallel to serial
          libmesh_assert(v.comm().size() > 1);
          WrappedPetsc<VecScatter> scatter;
          LibmeshPetscCall(VecScatterCreateToAll(v._vec, scatter.get(), nullptr));
          VecScatterBeginEnd(v.comm(), scatter, v._vec, _vec, INSERT_VALUES, SCATTER_FORWARD);
          break;
      }
      case SameToSame:
        // serial to serial or parallel to parallel
        LibmeshPetscCall(VecCopy(v._vec, _vec));
        break;
      case SerialToParallel:
        libmesh_not_implemented_msg(
            "Scattering from a serial vector on every rank to a parallel vector is not behavior we "
            "define because we do not verify the serial vector is the same on each rank");
      default:
        libmesh_error_msg("Unhandled vector combination");
    }
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
  this->_is_closed = true;
 
  return *this;
}

References libMesh::PetscVector< T >::_restore_array(), libMesh::PetscVector< T >::_vec, libMesh::NumericVector< T >::closed(), libMesh::ParallelObject::comm(), libMesh::WrappedPetsc< T >::get(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::libmesh_assert(), libMesh::PetscVector< T >::local_size(), libMesh::Parallel::Communicator::size(), libMesh::PetscVector< T >::size(), and libMesh::NumericVector< T >::type().

◆ operator=() [3/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 584 of file petsc_vector.C.

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

References libMesh::PS().

◆ operator=() [4/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 473 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
  libmesh_assert(this->closed());
 
  PetscScalar s = PS(s_in);
 
  if (this->size() != 0)
    {
      LibmeshPetscCall(VecSet(_vec, s));
 
      libmesh_assert(this->comm().verify(
          static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
 
      if (this->is_effectively_ghosted())
        VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
    }
 
  return *this;
}

References libMesh::closed(), and libMesh::libmesh_assert().

◆ operator=() [5/5]

template<typename T >

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

delete

◆ pointwise_divide()

template<typename T >

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

overridevirtual

Computes \( u_i \leftarrow \frac{v_{1,i}}{v_{2,i}} \) (summation not implied) i.e.

the pointwise (component-wise) division of vec1 and vec2, and stores the result in *this.

Implements libMesh::NumericVector< T >.

Definition at line 979 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  // Convert arguments to PetscVector*.
  const PetscVector<T> * const vec1_petsc = cast_ptr<const PetscVector<T> *>(&vec1);
  const PetscVector<T> * const vec2_petsc = cast_ptr<const PetscVector<T> *>(&vec2);
 
  // Call PETSc function.
  LibmeshPetscCall(VecPointwiseDivide(_vec, vec1_petsc->vec(), vec2_petsc->vec()));
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
  this->_is_closed = true;
}

References libMesh::libmesh_assert(), and libMesh::PetscVector< T >::vec().

◆ 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 955 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  // Convert arguments to PetscVector*.
  const PetscVector<T> * vec1_petsc = cast_ptr<const PetscVector<T> *>(&vec1);
  const PetscVector<T> * vec2_petsc = cast_ptr<const PetscVector<T> *>(&vec2);
 
  // Call PETSc function.
  LibmeshPetscCall(VecPointwiseMult(_vec, vec1_petsc->vec(), vec2_petsc->vec()));
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
  this->_is_closed = true;
}

References libMesh::libmesh_assert(), and libMesh::PetscVector< T >::vec().

◆ print() [1/2]

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

inlineinherited

Definition at line 1059 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 (auto i : index_range(*this))
    os << i << "\t"
       << (*this)(i).real() << "\t\t"
       << (*this)(i).imag() << std::endl;
}

References libMesh::index_range(), libMesh::initialized(), and libMesh::libmesh_assert().

◆ print() [2/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 1077 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 (auto i : index_range(*this))
    os << i << "\t" << (*this)(i) << std::endl;
}

References libMesh::index_range(), libMesh::initialized(), and libMesh::libmesh_assert().

◆ print_global() [1/2]

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

inlineinherited

Definition at line 1092 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 (auto i : make_range(v.size()))
    os << i << "\t"
       << v[i].real() << "\t\t"
       << v[i].imag() << std::endl;
}

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::make_range().

◆ print_global() [2/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 1114 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 (auto i : make_range(v.size()))
    os << i << "\t" << v[i] << std::endl;
}

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::make_range().

◆ print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_matlab()

template<typename T >

void libMesh::PetscVector< T >::print_matlab ( const std::string & filename = "" ) 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.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1003 of file petsc_vector.C.

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

References libMesh::closed(), libMesh::WrappedPetsc< T >::get(), and libMesh::libmesh_assert().

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

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

◆ read_matlab()

template<typename T >

void libMesh::NumericVector< T >::read_matlab ( const std::string & filename )

virtualinherited

Read the contents of the vector from the Matlab-script format used by PETSc.

If the size of the matrix in filename appears consistent with the existing partitioning of this then the existing parallel decomposition will be retained. If not, then this will be initialized with the size from the file, linearly partitioned onto the number of processors available.

Definition at line 297 of file numeric_vector.C.

{
  LOG_SCOPE("read_matlab()", "NumericVector");
 
#ifndef LIBMESH_HAVE_CXX11_REGEX
  libmesh_not_implemented();  // What is your compiler?!?  Email us!
  libmesh_ignore(filename);
#else
  parallel_object_only();
 
  const bool gzipped_file = Utility::ends_with(filename, ".gz");
 
  // If we don't already have this size, we'll need to reinit, and
  // determine which entries each processor is in charge of.
  std::vector<numeric_index_type> first_entries, end_entries;
 
  numeric_index_type first_entry = 0,
                     end_entry = 0,
                     n = 0;
 
  // We'll use an istream here; it might be an ifstream if we're
  // opening a raw ASCII file or a gzstream if we're opening a
  // compressed one.
  std::unique_ptr<std::istream> file;
 
  // First read through the file, saving size and entry data
  std::vector<T> entries;
 
  {
  // We'll read the vector on processor 0 rather than try to juggle
  // parallel I/O.
  if (this->processor_id() == 0)
    {
      // We'll be using regular expressions to make ourselves slightly
      // more robust to formatting.
      const std::regex start_regex // assignment like "Vec_0x84000002_1 = ["
        ("\\s*\\w+\\s*=\\s*\\[");
      const std::regex end_regex // end of assignment
        ("^[^%]*\\]");
 
      if (gzipped_file)
        {
#ifdef LIBMESH_HAVE_GZSTREAM
          auto inf = std::make_unique<igzstream>();
          libmesh_assert(inf);
          inf->open(filename.c_str(), std::ios::in);
          file = std::move(inf);
#else
          libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
#endif
        }
      else
        {
          auto inf = std::make_unique<std::ifstream>();
          libmesh_assert(inf);
 
          std::string new_name = Utility::unzip_file(filename);
 
          inf->open(new_name.c_str(), std::ios::in);
          file = std::move(inf);
        }
 
      const std::string whitespace = " \t";
 
      bool have_started = false;
      bool have_ended = false;
 
      for (std::string line; std::getline(*file, line);)
        {
          std::smatch sm;
 
          // First, try to match an entry.  This is the most common
          // case so we won't rely on slow std::regex for it.
          // stringstream is at least an improvement over that.
          std::istringstream l(line);
          T value;
          l >> value;
 
          if (!l.fail())
            {
              libmesh_error_msg_if
                (!have_started, "Confused by premature entries in vector file " << filename);
 
              entries.push_back(value);
              ++n;
            }
 
          else if (std::regex_search(line, start_regex))
            have_started = true;
 
          else if (std::regex_search(line, end_regex))
            {
              have_ended = true;
              break;
            }
        }
 
      libmesh_error_msg_if
        (!have_started, "Confused by missing assignment-beginning in vector file " << filename);
 
      libmesh_error_msg_if
        (!have_ended, "Confused by missing assignment-ending in vector file " << filename);
    }
 
  this->comm().broadcast(n);
 
  if (this->initialized() &&
      n == this->size())
    {
      first_entry = this->first_local_index(),
      end_entry = this->last_local_index();
    }
  else
    {
      // Determine which rows/columns each processor will be in charge of
      first_entry =     this->processor_id() * n / this->n_processors(),
      end_entry   = (this->processor_id()+1) * n / this->n_processors();
    }
 
  this->comm().gather(0, first_entry, first_entries);
  this->comm().gather(0, end_entry, end_entries);
 
  } // Done reading entry data and broadcasting vector size
 
  // If we're not already initialized compatibly with the file then
  // we'll initialize here
  bool need_init = !this->initialized() ||
                   (this->size() != n) ||
                   (this->local_size() != end_entry - first_entry);
 
  this->comm().max(need_init);
 
  if (need_init)
    this->init(n, end_entry - first_entry);
 
  // Set the vector values last.  The iota call here is inefficient
  // but it's probably better than calling a single virtual function
  // per index.
  if (this->processor_id() == 0)
    for (auto p : make_range(this->n_processors()))
      {
        const numeric_index_type first_entry_p = first_entries[p];
        const numeric_index_type n_local = end_entries[p] - first_entry_p;
        std::vector<numeric_index_type> indices(n_local);
        std::iota(indices.begin(), indices.end(), first_entry_p);
        this->insert(entries.data() + first_entries[p],
                     indices);
      }
 
  this->close();
#endif
}

References libMesh::Utility::ends_with(), and libMesh::libmesh_ignore().

◆ readable()

template<typename T >

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

inherited

Returns: whether or not this vector is able to be read for global operations

Definition at line 727 of file numeric_vector.C.

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

References libMesh::closed(), and libMesh::initialized().

Referenced by libMesh::NumericVector< Number >::build(), and libMesh::NumericVector< T >::compatible().

◆ reciprocal()

template<typename T >

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

overridevirtual

Computes the component-wise reciprocal, \( u_i \leftarrow \frac{1}{u_i} \, \forall i\).

Implements libMesh::NumericVector< T >.

Definition at line 141 of file petsc_vector.C.

{
  parallel_object_only();
 
 
  // VecReciprocal has been in PETSc since at least 2.3.3 days
  LibmeshPetscCall(VecReciprocal(_vec));
}

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

Referenced by PetscVectorTest::testGetArray().

◆ restore_subvector()

template<typename T >

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

overridevirtual

Restores a view into this vector using the indices in rows.

The subvector should have been acquired from get_subvector() with the same rows.

This is currently only implemented for PetscVector and EigenSparseVector.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1317 of file petsc_vector.C.

{
  auto * const petsc_subvector = cast_ptr<PetscVector<T> *>(subvector.get());
 
  // Construct index set
  WrappedPetsc<IS> parent_is;
  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                   cast_int<PetscInt>(rows.size()),
                                   numeric_petsc_cast(rows.data()),
                                   PETSC_USE_POINTER,
                                   parent_is.get()));
 
  Vec subvec = petsc_subvector->vec();
  LibmeshPetscCall(VecRestoreSubVector(_vec, parent_is, &subvec));
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
 
  this->_is_closed = true;
}

References libMesh::numeric_petsc_cast().

◆ 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 369 of file petsc_vector.C.

{
  parallel_object_only();
 
  this->_restore_array();
 
  PetscScalar factor = PS(factor_in);
 
  LibmeshPetscCall(VecScale(_vec, factor));
 
  libmesh_assert(this->comm().verify(
      static_cast<typename std::underlying_type<ParallelType>::type>(this->type())));
 
  if (this->is_effectively_ghosted())
    VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
}

References libMesh::libmesh_assert(), and libMesh::PS().

◆ set()

template<typename T >

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

overridevirtual

Sets v(i) = value.

Note that library implementations of this method are thread safe, e.g. we will lock _numeric_vector_mutex before writing to the vector

Implements libMesh::NumericVector< T >.

Definition at line 124 of file petsc_vector.C.

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

References libMesh::PS(), and value.

Referenced by PetscVectorTest::testGetArray(), and PetscVectorTest::testPetscOperations().

◆ set_type()

template<typename T >

void libMesh::NumericVector< T >::set_type ( ParallelType t )

inherited

Allow the user to change the ParallelType of the NumericVector under some circumstances.

If the NumericVector has not been initialized yet, then it is generally safe to change the ParallelType. otherwise, if the NumericVector has already been initialized with a specific type, we cannot change it without doing some extra copying/reinitialization work, and we currently throw an error if this is requested.

Definition at line 97 of file numeric_vector.C.

{
  // Check for no-op
  if (_type == t)
    return;
 
  // If the NumericVector is not yet initialized, then it is generally
  // safe to change the ParallelType, with minor restrictions.
  if (!this->initialized())
    {
      // If ghosted vectors are not enabled and the user requested a
      // GHOSTED vector, fall back on SERIAL.
#ifndef LIBMESH_ENABLE_GHOSTED
      if (t == GHOSTED)
        {
          _type = SERIAL;
          return;
        }
#endif
 
      _type = t;
      return;
    }
 
  // If we made it here, then the NumericVector was already
  // initialized and we don't currently allow the ParallelType to be
  // changed, although this could potentially be added later.
  libmesh_not_implemented();
}

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

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

◆ 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 1006 of file petsc_vector.h.

{
  libmesh_assert (this->initialized());
 
  PetscInt petsc_size=0;
 
  if (!this->initialized())
    return 0;
 
  LibmeshPetscCall(VecGetSize(_vec, &petsc_size));
 
  return static_cast<numeric_index_type>(petsc_size);
}

References libMesh::initialized(), and libMesh::libmesh_assert().

Referenced by libMesh::PetscVector< T >::operator=().

◆ 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 559 of file numeric_vector.C.

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

References libMesh::libmesh_assert(), and libMesh::Real.

Referenced by libMesh::System::discrete_var_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 576 of file numeric_vector.C.

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

References libMesh::libmesh_assert(), and libMesh::Real.

Referenced by libMesh::System::discrete_var_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 593 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

Referenced by libMesh::System::discrete_var_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 44 of file petsc_vector.C.

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

References libMesh::closed(), libMesh::libmesh_assert(), and 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 1249 of file petsc_vector.h.

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

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

Referenced by update_current_local_solution().

◆ type() [1/2]

template<typename T >

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

inlineinherited

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

Deprecated:: because it is dangerous to change the ParallelType of an already-initialized NumericVector. See NumericVector::set_type() for a safer, non-deprecated setter.

Definition at line 192 of file numeric_vector.h.

192{ return _type; }

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

◆ type() [2/2]

template<typename T >

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

inlineinherited

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

This is metadata reflecting what type of vector was requested, which should reflect what level of replication and ghosting is necessary in parallel.

Definition at line 158 of file numeric_vector.h.

158{ return _type; }

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

Referenced by libMesh::System::add_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DofMap::constrain_element_residual(), libMesh::PetscVector< T >::create_subvector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DofMap::heterogeneously_constrain_element_jacobian_and_residual(), libMesh::DofMap::heterogeneously_constrain_element_residual(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::LaspackVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::localize(), libMesh::PetscVector< T >::operator=(), libMesh::System::project_vector(), and libMesh::System::read_serialized_vector().

◆ vec() [1/2]

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 VecDestroy() on it, or very bad things will likely happen!

Definition at line 349 of file petsc_vector.h.

349{ libmesh_assert (_vec); return _vec; }

References libMesh::PetscVector< T >::_vec, and libMesh::libmesh_assert().

Referenced by libMesh::PetscPreconditioner< T >::apply(), libMesh::SlepcEigenSolver< T >::attach_deflation_space(), DMCreateGlobalVector_libMesh(), libMesh::PetscMatrix< T >::get_diagonal(), libMesh::PetscShellMatrix< T >::get_diagonal(), libMesh::TaoOptimizationSolver< T >::get_dual_variables(), libMesh::SlepcEigenSolver< T >::get_eigenpair(), main(), libMesh::PetscVector< T >::pointwise_divide(), libMesh::PetscVector< T >::pointwise_mult(), libMesh::PetscDiffSolver::solve(), libMesh::PetscLinearSolver< T >::solve_base(), libMesh::PetscShellMatrix< T >::vector_mult(), and libMesh::PetscShellMatrix< T >::vector_mult_add().

◆ vec() [2/2]

template<typename T >

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

inline

Definition at line 351 of file petsc_vector.h.

351{ libmesh_assert (_vec); return _vec; }

References libMesh::PetscVector< T >::_vec, and libMesh::libmesh_assert().

◆ 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 954 of file petsc_vector.h.

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

References libMesh::closed(), and libMesh::libmesh_assert().

Referenced by libMesh::TaoOptimizationSolver< T >::solve().

◆ 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 981 of file petsc_vector.h.

{
  std::unique_ptr<NumericVector<T>> cloned_vector =
    std::make_unique<PetscVector<T>>(this->comm(), this->type());
  cloned_vector->init(*this);
  return 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 373 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 375 of file petsc_vector.h.

◆ _communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

◆ _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 460 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 143 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 383 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 454 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 868 of file numeric_vector.h.

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

◆ _is_initialized

template<typename T >

bool libMesh::NumericVector< T >::_is_initialized

protectedinherited

true once init() has been called.

Definition at line 873 of file numeric_vector.h.

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

◆ _last

template<typename T >

numeric_index_type libMesh::PetscVector< T >::_last

mutableprivate

Last local index.

Only valid when _array_is_present

Definition at line 390 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 402 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 395 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 137 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 132 of file reference_counter.h.

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

◆ _numeric_vector_mutex

template<typename T >

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

protectedinherited

Mutex for performing thread-safe operations.

Definition at line 883 of file numeric_vector.h.

◆ _petsc_get_restore_array_mutex

template<typename T >

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

mutableprivate

Mutex for _get_array and _restore_array.

This is part of the object to keep down thread contention when reading from multiple PetscVectors simultaneously

Definition at line 429 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 412 of file petsc_vector.h.

◆ _type

template<typename T >

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

Type of vector.

Definition at line 878 of file numeric_vector.h.

Referenced by libMesh::PetscVector< T >::create_subvector(), libMesh::DistributedVector< T >::DistributedVector(), libMesh::EigenSparseVector< T >::EigenSparseVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::PetscVector< T >::init(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::LaspackVector< T >::LaspackVector(), libMesh::PetscVector< T >::PetscVector(), libMesh::PetscVector< T >::PetscVector(), libMesh::NumericVector< T >::swap(), libMesh::EigenSparseVector< T >::swap(), libMesh::NumericVector< T >::type(), and libMesh::NumericVector< T >::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 422 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 466 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 471 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 364 of file petsc_vector.h.

Referenced by libMesh::PetscVector< T >::add_vector(), libMesh::PetscVector< T >::create_subvector(), libMesh::PetscVector< T >::indefinite_dot(), libMesh::PetscVector< T >::init(), libMesh::PetscVector< T >::localize(), libMesh::PetscVector< T >::operator*=(), libMesh::PetscVector< T >::operator/=(), libMesh::PetscVector< T >::operator=(), libMesh::PetscVector< T >::PetscVector(), libMesh::PetscVector< T >::swap(), libMesh::PetscVector< T >::vec(), and libMesh::PetscVector< T >::vec().

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

include/numerics/petsc_vector.h
src/numerics/petsc_vector.C

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

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

◆ compatible()

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

◆ get_subvector()

◆ 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]

◆ is_effectively_ghosted()

◆ is_effectively_serial()

◆ l1_norm()

◆ l1_norm_diff()

◆ l2_norm()

◆ l2_norm_diff()

◆ last_local_index()