libMesh
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
libMesh::PetscVector< T > Class Template Referencefinal

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

#include <petsc_vector.h>

Inheritance diagram for libMesh::PetscVector< T >:
[legend]

Public Member Functions

 PetscVector (const Parallel::Communicator &comm_in, const ParallelType type=AUTOMATIC)
 Dummy-Constructor. More...
 
 PetscVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const ParallelType type=AUTOMATIC)
 Constructor. More...
 
 PetscVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const numeric_index_type n_local, const ParallelType type=AUTOMATIC)
 Constructor. More...
 
 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. More...
 
 PetscVector (Vec v, const Parallel::Communicator &comm_in)
 Constructor. More...
 
PetscVector< T > & operator= (const PetscVector< T > &v)
 Copy assignment operator. More...
 
 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. More...
 
 PetscVector (const PetscVector &)=delete
 
PetscVectoroperator= (PetscVector &&)=delete
 
virtual ~PetscVector ()
 
virtual void close () override
 Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across processors. More...
 
virtual void clear () noexcept override
 clear() is called from the destructor, so it should not throw. More...
 
virtual void zero () override
 Set all entries to zero. More...
 
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. More...
 
virtual void init (const numeric_index_type N, const bool fast=false, const ParallelType type=AUTOMATIC) override
 Call init() with n_local = N. More...
 
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. More...
 
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. More...
 
virtual NumericVector< T > & operator= (const T s) override
 Sets all entries of the vector to the value s. More...
 
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. More...
 
virtual NumericVector< T > & operator= (const std::vector< T > &v) override
 Sets (*this)(i) = v(i) for each entry of the vector. More...
 
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. More...
 
PetscScalar * get_array ()
 Get read/write access to the raw PETSc Vector data array. More...
 
const PetscScalar * get_array_read () const
 Get read only access to the raw PETSc Vector data array. More...
 
void restore_array ()
 Restore the data array. More...
 
virtual NumericVector< T > & operator+= (const NumericVector< T > &v) override
 Adds v to *this, \( \vec{u} \leftarrow \vec{u} + \vec{v} \). More...
 
virtual NumericVector< T > & operator-= (const NumericVector< T > &v) override
 Subtracts v from *this, \( \vec{u} \leftarrow \vec{u} - \vec{v} \). More...
 
virtual void reciprocal () override
 Computes the component-wise reciprocal, \( u_i \leftarrow \frac{1}{u_i} \, \forall i\). More...
 
virtual void conjugate () override
 Negates the imaginary component of each entry in the vector. More...
 
virtual void set (const numeric_index_type i, const T value) override
 Sets v(i) = value. More...
 
virtual void add (const numeric_index_type i, const T value) override
 Adds value to the vector entry specified by i. More...
 
virtual void add (const T s) override
 Adds s to each entry of the vector, \( u_i \leftarrow u_i + s \). More...
 
virtual void add (const NumericVector< T > &v) override
 Adds v to this, \( \vec{u} \leftarrow \vec{u} + \vec{v} \). More...
 
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} \). More...
 
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]. More...
 
virtual void add_vector (const NumericVector< T > &v, const SparseMatrix< T > &A) override
 Computes \( \vec{u} \leftarrow \vec{u} + A \vec{v} \), i.e. More...
 
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. More...
 
void add_vector_conjugate_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A)
 \( U \leftarrow U + A^H v \). More...
 
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. More...
 
virtual void scale (const T factor) override
 Scale each element of the vector by the given factor. More...
 
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\). More...
 
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\). More...
 
virtual void abs () override
 Sets \( u_i \leftarrow |u_i| \) for each entry in the vector. More...
 
virtual T dot (const NumericVector< T > &v) const override
 
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. More...
 
virtual void localize (NumericVector< T > &v_local) const override
 Same, but fills a NumericVector<T> instead of a std::vector. More...
 
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. More...
 
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". More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
virtual void print_matlab (const std::string &name="") const override
 Print the contents of the vector in Matlab's sparse matrix format. More...
 
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. More...
 
virtual void swap (NumericVector< T > &v) override
 Swaps the contents of this with v. More...
 
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. More...
 
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. More...
 
template<>
void localize_to_one (std::vector< Real > &v_local, const processor_id_type timpi_mpi_var(pid)) const
 
template<>
void localize_to_one (std::vector< Complex > &v_local, const processor_id_type pid) const
 
virtual bool initialized () const
 
ParallelType type () const
 
ParallelTypetype ()
 
void set_type (ParallelType t)
 Allow the user to change the ParallelType of the NumericVector under some circumstances. More...
 
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. More...
 
NumericVector< T > & operator*= (const T a)
 Scales the vector by a, \( \vec{u} \leftarrow a\vec{u} \). More...
 
NumericVector< T > & operator/= (const T a)
 Scales the vector by 1/a, \( \vec{u} \leftarrow \frac{1}{a}\vec{u} \). More...
 
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]. More...
 
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). More...
 
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). More...
 
void add_vector (const NumericVector< T > &v, const ShellMatrix< T > &A)
 Computes \( \vec{u} \leftarrow \vec{u} + A \vec{v} \), i.e. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<>
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. More...
 
template<>
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. More...
 
bool readable () const
 
bool compatible (const NumericVector< T > &v) const
 
const Parallel::Communicatorcomm () 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. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
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. More...
 

Protected Member Functions

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

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. More...
 
bool _is_initialized
 true once init() has been called. More...
 
ParallelType _type
 Type of vector. More...
 
std::mutex _numeric_vector_mutex
 Mutex for performing thread-safe operations. More...
 
const Parallel::Communicator_communicator
 

Static Protected Attributes

static Counts _counts
 Actually holds the data. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 

Private Types

typedef std::unordered_map< numeric_index_type, numeric_index_typeGlobalToLocalMap
 Type for map that maps global to local ghost cells. More...
 

Private Member Functions

void _get_array (bool read_only) const
 Queries the array (and the local form if the vector is ghosted) from PETSc. More...
 
void _restore_array () const
 Restores the array (and the local form if the vector is ghosted) to PETSc. More...
 
template<NormType N>
Real norm () const
 

Private Attributes

Vec _vec
 Actual PETSc vector datatype to hold vector entries. More...
 
std::atomic< bool > _array_is_present
 If true, the actual PETSc array of the values of the vector is currently accessible. More...
 
bool _array_is_present
 
numeric_index_type _first
 First local index. More...
 
numeric_index_type _last
 Last local index. More...
 
numeric_index_type _local_size
 Size of the local values from _get_array() More...
 
Vec _local_form
 PETSc vector datatype to hold the local form of a ghosted vector. More...
 
const PetscScalar * _read_only_values
 Pointer to the actual PETSc array of the values of the vector. More...
 
PetscScalar * _values
 Pointer to the actual PETSc array of the values of the vector. More...
 
std::mutex _petsc_get_restore_array_mutex
 Mutex for _get_array and _restore_array. More...
 
GlobalToLocalMap _global_to_local_map
 Map that maps global to local ghost cells (will be empty if not in ghost cell mode). More...
 
bool _destroy_vec_on_exit
 This boolean value should only be set to false for the constructor which takes a PETSc Vec object. More...
 
bool _values_manually_retrieved
 Whether or not the data array has been manually retrieved using get_array() or get_array_read() More...
 
bool _values_read_only
 Whether or not the data array is for read only access. More...
 

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 444 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 485 of file petsc_vector.h.

485  :
486  NumericVector<T>(comm_in, ptype),
487  _vec(nullptr),
488  _array_is_present(false),
489  _first(0),
490  _last(0),
491  _local_size(0),
492  _local_form(nullptr),
493  _read_only_values(nullptr),
494  _values(nullptr),
496  _destroy_vec_on_exit(true),
498  _values_read_only(false)
499 {
500  this->_type = ptype;
501 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
ParallelType _type
Type of vector.
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

509  :
510  NumericVector<T>(comm_in, ptype),
511  _vec(nullptr),
512  _array_is_present(false),
513  _first(0),
514  _last(0),
515  _local_size(0),
516  _local_form(nullptr),
517  _read_only_values(nullptr),
518  _values(nullptr),
520  _destroy_vec_on_exit(true),
522  _values_read_only(false)
523 {
524  this->init(n, n, false, ptype);
525 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
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.
Definition: petsc_vector.h:693
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

534  :
535  NumericVector<T>(comm_in, ptype),
536  _vec(nullptr),
537  _array_is_present(false),
538  _first(0),
539  _last(0),
540  _local_size(0),
541  _local_form(nullptr),
542  _read_only_values(nullptr),
543  _values(nullptr),
545  _destroy_vec_on_exit(true),
547  _values_read_only(false)
548 {
549  this->init(n, n_local, false, ptype);
550 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
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.
Definition: petsc_vector.h:693
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

560  :
561  NumericVector<T>(comm_in, ptype),
562  _vec(nullptr),
563  _array_is_present(false),
564  _first(0),
565  _last(0),
566  _local_size(0),
567  _local_form(nullptr),
568  _read_only_values(nullptr),
569  _values(nullptr),
571  _destroy_vec_on_exit(true),
573  _values_read_only(false)
574 {
575  this->init(n, n_local, ghost, false, ptype);
576 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
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.
Definition: petsc_vector.h:693
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

585  :
586  NumericVector<T>(comm_in, AUTOMATIC),
587  _vec(v),
588  _array_is_present(false),
589  _first(0),
590  _last(0),
591  _local_size(0),
592  _local_form(nullptr),
593  _read_only_values(nullptr),
594  _values(nullptr),
596  _destroy_vec_on_exit(false),
598  _values_read_only(false)
599 {
600  this->_is_closed = true;
601  this->_is_initialized = true;
602 
603  /* We need to ask PETSc about the (local to global) ghost value
604  mapping and create the inverse mapping out of it. */
605  PetscInt petsc_local_size=0;
606  LibmeshPetscCall(VecGetLocalSize(_vec, &petsc_local_size));
607 
608  // Get the vector type from PETSc.
609  VecType ptype;
610  LibmeshPetscCall(VecGetType(_vec, &ptype));
611 
612 #if PETSC_RELEASE_GREATER_EQUALS(3, 21, 0)
613  // Fande only implemented VecGhostGetGhostIS for VECMPI
614  if (std::strcmp(ptype, VECMPI) == 0)
615  {
616  IS ghostis;
617  LibmeshPetscCall(VecGhostGetGhostIS(_vec, &ghostis));
618 
619  Vec localrep;
620  LibmeshPetscCall(VecGhostGetLocalForm(_vec, &localrep));
621 
622  // If is a sparsely stored vector, set up our new mapping
623  // Only checking mapping is not enough to determine if a vec is ghosted
624  // We need to check if vec has a local representation
625  if (ghostis && localrep)
626  {
627  PetscInt ghost_size;
628  LibmeshPetscCall(ISGetSize(ghostis, &ghost_size));
629 
630  const PetscInt * indices;
631  LibmeshPetscCall(ISGetIndices(ghostis, &indices));
632 
633  for (const auto i : make_range(ghost_size))
634  _global_to_local_map[indices[i]] = i;
635  this->_type = GHOSTED;
636  LibmeshPetscCall(ISRestoreIndices(ghostis, &indices));
637  }
638  else
639  this->_type = PARALLEL;
640  }
641  else if (std::strcmp(ptype,VECSHARED) == 0)
642 #else // PETSc < 3.21.0
643  if ((std::strcmp(ptype,VECSHARED) == 0) || (std::strcmp(ptype,VECMPI) == 0))
644 #endif
645  {
646  ISLocalToGlobalMapping mapping;
647  LibmeshPetscCall(VecGetLocalToGlobalMapping(_vec, &mapping));
648 
649  Vec localrep;
650  LibmeshPetscCall(VecGhostGetLocalForm(_vec,&localrep));
651  // If is a sparsely stored vector, set up our new mapping
652  // Only checking mapping is not enough to determine if a vec is ghosted
653  // We need to check if vec has a local representation
654  if (mapping && localrep)
655  {
656  const numeric_index_type my_local_size = static_cast<numeric_index_type>(petsc_local_size);
657  const numeric_index_type ghost_begin = static_cast<numeric_index_type>(petsc_local_size);
658  PetscInt n;
659  LibmeshPetscCall(ISLocalToGlobalMappingGetSize(mapping, &n));
660 
661  const numeric_index_type ghost_end = static_cast<numeric_index_type>(n);
662  const PetscInt * indices;
663  LibmeshPetscCall(ISLocalToGlobalMappingGetIndices(mapping,&indices));
664 
665  for (numeric_index_type i=ghost_begin; i<ghost_end; i++)
666  _global_to_local_map[indices[i]] = i-my_local_size;
667  this->_type = GHOSTED;
668  LibmeshPetscCall(ISLocalToGlobalMappingRestoreIndices(mapping, &indices));
669  }
670  else
671  this->_type = PARALLEL;
672 
673  LibmeshPetscCall(VecGhostRestoreLocalForm(_vec,&localrep));
674  }
675  else
676  this->_type = SERIAL;
677 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _is_initialized
true once init() has been called.
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
dof_id_type numeric_index_type
Definition: id_types.h:99
ParallelType _type
Type of vector.
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

685 {
686  this->clear ();
687 }
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.
Definition: petsc_vector.h:889

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_onlyWhether or not a read only copy of the raw data

Definition at line 1180 of file petsc_vector.C.

1181 {
1182  libmesh_assert (this->initialized());
1183 
1184  bool initially_array_is_present = _array_is_present.load(std::memory_order_acquire);
1185 
1186  // If we already have a read/write array - and we're trying
1187  // to get a read only array - let's just use the read write
1188  if (initially_array_is_present && read_only && !_values_read_only)
1190 
1191  // If the values have already been retrieved and we're currently
1192  // trying to get a non-read only view (ie read/write) and the
1193  // values are currently read only... then we need to restore
1194  // the array first... and then retrieve it again.
1195  if (initially_array_is_present && !read_only && _values_read_only)
1196  {
1197  _restore_array();
1198  initially_array_is_present = false;
1199  }
1200 
1201  if (!initially_array_is_present)
1202  {
1203  std::scoped_lock lock(_petsc_get_restore_array_mutex);
1204  if (!_array_is_present.load(std::memory_order_relaxed))
1205  {
1206  if (this->type() != GHOSTED)
1207  {
1208  if (read_only)
1209  {
1210  LibmeshPetscCall(VecGetArrayRead(_vec, &_read_only_values));
1211  _values_read_only = true;
1212  }
1213  else
1214  {
1215  LibmeshPetscCall(VecGetArray(_vec, &_values));
1216  _values_read_only = false;
1217  }
1218  _local_size = this->local_size();
1219  }
1220  else
1221  {
1222  LibmeshPetscCall(VecGhostGetLocalForm (_vec,&_local_form));
1223 
1224  if (read_only)
1225  {
1226  LibmeshPetscCall(VecGetArrayRead(_local_form, &_read_only_values));
1227  _values_read_only = true;
1228  }
1229  else
1230  {
1231  LibmeshPetscCall(VecGetArray(_local_form, &_values));
1232  _values_read_only = false;
1233  }
1234 
1235  PetscInt my_local_size = 0;
1236  LibmeshPetscCall(VecGetLocalSize(_local_form, &my_local_size));
1237  _local_size = static_cast<numeric_index_type>(my_local_size);
1238  }
1239 
1240  { // cache ownership range
1241  PetscInt petsc_first=0, petsc_last=0;
1242  LibmeshPetscCall(VecGetOwnershipRange (_vec, &petsc_first, &petsc_last));
1243  _first = static_cast<numeric_index_type>(petsc_first);
1244  _last = static_cast<numeric_index_type>(petsc_last);
1245  }
1246  _array_is_present.store(true, std::memory_order_release);
1247  }
1248  }
1249 }
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
virtual bool initialized() const
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
std::mutex _petsc_get_restore_array_mutex
Mutex for _get_array and _restore_array.
Definition: petsc_vector.h:425
ParallelType type() const
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379

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

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

1255 {
1256  libmesh_error_msg_if(_values_manually_retrieved,
1257  "PetscVector values were manually retrieved but are being automatically restored!");
1258 
1259  libmesh_assert (this->initialized());
1260  if (_array_is_present.load(std::memory_order_acquire))
1261  {
1262  std::scoped_lock lock(_petsc_get_restore_array_mutex);
1263  if (_array_is_present.load(std::memory_order_relaxed))
1264  {
1265  if (this->type() != GHOSTED)
1266  {
1267  if (_values_read_only)
1268  LibmeshPetscCall(VecRestoreArrayRead (_vec, &_read_only_values));
1269  else
1270  LibmeshPetscCall(VecRestoreArray (_vec, &_values));
1271 
1272  _values = nullptr;
1273  }
1274  else
1275  {
1276  if (_values_read_only)
1277  LibmeshPetscCall(VecRestoreArrayRead (_local_form, &_read_only_values));
1278  else
1279  LibmeshPetscCall(VecRestoreArray (_local_form, &_values));
1280 
1281  _values = nullptr;
1282  LibmeshPetscCall(VecGhostRestoreLocalForm (_vec,&_local_form));
1283  _local_form = nullptr;
1284  _local_size = 0;
1285  }
1286  _array_is_present.store(false, std::memory_order_release);
1287  }
1288  }
1289 }
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_read_only
Whether or not the data array is for read only access.
Definition: petsc_vector.h:467
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
libmesh_assert(ctx)
std::mutex _petsc_get_restore_array_mutex
Mutex for _get_array and _restore_array.
Definition: petsc_vector.h:425
ParallelType type() const
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

412 {
413  parallel_object_only();
414 
415  this->_restore_array();
416 
417  LibmeshPetscCall(VecAbs(_vec));
418 
419  libmesh_assert(this->comm().verify(int(this->type())));
420 
421  if (this->type() == GHOSTED)
422  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
423 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
ParallelType type() const

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

Referenced by main().

166 {
167  this->_restore_array();
168  libmesh_assert_less (i, size());
169 
170  PetscInt i_val = static_cast<PetscInt>(i);
171  PetscScalar petsc_value = PS(value);
172 
173  std::scoped_lock lock(this->_numeric_vector_mutex);
174  LibmeshPetscCall(VecSetValues (_vec, 1, &i_val, &petsc_value, ADD_VALUES));
175 
176  this->_is_closed = false;
177 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscScalar PS(T val)
Definition: petsc_macro.h:168
static const bool value
Definition: xdr_io.C:55
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ add() [2/4]

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

Adds s to each entry of the vector, \( u_i \leftarrow u_i + s \).

Implements libMesh::NumericVector< T >.

Definition at line 294 of file petsc_vector.C.

295 {
296  this->_get_array(false);
297 
298  for (numeric_index_type i=0; i<_local_size; i++)
299  _values[i] += PetscScalar(v_in);
300 }
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
void _get_array(bool read_only) const
Queries the array (and the local form if the vector is ghosted) from PETSc.
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
dof_id_type numeric_index_type
Definition: id_types.h:99

◆ add() [3/4]

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

Adds v to this, \( \vec{u} \leftarrow \vec{u} + \vec{v} \).

Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 305 of file petsc_vector.C.

306 {
307  parallel_object_only();
308 
309  this->add (1., v);
310 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
Definition: petsc_vector.C:165

◆ add() [4/4]

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

Vector addition with a scalar multiple, \( \vec{u} \leftarrow \vec{u} + a\vec{v} \).

Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 315 of file petsc_vector.C.

316 {
317  parallel_object_only();
318 
319  this->_restore_array();
320 
321  // VecAXPY doesn't support &x==&y
322  if (this == &v_in)
323  {
324  this->scale(a_in+1);
325  return;
326  }
327 
328  PetscScalar a = PS(a_in);
329 
330  // Make sure the NumericVector passed in is really a PetscVector
331  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
332  v->_restore_array();
333 
334  libmesh_assert_equal_to (this->size(), v->size());
335 
336  LibmeshPetscCall(VecAXPY(_vec, a, v->vec()));
337 
338  libmesh_assert(this->comm().verify(int(this->type())));
339 
340  if (this->type() == GHOSTED)
341  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
342 
343  this->_is_closed = true;
344 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscScalar PS(T val)
Definition: petsc_macro.h:168
libmesh_assert(ctx)
ParallelType type() const
virtual void scale(const T factor) override
Scale each element of the vector by the given factor.
Definition: petsc_vector.C:368
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ add_vector() [1/6]

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

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

This should be overridden in subclasses for efficiency. Note that library implementations of this method are thread safe

Reimplemented from libMesh::NumericVector< T >.

Definition at line 182 of file petsc_vector.C.

184 {
185  // If we aren't adding anything just return
186  if (dof_indices.empty())
187  return;
188 
189  this->_restore_array();
190 
191  const PetscInt * i_val = reinterpret_cast<const PetscInt *>(dof_indices.data());
192  const PetscScalar * petsc_value = pPS(v);
193 
194  std::scoped_lock lock(this->_numeric_vector_mutex);
195  LibmeshPetscCall(VecSetValues (_vec, cast_int<PetscInt>(dof_indices.size()),
196  i_val, petsc_value, ADD_VALUES));
197 
198  this->_is_closed = false;
199 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
PetscScalar * pPS(T *ptr)
Definition: petsc_macro.h:174
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ add_vector() [2/6]

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

Computes \( \vec{u} \leftarrow \vec{u} + A \vec{v} \), i.e.

adds the product of a SparseMatrix A and a NumericVector v to this.

Implements libMesh::NumericVector< T >.

Definition at line 204 of file petsc_vector.C.

206 {
207  parallel_object_only();
208 
209  this->_restore_array();
210  // Make sure the data passed in are really of Petsc types
211  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
212  const PetscMatrixBase<T> * A = cast_ptr<const PetscMatrixBase<T> *>(&A_in);
213 
214 
215  // We shouldn't close() the matrix for you, as that would potentially modify the state of a const object.
216  if (!A->closed())
217  {
218  libmesh_warning("Matrix A must be assembled before calling PetscVector::add_vector(v, A).\n"
219  "Please update your code, as this warning will become an error in a future release.");
220  libmesh_deprecated();
221  const_cast<PetscMatrixBase<T> *>(A)->close();
222  }
223 
224  // The const_cast<> is not elegant, but it is required since PETSc
225  // expects a non-const Mat.
226  LibmeshPetscCall(MatMultAdd(const_cast<PetscMatrixBase<T> *>(A)->mat(), v->_vec, _vec, _vec));
227 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
Definition: petsc_vector.h:871

◆ add_vector() [3/6]

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

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

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

Definition at line 959 of file numeric_vector.h.

961 {
962  libmesh_assert(v.size() == dof_indices.size());
963  if (!v.empty())
964  this->add_vector(v.data(), dof_indices);
965 }
virtual void add_vector(const T *v, const std::vector< numeric_index_type > &dof_indices)
Computes , where v is a pointer and each dof_indices[i] specifies where to add value v[i]...
libmesh_assert(ctx)

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

662 {
663  libmesh_assert(v.readable());
664 
665  const std::size_t n = dof_indices.size();
666  libmesh_assert_equal_to(v.size(), n);
667  for (numeric_index_type i=0; i != n; i++)
668  this->add (dof_indices[i], v(i));
669 }
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
virtual void add(const numeric_index_type i, const T value)=0
Adds value to the vector entry specified by i.

◆ add_vector() [5/6]

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

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

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

Definition at line 971 of file numeric_vector.h.

973 {
974  libmesh_assert(v.size() == dof_indices.size());
975  if (!v.empty())
976  this->add_vector(&v(0), dof_indices);
977 }
virtual void add_vector(const T *v, const std::vector< numeric_index_type > &dof_indices)
Computes , where v is a pointer and each dof_indices[i] specifies where to add value v[i]...
libmesh_assert(ctx)

◆ add_vector() [6/6]

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

Computes \( \vec{u} \leftarrow \vec{u} + A \vec{v} \), i.e.

adds the product of a ShellMatrix A and a NumericVector v to this.

Definition at line 674 of file numeric_vector.C.

676 {
677  libmesh_assert(this->compatible(v));
678 
679  a.vector_mult_add(*this,v);
680 }
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const

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

262 {
263  parallel_object_only();
264 
265  this->_restore_array();
266  // Make sure the data passed in are really of Petsc types
267  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
268  const PetscMatrixBase<T> * A = cast_ptr<const PetscMatrixBase<T> *>(&A_in);
269 
270  // We shouldn't close() the matrix for you, as that would potentially modify the state of a const object.
271  if (!A->closed())
272  {
273  libmesh_warning("Matrix A must be assembled before calling PetscVector::add_vector_conjugate_transpose(v, A).\n"
274  "Please update your code, as this warning will become an error in a future release.");
275  libmesh_deprecated();
276  const_cast<PetscMatrixBase<T> *>(A)->close();
277  }
278 
279  // Store a temporary copy since MatMultHermitianTransposeAdd doesn't seem to work
280  // TODO: Find out why MatMultHermitianTransposeAdd doesn't work, might be a PETSc bug?
281  std::unique_ptr<NumericVector<Number>> this_clone = this->clone();
282 
283  // The const_cast<> is not elegant, but it is required since PETSc
284  // expects a non-const Mat.
285  LibmeshPetscCall(MatMultHermitianTranspose(const_cast<PetscMatrixBase<T> *>(A)->mat(), v->_vec, _vec));
286 
287  // Add the temporary copy to the matvec result
288  this->add(1., *this_clone);
289 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
Definition: petsc_vector.C:165
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
virtual std::unique_ptr< NumericVector< T > > clone() const override
Definition: petsc_vector.h:953
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
Definition: petsc_vector.h:871

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

234 {
235  parallel_object_only();
236 
237  this->_restore_array();
238  // Make sure the data passed in are really of Petsc types
239  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
240  const PetscMatrixBase<T> * A = cast_ptr<const PetscMatrixBase<T> *>(&A_in);
241 
242 
243  // We shouldn't close() the matrix for you, as that would potentially modify the state of a const object.
244  if (!A->closed())
245  {
246  libmesh_warning("Matrix A must be assembled before calling PetscVector::add_vector_transpose(v, A).\n"
247  "Please update your code, as this warning will become an error in a future release.");
248  libmesh_deprecated();
249  const_cast<PetscMatrixBase<T> *>(A)->close();
250  }
251 
252  // The const_cast<> is not elegant, but it is required since PETSc
253  // expects a non-const Mat.
254  LibmeshPetscCall(MatMultTransposeAdd(const_cast<PetscMatrixBase<T> *>(A)->mat(), v->_vec, _vec, _vec));
255 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
Definition: petsc_vector.h:871

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

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::add_vector(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::DiagonalMatrix< T >::DiagonalMatrix(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::StaticCondensation::init(), main(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), MeshFunctionTest::read_variable_info_from_output_data(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::ClawSystem::solve_conservation_law(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), DiagonalMatrixTest::testNumerics(), SystemsTest::testProjectCubeWithMeshFunction(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), and libMesh::RBConstruction::update_residual_terms().

64 {
65  // Build the appropriate vector
66  switch (solver_package)
67  {
68 
69 #ifdef LIBMESH_HAVE_LASPACK
70  case LASPACK_SOLVERS:
71  return std::make_unique<LaspackVector<T>>(comm, parallel_type);
72 #endif
73 
74 #ifdef LIBMESH_HAVE_PETSC
75  case PETSC_SOLVERS:
76  return std::make_unique<PetscVector<T>>(comm, parallel_type);
77 #endif
78 
79 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
80  case TRILINOS_SOLVERS:
81  return std::make_unique<EpetraVector<T>>(comm, parallel_type);
82 #endif
83 
84 #ifdef LIBMESH_HAVE_EIGEN
85  case EIGEN_SOLVERS:
86  return std::make_unique<EigenSparseVector<T>>(comm, parallel_type);
87 #endif
88 
89  default:
90  return std::make_unique<DistributedVector<T>>(comm, parallel_type);
91  }
92 }
const Parallel::Communicator & comm() const

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

890 {
891  exceptionless_parallel_object_only();
892 
893  if (this->initialized())
894  this->_restore_array();
895 
896  if ((this->initialized()) && (this->_destroy_vec_on_exit))
897  {
898  // If we encounter an error here, print a warning but otherwise
899  // keep going since we may be recovering from an exception.
900  PetscErrorCode ierr = VecDestroy(&_vec);
901  if (ierr)
902  libmesh_warning("Warning: VecDestroy returned a non-zero error code which we ignored.");
903  }
904 
905  this->_is_closed = this->_is_initialized = false;
906 
907  _global_to_local_map.clear();
908 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
bool _is_initialized
true once init() has been called.
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

Referenced by PetscVectorTest::testPetscOperations().

954 {
955  std::unique_ptr<NumericVector<T>> cloned_vector =
956  std::make_unique<PetscVector<T>>(this->comm(), this->type());
957  cloned_vector->init(*this, true);
958  *cloned_vector = *this;
959  return cloned_vector;
960 }
const Parallel::Communicator & comm() const
ParallelType type() const

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

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

872 {
873  parallel_object_only();
874 
875  this->_restore_array();
876 
877  VecAssemblyBeginEnd(this->comm(), _vec);
878 
879  if (this->type() == GHOSTED)
880  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
881 
882  this->_is_closed = true;
883 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
ParallelType type() const
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

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

182 { return _is_closed; }
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), VolumeTest::testC0PolygonMethods(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

98  { return _communicator; }
const Parallel::Communicator & _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.

155 {
156  libmesh_assert(this->compatible(other_vector));
157 
158  int first_different_i = std::numeric_limits<int>::max();
160 
161  while (first_different_i==std::numeric_limits<int>::max()
162  && i<last_local_index())
163  {
164  if (std::abs((*this)(i) - other_vector(i)) > threshold)
165  first_different_i = i;
166  else
167  i++;
168  }
169 
170  // Find the correct first differing index in parallel
171  this->comm().min(first_different_i);
172 
173  if (first_different_i == std::numeric_limits<int>::max())
174  return -1;
175 
176  return first_different_i;
177 }
const Parallel::Communicator & comm() const
void min(const T &r, T &o, Request &req) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const
virtual numeric_index_type first_local_index() const =0
virtual numeric_index_type last_local_index() const =0

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

693 {
694  return this->readable() && v.readable() &&
695  this->size() == v.size() &&
696  this->local_size() == v.local_size() &&
697  this->first_local_index() == v.first_local_index() &&
698  this->last_local_index() == v.last_local_index();
699 }
virtual numeric_index_type size() const =0
virtual numeric_index_type first_local_index() const =0
virtual numeric_index_type local_size() const =0
virtual numeric_index_type last_local_index() const =0

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

154 {
155  parallel_object_only();
156 
157 
158  // We just call the PETSc VecConjugate
159  LibmeshPetscCall(VecConjugate(_vec));
160 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360

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

Similar to the create_submatrix() routine for the SparseMatrix class, it is currently only implemented for PetscVectors. The boolean parameter 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 the boolean parameter should be set to false

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1084 of file petsc_vector.C.

1087 {
1088  parallel_object_only();
1089 
1090  libmesh_error_msg_if(
1091  subvector.type() == GHOSTED,
1092  "We do not support scattering parallel information to ghosts for subvectors");
1093 
1094  this->_restore_array();
1095 
1096  // PETSc data structures
1097 
1098  // Make sure the passed in subvector is really a PetscVector
1099  PetscVector<T> * petsc_subvector = cast_ptr<PetscVector<T> *>(&subvector);
1100 
1101  // If the petsc_subvector is already initialized, we assume that the
1102  // user has already allocated the *correct* amount of space for it.
1103  // If not, we use the appropriate PETSc routines to initialize it.
1104  if (!petsc_subvector->initialized())
1105  {
1106  libmesh_assert(petsc_subvector->_type == AUTOMATIC || petsc_subvector->_type == PARALLEL);
1107 
1108  if (supplying_global_rows)
1109  // Initialize the petsc_subvector to have enough space to hold
1110  // the entries which will be scattered into it. Note: such an
1111  // init() function (where we let PETSc decide the number of local
1112  // entries) is not currently offered by the PetscVector
1113  // class. Should we differentiate here between sequential and
1114  // parallel vector creation based on this->n_processors() ?
1115  LibmeshPetscCall(VecCreateMPI(this->comm().get(),
1116  PETSC_DECIDE, // n_local
1117  cast_int<PetscInt>(rows.size()), // n_global
1118  &(petsc_subvector->_vec)));
1119  else
1120  LibmeshPetscCall(VecCreateMPI(this->comm().get(),
1121  cast_int<PetscInt>(rows.size()),
1122  PETSC_DETERMINE,
1123  &(petsc_subvector->_vec)));
1124 
1125  LibmeshPetscCall(VecSetFromOptions (petsc_subvector->_vec));
1126 
1127  // We created a parallel vector
1128  petsc_subvector->_type = PARALLEL;
1129 
1130  // Mark the subvector as initialized
1131  petsc_subvector->_is_initialized = true;
1132  }
1133  else
1134  {
1135  petsc_subvector->_restore_array();
1136  }
1137 
1138  std::vector<PetscInt> idx(rows.size());
1139  if (supplying_global_rows)
1140  std::iota (idx.begin(), idx.end(), 0);
1141  else
1142  {
1143  PetscInt start;
1144  LibmeshPetscCall(VecGetOwnershipRange(petsc_subvector->_vec, &start, nullptr));
1145  std::iota (idx.begin(), idx.end(), start);
1146  }
1147 
1148  // Construct index sets
1149  WrappedPetsc<IS> parent_is;
1150  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
1151  cast_int<PetscInt>(rows.size()),
1152  numeric_petsc_cast(rows.data()),
1153  PETSC_USE_POINTER,
1154  parent_is.get()));
1155 
1156  WrappedPetsc<IS> subvector_is;
1157  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
1158  cast_int<PetscInt>(rows.size()),
1159  idx.data(),
1160  PETSC_USE_POINTER,
1161  subvector_is.get()));
1162 
1163  // Construct the scatter object
1164  WrappedPetsc<VecScatter> scatter;
1165  LibmeshPetscCall(VecScatterCreate(this->_vec,
1166  parent_is,
1167  petsc_subvector->_vec,
1168  subvector_is,
1169  scatter.get()));
1170 
1171  // Actually perform the scatter
1172  VecScatterBeginEnd(this->comm(), scatter, this->_vec, petsc_subvector->_vec, INSERT_VALUES, SCATTER_FORWARD);
1173 
1174  petsc_subvector->_is_closed = true;
1175 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void iota(ForwardIter first, ForwardIter last, T value)
Utility::iota was created back when std::iota was just an SGI STL extension.
Definition: utility.h:229
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
libmesh_assert(ctx)
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)
A useful inline function which replaces the macros used previously.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

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

427 {
428  parallel_object_only();
429 
430  this->_restore_array();
431 
432  // Error flag
433 
434  // Return value
435  PetscScalar value=0.;
436 
437  // Make sure the NumericVector passed in is really a PetscVector
438  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
439 
440  // 2.3.x (at least) style. Untested for previous versions.
441  LibmeshPetscCall(VecDot(this->_vec, v->_vec, &value));
442 
443  return static_cast<T>(value);
444 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
static const bool value
Definition: xdr_io.C:55

◆ el()

template<typename T>
virtual T libMesh::NumericVector< T >::el ( const numeric_index_type  i) const
inlinevirtualinherited
Returns
(*this)(i).

Definition at line 375 of file numeric_vector.h.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

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

Referenced by PetscVectorTest::testPetscOperations().

1000 {
1001  libmesh_assert (this->initialized());
1002 
1003  numeric_index_type first = 0;
1004 
1005  if (_array_is_present) // Can we use cached values?
1006  first = _first;
1007  else
1008  {
1009  PetscInt petsc_first=0, petsc_last=0;
1010  LibmeshPetscCall(VecGetOwnershipRange (_vec, &petsc_first, &petsc_last));
1011  first = static_cast<numeric_index_type>(petsc_first);
1012  }
1013 
1014  return first;
1015 }
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379

◆ get() [1/2]

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

Access multiple components at once.

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

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1121 of file petsc_vector.h.

1123 {
1124  this->_get_array(true);
1125 
1126  const std::size_t num = index.size();
1127 
1128  for (std::size_t i=0; i<num; i++)
1129  {
1130  const numeric_index_type local_index = this->map_global_to_local_index(index[i]);
1131 #ifndef NDEBUG
1132  if (this->type() == GHOSTED)
1133  {
1134  libmesh_assert_less (local_index, _local_size);
1135  }
1136 #endif
1137  values[i] = static_cast<T>(_read_only_values[local_index]);
1138  }
1139 }
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
void _get_array(bool read_only) const
Queries the array (and the local form if the vector is ghosted) from PETSc.
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
dof_id_type numeric_index_type
Definition: id_types.h:99
numeric_index_type map_global_to_local_index(const numeric_index_type i) const
ParallelType type() const

◆ get() [2/2]

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

Access multiple components at once.

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

Definition at line 944 of file numeric_vector.h.

946 {
947  const std::size_t num = index.size();
948  values.resize(num);
949  if (!num)
950  return;
951 
952  this->get(index, values.data());
953 }

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

Referenced by PetscVectorTest::testGetArray().

1145 {
1146  _get_array(false);
1148 
1149  return _values;
1150 }
void _get_array(bool read_only) const
Queries the array (and the local form if the vector is ghosted) from PETSc.
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

Referenced by PetscVectorTest::testGetArray().

1156 {
1157  _get_array(true);
1159 
1160  return _read_only_values;
1161 }
void _get_array(bool read_only) const
Queries the array (and the local form if the vector is ghosted) from PETSc.
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

◆ get_info()

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

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

Similar to the create_submatrix() routine for the SparseMatrix class, it is currently only implemented for PetscVectors.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1293 of file petsc_vector.C.

1294 {
1295  // Construct index set
1296  WrappedPetsc<IS> parent_is;
1297  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
1298  cast_int<PetscInt>(rows.size()),
1299  numeric_petsc_cast(rows.data()),
1300  PETSC_USE_POINTER,
1301  parent_is.get()));
1302 
1303  Vec subvec;
1304  LibmeshPetscCall(VecGetSubVector(_vec, parent_is, &subvec));
1305 
1306  this->_is_closed = false;
1307 
1308  return std::make_unique<PetscVector<T>>(subvec, this->comm());
1309 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

213 {
214  libmesh_assert(this->compatible(other_vector));
215 
216  int first_different_i = std::numeric_limits<int>::max();
218 
219  const Real my_norm = this->linfty_norm();
220  const Real other_norm = other_vector.linfty_norm();
221  const Real abs_threshold = std::max(my_norm, other_norm) * threshold;
222 
223  do
224  {
225  if (std::abs((*this)(i) - other_vector(i) ) > abs_threshold)
226  first_different_i = i;
227  else
228  i++;
229  }
230  while (first_different_i==std::numeric_limits<int>::max()
231  && i<last_local_index());
232 
233  // Find the correct first differing index in parallel
234  this->comm().min(first_different_i);
235 
236  if (first_different_i == std::numeric_limits<int>::max())
237  return -1;
238 
239  return first_different_i;
240 }
const Parallel::Communicator & comm() const
void min(const T &r, T &o, Request &req) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const
virtual numeric_index_type first_local_index() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual numeric_index_type last_local_index() const =0
virtual Real linfty_norm() const =0

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

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

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

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

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

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

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

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

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

448 {
449  parallel_object_only();
450 
451  this->_restore_array();
452 
453  // Error flag
454 
455  // Return value
456  PetscScalar value=0.;
457 
458  // Make sure the NumericVector passed in is really a PetscVector
459  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
460 
461  // 2.3.x (at least) style. Untested for previous versions.
462  LibmeshPetscCall(VecTDot(this->_vec, v->_vec, &value));
463 
464  return static_cast<T>(value);
465 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
static const bool value
Definition: xdr_io.C:55

◆ init() [1/4]

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

Change the dimension of the vector to n.

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

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

Implements libMesh::NumericVector< T >.

Definition at line 693 of file petsc_vector.h.

Referenced by libMesh::PetscVector< libMesh::Number >::clone(), libMesh::PetscVector< libMesh::Number >::localize(), and libMesh::PetscVector< libMesh::Number >::zero_clone().

697 {
698  parallel_object_only();
699 
700  PetscInt petsc_n=static_cast<PetscInt>(n);
701 
702  // Clear initialized vectors
703  if (this->initialized())
704  this->clear();
705 
706  if (ptype == AUTOMATIC)
707  {
708  if (n == n_local)
709  this->_type = SERIAL;
710  else
711  this->_type = PARALLEL;
712  }
713  else
714  this->_type = ptype;
715 
716  libmesh_assert ((this->_type==SERIAL && n==n_local) ||
717  this->_type==PARALLEL);
718 
719  // create a sequential vector if on only 1 processor
720  if (this->_type == SERIAL)
721  {
722  LibmeshPetscCallA(PETSC_COMM_SELF, VecCreate(PETSC_COMM_SELF, &_vec));
723  LibmeshPetscCallA(PETSC_COMM_SELF, VecSetSizes(_vec, petsc_n, petsc_n));
724  LibmeshPetscCallA(PETSC_COMM_SELF, VecSetFromOptions (_vec));
725  }
726  // otherwise create an MPI-enabled vector
727  else if (this->_type == PARALLEL)
728  {
729 #ifdef LIBMESH_HAVE_MPI
730  PetscInt petsc_n_local=cast_int<PetscInt>(n_local);
731  libmesh_assert_less_equal (n_local, n);
732  // Use more generic function instead of VecCreateSeq/MPI
733  LibmeshPetscCall(VecCreate(this->comm().get(), &_vec));
734  LibmeshPetscCall(VecSetSizes(_vec, petsc_n_local, petsc_n));
735 #else
736  libmesh_assert_equal_to (n_local, n);
737  LibmeshPetscCallA(PETSC_COMM_SELF, VecCreate(PETSC_COMM_SELF, &_vec));
738  LibmeshPetscCallA(PETSC_COMM_SELF, VecSetSizes(_vec, petsc_n, petsc_n));
739 #endif
740  LibmeshPetscCall(VecSetFromOptions(_vec));
741  }
742  else
743  libmesh_error_msg("Unsupported type " << Utility::enum_to_string(this->_type));
744 
745  this->_is_initialized = true;
746  this->_is_closed = true;
747 
748 
749  if (fast == false)
750  this->zero ();
751 }
virtual void zero() override
Set all entries to zero.
Definition: petsc_vector.h:914
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
bool _is_initialized
true once init() has been called.
libmesh_assert(ctx)
ParallelType _type
Type of vector.
std::string enum_to_string(const T e)
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.
Definition: petsc_vector.h:889
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ init() [2/4]

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

Call init() with n_local = N.

Implements libMesh::NumericVector< T >.

Definition at line 757 of file petsc_vector.h.

760 {
761  this->init(n,n,fast,ptype);
762 }
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.
Definition: petsc_vector.h:693

◆ init() [3/4]

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

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

Implements libMesh::NumericVector< T >.

◆ init() [4/4]

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

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

Implements libMesh::NumericVector< T >.

Definition at line 833 of file petsc_vector.h.

835 {
836  parallel_object_only();
837 
838  // Clear initialized vectors
839  if (this->initialized())
840  this->clear();
841 
842  const PetscVector<T> & v = cast_ref<const PetscVector<T> &>(other);
843 
844  // Other vector should restore array.
845  if (v.initialized())
846  {
847  v._restore_array();
848  }
849 
850  this->_global_to_local_map = v._global_to_local_map;
851 
852  // Even if we're initializing sizes based on an uninitialized or
853  // unclosed vector, *this* vector is being initialized now and is
854  // initially closed.
855  this->_is_closed = true; // v._is_closed;
856  this->_is_initialized = true; // v._is_initialized;
857 
858  this->_type = v._type;
859 
860  // We want to have a valid Vec, even if it's initially of size zero
861  LibmeshPetscCall(VecDuplicate (v._vec, &this->_vec));
862 
863  if (fast == false)
864  this->zero ();
865 }
virtual void zero() override
Set all entries to zero.
Definition: petsc_vector.h:914
virtual bool initialized() const
bool _is_initialized
true once init() has been called.
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
ParallelType _type
Type of vector.
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.
Definition: petsc_vector.h:889
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ initialized()

template<typename T>
virtual bool libMesh::NumericVector< T >::initialized ( ) const
inlinevirtualinherited
Returns
true if the vector has been initialized, false otherwise.

Definition at line 149 of file numeric_vector.h.

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

149 { return _is_initialized; }
bool _is_initialized
true once init() has been called.

◆ insert() [1/5]

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

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

Note that library implementations of this method are thread safe

Reimplemented from libMesh::NumericVector< T >.

Definition at line 349 of file petsc_vector.C.

351 {
352  if (dof_indices.empty())
353  return;
354 
355  this->_restore_array();
356 
357  PetscInt * idx_values = numeric_petsc_cast(dof_indices.data());
358  std::scoped_lock lock(this->_numeric_vector_mutex);
359  LibmeshPetscCall(VecSetValues (_vec, cast_int<PetscInt>(dof_indices.size()),
360  idx_values, pPS(v), INSERT_VALUES));
361 
362  this->_is_closed = false;
363 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
PetscScalar * pPS(T *ptr)
Definition: petsc_macro.h:174
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ insert() [2/5]

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

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

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

Definition at line 983 of file numeric_vector.h.

985 {
986  libmesh_assert(v.size() == dof_indices.size());
987  if (!v.empty())
988  this->insert(v.data(), dof_indices);
989 }
virtual void insert(const T *v, const std::vector< numeric_index_type > &dof_indices)
Inserts the entries of v in *this at the locations specified by v.
libmesh_assert(ctx)

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

142 {
143  libmesh_assert_equal_to (V.size(), dof_indices.size());
144  libmesh_assert (V.readable());
145 
146  for (auto i : index_range(dof_indices))
147  this->set (dof_indices[i], V(i));
148 }
libmesh_assert(ctx)
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117

◆ insert() [4/5]

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

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

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

Definition at line 995 of file numeric_vector.h.

997 {
998  libmesh_assert(v.size() == dof_indices.size());
999  if (!v.empty())
1000  this->insert(&v(0), dof_indices);
1001 }
virtual void insert(const T *v, const std::vector< numeric_index_type > &dof_indices)
Inserts the entries of v in *this at the locations specified by v.
libmesh_assert(ctx)

◆ insert() [5/5]

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

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

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

Definition at line 1007 of file numeric_vector.h.

1009 {
1010  libmesh_assert(v.size() == dof_indices.size());
1011  if (!v.empty())
1012  this->insert(&v(0), dof_indices);
1013 }
virtual void insert(const T *v, const std::vector< numeric_index_type > &dof_indices)
Inserts the entries of v in *this at the locations specified by v.
libmesh_assert(ctx)

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

75 {
76  return PetscVector<T>::norm<NORM_1>();
77 }
Real norm() const
Definition: petsc_vector.C:60

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

633 {
634  libmesh_assert(this->compatible(v));
635 
636  Real norm = 0;
637  for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
638  norm += libMesh::l1_norm_diff((*this)(i), v(i));
639 
640  this->comm().sum(norm);
641 
642  return norm;
643 }
void sum(T &r) const
const Parallel::Communicator & comm() const
auto l1_norm_diff(const NumericVector< T > &vec1, const NumericVector< T > &vec2)
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
virtual numeric_index_type first_local_index() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual numeric_index_type last_local_index() const =0

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

80 {
81  return PetscVector<T>::norm<NORM_2>();
82 }
Real norm() const
Definition: petsc_vector.C:60

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

617 {
618  libmesh_assert(this->compatible(v));
619 
620  Real norm = 0;
621  for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
622  norm += TensorTools::norm_sq((*this)(i) - v(i));
623 
624  this->comm().sum(norm);
625 
626  return std::sqrt(norm);
627 }
void sum(T &r) const
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
virtual numeric_index_type first_local_index() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
auto norm_sq(const T &a) -> decltype(std::norm(a))
Definition: tensor_tools.h:104
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual numeric_index_type last_local_index() const =0

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

Referenced by PetscVectorTest::testPetscOperations().

1022 {
1023  libmesh_assert (this->initialized());
1024 
1025  numeric_index_type last = 0;
1026 
1027  if (_array_is_present) // Can we use cached values?
1028  last = _last;
1029  else
1030  {
1031  PetscInt petsc_first=0, petsc_last=0;
1032  LibmeshPetscCall(VecGetOwnershipRange (_vec, &petsc_first, &petsc_last));
1033  last = static_cast<numeric_index_type>(petsc_last);
1034  }
1035 
1036  return last;
1037 }
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)

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

85 {
86  return PetscVector<T>::norm<NORM_INFINITY>();
87 }
Real norm() const
Definition: petsc_vector.C:60

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

183 {
184  libmesh_assert(this->compatible(other_vector));
185 
186  int first_different_i = std::numeric_limits<int>::max();
188 
189  do
190  {
191  if (std::abs((*this)(i) - other_vector(i)) > threshold *
192  std::max(std::abs((*this)(i)), std::abs(other_vector(i))))
193  first_different_i = i;
194  else
195  i++;
196  }
197  while (first_different_i==std::numeric_limits<int>::max()
198  && i<last_local_index());
199 
200  // Find the correct first differing index in parallel
201  this->comm().min(first_different_i);
202 
203  if (first_different_i == std::numeric_limits<int>::max())
204  return -1;
205 
206  return first_different_i;
207 }
const Parallel::Communicator & comm() const
void min(const T &r, T &o, Request &req) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const
virtual numeric_index_type first_local_index() const =0
virtual numeric_index_type last_local_index() const =0

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

Referenced by libMesh::PetscVector< libMesh::Number >::localize(), and libMesh::PetscVector< libMesh::Number >::operator=().

985 {
986  libmesh_assert (this->initialized());
987 
988  PetscInt petsc_size=0;
989 
990  LibmeshPetscCall(VecGetLocalSize(_vec, &petsc_size));
991 
992  return static_cast<numeric_index_type>(petsc_size);
993 }
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)

◆ localize() [1/5]

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

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

Implements libMesh::NumericVector< T >.

Definition at line 787 of file petsc_vector.C.

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

788 {
789  parallel_object_only();
790 
791  this->_restore_array();
792 
793  // This function must be run on all processors at once
794  parallel_object_only();
795 
796  const PetscInt n = this->size();
797  const PetscInt nl = this->local_size();
798  PetscScalar * values;
799 
800  v_local.clear();
801  v_local.resize(n, 0.);
802 
803  LibmeshPetscCall(VecGetArray (_vec, &values));
804 
806 
807  for (PetscInt i=0; i<nl; i++)
808  v_local[i+ioff] = static_cast<T>(values[i]);
809 
810  LibmeshPetscCall(VecRestoreArray (_vec, &values));
811 
812  this->comm().sum(v_local);
813 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
virtual numeric_index_type first_local_index() const override
Definition: petsc_vector.h:999
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
void sum(T &r) const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
dof_id_type numeric_index_type
Definition: id_types.h:99

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

579 {
580  parallel_object_only();
581 
582  this->_restore_array();
583 
584  // Make sure the NumericVector passed in is really a PetscVector
585  PetscVector<T> * v_local = cast_ptr<PetscVector<T> *>(&v_local_in);
586 
587  libmesh_assert(v_local);
588  // v_local_in should be closed
589  libmesh_assert(v_local->closed());
590  libmesh_assert_equal_to (v_local->size(), this->size());
591  // 1) v_local_in is a large vector to hold the whole world
592  // 2) v_local_in is a ghosted vector
593  // 3) v_local_in is a parallel vector
594  // Cases 2) and 3) should be scalable
595  libmesh_assert(this->size()==v_local->local_size() || this->local_size()==v_local->local_size());
596 
597 
598  if (v_local->type() == SERIAL && this->size() == v_local->local_size())
599  {
600  WrappedPetsc<VecScatter> scatter;
601  LibmeshPetscCall(VecScatterCreateToAll(_vec, scatter.get(), nullptr));
602  VecScatterBeginEnd(this->comm(), scatter, _vec, v_local->_vec, INSERT_VALUES, SCATTER_FORWARD);
603  }
604  // Two vectors have the same size, and we should just do a simple copy.
605  // v_local could be either a parallel or ghosted vector
606  else if (this->local_size() == v_local->local_size())
607  LibmeshPetscCall(VecCopy(_vec,v_local->_vec));
608  else
609  libmesh_error_msg("Vectors are inconsistent");
610 
611  // Make sure ghost dofs are up to date
612  // We do not call "close" here to save a global reduction
613  if (v_local->type() == GHOSTED)
614  VecGhostUpdateBeginEnd(this->comm(), v_local->_vec, INSERT_VALUES, SCATTER_FORWARD);
615 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)

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

622 {
623  parallel_object_only();
624 
625  libmesh_assert(this->comm().verify(int(this->type())));
626  libmesh_assert(this->comm().verify(int(v_local_in.type())));
627 
628  // FIXME: Workaround for a strange bug at large-scale.
629  // If we have ghosting, PETSc lets us just copy the solution, and
630  // doing so avoids a segfault?
631  if (v_local_in.type() == GHOSTED &&
632  this->type() == PARALLEL)
633  {
634  v_local_in = *this;
635  return;
636  }
637 
638  // Normal code path begins here
639 
640  this->_restore_array();
641 
642  // Make sure the NumericVector passed in is really a PetscVector
643  PetscVector<T> * v_local = cast_ptr<PetscVector<T> *>(&v_local_in);
644 
645  libmesh_assert(v_local);
646  libmesh_assert_equal_to (v_local->size(), this->size());
647  libmesh_assert_less_equal (send_list.size(), v_local->size());
648 
649  const numeric_index_type n_sl =
650  cast_int<numeric_index_type>(send_list.size());
651 
652  std::vector<PetscInt> idx(n_sl + this->local_size());
653  for (numeric_index_type i=0; i<n_sl; i++)
654  idx[i] = static_cast<PetscInt>(send_list[i]);
655  for (auto i : make_range(this->local_size()))
656  idx[n_sl+i] = i + this->first_local_index();
657 
658  // Create the index set & scatter objects
659  WrappedPetsc<IS> is;
660  PetscInt * idxptr = idx.empty() ? nullptr : idx.data();
661  LibmeshPetscCall(ISCreateGeneral(this->comm().get(), n_sl+this->local_size(),
662  idxptr, PETSC_USE_POINTER, is.get()));
663 
664  WrappedPetsc<VecScatter> scatter;
665  LibmeshPetscCall(VecScatterCreate(_vec, is,
666  v_local->_vec, is,
667  scatter.get()));
668 
669  // Perform the scatter
670  VecScatterBeginEnd(this->comm(), scatter, _vec, v_local->_vec, INSERT_VALUES, SCATTER_FORWARD);
671 
672  // Make sure ghost dofs are up to date
673  if (v_local->type() == GHOSTED)
674  v_local->close();
675 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
virtual numeric_index_type first_local_index() const override
Definition: petsc_vector.h:999
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
PetscErrorCode PetscInt const PetscInt IS * is
ParallelType type() const
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)
A useful inline function which replaces the macros used previously.

◆ localize() [4/5]

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


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

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

Example:

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

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

Implements libMesh::NumericVector< T >.

Definition at line 680 of file petsc_vector.C.

682 {
683  parallel_object_only();
684 
685  // Error code used to check the status of all PETSc function calls.
686 
687  // Create a sequential destination Vec with the right number of entries on each proc.
688  WrappedPetsc<Vec> dest;
689  LibmeshPetscCall(VecCreateSeq(PETSC_COMM_SELF, cast_int<PetscInt>(indices.size()), dest.get()));
690 
691  // Create an IS using the libmesh routine. PETSc does not own the
692  // IS memory in this case, it is automatically cleaned up by the
693  // std::vector destructor.
694  PetscInt * idxptr =
695  indices.empty() ? nullptr : numeric_petsc_cast(indices.data());
696  WrappedPetsc<IS> is;
697  LibmeshPetscCall(ISCreateGeneral(this->comm().get(), cast_int<PetscInt>(indices.size()), idxptr,
698  PETSC_USE_POINTER, is.get()));
699 
700  // Create the VecScatter object. "PETSC_NULL" means "use the identity IS".
701  WrappedPetsc<VecScatter> scatter;
702  LibmeshPetscCall(VecScatterCreate(_vec,
703  /*src is=*/is,
704  /*dest vec=*/dest,
705  /*dest is=*/LIBMESH_PETSC_NULLPTR,
706  scatter.get()));
707 
708  // Do the scatter
709  VecScatterBeginEnd(this->comm(), scatter, _vec, dest, INSERT_VALUES, SCATTER_FORWARD);
710 
711  // Get access to the values stored in dest.
712  PetscScalar * values;
713  LibmeshPetscCall(VecGetArray (dest, &values));
714 
715  // Store values into the provided v_local. Make sure there is enough
716  // space reserved and then clear out any existing entries before
717  // inserting.
718  v_local.reserve(indices.size());
719  v_local.clear();
720  v_local.insert(v_local.begin(), values, values+indices.size());
721 
722  // We are done using it, so restore the array.
723  LibmeshPetscCall(VecRestoreArray (dest, &values));
724 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
PetscErrorCode PetscInt const PetscInt IS * is

◆ localize() [5/5]

template<typename T>
void libMesh::PetscVector< T >::localize ( const numeric_index_type  first_local_idx,
const numeric_index_type  last_local_idx,
const std::vector< numeric_index_type > &  send_list 
)
overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 729 of file petsc_vector.C.

732 {
733  parallel_object_only();
734 
735  this->_restore_array();
736 
737  libmesh_assert_less_equal (send_list.size(), this->size());
738  libmesh_assert_less_equal (last_local_idx+1, this->size());
739 
740  const numeric_index_type my_size = this->size();
741  const numeric_index_type my_local_size = (last_local_idx + 1 - first_local_idx);
742 
743  // Don't bother for serial cases
744  // if ((first_local_idx == 0) &&
745  // (my_local_size == my_size))
746  // But we do need to stay in sync for degenerate cases
747  if (this->n_processors() == 1)
748  return;
749 
750 
751  // Build a parallel vector, initialize it with the local
752  // parts of (*this)
753  PetscVector<T> parallel_vec(this->comm(), PARALLEL);
754 
755  parallel_vec.init (my_size, my_local_size, true, PARALLEL);
756 
757 
758  // Copy part of *this into the parallel_vec
759  {
760  // Create idx, idx[i] = i+first_local_idx;
761  std::vector<PetscInt> idx(my_local_size);
762  std::iota (idx.begin(), idx.end(), first_local_idx);
763 
764  // Create the index set & scatter objects
765  WrappedPetsc<IS> is;
766  LibmeshPetscCall(ISCreateGeneral(this->comm().get(), my_local_size,
767  my_local_size ? idx.data() : nullptr, PETSC_USE_POINTER, is.get()));
768 
769  WrappedPetsc<VecScatter> scatter;
770  LibmeshPetscCall(VecScatterCreate(_vec, is,
771  parallel_vec._vec, is,
772  scatter.get()));
773 
774  // Perform the scatter
775  VecScatterBeginEnd(this->comm(), scatter, _vec, parallel_vec._vec, INSERT_VALUES, SCATTER_FORWARD);
776  }
777 
778  // localize like normal
779  parallel_vec.close();
780  parallel_vec.localize (*this, send_list);
781  this->close();
782 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void iota(ForwardIter first, ForwardIter last, T value)
Utility::iota was created back when std::iota was just an SGI STL extension.
Definition: utility.h:229
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
processor_id_type n_processors() const
dof_id_type numeric_index_type
Definition: id_types.h:99
PetscErrorCode PetscInt const PetscInt IS * is
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
Definition: petsc_vector.h:871
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)
A useful inline function which replaces the macros used previously.

◆ localize_to_one() [1/3]

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

Creates a local copy of the global vector in v_local only on processor proc_id.

By default the data is sent to processor 0. This method is useful for outputting data from one processor.

Implements libMesh::NumericVector< T >.

◆ localize_to_one() [2/3]

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

Definition at line 821 of file petsc_vector.C.

824 {
825  parallel_object_only();
826 
827  this->_restore_array();
828 
829  const PetscInt n = size();
830  PetscScalar * values;
831 
832  // only one processor
833  if (n_processors() == 1)
834  {
835  v_local.resize(n);
836 
837  LibmeshPetscCall(VecGetArray (_vec, &values));
838 
839  for (PetscInt i=0; i<n; i++)
840  v_local[i] = static_cast<Real>(values[i]);
841 
842  LibmeshPetscCall(VecRestoreArray (_vec, &values));
843  }
844 
845  // otherwise multiple processors
846 #ifdef LIBMESH_HAVE_MPI
847  else
848  {
849  if (pid == 0) // optimized version for localizing to 0
850  {
851  WrappedPetsc<Vec> vout;
852  WrappedPetsc<VecScatter> ctx;
853 
854  LibmeshPetscCall(VecScatterCreateToZero(_vec, ctx.get(), vout.get()));
855 
856  VecScatterBeginEnd(this->comm(), ctx, _vec, vout, INSERT_VALUES, SCATTER_FORWARD);
857 
858  if (processor_id() == 0)
859  {
860  v_local.resize(n);
861 
862  LibmeshPetscCall(VecGetArray (vout, &values));
863 
864  for (PetscInt i=0; i<n; i++)
865  v_local[i] = static_cast<Real>(values[i]);
866 
867  LibmeshPetscCall(VecRestoreArray (vout, &values));
868  }
869  }
870  else
871  {
872  v_local.resize(n);
873 
874  numeric_index_type ioff = this->first_local_index();
875  std::vector<Real> local_values (n, 0.);
876 
877  {
878  LibmeshPetscCall(VecGetArray (_vec, &values));
879 
880  const PetscInt nl = local_size();
881  for (PetscInt i=0; i<nl; i++)
882  local_values[i+ioff] = static_cast<Real>(values[i]);
883 
884  LibmeshPetscCall(VecRestoreArray (_vec, &values));
885  }
886 
887 
888  MPI_Reduce (local_values.data(), v_local.data(), n,
889  Parallel::StandardType<Real>(),
890  Parallel::OpFunction<Real>::sum(), pid,
891  this->comm().get());
892  }
893  }
894 #endif // LIBMESH_HAVE_MPI
895 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
virtual numeric_index_type first_local_index() const override
Definition: petsc_vector.h:999
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
processor_id_type n_processors() const
dof_id_type numeric_index_type
Definition: id_types.h:99
communicator & get()
void * ctx
processor_id_type processor_id() const

◆ localize_to_one() [3/3]

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

Definition at line 904 of file petsc_vector.C.

906 {
907  parallel_object_only();
908 
909  this->_restore_array();
910 
911  const PetscInt n = size();
912  const PetscInt nl = local_size();
913  PetscScalar * values;
914 
915 
916  v_local.resize(n);
917 
918 
919  for (PetscInt i=0; i<n; i++)
920  v_local[i] = 0.;
921 
922  // only one processor
923  if (n_processors() == 1)
924  {
925  LibmeshPetscCall(VecGetArray (_vec, &values));
926 
927  for (PetscInt i=0; i<n; i++)
928  v_local[i] = static_cast<Complex>(values[i]);
929 
930  LibmeshPetscCall(VecRestoreArray (_vec, &values));
931  }
932 
933  // otherwise multiple processors
934  else
935  {
936  numeric_index_type ioff = this->first_local_index();
937 
938  /* in here the local values are stored, acting as send buffer for MPI
939  * initialize to zero, since we collect using MPI_SUM
940  */
941  std::vector<Real> real_local_values(n, 0.);
942  std::vector<Real> imag_local_values(n, 0.);
943 
944  {
945  LibmeshPetscCall(VecGetArray (_vec, &values));
946 
947  // provide my local share to the real and imag buffers
948  for (PetscInt i=0; i<nl; i++)
949  {
950  real_local_values[i+ioff] = static_cast<Complex>(values[i]).real();
951  imag_local_values[i+ioff] = static_cast<Complex>(values[i]).imag();
952  }
953 
954  LibmeshPetscCall(VecRestoreArray (_vec, &values));
955  }
956 
957  /* have buffers of the real and imaginary part of v_local.
958  * Once MPI_Reduce() collected all the real and imaginary
959  * parts in these std::vector<Real>, the values can be
960  * copied to v_local
961  */
962  std::vector<Real> real_v_local(n);
963  std::vector<Real> imag_v_local(n);
964 
965  // collect entries from other proc's in real_v_local, imag_v_local
966  MPI_Reduce (real_local_values.data(),
967  real_v_local.data(), n,
968  Parallel::StandardType<Real>(),
969  Parallel::OpFunction<Real>::sum(),
970  pid, this->comm().get());
971 
972  MPI_Reduce (imag_local_values.data(),
973  imag_v_local.data(), n,
974  Parallel::StandardType<Real>(),
975  Parallel::OpFunction<Real>::sum(),
976  pid, this->comm().get());
977 
978  // copy real_v_local and imag_v_local to v_local
979  for (PetscInt i=0; i<n; i++)
980  v_local[i] = Complex(real_v_local[i], imag_v_local[i]);
981  }
982 }
boost::multiprecision::float128 real(const boost::multiprecision::float128 in)
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
virtual numeric_index_type first_local_index() const override
Definition: petsc_vector.h:999
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
processor_id_type n_processors() const
dof_id_type numeric_index_type
Definition: id_types.h:99
communicator & get()
std::complex< Real > Complex
boost::multiprecision::float128 imag(const boost::multiprecision::float128)

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

1044 {
1045  libmesh_assert (this->initialized());
1046 
1047  numeric_index_type first=0;
1048  numeric_index_type last=0;
1049 
1050  if (_array_is_present) // Can we use cached values?
1051  {
1052  first = _first;
1053  last = _last;
1054  }
1055  else
1056  {
1057  PetscInt petsc_first=0, petsc_last=0;
1058  LibmeshPetscCall(VecGetOwnershipRange (_vec, &petsc_first, &petsc_last));
1059  first = static_cast<numeric_index_type>(petsc_first);
1060  last = static_cast<numeric_index_type>(petsc_last);
1061  }
1062 
1063 
1064  if ((i>=first) && (i<last))
1065  {
1066  return i-first;
1067  }
1068 
1069  GlobalToLocalMap::const_iterator it = _global_to_local_map.find(i);
1070 #ifndef NDEBUG
1071  const GlobalToLocalMap::const_iterator end = _global_to_local_map.end();
1072  if (it == end)
1073  {
1074  std::ostringstream error_message;
1075  error_message << "No index " << i << " in ghosted vector.\n"
1076  << "Vector contains [" << first << ',' << last << ")\n";
1077  GlobalToLocalMap::const_iterator b = _global_to_local_map.begin();
1078  if (b == end)
1079  {
1080  error_message << "And empty ghost array.\n";
1081  }
1082  else
1083  {
1084  error_message << "And ghost array {" << b->first;
1085  for (++b; b != end; ++b)
1086  error_message << ',' << b->first;
1087  error_message << "}\n";
1088  }
1089 
1090  libmesh_error_msg(error_message.str());
1091  }
1092  libmesh_assert (it != _global_to_local_map.end());
1093 #endif
1094  return it->second+last-first;
1095 }
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
numeric_index_type _last
Last local index.
Definition: petsc_vector.h:386
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
numeric_index_type _first
First local index.
Definition: petsc_vector.h:379

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

1195 {
1196  parallel_object_only();
1197 
1198  this->_restore_array();
1199 
1200  PetscInt index=0;
1201  PetscReal returnval=0.;
1202 
1203  LibmeshPetscCall(VecMax (_vec, &index, &returnval));
1204 
1205  // this return value is correct: VecMax returns a PetscReal
1206  return static_cast<Real>(returnval);
1207 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE 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 1240 of file petsc_vector.h.

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

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

1176 {
1177  parallel_object_only();
1178 
1179  this->_restore_array();
1180 
1181  PetscInt index=0;
1182  PetscReal returnval=0.;
1183 
1184  LibmeshPetscCall(VecMin (_vec, &index, &returnval));
1185 
1186  // this return value is correct: VecMin returns a PetscReal
1187  return static_cast<Real>(returnval);
1188 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE 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.

References libMesh::ReferenceCounter::_n_objects.

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

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

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

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
const Parallel::Communicator & _communicator
processor_id_type size() const
uint8_t processor_id_type
libmesh_assert(ctx)

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

61 {
62  parallel_object_only();
63 
64  this->_restore_array();
65  libmesh_assert(this->closed());
66 
67  PetscReal value=0.;
68 
69  LibmeshPetscCall(VecNorm (_vec, N, &value));
70 
71  return static_cast<Real>(value);
72 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
virtual bool closed() const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
static const bool value
Definition: xdr_io.C:55

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

1102 {
1103  this->_get_array(true);
1104 
1105  const numeric_index_type local_index = this->map_global_to_local_index(i);
1106 
1107 #ifndef NDEBUG
1108  if (this->type() == GHOSTED)
1109  {
1110  libmesh_assert_less (local_index, _local_size);
1111  }
1112 #endif
1113 
1114  return static_cast<T>(_read_only_values[local_index]);
1115 }
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
void _get_array(bool read_only) const
Queries the array (and the local form if the vector is ghosted) from PETSc.
const PetscScalar * _read_only_values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:408
dof_id_type numeric_index_type
Definition: id_types.h:99
numeric_index_type map_global_to_local_index(const numeric_index_type i) const
ParallelType type() const

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

386 {
387  parallel_object_only();
388 
389 
390  const PetscVector<T> * v_vec = cast_ptr<const PetscVector<T> *>(&v);
391 
392  LibmeshPetscCall(VecPointwiseMult(_vec, _vec, v_vec->_vec));
393 
394  return *this;
395 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360

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

420 { this->scale(a); return *this; }
virtual void scale(const T factor)=0
Scale each element of the vector by the given factor.

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

94 {
95  parallel_object_only();
96 
97  this->_restore_array();
98  libmesh_assert(this->closed());
99 
100  this->add(1., v);
101 
102  return *this;
103 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
Definition: petsc_vector.C:165
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
virtual bool closed() const

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

110 {
111  parallel_object_only();
112 
113  this->_restore_array();
114  libmesh_assert(this->closed());
115 
116  this->add(-1., v);
117 
118  return *this;
119 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
Definition: petsc_vector.C:165
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
virtual bool closed() const

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

399 {
400  parallel_object_only();
401 
402 
403  const PetscVector<T> * v_vec = cast_ptr<const PetscVector<T> *>(&v);
404 
405  LibmeshPetscCall(VecPointwiseDivide(_vec, _vec, v_vec->_vec));
406 
407  return *this;
408 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360

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

438 { this->scale(1./a); return *this; }
virtual void scale(const T factor)=0
Scale each element of the vector by the given factor.

◆ operator=() [1/5]

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

Copy assignment operator.

Calls VecCopy after performing various checks.

Returns
A reference to *this as the derived type.

Definition at line 512 of file petsc_vector.C.

513 {
514  parallel_object_only();
515 
516  this->_restore_array();
517  v._restore_array();
518 
519  libmesh_assert_equal_to (this->size(), v.size());
520  libmesh_assert_equal_to (this->local_size(), v.local_size());
521  libmesh_assert (v.closed());
522 
523 
524  LibmeshPetscCall(VecCopy (v._vec, this->_vec));
525 
526  libmesh_assert(this->comm().verify(int(this->type())));
527 
528  if (this->type() == GHOSTED)
529  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
530 
531  this->_is_closed = true;
532 
533  return *this;
534 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
virtual numeric_index_type local_size() const override
Definition: petsc_vector.h:984
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
ParallelType type() const
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ operator=() [2/5]

template<typename T>
PetscVector& libMesh::PetscVector< T >::operator= ( PetscVector< T > &&  )
delete

◆ operator=() [3/5]

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

Sets all entries of the vector to the value s.

Returns
A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 470 of file petsc_vector.C.

471 {
472  parallel_object_only();
473 
474  this->_restore_array();
475  libmesh_assert(this->closed());
476 
477  PetscScalar s = PS(s_in);
478 
479  if (this->size() != 0)
480  {
481  LibmeshPetscCall(VecSet(_vec, s));
482 
483  libmesh_assert(this->comm().verify(int(this->type())));
484 
485  if (this->type() == GHOSTED)
486  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
487  }
488 
489  return *this;
490 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscScalar PS(T val)
Definition: petsc_macro.h:168
libmesh_assert(ctx)
virtual bool closed() const
ParallelType type() const

◆ operator=() [4/5]

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

This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual.

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

Returns
A reference to *this as the base type.

Implements libMesh::NumericVector< T >.

Definition at line 496 of file petsc_vector.C.

497 {
498  parallel_object_only();
499 
500  // Make sure the NumericVector passed in is really a PetscVector
501  const PetscVector<T> * v = cast_ptr<const PetscVector<T> *>(&v_in);
502 
503  *this = *v;
504 
505  return *this;
506 }

◆ operator=() [5/5]

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

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

Returns
A reference to *this as the base type.

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

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

Implements libMesh::NumericVector< T >.

Definition at line 540 of file petsc_vector.C.

541 {
542  parallel_object_only();
543 
544  this->_get_array(false);
545 
550  if (this->size() == v.size())
551  {
554  for (numeric_index_type i=0; i<last-first; i++)
555  _values[i] = PS(v[first + i]);
556  }
557 
562  else
563  {
564  for (numeric_index_type i=0; i<_local_size; i++)
565  _values[i] = PS(v[i]);
566  }
567 
568  // Make sure ghost dofs are up to date
569  if (this->type() == GHOSTED)
570  this->close();
571 
572  return *this;
573 }
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
numeric_index_type _local_size
Size of the local values from _get_array()
Definition: petsc_vector.h:391
virtual numeric_index_type first_local_index() const override
Definition: petsc_vector.h:999
void _get_array(bool read_only) const
Queries the array (and the local form if the vector is ghosted) from PETSc.
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
PetscScalar PS(T val)
Definition: petsc_macro.h:168
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type last_local_index() const override
ParallelType type() const
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
Definition: petsc_vector.h:871

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

1014 {
1015  parallel_object_only();
1016 
1017  this->_restore_array();
1018 
1019  // Convert arguments to PetscVector*.
1020  const PetscVector<T> * const vec1_petsc = cast_ptr<const PetscVector<T> *>(&vec1);
1021  const PetscVector<T> * const vec2_petsc = cast_ptr<const PetscVector<T> *>(&vec2);
1022 
1023  // Call PETSc function.
1024  LibmeshPetscCall(VecPointwiseDivide(_vec, vec1_petsc->vec(), vec2_petsc->vec()));
1025 
1026  libmesh_assert(this->comm().verify(int(this->type())));
1027 
1028  if (this->type() == GHOSTED)
1029  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
1030 
1031  this->_is_closed = true;
1032 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
ParallelType type() const
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

991 {
992  parallel_object_only();
993 
994  this->_restore_array();
995 
996  // Convert arguments to PetscVector*.
997  const PetscVector<T> * vec1_petsc = cast_ptr<const PetscVector<T> *>(&vec1);
998  const PetscVector<T> * vec2_petsc = cast_ptr<const PetscVector<T> *>(&vec2);
999 
1000  // Call PETSc function.
1001  LibmeshPetscCall(VecPointwiseMult(_vec, vec1_petsc->vec(), vec2_petsc->vec()));
1002 
1003  libmesh_assert(this->comm().verify(int(this->type())));
1004 
1005  if (this->type() == GHOSTED)
1006  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
1007 
1008  this->_is_closed = true;
1009 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
ParallelType type() const
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ print() [1/2]

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

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

Definition at line 1040 of file numeric_vector.h.

1041 {
1042  libmesh_assert (this->initialized());
1043  os << "Size\tglobal = " << this->size()
1044  << "\t\tlocal = " << this->local_size() << std::endl;
1045 
1046  os << "#\tValue" << std::endl;
1047  for (auto i : index_range(*this))
1048  os << i << "\t" << (*this)(i) << std::endl;
1049 }
virtual bool initialized() const
virtual numeric_index_type size() const =0
libmesh_assert(ctx)
virtual numeric_index_type local_size() const =0
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117

◆ print() [2/2]

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

Definition at line 1022 of file numeric_vector.h.

1023 {
1024  libmesh_assert (this->initialized());
1025  os << "Size\tglobal = " << this->size()
1026  << "\t\tlocal = " << this->local_size() << std::endl;
1027 
1028  // std::complex<>::operator<<() is defined, but use this form
1029  os << "#\tReal part\t\tImaginary part" << std::endl;
1030  for (auto i : index_range(*this))
1031  os << i << "\t"
1032  << (*this)(i).real() << "\t\t"
1033  << (*this)(i).imag() << std::endl;
1034 }
boost::multiprecision::float128 real(const boost::multiprecision::float128 in)
virtual bool initialized() const
virtual numeric_index_type size() const =0
libmesh_assert(ctx)
virtual numeric_index_type local_size() const =0
boost::multiprecision::float128 imag(const boost::multiprecision::float128)
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117

◆ print_global() [1/2]

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

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

Definition at line 1077 of file numeric_vector.h.

1078 {
1079  libmesh_assert (this->initialized());
1080 
1081  std::vector<T> v(this->size());
1082  this->localize(v);
1083 
1084  // Right now we only want one copy of the output
1085  if (this->processor_id())
1086  return;
1087 
1088  os << "Size\tglobal = " << this->size() << std::endl;
1089  os << "#\tValue" << std::endl;
1090  for (auto i : make_range(v.size()))
1091  os << i << "\t" << v[i] << std::endl;
1092 }
virtual bool initialized() const
virtual numeric_index_type size() const =0
libmesh_assert(ctx)
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
processor_id_type processor_id() const
virtual void localize(std::vector< T > &v_local) const =0
Creates a copy of the global vector in the local vector v_local.

◆ print_global() [2/2]

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

Definition at line 1055 of file numeric_vector.h.

1056 {
1057  libmesh_assert (this->initialized());
1058 
1059  std::vector<Complex> v(this->size());
1060  this->localize(v);
1061 
1062  // Right now we only want one copy of the output
1063  if (this->processor_id())
1064  return;
1065 
1066  os << "Size\tglobal = " << this->size() << std::endl;
1067  os << "#\tReal part\t\tImaginary part" << std::endl;
1068  for (auto i : make_range(v.size()))
1069  os << i << "\t"
1070  << v[i].real() << "\t\t"
1071  << v[i].imag() << std::endl;
1072 }
virtual bool initialized() const
virtual numeric_index_type size() const =0
libmesh_assert(ctx)
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
processor_id_type processor_id() const
virtual void localize(std::vector< T > &v_local) const =0
Creates a copy of the global vector in the local vector v_local.

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

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

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

1036 {
1037  parallel_object_only();
1038 
1039  this->_restore_array();
1040  libmesh_assert (this->closed());
1041 
1042  // Create an ASCII file containing the matrix
1043  // if a filename was provided.
1044  if (name != "")
1045  {
1046  WrappedPetsc<PetscViewer> petsc_viewer;
1047 
1048  LibmeshPetscCall(PetscViewerASCIIOpen(this->comm().get(),
1049  name.c_str(),
1050  petsc_viewer.get()));
1051 
1052 #if PETSC_VERSION_LESS_THAN(3,7,0)
1053  LibmeshPetscCall(PetscViewerSetFormat (petsc_viewer,
1054  PETSC_VIEWER_ASCII_MATLAB));
1055 #else
1056  LibmeshPetscCall(PetscViewerPushFormat (petsc_viewer,
1057  PETSC_VIEWER_ASCII_MATLAB));
1058 #endif
1059 
1060  LibmeshPetscCall(VecView (_vec, petsc_viewer));
1061  }
1062 
1063  // Otherwise the matrix will be dumped to the screen.
1064  else
1065  {
1066 
1067 #if PETSC_VERSION_LESS_THAN(3,7,0)
1068  LibmeshPetscCall(PetscViewerSetFormat (PETSC_VIEWER_STDOUT_WORLD,
1069  PETSC_VIEWER_ASCII_MATLAB));
1070 #else
1071  LibmeshPetscCall(PetscViewerPushFormat (PETSC_VIEWER_STDOUT_WORLD,
1072  PETSC_VIEWER_ASCII_MATLAB));
1073 #endif
1074 
1075  LibmeshPetscCall(VecView (_vec, PETSC_VIEWER_STDOUT_WORLD));
1076  }
1077 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
virtual bool closed() const

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

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
processor_id_type rank() const
const Parallel::Communicator & _communicator

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

298 {
299  LOG_SCOPE("read_matlab()", "NumericVector");
300 
301 #ifndef LIBMESH_HAVE_CXX11_REGEX
302  libmesh_not_implemented(); // What is your compiler?!? Email us!
303  libmesh_ignore(filename);
304 #else
305  parallel_object_only();
306 
307  const bool gzipped_file = Utility::ends_with(filename, ".gz");
308 
309  // If we don't already have this size, we'll need to reinit, and
310  // determine which entries each processor is in charge of.
311  std::vector<numeric_index_type> first_entries, end_entries;
312 
313  numeric_index_type first_entry = 0,
314  end_entry = 0,
315  n = 0;
316 
317  // We'll use an istream here; it might be an ifstream if we're
318  // opening a raw ASCII file or a gzstream if we're opening a
319  // compressed one.
320  std::unique_ptr<std::istream> file;
321 
322  // First read through the file, saving size and entry data
323  std::vector<T> entries;
324 
325  {
326  // We'll read the vector on processor 0 rather than try to juggle
327  // parallel I/O.
328  if (this->processor_id() == 0)
329  {
330  // We'll be using regular expressions to make ourselves slightly
331  // more robust to formatting.
332  const std::regex start_regex // assignment like "Vec_0x84000002_1 = ["
333  ("\\s*\\w+\\s*=\\s*\\[");
334  const std::regex end_regex // end of assignment
335  ("^[^%]*\\]");
336 
337  if (gzipped_file)
338  {
339 #ifdef LIBMESH_HAVE_GZSTREAM
340  auto inf = std::make_unique<igzstream>();
341  libmesh_assert(inf);
342  inf->open(filename.c_str(), std::ios::in);
343  file = std::move(inf);
344 #else
345  libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
346 #endif
347  }
348  else
349  {
350  auto inf = std::make_unique<std::ifstream>();
351  libmesh_assert(inf);
352 
353  std::string new_name = Utility::unzip_file(filename);
354 
355  inf->open(new_name.c_str(), std::ios::in);
356  file = std::move(inf);
357  }
358 
359  const std::string whitespace = " \t";
360 
361  bool have_started = false;
362  bool have_ended = false;
363 
364  for (std::string line; std::getline(*file, line);)
365  {
366  std::smatch sm;
367 
368  // First, try to match an entry. This is the most common
369  // case so we won't rely on slow std::regex for it.
370  // stringstream is at least an improvement over that.
371  std::istringstream l(line);
372  T value;
373  l >> value;
374 
375  if (!l.fail())
376  {
377  libmesh_error_msg_if
378  (!have_started, "Confused by premature entries in vector file " << filename);
379 
380  entries.push_back(value);
381  ++n;
382  }
383 
384  else if (std::regex_search(line, start_regex))
385  have_started = true;
386 
387  else if (std::regex_search(line, end_regex))
388  {
389  have_ended = true;
390  break;
391  }
392  }
393 
394  libmesh_error_msg_if
395  (!have_started, "Confused by missing assignment-beginning in vector file " << filename);
396 
397  libmesh_error_msg_if
398  (!have_ended, "Confused by missing assignment-ending in vector file " << filename);
399  }
400 
401  this->comm().broadcast(n);
402 
403  if (this->initialized() &&
404  n == this->size())
405  {
406  first_entry = this->first_local_index(),
407  end_entry = this->last_local_index();
408  }
409  else
410  {
411  // Determine which rows/columns each processor will be in charge of
412  first_entry = this->processor_id() * n / this->n_processors(),
413  end_entry = (this->processor_id()+1) * n / this->n_processors();
414  }
415 
416  this->comm().gather(0, first_entry, first_entries);
417  this->comm().gather(0, end_entry, end_entries);
418 
419  } // Done reading entry data and broadcasting vector size
420 
421  // If we're not already initialized compatibly with the file then
422  // we'll initialize here
423  bool need_init = !this->initialized() ||
424  (this->size() != n) ||
425  (this->local_size() != end_entry - first_entry);
426 
427  this->comm().max(need_init);
428 
429  if (need_init)
430  this->init(n, end_entry - first_entry);
431 
432  // Set the vector values last. The iota call here is inefficient
433  // but it's probably better than calling a single virtual function
434  // per index.
435  if (this->processor_id() == 0)
436  for (auto p : make_range(this->n_processors()))
437  {
438  const numeric_index_type first_entry_p = first_entries[p];
439  const numeric_index_type n_local = end_entries[p] - first_entry_p;
440  std::vector<numeric_index_type> indices(n_local);
441  std::iota(indices.begin(), indices.end(), first_entry_p);
442  this->insert(entries.data() + first_entries[p],
443  indices);
444  }
445 
446  this->close();
447 #endif
448 }
virtual void insert(const T *v, const std::vector< numeric_index_type > &dof_indices)
Inserts the entries of v in *this at the locations specified by v.
bool ends_with(std::string_view superstring, std::string_view suffix)
Look for a substring at the very end of a string.
Definition: utility.C:213
virtual bool initialized() const
void gather(const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
virtual numeric_index_type size() const =0
const Parallel::Communicator & comm() const
virtual void init(const numeric_index_type n, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC)=0
Change the dimension of the vector to n.
void iota(ForwardIter first, ForwardIter last, T value)
Utility::iota was created back when std::iota was just an SGI STL extension.
Definition: utility.h:229
processor_id_type n_processors() const
void libmesh_ignore(const Args &...)
dof_id_type numeric_index_type
Definition: id_types.h:99
std::string unzip_file(std::string_view name)
Create an unzipped copy of a bz2 or xz file, returning the name of the now-unzipped file that can be ...
Definition: utility.C:164
libmesh_assert(ctx)
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
virtual void close()=0
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
virtual numeric_index_type first_local_index() const =0
void max(const T &r, T &o, Request &req) const
virtual numeric_index_type local_size() const =0
static const bool value
Definition: xdr_io.C:55
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
processor_id_type processor_id() const
virtual numeric_index_type last_local_index() const =0

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

Referenced by libMesh::NumericVector< Number >::add_vector(), libMesh::NumericVector< Number >::compatible(), and libMesh::NumericVector< Number >::insert().

686 {
687  return this->initialized() && this->closed();
688 }
virtual bool initialized() const
virtual bool closed() const

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

142 {
143  parallel_object_only();
144 
145 
146  // VecReciprocal has been in PETSc since at least 2.3.3 days
147  LibmeshPetscCall(VecReciprocal(_vec));
148 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360

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

Referenced by PetscVectorTest::testGetArray().

1166 {
1167  // \note \p _values_manually_retrieved needs to be set to \p false
1168  // \e before calling \p _restore_array()!
1170  _restore_array();
1171 }
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
bool _values_manually_retrieved
Whether or not the data array has been manually retrieved using get_array() or get_array_read() ...
Definition: petsc_vector.h:462

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

This is currently only implemented for PetscVectors.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 1313 of file petsc_vector.C.

1315 {
1316  auto * const petsc_subvector = cast_ptr<PetscVector<T> *>(subvector.get());
1317 
1318  // Construct index set
1319  WrappedPetsc<IS> parent_is;
1320  LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
1321  cast_int<PetscInt>(rows.size()),
1322  numeric_petsc_cast(rows.data()),
1323  PETSC_USE_POINTER,
1324  parent_is.get()));
1325 
1326  Vec subvec = petsc_subvector->vec();
1327  LibmeshPetscCall(VecRestoreSubVector(_vec, parent_is, &subvec));
1328 
1329  if (this->type() == GHOSTED)
1330  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
1331 
1332  this->_is_closed = true;
1333 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
PetscInt * numeric_petsc_cast(const numeric_index_type *p)
ParallelType type() const
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

369 {
370  parallel_object_only();
371 
372  this->_restore_array();
373 
374  PetscScalar factor = PS(factor_in);
375 
376  LibmeshPetscCall(VecScale(_vec, factor));
377 
378  libmesh_assert(this->comm().verify(int(this->type())));
379 
380  if (this->type() == GHOSTED)
381  VecGhostUpdateBeginEnd(this->comm(), _vec, INSERT_VALUES, SCATTER_FORWARD);
382 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
const Parallel::Communicator & comm() const
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscScalar PS(T val)
Definition: petsc_macro.h:168
libmesh_assert(ctx)
ParallelType type() const

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

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

125 {
126  this->_restore_array();
127  libmesh_assert_less (i, size());
128 
129  PetscInt i_val = static_cast<PetscInt>(i);
130  PetscScalar petsc_value = PS(value);
131 
132  std::scoped_lock lock(this->_numeric_vector_mutex);
133  LibmeshPetscCall(VecSetValues (_vec, 1, &i_val, &petsc_value, INSERT_VALUES));
134 
135  this->_is_closed = false;
136 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
virtual numeric_index_type size() const override
Definition: petsc_vector.h:966
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
PetscScalar PS(T val)
Definition: petsc_macro.h:168
static const bool value
Definition: xdr_io.C:55
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

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

98 {
99  // Check for no-op
100  if (_type == t)
101  return;
102 
103  // If the NumericVector is not yet initialized, then it is generally
104  // safe to change the ParallelType, with minor restrictions.
105  if (!this->initialized())
106  {
107  // If ghosted vectors are not enabled and the user requested a
108  // GHOSTED vector, fall back on SERIAL.
109 #ifndef LIBMESH_ENABLE_GHOSTED
110  if (t == GHOSTED)
111  {
112  _type = SERIAL;
113  return;
114  }
115 #endif
116 
117  _type = t;
118  return;
119  }
120 
121  // If we made it here, then the NumericVector was already
122  // initialized and we don't currently allow the ParallelType to be
123  // changed, although this could potentially be added later.
124  libmesh_not_implemented();
125 }
virtual bool initialized() const
ParallelType _type
Type of 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 966 of file petsc_vector.h.

Referenced by libMesh::PetscVector< libMesh::Number >::add(), libMesh::PetscVector< libMesh::Number >::localize(), and libMesh::PetscVector< libMesh::Number >::operator=().

967 {
968  libmesh_assert (this->initialized());
969 
970  PetscInt petsc_size=0;
971 
972  if (!this->initialized())
973  return 0;
974 
975  LibmeshPetscCall(VecGetSize(_vec, &petsc_size));
976 
977  return static_cast<numeric_index_type>(petsc_size);
978 }
virtual bool initialized() const
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)

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

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

560 {
561  libmesh_assert (this->readable());
562 
563  const NumericVector<T> & v = *this;
564 
565  Real norm = 0;
566 
567  for (const auto & index : indices)
568  norm += std::abs(v(index));
569 
570  this->comm().sum(norm);
571 
572  return norm;
573 }
void sum(T &r) const
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

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

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

577 {
578  libmesh_assert (this->readable());
579 
580  const NumericVector<T> & v = *this;
581 
582  Real norm = 0;
583 
584  for (const auto & index : indices)
585  norm += TensorTools::norm_sq(v(index));
586 
587  this->comm().sum(norm);
588 
589  return std::sqrt(norm);
590 }
void sum(T &r) const
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
auto norm_sq(const T &a) -> decltype(std::norm(a))
Definition: tensor_tools.h:104

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

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

594 {
595  libmesh_assert (this->readable());
596 
597  const NumericVector<T> & v = *this;
598 
599  Real norm = 0;
600 
601  for (const auto & index : indices)
602  {
603  Real value = std::abs(v(index));
604  if (value > norm)
605  norm = value;
606  }
607 
608  this->comm().max(norm);
609 
610  return norm;
611 }
const Parallel::Communicator & comm() const
libmesh_assert(ctx)
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void max(const T &r, T &o, Request &req) const
static const bool value
Definition: xdr_io.C:55

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

45 {
46  this->_restore_array();
47  libmesh_assert(this->closed());
48 
49  PetscScalar value=0.;
50 
51  LibmeshPetscCall(VecSum (_vec, &value));
52 
53  return static_cast<T>(value);
54 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
virtual bool closed() const
static const bool value
Definition: xdr_io.C:55

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

Referenced by libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), DMlibMeshFunction(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), and update_current_local_solution().

1214 {
1215  parallel_object_only();
1216 
1217  NumericVector<T>::swap(other);
1218 
1219  PetscVector<T> & v = cast_ref<PetscVector<T> &>(other);
1220 
1221  std::swap(_vec, v._vec);
1222  std::swap(_destroy_vec_on_exit, v._destroy_vec_on_exit);
1223  std::swap(_global_to_local_map, v._global_to_local_map);
1224 
1225 #ifdef LIBMESH_HAVE_CXX11_THREAD
1226  // Only truly atomic for v... but swap() doesn't really need to be thread safe!
1227  _array_is_present = v._array_is_present.exchange(_array_is_present);
1228 #else
1229  std::swap(_array_is_present, v._array_is_present);
1230 #endif
1231 
1232  std::swap(_local_form, v._local_form);
1233  std::swap(_values, v._values);
1234 }
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a PETSc Vec object...
Definition: petsc_vector.h:456
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
PetscScalar * _values
Pointer to the actual PETSc array of the values of the vector.
Definition: petsc_vector.h:418
std::atomic< bool > _array_is_present
If true, the actual PETSc array of the values of the vector is currently accessible.
Definition: petsc_vector.h:369
Vec _local_form
PETSc vector datatype to hold the local form of a ghosted vector.
Definition: petsc_vector.h:398
GlobalToLocalMap _global_to_local_map
Map that maps global to local ghost cells (will be empty if not in ghost cell mode).
Definition: petsc_vector.h:450
virtual void swap(NumericVector< T > &v)
Swaps the contents of this with v.

◆ type() [1/2]

template<typename T>
ParallelType libMesh::NumericVector< T >::type ( ) const
inlineinherited

◆ type() [2/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 164 of file numeric_vector.h.

164 { return _type; }
ParallelType _type
Type of vector.

◆ vec() [1/2]

template<typename T>
Vec libMesh::PetscVector< T >::vec ( )
inline

◆ vec() [2/2]

template<typename T>
Vec libMesh::PetscVector< T >::vec ( ) const
inline

Definition at line 347 of file petsc_vector.h.

347 { libmesh_assert (_vec); return _vec; }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
libmesh_assert(ctx)

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

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

915 {
916  parallel_object_only();
917 
918  libmesh_assert(this->closed());
919 
920  this->_restore_array();
921 
922  PetscScalar z=0.;
923 
924  if (this->type() != GHOSTED)
925  LibmeshPetscCall(VecSet (_vec, z));
926  else
927  {
928  /* Vectors that include ghost values require a special
929  handling. */
930  Vec loc_vec;
931  LibmeshPetscCall(VecGhostGetLocalForm (_vec,&loc_vec));
932  LibmeshPetscCall(VecSet (loc_vec, z));
933  LibmeshPetscCall(VecGhostRestoreLocalForm (_vec, &loc_vec));
934  }
935 }
Vec _vec
Actual PETSc vector datatype to hold vector entries.
Definition: petsc_vector.h:360
void _restore_array() const
Restores the array (and the local form if the vector is ghosted) to PETSc.
libmesh_assert(ctx)
virtual bool closed() const
ParallelType type() const

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

942 {
943  std::unique_ptr<NumericVector<T>> cloned_vector =
944  std::make_unique<PetscVector<T>>(this->comm(), this->type());
945  cloned_vector->init(*this);
946  return cloned_vector;
947 }
const Parallel::Communicator & comm() const
ParallelType type() const

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

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

◆ _array_is_present [2/2]

template<typename T>
bool libMesh::PetscVector< T >::_array_is_present
mutableprivate

Definition at line 371 of file petsc_vector.h.

◆ _communicator

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

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

Referenced by libMesh::PetscVector< libMesh::Number >::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 379 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 450 of file petsc_vector.h.

Referenced by libMesh::PetscVector< libMesh::Number >::init(), and libMesh::PetscVector< libMesh::Number >::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 831 of file numeric_vector.h.

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

◆ _is_initialized

template<typename T>
bool libMesh::NumericVector< T >::_is_initialized
protectedinherited

◆ _last

template<typename T>
numeric_index_type libMesh::PetscVector< T >::_last
mutableprivate

Last local index.

Only valid when _array_is_present

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

Referenced by libMesh::PetscVector< libMesh::Number >::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 391 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(), 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 846 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 425 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 408 of file petsc_vector.h.

◆ _type

template<typename T>
ParallelType libMesh::NumericVector< T >::_type
protectedinherited

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

Referenced by libMesh::PetscVector< libMesh::Number >::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 462 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 467 of file petsc_vector.h.

◆ _vec

template<typename T>
Vec libMesh::PetscVector< T >::_vec
private

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