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

This class provides a nice interface to the Trilinos Epetra_Vector object. More...

#include <trilinos_epetra_vector.h>

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

Public Member Functions

 EpetraVector (const Parallel::Communicator &comm, const ParallelType type=AUTOMATIC)
 Dummy-Constructor. More...
 
 EpetraVector (const Parallel::Communicator &comm, const numeric_index_type n, const ParallelType type=AUTOMATIC)
 Constructor. More...
 
 EpetraVector (const Parallel::Communicator &comm, const numeric_index_type n, const numeric_index_type n_local, const ParallelType type=AUTOMATIC)
 Constructor. More...
 
 EpetraVector (const Parallel::Communicator &comm, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType type=AUTOMATIC)
 Constructor. More...
 
 EpetraVector (Epetra_Vector &v, const Parallel::Communicator &comm)
 Constructor. More...
 
 EpetraVector (EpetraVector &&)=delete
 This class manages the lifetime of an Epetra_Vector manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor. More...
 
 EpetraVector (const EpetraVector &)=delete
 
EpetraVectoroperator= (const EpetraVector &)=delete
 
EpetraVectoroperator= (EpetraVector &&)=delete
 
virtual ~EpetraVector ()
 
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
 
virtual T operator() (const numeric_index_type i) const override
 
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 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 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...
 
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 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
 
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 swap (NumericVector< T > &v) override
 Swaps the contents of this with v. More...
 
virtual std::size_t max_allowed_id () const override
 
Epetra_Vector * vec ()
 
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
 
virtual void get (const std::vector< numeric_index_type > &index, T *values) const
 Access multiple components at once. More...
 
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 pointwise_divide (const NumericVector< T > &vec1, const NumericVector< T > &vec2)=0
 Computes \( u_i \leftarrow \frac{v_{1,i}}{v_{2,i}} \) (summation not implied) i.e. More...
 
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 print_matlab (const std::string &filename="") const
 Print the contents of the vector in Matlab's sparse matrix format. More...
 
virtual void read_matlab (const std::string &filename)
 Read the contents of the vector from the Matlab-script format used by PETSc. More...
 
virtual void create_subvector (NumericVector< T > &, const std::vector< numeric_index_type > &, bool=true) const
 Fills in subvector from this vector using the indices in rows. More...
 
virtual std::unique_ptr< NumericVector< T > > get_subvector (const std::vector< numeric_index_type > &)
 Creates a view into this vector using the indices in rows. More...
 
virtual void restore_subvector (std::unique_ptr< NumericVector< T >>, const std::vector< numeric_index_type > &)
 Restores a view into this vector using the indices in rows. 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 Member Functions

int SumIntoGlobalValues (int numIDs, const int *GIDs, const double *values)
 Accumulate values into the vector, adding them to any values that already exist for the specified indices. More...
 
int SumIntoGlobalValues (const Epetra_IntSerialDenseVector &GIDs, const Epetra_SerialDenseVector &values)
 Accumulate values into the vector, adding them to any values that already exist for the specified GIDs. More...
 
int ReplaceGlobalValues (int numIDs, const int *GIDs, const double *values)
 Copy values into the vector overwriting any values that already exist for the specified indices. More...
 
int ReplaceGlobalValues (const Epetra_IntSerialDenseVector &GIDs, const Epetra_SerialDenseVector &values)
 Copy values into the vector, replacing any values that already exist for the specified GIDs. More...
 
int SumIntoGlobalValues (int numIDs, const int *GIDs, const int *numValuesPerID, const double *values)
 
int ReplaceGlobalValues (int numIDs, const int *GIDs, const int *numValuesPerID, const double *values)
 
int GlobalAssemble (Epetra_CombineMode mode=Add)
 Gather any overlapping/shared data into the non-overlapping partitioning defined by the Map that was passed to this vector at construction time. More...
 
void setIgnoreNonLocalEntries (bool flag)
 Set whether or not non-local data values should be ignored. More...
 
void FEoperatorequals (const EpetraVector &source)
 
int inputValues (int numIDs, const int *GIDs, const double *values, bool accumulate)
 
int inputValues (int numIDs, const int *GIDs, const int *numValuesPerID, const double *values, bool accumulate)
 
int inputNonlocalValue (int GID, double value, bool accumulate)
 
int inputNonlocalValues (int GID, int numValues, const double *values, bool accumulate)
 
void destroyNonlocalData ()
 

Private Attributes

Epetra_Vector * _vec
 Actual Epetra vector datatype to hold vector entries. More...
 
std::unique_ptr< Epetra_Map > _map
 Holds the distributed Map. More...
 
bool _destroy_vec_on_exit
 This boolean value should only be set to false for the constructor which takes a Epetra Vec object. More...
 
int myFirstID_
 
int myNumIDs_
 
double * myCoefs_
 
intnonlocalIDs_
 
intnonlocalElementSize_
 
int numNonlocalIDs_
 
int allocatedNonlocalLength_
 
double ** nonlocalCoefs_
 
unsigned char last_edit
 Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add (2), so we can decide how to do the GlobalAssemble() More...
 
bool ignoreNonLocalEntries_
 

Detailed Description

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

This class provides a nice interface to the Trilinos Epetra_Vector object.

All overridden virtual functions are documented in numeric_vector.h.

Author
Derek R. Gaston
Date
2008

Definition at line 65 of file trilinos_epetra_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.

Constructor & Destructor Documentation

◆ EpetraVector() [1/7]

template<typename T >
libMesh::EpetraVector< T >::EpetraVector ( const Parallel::Communicator comm,
const ParallelType  type = AUTOMATIC 
)
inlineexplicit

Dummy-Constructor.

Dimension=0

Definition at line 414 of file trilinos_epetra_vector.h.

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

415  :
416  NumericVector<T>(comm, type),
417  _destroy_vec_on_exit(true),
418  myFirstID_(0),
419  myNumIDs_(0),
420  myCoefs_(nullptr),
421  nonlocalIDs_(nullptr),
422  nonlocalElementSize_(nullptr),
423  numNonlocalIDs_(0),
425  nonlocalCoefs_(nullptr),
426  last_edit(0),
428 {
429  this->_type = type;
430 }
const Parallel::Communicator & comm() const
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
ParallelType _type
Type of vector.
ParallelType type() const

◆ EpetraVector() [2/7]

template<typename T >
libMesh::EpetraVector< T >::EpetraVector ( const Parallel::Communicator comm,
const numeric_index_type  n,
const ParallelType  type = AUTOMATIC 
)
inlineexplicit

Constructor.

Set dimension to n and initialize all elements with zero.

Definition at line 436 of file trilinos_epetra_vector.h.

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

438  :
439  NumericVector<T>(comm, type),
440  _destroy_vec_on_exit(true),
441  myFirstID_(0),
442  myNumIDs_(0),
443  myCoefs_(nullptr),
444  nonlocalIDs_(nullptr),
445  nonlocalElementSize_(nullptr),
446  numNonlocalIDs_(0),
448  nonlocalCoefs_(nullptr),
449  last_edit(0),
451 
452 {
453  this->init(n, n, false, type);
454 }
const Parallel::Communicator & comm() const
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
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.
ParallelType type() const

◆ EpetraVector() [3/7]

template<typename T >
libMesh::EpetraVector< T >::EpetraVector ( const Parallel::Communicator comm,
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 460 of file trilinos_epetra_vector.h.

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

463  :
464  NumericVector<T>(comm, type),
465  _destroy_vec_on_exit(true),
466  myFirstID_(0),
467  myNumIDs_(0),
468  myCoefs_(nullptr),
469  nonlocalIDs_(nullptr),
470  nonlocalElementSize_(nullptr),
471  numNonlocalIDs_(0),
473  nonlocalCoefs_(nullptr),
474  last_edit(0),
476 {
477  this->init(n, n_local, false, type);
478 }
const Parallel::Communicator & comm() const
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
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.
ParallelType type() const

◆ EpetraVector() [4/7]

template<typename T >
libMesh::EpetraVector< T >::EpetraVector ( const Parallel::Communicator comm,
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 526 of file trilinos_epetra_vector.h.

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

530  :
531  NumericVector<T>(comm, AUTOMATIC),
532  _destroy_vec_on_exit(true),
533  myFirstID_(0),
534  myNumIDs_(0),
535  myCoefs_(nullptr),
536  nonlocalIDs_(nullptr),
537  nonlocalElementSize_(nullptr),
538  numNonlocalIDs_(0),
540  nonlocalCoefs_(nullptr),
541  last_edit(0),
543 {
544  this->init(n, n_local, ghost, false, type);
545 }
const Parallel::Communicator & comm() const
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
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.
ParallelType type() const

◆ EpetraVector() [5/7]

template<typename T >
libMesh::EpetraVector< T >::EpetraVector ( Epetra_Vector &  v,
const Parallel::Communicator comm 
)
inline

Constructor.

Creates a EpetraVector assuming you already have a valid Epetra Vec object. In this case, v is NOT destroyed by the EpetraVector 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 EpetraVector.

Definition at line 485 of file trilinos_epetra_vector.h.

References libMesh::NumericVector< T >::_is_closed, libMesh::NumericVector< T >::_is_initialized, libMesh::EpetraVector< T >::_map, libMesh::NumericVector< T >::_type, libMesh::EpetraVector< T >::_vec, libMesh::ParallelObject::comm(), libMesh::EpetraVector< T >::myCoefs_, libMesh::EpetraVector< T >::myFirstID_, libMesh::EpetraVector< T >::myNumIDs_, and libMesh::PARALLEL.

486  :
487  NumericVector<T>(comm, AUTOMATIC),
488  _destroy_vec_on_exit(false),
489  myFirstID_(0),
490  myNumIDs_(0),
491  myCoefs_(nullptr),
492  nonlocalIDs_(nullptr),
493  nonlocalElementSize_(nullptr),
494  numNonlocalIDs_(0),
496  nonlocalCoefs_(nullptr),
497  last_edit(0),
499 {
500  _vec = &v;
501 
502  this->_type = PARALLEL; // FIXME - need to determine this from v!
503 
504  myFirstID_ = _vec->Map().MinMyGID();
505  myNumIDs_ = _vec->Map().NumMyElements();
506 
507  _map = std::make_unique<Epetra_Map>
508  (_vec->GlobalLength(),
509  _vec->MyLength(),
510  0, // IndexBase = 0 for C/C++, 1 for Fortran.
511  Epetra_MpiComm (this->comm().get()));
512 
513  //Currently we impose the restriction that NumVectors==1, so we won't
514  //need the LDA argument when calling ExtractView. Hence the "dummy" arg.
515  int dummy;
516  _vec->ExtractView(&myCoefs_, &dummy);
517 
518  this->_is_closed = true;
519  this->_is_initialized = true;
520 }
std::unique_ptr< Epetra_Map > _map
Holds the distributed Map.
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
const Parallel::Communicator & comm() const
bool _is_initialized
true once init() has been called.
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
ParallelType _type
Type of vector.
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ EpetraVector() [6/7]

template<typename T>
libMesh::EpetraVector< T >::EpetraVector ( EpetraVector< T > &&  )
delete

This class manages the lifetime of an Epetra_Vector manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor.

◆ EpetraVector() [7/7]

template<typename T>
libMesh::EpetraVector< T >::EpetraVector ( const EpetraVector< T > &  )
delete

◆ ~EpetraVector()

template<typename T >
libMesh::EpetraVector< T >::~EpetraVector ( )
inlinevirtual

Definition at line 562 of file trilinos_epetra_vector.h.

563 {
564  this->clear ();
565 }
virtual void clear() noexcept override
clear() is called from the destructor, so it should not throw.

Member Function Documentation

◆ abs()

template<typename T >
void libMesh::EpetraVector< T >::abs ( )
overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 325 of file trilinos_epetra_vector.C.

326 {
327  _vec->Abs(*_vec);
328 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

◆ add() [1/4]

template<typename T >
void libMesh::EpetraVector< 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 214 of file trilinos_epetra_vector.C.

References value.

215 {
216  int i = static_cast<int> (i_in);
217  T value = value_in;
218 
219  libmesh_assert_less (i_in, this->size());
220 
221  std::scoped_lock lock(this->_numeric_vector_mutex);
222  SumIntoGlobalValues(1, &i, &value);
223 
224  this->_is_closed = false;
225 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
virtual numeric_index_type size() const override
int SumIntoGlobalValues(int numIDs, const int *GIDs, const double *values)
Accumulate values into the vector, adding them to any values that already exist for the specified ind...
static const bool value
Definition: xdr_io.C:54
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::EpetraVector< 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 271 of file trilinos_epetra_vector.C.

272 {
273  const unsigned int nl = _vec->MyLength();
274 
275  T * values = _vec->Values();
276 
277  for (unsigned int i=0; i<nl; i++)
278  values[i]+=v_in;
279 
280  this->_is_closed = false;
281 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ add() [3/4]

template<typename T >
void libMesh::EpetraVector< 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 285 of file trilinos_epetra_vector.C.

286 {
287  this->add (1., v);
288 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.

◆ add() [4/4]

template<typename T >
void libMesh::EpetraVector< 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 292 of file trilinos_epetra_vector.C.

References libMesh::EpetraVector< T >::_vec, and libMesh::EpetraVector< T >::size().

293 {
294  const EpetraVector<T> * v = cast_ptr<const EpetraVector<T> *>(&v_in);
295 
296  libmesh_assert_equal_to (this->size(), v->size());
297 
298  _vec->Update(a_in,*v->_vec, 1.);
299 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
virtual numeric_index_type size() const override

◆ add_vector() [1/6]

template<typename T >
void libMesh::EpetraVector< 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 230 of file trilinos_epetra_vector.C.

References libMesh::numeric_trilinos_cast().

232 {
233  libmesh_assert_equal_to (sizeof(numeric_index_type), sizeof(int));
234 
235  std::scoped_lock lock(this->_numeric_vector_mutex);
236  SumIntoGlobalValues (cast_int<numeric_index_type>(dof_indices.size()),
237  numeric_trilinos_cast(dof_indices.data()),
238  const_cast<T *>(v));
239 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
dof_id_type numeric_index_type
Definition: id_types.h:99
int SumIntoGlobalValues(int numIDs, const int *GIDs, const double *values)
Accumulate values into the vector, adding them to any values that already exist for the specified ind...
int * numeric_trilinos_cast(const numeric_index_type *p)

◆ add_vector() [2/6]

template<typename T >
void libMesh::EpetraVector< 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 245 of file trilinos_epetra_vector.C.

References libMesh::EpetraVector< T >::_vec, and libMesh::EpetraVector< T >::zero_clone().

247 {
248  const EpetraVector<T> * v = cast_ptr<const EpetraVector<T> *>(&v_in);
249  const EpetraMatrix<T> * A = cast_ptr<const EpetraMatrix<T> *>(&A_in);
250 
251  // FIXME - does Trilinos let us do this *without* memory allocation?
252  std::unique_ptr<NumericVector<T>> temp = v->zero_clone();
253  EpetraVector<T> * temp_v = cast_ptr<EpetraVector<T> *>(temp.get());
254  A->mat()->Multiply(false, *v->_vec, *temp_v->_vec);
255  *this += *temp;
256 }

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

template<typename T >
void libMesh::EpetraVector< 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 262 of file trilinos_epetra_vector.C.

264 {
265  libmesh_not_implemented();
266 }

◆ 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(), 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::EpetraVector< T >::clear ( )
inlineoverridevirtualnoexcept

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

Reimplemented from libMesh::NumericVector< T >.

Definition at line 676 of file trilinos_epetra_vector.h.

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

677 {
678  if (this->initialized())
679  {
680  // We might just be an interface to a user-provided _vec
681  if (this->_destroy_vec_on_exit)
682  {
683  delete _vec;
684  _vec = nullptr;
685  }
686 
687  // But we currently always own our own _map
688  _map.reset();
689  }
690 
691  this->_is_closed = this->_is_initialized = false;
692 }
std::unique_ptr< Epetra_Map > _map
Holds the distributed Map.
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
bool _is_initialized
true once init() has been called.
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
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::EpetraVector< 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 722 of file trilinos_epetra_vector.h.

References libMesh::AUTOMATIC.

723 {
724  std::unique_ptr<NumericVector<T>> cloned_vector =
725  std::make_unique<EpetraVector<T>>(this->comm(), AUTOMATIC);
726  cloned_vector->init(*this, true);
727  *cloned_vector = *this;
728  return cloned_vector;
729 }
const Parallel::Communicator & comm() const

◆ close()

template<typename T >
void libMesh::EpetraVector< 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 652 of file trilinos_epetra_vector.h.

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

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

653 {
654  libmesh_assert (this->initialized());
655 
656  // Are we adding or inserting?
657  unsigned char global_last_edit = last_edit;
658  this->comm().max(global_last_edit);
659  libmesh_assert(!last_edit || last_edit == global_last_edit);
660 
661  if (global_last_edit == 1)
662  this->GlobalAssemble(Insert);
663  else if (global_last_edit == 2)
664  this->GlobalAssemble(Add);
665  else
666  libmesh_assert(!global_last_edit);
667 
668  this->_is_closed = true;
669  this->last_edit = 0;
670 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
int GlobalAssemble(Epetra_CombineMode mode=Add)
Gather any overlapping/shared data into the non-overlapping partitioning defined by the Map that was ...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
libmesh_assert(ctx)
void max(const T &r, T &o, Request &req) 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::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(), 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(), 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::EpetraVector< T >::conjugate ( )
overridevirtual

Negates the imaginary component of each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 206 of file trilinos_epetra_vector.C.

207 {
208  // EPetra is real, rendering this a no-op.
209 }

◆ create_subvector()

template<typename T>
virtual void libMesh::NumericVector< T >::create_subvector ( NumericVector< T > &  ,
const std::vector< numeric_index_type > &  ,
bool  = true 
) const
inlinevirtualinherited

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 in libMesh::PetscVector< T >.

Definition at line 762 of file numeric_vector.h.

Referenced by libMesh::StaticCondensation::forward_elimination().

765  {
766  libmesh_not_implemented();
767  }

◆ destroyNonlocalData()

template<typename T >
void libMesh::EpetraVector< T >::destroyNonlocalData ( )
private

Definition at line 906 of file trilinos_epetra_vector.C.

907 {
908  if (allocatedNonlocalLength_ > 0) {
909  delete [] nonlocalIDs_;
910  delete [] nonlocalElementSize_;
911  nonlocalIDs_ = nullptr;
912  nonlocalElementSize_ = nullptr;
913  for (int i=0; i<numNonlocalIDs_; ++i) {
914  delete [] nonlocalCoefs_[i];
915  }
916  delete [] nonlocalCoefs_;
917  nonlocalCoefs_ = nullptr;
918  numNonlocalIDs_ = 0;
920  }
921  return;
922 }

◆ 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::EpetraVector< 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 332 of file trilinos_epetra_vector.C.

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

333 {
334  const EpetraVector<T> * v = cast_ptr<const EpetraVector<T> *>(&v_in);
335 
336  T result=0.0;
337 
338  _vec->Dot(*v->_vec, &result);
339 
340  return result;
341 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

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

◆ FEoperatorequals()

template<typename T >
void libMesh::EpetraVector< T >::FEoperatorequals ( const EpetraVector< T > &  source)
private

Definition at line 878 of file trilinos_epetra_vector.C.

References libMesh::EpetraVector< T >::_vec, libMesh::EpetraVector< T >::allocatedNonlocalLength_, libMesh::EpetraVector< T >::nonlocalCoefs_, libMesh::EpetraVector< T >::nonlocalElementSize_, libMesh::EpetraVector< T >::nonlocalIDs_, and libMesh::EpetraVector< T >::numNonlocalIDs_.

879 {
880  (*_vec) = *(source._vec);
881 
883 
884  if (source.allocatedNonlocalLength_ > 0) {
885  allocatedNonlocalLength_ = source.allocatedNonlocalLength_;
886  numNonlocalIDs_ = source.numNonlocalIDs_;
890  for (int i=0; i<numNonlocalIDs_; ++i) {
891  int elemSize = source.nonlocalElementSize_[i];
892  nonlocalCoefs_[i] = new double[elemSize];
893  nonlocalIDs_[i] = source.nonlocalIDs_[i];
894  nonlocalElementSize_[i] = elemSize;
895  for (int j=0; j<elemSize; ++j) {
896  nonlocalCoefs_[i][j] = source.nonlocalCoefs_[i][j];
897  }
898  }
899  }
900 }

◆ first_local_index()

template<typename T >
numeric_index_type libMesh::EpetraVector< 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 755 of file trilinos_epetra_vector.h.

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

756 {
757  libmesh_assert (this->initialized());
758 
759  return _vec->Map().MinMyGID();
760 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)

◆ get() [1/2]

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

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 in libMesh::PetscVector< T >.

Definition at line 930 of file numeric_vector.h.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::EquationSystems::build_parallel_solution_vector(), compute_residual(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::HDGProblem::jacobian(), libMesh::FEMContext::pre_fe_reinit(), libMesh::System::project_vector(), libMesh::System::request_vector(), libMesh::HDGProblem::residual(), libMesh::System::restrict_vectors(), libMesh::StaticCondensation::set_local_vectors(), libMesh::System::solve_for_unconstrained_dofs(), and libMesh::System::vector_name().

932 {
933  const std::size_t num = index.size();
934  for (std::size_t i=0; i<num; i++)
935  {
936  values[i] = (*this)(index[i]);
937  }
938 }

◆ 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_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>
virtual std::unique_ptr<NumericVector<T> > libMesh::NumericVector< T >::get_subvector ( const std::vector< numeric_index_type > &  )
inlinevirtualinherited

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 in libMesh::PetscVector< T >, and libMesh::PetscVector< libMesh::Number >.

Definition at line 776 of file numeric_vector.h.

Referenced by libMesh::StaticCondensation::apply(), libMesh::CondensedEigenSystem::copy_sub_to_super(), and libMesh::CondensedEigenSystem::copy_super_to_sub().

777  {
778  libmesh_not_implemented();
779  }

◆ 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

◆ GlobalAssemble()

template<typename T >
int libMesh::EpetraVector< T >::GlobalAssemble ( Epetra_CombineMode  mode = Add)
private

Gather any overlapping/shared data into the non-overlapping partitioning defined by the Map that was passed to this vector at construction time.

Data imported from other processors is stored on the owning processor with a "sumInto" or accumulate operation. This is a collective method – every processor must enter it before any will complete it.

Definition at line 832 of file trilinos_epetra_vector.C.

833 {
834  //In this method we need to gather all the non-local (overlapping) data
835  //that's been input on each processor, into the (probably) non-overlapping
836  //distribution defined by the map that 'this' vector was constructed with.
837 
838  //We don't need to do anything if there's only one processor or if
839  //ignoreNonLocalEntries_ is true.
840  if (_vec->Map().Comm().NumProc() < 2 || ignoreNonLocalEntries_) {
841  return(0);
842  }
843 
844 
845 
846  //First build a map that describes the data in nonlocalIDs_/nonlocalCoefs_.
847  //We'll use the arbitrary distribution constructor of Map.
848 
849  Epetra_BlockMap sourceMap(-1, numNonlocalIDs_,
851  _vec->Map().IndexBase(), _vec->Map().Comm());
852 
853  //Now build a vector to hold our nonlocalCoefs_, and to act as the source-
854  //vector for our import operation.
855  Epetra_MultiVector nonlocalVector(sourceMap, 1);
856 
857  int i,j;
858  for (i=0; i<numNonlocalIDs_; ++i) {
859  for (j=0; j<nonlocalElementSize_[i]; ++j) {
860  nonlocalVector.ReplaceGlobalValue(nonlocalIDs_[i], j, 0,
861  nonlocalCoefs_[i][j]);
862  }
863  }
864 
865  Epetra_Export exporter(sourceMap, _vec->Map());
866 
867  EPETRA_CHK_ERR( _vec->Export(nonlocalVector, exporter, mode) );
868 
870 
871  return(0);
872 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

◆ 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

◆ init() [1/4]

template<typename T >
void libMesh::EpetraVector< 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 571 of file trilinos_epetra_vector.h.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::AUTOMATIC, libMesh::GHOSTED, libMesh::libmesh_assert(), libMesh::PARALLEL, libMesh::SERIAL, and libMesh::zero.

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

575 {
576  // We default to allocating n_local local storage
577  numeric_index_type my_n_local = n_local;
578 
579  if (type == AUTOMATIC)
580  {
581  if (n == n_local)
582  this->_type = SERIAL;
583  else
584  this->_type = PARALLEL;
585  }
586  else if (type == GHOSTED)
587  {
588  // We don't yet support GHOSTED Epetra vectors, so to get the
589  // same functionality we need a SERIAL vector with local
590  // storage allocated for every entry.
591  this->_type = SERIAL;
592  my_n_local = n;
593  }
594  else
595  this->_type = type;
596 
597  libmesh_assert ((this->_type==SERIAL && n==my_n_local) ||
598  this->_type==PARALLEL);
599 
600  _map = std::make_unique<Epetra_Map>
601  (static_cast<int>(n),
602  my_n_local,
603  0,
604  Epetra_MpiComm (this->comm().get()));
605 
606  _vec = new Epetra_Vector(*_map);
607 
608  myFirstID_ = _vec->Map().MinMyGID();
609  myNumIDs_ = _vec->Map().NumMyElements();
610 
611  // Currently we impose the restriction that NumVectors==1, so we won't
612  // need the LDA argument when calling ExtractView. Hence the "dummy" arg.
613  int dummy;
614  _vec->ExtractView(&myCoefs_, &dummy);
615 
616  this->_is_initialized = true;
617  this->_is_closed = true;
618  this->last_edit = 0;
619 
620  if (fast == false)
621  this->zero ();
622 }
std::unique_ptr< Epetra_Map > _map
Holds the distributed Map.
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
const Parallel::Communicator & comm() const
bool _is_initialized
true once init() has been called.
virtual void zero() override
Set all entries to zero.
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
communicator & get()
ParallelType _type
Type of vector.
ParallelType type() const
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::EpetraVector< 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 641 of file trilinos_epetra_vector.h.

References libMesh::TriangleWrapper::init().

644 {
645  this->init(n,n,fast,type);
646 }
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.
ParallelType type() const

◆ init() [3/4]

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

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

Implements libMesh::NumericVector< T >.

Definition at line 627 of file trilinos_epetra_vector.h.

References libMesh::TriangleWrapper::init().

632 {
633  // TODO: we shouldn't ignore the ghost sparsity pattern
634  this->init(n, n_local, fast, type);
635 }
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.
ParallelType type() const

◆ init() [4/4]

template<class T >
void libMesh::EpetraVector< T >::init ( const NumericVector< T > &  other,
const bool  fast = false 
)
overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 552 of file trilinos_epetra_vector.h.

References libMesh::TriangleWrapper::init(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::size(), and libMesh::NumericVector< T >::type().

554 {
555  this->init(other.size(),other.local_size(),fast,other.type());
556 }
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.

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

◆ inputNonlocalValue()

template<typename T >
int libMesh::EpetraVector< T >::inputNonlocalValue ( int  GID,
double  value,
bool  accumulate 
)
private

Definition at line 730 of file trilinos_epetra_vector.C.

References value.

731 {
732  int insertPoint = -1;
733 
734  //find offset of GID in nonlocalIDs_
735  int offset = Epetra_Util_binary_search(GID, nonlocalIDs_, numNonlocalIDs_,
736  insertPoint);
737  if (offset >= 0) {
738  //if offset >= 0
739  // put value in nonlocalCoefs_[offset][0]
740 
741  if (accumulate) {
742  nonlocalCoefs_[offset][0] += value;
743  }
744  else {
745  nonlocalCoefs_[offset][0] = value;
746  }
747  }
748  else {
749  //else
750  // insert GID in nonlocalIDs_
751  // insert 1 in nonlocalElementSize_
752  // insert value in nonlocalCoefs_
753 
754  int tmp1 = numNonlocalIDs_;
755  int tmp2 = allocatedNonlocalLength_;
756  int tmp3 = allocatedNonlocalLength_;
757  EPETRA_CHK_ERR( Epetra_Util_insert(GID, insertPoint, nonlocalIDs_,
758  tmp1, tmp2) );
759  --tmp1;
760  EPETRA_CHK_ERR( Epetra_Util_insert(1, insertPoint, nonlocalElementSize_,
761  tmp1, tmp3) );
762  double * values = new double[1];
763  values[0] = value;
764  EPETRA_CHK_ERR( Epetra_Util_insert(values, insertPoint, nonlocalCoefs_,
766  }
767 
768  return(0);
769 }
static const bool value
Definition: xdr_io.C:54

◆ inputNonlocalValues()

template<typename T >
int libMesh::EpetraVector< T >::inputNonlocalValues ( int  GID,
int  numValues,
const double *  values,
bool  accumulate 
)
private

Definition at line 773 of file trilinos_epetra_vector.C.

References libMesh::err.

777 {
778  int insertPoint = -1;
779 
780  //find offset of GID in nonlocalIDs_
781  int offset = Epetra_Util_binary_search(GID, nonlocalIDs_, numNonlocalIDs_,
782  insertPoint);
783  if (offset >= 0) {
784  //if offset >= 0
785  // put value in nonlocalCoefs_[offset][0]
786 
787  if (numValues != nonlocalElementSize_[offset]) {
788  libMesh::err << "Epetra_FEVector ERROR: block-size for GID " << GID << " is "
789  << numValues<<" which doesn't match previously set block-size of "
790  << nonlocalElementSize_[offset] << std::endl;
791  return(-1);
792  }
793 
794  if (accumulate) {
795  for (int j=0; j<numValues; ++j) {
796  nonlocalCoefs_[offset][j] += values[j];
797  }
798  }
799  else {
800  for (int j=0; j<numValues; ++j) {
801  nonlocalCoefs_[offset][j] = values[j];
802  }
803  }
804  }
805  else {
806  //else
807  // insert GID in nonlocalIDs_
808  // insert numValues in nonlocalElementSize_
809  // insert values in nonlocalCoefs_
810 
811  int tmp1 = numNonlocalIDs_;
812  int tmp2 = allocatedNonlocalLength_;
813  int tmp3 = allocatedNonlocalLength_;
814  EPETRA_CHK_ERR( Epetra_Util_insert(GID, insertPoint, nonlocalIDs_,
815  tmp1, tmp2) );
816  --tmp1;
817  EPETRA_CHK_ERR( Epetra_Util_insert(numValues, insertPoint, nonlocalElementSize_,
818  tmp1, tmp3) );
819  double * newvalues = new double[numValues];
820  for (int j=0; j<numValues; ++j) {
821  newvalues[j] = values[j];
822  }
823  EPETRA_CHK_ERR( Epetra_Util_insert(newvalues, insertPoint, nonlocalCoefs_,
825  }
826 
827  return(0);
828 }
OStreamProxy err

◆ inputValues() [1/2]

template<typename T >
int libMesh::EpetraVector< T >::inputValues ( int  numIDs,
const int GIDs,
const double *  values,
bool  accumulate 
)
private

Definition at line 650 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

654 {
655  if (accumulate) {
656  libmesh_assert(last_edit == 0 || last_edit == 2);
657  last_edit = 2;
658  } else {
659  libmesh_assert(last_edit == 0 || last_edit == 1);
660  last_edit = 1;
661  }
662 
663  //Important note!! This method assumes that there is only 1 point
664  //associated with each element.
665 
666  for (int i=0; i<numIDs; ++i) {
667  if (_vec->Map().MyGID(GIDs[i])) {
668  if (accumulate) {
669  _vec->SumIntoGlobalValue(GIDs[i], 0, 0, values[i]);
670  }
671  else {
672  _vec->ReplaceGlobalValue(GIDs[i], 0, 0, values[i]);
673  }
674  }
675  else {
676  if (!ignoreNonLocalEntries_) {
677  EPETRA_CHK_ERR( inputNonlocalValue(GIDs[i], values[i], accumulate) );
678  }
679  }
680  }
681 
682  return(0);
683 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
libmesh_assert(ctx)
int inputNonlocalValue(int GID, double value, bool accumulate)

◆ inputValues() [2/2]

template<typename T >
int libMesh::EpetraVector< T >::inputValues ( int  numIDs,
const int GIDs,
const int numValuesPerID,
const double *  values,
bool  accumulate 
)
private

Definition at line 687 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

692 {
693  if (accumulate) {
694  libmesh_assert(last_edit == 0 || last_edit == 2);
695  last_edit = 2;
696  } else {
697  libmesh_assert(last_edit == 0 || last_edit == 1);
698  last_edit = 1;
699  }
700 
701  int offset=0;
702  for (int i=0; i<numIDs; ++i) {
703  int numValues = numValuesPerID[i];
704  if (_vec->Map().MyGID(GIDs[i])) {
705  if (accumulate) {
706  for (int j=0; j<numValues; ++j) {
707  _vec->SumIntoGlobalValue(GIDs[i], j, 0, values[offset+j]);
708  }
709  }
710  else {
711  for (int j=0; j<numValues; ++j) {
712  _vec->ReplaceGlobalValue(GIDs[i], j, 0, values[offset+j]);
713  }
714  }
715  }
716  else {
717  if (!ignoreNonLocalEntries_) {
718  EPETRA_CHK_ERR( inputNonlocalValues(GIDs[i], numValues,
719  &(values[offset]), accumulate) );
720  }
721  }
722  offset += numValues;
723  }
724 
725  return(0);
726 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
int inputNonlocalValues(int GID, int numValues, const double *values, bool accumulate)
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
libmesh_assert(ctx)

◆ insert() [1/5]

template<typename T >
void libMesh::EpetraVector< 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 304 of file trilinos_epetra_vector.C.

References libMesh::numeric_trilinos_cast().

306 {
307  libmesh_assert_equal_to (sizeof(numeric_index_type), sizeof(int));
308 
309  std::scoped_lock lock(this->_numeric_vector_mutex);
310  ReplaceGlobalValues (cast_int<numeric_index_type>(dof_indices.size()),
311  numeric_trilinos_cast(dof_indices.data()),
312  const_cast<T *>(v));
313  this->_is_closed = false;
314 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
int ReplaceGlobalValues(int numIDs, const int *GIDs, const double *values)
Copy values into the vector overwriting any values that already exist for the specified indices...
dof_id_type numeric_index_type
Definition: id_types.h:99
int * numeric_trilinos_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::EpetraVector< 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 69 of file trilinos_epetra_vector.C.

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

70 {
71  libmesh_assert(this->closed());
72 
73  Real value;
74 
75  _vec->Norm1(&value);
76 
77  return value;
78 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
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:54

◆ 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::EpetraVector< 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 81 of file trilinos_epetra_vector.C.

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

82 {
83  libmesh_assert(this->closed());
84 
85  Real value;
86 
87  _vec->Norm2(&value);
88 
89  return value;
90 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
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:54

◆ 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::EpetraVector< 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 766 of file trilinos_epetra_vector.h.

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

767 {
768  libmesh_assert (this->initialized());
769 
770  return _vec->Map().MaxMyGID()+1;
771 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)

◆ linfty_norm()

template<typename T >
Real libMesh::EpetraVector< 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 93 of file trilinos_epetra_vector.C.

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

94 {
95  libmesh_assert(this->closed());
96 
97  Real value;
98 
99  _vec->NormInf(&value);
100 
101  return value;
102 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
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:54

◆ 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::EpetraVector< 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 746 of file trilinos_epetra_vector.h.

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

747 {
748  libmesh_assert (this->initialized());
749 
750  return _vec->MyLength();
751 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)

◆ localize() [1/5]

template<typename T >
void libMesh::EpetraVector< 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 532 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

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

533 {
534  // This function must be run on all processors at once
535  parallel_object_only();
536 
537  const unsigned int n = this->size();
538  const unsigned int nl = this->local_size();
539 
540  libmesh_assert(this->_vec);
541 
542  v_local.clear();
543  v_local.reserve(n);
544 
545  // build up my local part
546  for (unsigned int i=0; i<nl; i++)
547  v_local.push_back((*this->_vec)[i]);
548 
549  this->comm().allgather (v_local);
550 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
const Parallel::Communicator & comm() const
virtual numeric_index_type size() const override
libmesh_assert(ctx)
virtual numeric_index_type local_size() const override

◆ localize() [2/5]

template<typename T >
void libMesh::EpetraVector< 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 420 of file trilinos_epetra_vector.C.

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

421 {
422  EpetraVector<T> * v_local = cast_ptr<EpetraVector<T> *>(&v_local_in);
423 
424  Epetra_Map rootMap = Epetra_Util::Create_Root_Map( *_map, -1);
425  v_local->_vec->ReplaceMap(rootMap);
426 
427  Epetra_Import importer(v_local->_vec->Map(), *_map);
428  v_local->_vec->Import(*_vec, importer, Insert);
429 }
std::unique_ptr< Epetra_Map > _map
Holds the distributed Map.
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

◆ localize() [3/5]

template<typename T >
void libMesh::EpetraVector< 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 434 of file trilinos_epetra_vector.C.

436 {
437  // TODO: optimize to sync only the send list values
438  this->localize(v_local_in);
439 
440  // EpetraVector<T> * v_local =
441  // cast_ptr<EpetraVector<T> *>(&v_local_in);
442 
443  // libmesh_assert(this->_map.get());
444  // libmesh_assert(v_local->_map.get());
445  // libmesh_assert_equal_to (v_local->local_size(), this->size());
446  // libmesh_assert_less_equal (send_list.size(), v_local->size());
447 
448  // Epetra_Import importer (*v_local->_map, *this->_map);
449 
450  // v_local->_vec->Import (*this->_vec, importer, Insert);
451 }
virtual void localize(std::vector< T > &v_local) const override
Creates a copy of the global vector in the local vector v_local.

◆ localize() [4/5]

template<typename T >
void libMesh::EpetraVector< 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 456 of file trilinos_epetra_vector.C.

References libMesh::index_range().

458 {
459  // Create a "replicated" map for importing values. This is
460  // equivalent to creating a general Epetra_Map with
461  // NumGlobalElements == NumMyElements.
462  Epetra_LocalMap import_map(static_cast<int>(indices.size()),
463  /*IndexBase=*/0,
464  _map->Comm());
465 
466  // Get a pointer to the list of global elements for the map, and set
467  // all the values from indices.
468  int * import_map_global_elements = import_map.MyGlobalElements();
469  for (auto i : index_range(indices))
470  import_map_global_elements[i] = indices[i];
471 
472  // Create a new EpetraVector to import values into.
473  Epetra_Vector import_vector(import_map);
474 
475  // Set up an "Import" object which associates the two maps.
476  Epetra_Import import_object(import_map, *_map);
477 
478  // Import the values
479  import_vector.Import(*_vec, import_object, Insert);
480 
481  // Get a pointer to the imported values array and the length of the
482  // array.
483  T * values = import_vector.Values();
484  int import_vector_length = import_vector.MyLength();
485 
486  // Copy the imported values into v_local
487  v_local.resize(import_vector_length);
488  for (int i=0; i<import_vector_length; ++i)
489  v_local[i] = values[i];
490 }
std::unique_ptr< Epetra_Map > _map
Holds the distributed Map.
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
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

◆ localize() [5/5]

template<typename T >
void libMesh::EpetraVector< 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 495 of file trilinos_epetra_vector.C.

References libMesh::EpetraVector< T >::close(), libMesh::EpetraVector< T >::init(), libMesh::EpetraVector< T >::localize(), libMesh::PARALLEL, and libMesh::EpetraVector< T >::set().

498 {
499  // Only good for serial vectors.
500  libmesh_assert_equal_to (this->size(), this->local_size());
501  libmesh_assert_greater (last_local_idx, first_local_idx);
502  libmesh_assert_less_equal (send_list.size(), this->size());
503  libmesh_assert_less (last_local_idx, this->size());
504 
505  const unsigned int my_size = this->size();
506  const unsigned int my_local_size = (last_local_idx - first_local_idx + 1);
507 
508  // Don't bother for serial cases
509  if ((first_local_idx == 0) &&
510  (my_local_size == my_size))
511  return;
512 
513  // Build a parallel vector, initialize it with the local
514  // parts of (*this)
515  EpetraVector<T> parallel_vec(this->comm(), PARALLEL);
516 
517  parallel_vec.init (my_size, my_local_size, true, PARALLEL);
518 
519  // Copy part of *this into the parallel_vec
520  for (numeric_index_type i=first_local_idx; i<=last_local_idx; i++)
521  parallel_vec.set(i,this->el(i));
522 
523  // localize like normal
524  parallel_vec.close();
525  parallel_vec.localize (*this, send_list);
526  this->close();
527 }
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
const Parallel::Communicator & comm() const
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual numeric_index_type local_size() const override

◆ localize_to_one()

template<typename T >
void libMesh::EpetraVector< 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 >.

Definition at line 555 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

557 {
558  // This function must be run on all processors at once
559  parallel_object_only();
560 
561  const unsigned int n = this->size();
562  const unsigned int nl = this->local_size();
563 
564  libmesh_assert_less (pid, this->n_processors());
565  libmesh_assert(this->_vec);
566 
567  v_local.clear();
568  v_local.reserve(n);
569 
570 
571  // build up my local part
572  for (unsigned int i=0; i<nl; i++)
573  v_local.push_back((*this->_vec)[i]);
574 
575  this->comm().gather (pid, v_local);
576 }
void gather(const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
const Parallel::Communicator & comm() const
virtual numeric_index_type size() const override
processor_id_type n_processors() const
libmesh_assert(ctx)
virtual numeric_index_type local_size() const override

◆ max()

template<typename T >
Real libMesh::EpetraVector< 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 804 of file trilinos_epetra_vector.h.

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

805 {
806  libmesh_assert (this->initialized());
807 
808  T value;
809 
810  _vec->MaxValue(&value);
811 
812  return value;
813 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)
static const bool value
Definition: xdr_io.C:54

◆ max_allowed_id()

template<typename T >
std::size_t libMesh::EpetraVector< 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 844 of file trilinos_epetra_vector.h.

845 {
846  // Epetra_Vector seems to use hard-coded ints in its various indexing routines.
847  return std::numeric_limits<int>::max();
848 }

◆ min()

template<typename T >
Real libMesh::EpetraVector< 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 789 of file trilinos_epetra_vector.h.

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

790 {
791  libmesh_assert (this->initialized());
792 
793  T value;
794 
795  _vec->MinValue(&value);
796 
797  return value;
798 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)
static const bool value
Definition: xdr_io.C:54

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

◆ operator()()

template<typename T >
T libMesh::EpetraVector< 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 776 of file trilinos_epetra_vector.h.

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

777 {
778  libmesh_assert (this->initialized());
779  libmesh_assert ( ((i >= this->first_local_index()) &&
780  (i < this->last_local_index())) );
781 
782  return (*_vec)[i-this->first_local_index()];
783 }
virtual numeric_index_type last_local_index() const override
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)
virtual numeric_index_type first_local_index() const override

◆ operator*=() [1/2]

template<typename T >
NumericVector< T > & libMesh::EpetraVector< 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 131 of file trilinos_epetra_vector.C.

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

132 {
133  libmesh_assert(this->closed());
134  libmesh_assert_equal_to(size(), v.size());
135 
136  const EpetraVector<T> & v_vec = cast_ref<const EpetraVector<T> &>(v);
137 
138  _vec->Multiply(1.0, *v_vec._vec, *_vec, 0.0);
139 
140  return *this;
141 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
virtual numeric_index_type size() const override
libmesh_assert(ctx)
virtual bool closed() const

◆ 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::EpetraVector< 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 106 of file trilinos_epetra_vector.C.

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

107 {
108  libmesh_assert(this->closed());
109 
110  this->add(1., v);
111 
112  return *this;
113 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
libmesh_assert(ctx)
virtual bool closed() const

◆ operator-=()

template<typename T >
NumericVector< T > & libMesh::EpetraVector< 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 119 of file trilinos_epetra_vector.C.

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

120 {
121  libmesh_assert(this->closed());
122 
123  this->add(-1., v);
124 
125  return *this;
126 }
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
libmesh_assert(ctx)
virtual bool closed() const

◆ operator/=() [1/2]

template<typename T >
NumericVector< T > & libMesh::EpetraVector< 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 146 of file trilinos_epetra_vector.C.

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

147 {
148  libmesh_assert(this->closed());
149  libmesh_assert_equal_to(size(), v.size());
150 
151  const EpetraVector<T> & v_vec = cast_ref<const EpetraVector<T> &>(v);
152 
153  _vec->ReciprocalMultiply(1.0, *v_vec._vec, *_vec, 0.0);
154 
155  return *this;
156 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
virtual numeric_index_type size() const override
libmesh_assert(ctx)
virtual bool closed() const

◆ 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>
EpetraVector& libMesh::EpetraVector< T >::operator= ( const EpetraVector< T > &  )
delete

◆ operator=() [2/5]

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

◆ operator=() [3/5]

template<typename T >
NumericVector< T > & libMesh::EpetraVector< 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 357 of file trilinos_epetra_vector.C.

358 {
359  _vec->PutScalar(s_in);
360 
361  return *this;
362 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

◆ operator=() [4/5]

template<typename T >
NumericVector< T > & libMesh::EpetraVector< 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 368 of file trilinos_epetra_vector.C.

369 {
370  // This function could be implemented in terms of the copy
371  // assignment operator (see other NumericVector subclasses) but that
372  // function is currently deleted so calling this function is an error.
373  // const EpetraVector<T> * v = cast_ptr<const EpetraVector<T> *>(&v_in);
374  // *this = *v;
375  libmesh_not_implemented();
376  return *this;
377 }

◆ operator=() [5/5]

template<typename T >
NumericVector< T > & libMesh::EpetraVector< 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 383 of file trilinos_epetra_vector.C.

384 {
385  T * values = _vec->Values();
386 
391  if (this->size() == v.size())
392  {
393  const unsigned int nl=this->local_size();
394  const unsigned int fli=this->first_local_index();
395 
396  for (unsigned int i=0;i<nl;i++)
397  values[i]=v[fli+i];
398  }
399 
404  else
405  {
406  libmesh_assert_equal_to (v.size(), this->local_size());
407 
408  const unsigned int nl=this->local_size();
409 
410  for (unsigned int i=0;i<nl;i++)
411  values[i]=v[i];
412  }
413 
414  return *this;
415 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
virtual numeric_index_type size() const override
virtual numeric_index_type first_local_index() const override
virtual numeric_index_type local_size() const override

◆ pointwise_divide()

template<typename T>
virtual void libMesh::NumericVector< T >::pointwise_divide ( const NumericVector< T > &  vec1,
const NumericVector< T > &  vec2 
)
pure virtualinherited

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.

Implemented in libMesh::PetscVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

◆ pointwise_mult()

template<typename T >
void libMesh::EpetraVector< 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 345 of file trilinos_epetra_vector.C.

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

347 {
348  const EpetraVector<T> * v1 = cast_ptr<const EpetraVector<T> *>(&vec1);
349  const EpetraVector<T> * v2 = cast_ptr<const EpetraVector<T> *>(&vec2);
350 
351  _vec->Multiply(1.0, *v1->_vec, *v2->_vec, 0.0);
352 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

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

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 in libMesh::PetscVector< T >, and libMesh::PetscVector< libMesh::Number >.

Definition at line 245 of file numeric_vector.C.

Referenced by libMesh::RBConstruction::enrich_basis_from_rhs_terms().

246 {
247  parallel_object_only();
248 
249  libmesh_assert (this->initialized());
250 
251  const numeric_index_type first_dof = this->first_local_index(),
252  end_dof = this->last_local_index();
253 
254  // We'll print the vector from processor 0 to make sure
255  // it's serialized properly
256  if (this->processor_id() == 0)
257  {
258  std::unique_ptr<std::ofstream> file;
259 
260  if (filename != "")
261  file = std::make_unique<std::ofstream>(filename.c_str());
262 
263  std::ostream & os = (filename == "") ? libMesh::out : *file;
264 
265  // Print a header similar to PETSC_VIEWER_ASCII_MATLAB
266  os << "%Vec Object: () " << this->n_processors() << " MPI processes\n"
267  << "% type: " << (this->n_processors() > 1 ? "mpi" : "seq") << "\n"
268  << "Vec = [\n";
269 
270  for (numeric_index_type i : make_range(end_dof))
271  os << (*this)(i) << '\n';
272 
273  std::vector<T> cbuf;
274  for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
275  {
276  this->comm().receive(p, cbuf);
277 
278  for (auto c : cbuf)
279  os << c << '\n';
280  }
281 
282  os << "];\n" << std::endl;
283  }
284  else
285  {
286  std::vector<T> cbuf(end_dof - first_dof);
287 
288  for (numeric_index_type i : make_range(end_dof - first_dof))
289  cbuf[i] = (*this)(first_dof+i);
290  this->comm().send(0,cbuf);
291  }
292 }
virtual bool initialized() const
const Parallel::Communicator & comm() const
processor_id_type n_processors() const
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
virtual numeric_index_type first_local_index() const =0
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const
OStreamProxy out
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

◆ 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 = (filename.rfind(".gz") == filename.size() - 3);
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.
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:54
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::EpetraVector< T >::reciprocal ( )
overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 178 of file trilinos_epetra_vector.C.

179 {
180  // The Epetra::reciprocal() function takes a constant reference to *another* vector,
181  // and fills _vec with its reciprocal. Does that mean we can't pass *_vec as the
182  // argument?
183  // _vec->reciprocal( *_vec );
184 
185  // Alternatively, compute the reciprocal by hand... see also the add(T) member that does this...
186  const unsigned int nl = _vec->MyLength();
187 
188  T * values = _vec->Values();
189 
190  for (unsigned int i=0; i<nl; i++)
191  {
192  // Don't divide by zero (maybe only check this in debug mode?)
193  libmesh_error_msg_if(std::abs(values[i]) < std::numeric_limits<T>::min(),
194  "Error, divide by zero in DistributedVector<T>::reciprocal()!");
195 
196  values[i] = 1. / values[i];
197  }
198 
199  // Leave the vector in a closed state...
200  this->close();
201 }
virtual void close() override
Calls the NumericVector&#39;s internal assembly routines, ensuring that the values are consistent across ...
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

◆ ReplaceGlobalValues() [1/3]

template<typename T >
int libMesh::EpetraVector< T >::ReplaceGlobalValues ( int  numIDs,
const int GIDs,
const double *  values 
)
private

Copy values into the vector overwriting any values that already exist for the specified indices.

Definition at line 619 of file trilinos_epetra_vector.C.

622 {
623  return( inputValues( numIDs, GIDs, values, false) );
624 }
int inputValues(int numIDs, const int *GIDs, const double *values, bool accumulate)

◆ ReplaceGlobalValues() [2/3]

template<typename T >
int libMesh::EpetraVector< T >::ReplaceGlobalValues ( const Epetra_IntSerialDenseVector &  GIDs,
const Epetra_SerialDenseVector &  values 
)
private

Copy values into the vector, replacing any values that already exist for the specified GIDs.

Parameters
GIDsList of global ids. Must be the same length as the accompanying list of values.
valuesList of coefficient values. Must be the same length as the accompanying list of GIDs.

Definition at line 628 of file trilinos_epetra_vector.C.

630 {
631  if (GIDs.Length() != values.Length()) {
632  return(-1);
633  }
634 
635  return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), false) );
636 }
int inputValues(int numIDs, const int *GIDs, const double *values, bool accumulate)

◆ ReplaceGlobalValues() [3/3]

template<typename T >
int libMesh::EpetraVector< T >::ReplaceGlobalValues ( int  numIDs,
const int GIDs,
const int numValuesPerID,
const double *  values 
)
private

Definition at line 640 of file trilinos_epetra_vector.C.

644 {
645  return( inputValues( numIDs, GIDs, numValuesPerID, values, false) );
646 }
int inputValues(int numIDs, const int *GIDs, const double *values, bool accumulate)

◆ restore_subvector()

template<typename T>
virtual void libMesh::NumericVector< T >::restore_subvector ( std::unique_ptr< NumericVector< T >>  ,
const std::vector< numeric_index_type > &   
)
inlinevirtualinherited

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

This is currently only implemented for PetscVectors.

Reimplemented in libMesh::PetscVector< T >.

Definition at line 786 of file numeric_vector.h.

Referenced by libMesh::StaticCondensation::apply(), libMesh::CondensedEigenSystem::copy_sub_to_super(), and libMesh::CondensedEigenSystem::copy_super_to_sub().

788  {
789  libmesh_not_implemented();
790  }

◆ scale()

template<typename T >
void libMesh::EpetraVector< T >::scale ( const T  factor)
overridevirtual

Scale each element of the vector by the given factor.

Implements libMesh::NumericVector< T >.

Definition at line 319 of file trilinos_epetra_vector.C.

320 {
321  _vec->Scale(factor_in);
322 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.

◆ set()

template<typename T >
void libMesh::EpetraVector< 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 162 of file trilinos_epetra_vector.C.

References value.

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

163 {
164  int i = static_cast<int> (i_in);
165  T value = value_in;
166 
167  libmesh_assert_less (i_in, this->size());
168 
169  std::scoped_lock lock(this->_numeric_vector_mutex);
170  ReplaceGlobalValues(1, &i, &value);
171 
172  this->_is_closed = false;
173 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
virtual numeric_index_type size() const override
int ReplaceGlobalValues(int numIDs, const int *GIDs, const double *values)
Copy values into the vector overwriting any values that already exist for the specified indices...
static const bool value
Definition: xdr_io.C:54
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.

◆ setIgnoreNonLocalEntries()

template<typename T>
void libMesh::EpetraVector< T >::setIgnoreNonLocalEntries ( bool  flag)
inlineprivate

Set whether or not non-local data values should be ignored.

Definition at line 358 of file trilinos_epetra_vector.h.

References libMesh::EpetraVector< T >::ignoreNonLocalEntries_.

359  {
360  ignoreNonLocalEntries_ = flag;
361  }

◆ size()

template<typename T >
numeric_index_type libMesh::EpetraVector< T >::size ( ) const
inlineoverridevirtual
Returns
The size of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 735 of file trilinos_epetra_vector.h.

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

Referenced by libMesh::EpetraVector< T >::add().

736 {
737  libmesh_assert (this->initialized());
738 
739  return _vec->GlobalLength();
740 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
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:54

◆ sum()

template<typename T >
T libMesh::EpetraVector< T >::sum ( ) const
overridevirtual
Returns
The sum of all values in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 50 of file trilinos_epetra_vector.C.

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

51 {
52  libmesh_assert(this->closed());
53 
54  const unsigned int nl = _vec->MyLength();
55 
56  T sum=0.0;
57 
58  T * values = _vec->Values();
59 
60  for (unsigned int i=0; i<nl; i++)
61  sum += values[i];
62 
63  this->comm().sum(sum);
64 
65  return sum;
66 }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
void sum(T &r) const
const Parallel::Communicator & comm() const
virtual T sum() const override
libmesh_assert(ctx)
virtual bool closed() const

◆ SumIntoGlobalValues() [1/3]

template<typename T >
int libMesh::EpetraVector< T >::SumIntoGlobalValues ( int  numIDs,
const int GIDs,
const double *  values 
)
private

Accumulate values into the vector, adding them to any values that already exist for the specified indices.

Definition at line 588 of file trilinos_epetra_vector.C.

591 {
592  return( inputValues( numIDs, GIDs, values, true) );
593 }
int inputValues(int numIDs, const int *GIDs, const double *values, bool accumulate)

◆ SumIntoGlobalValues() [2/3]

template<typename T >
int libMesh::EpetraVector< T >::SumIntoGlobalValues ( const Epetra_IntSerialDenseVector &  GIDs,
const Epetra_SerialDenseVector &  values 
)
private

Accumulate values into the vector, adding them to any values that already exist for the specified GIDs.

Parameters
GIDsList of global ids. Must be the same length as the accompanying list of values.
valuesList of coefficient values. Must be the same length as the accompanying list of GIDs.

Definition at line 597 of file trilinos_epetra_vector.C.

599 {
600  if (GIDs.Length() != values.Length()) {
601  return(-1);
602  }
603 
604  return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), true) );
605 }
int inputValues(int numIDs, const int *GIDs, const double *values, bool accumulate)

◆ SumIntoGlobalValues() [3/3]

template<typename T >
int libMesh::EpetraVector< T >::SumIntoGlobalValues ( int  numIDs,
const int GIDs,
const int numValuesPerID,
const double *  values 
)
private

Definition at line 609 of file trilinos_epetra_vector.C.

613 {
614  return( inputValues( numIDs, GIDs, numValuesPerID, values, true) );
615 }
int inputValues(int numIDs, const int *GIDs, const double *values, bool accumulate)

◆ swap()

template<typename T >
void libMesh::EpetraVector< 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 819 of file trilinos_epetra_vector.h.

References libMesh::EpetraVector< T >::_destroy_vec_on_exit, libMesh::EpetraVector< T >::_map, libMesh::EpetraVector< T >::_vec, libMesh::EpetraVector< T >::allocatedNonlocalLength_, libMesh::EpetraVector< T >::ignoreNonLocalEntries_, libMesh::EpetraVector< T >::last_edit, libMesh::EpetraVector< T >::myCoefs_, libMesh::EpetraVector< T >::myFirstID_, libMesh::EpetraVector< T >::myNumIDs_, libMesh::EpetraVector< T >::nonlocalCoefs_, libMesh::EpetraVector< T >::nonlocalElementSize_, libMesh::EpetraVector< T >::nonlocalIDs_, libMesh::EpetraVector< T >::numNonlocalIDs_, and libMesh::NumericVector< T >::swap().

Referenced by libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

820 {
821  NumericVector<T>::swap(other);
822 
823  EpetraVector<T> & v = cast_ref<EpetraVector<T> &>(other);
824 
825  std::swap(_vec, v._vec);
826  _map.swap(v._map);
827  std::swap(_destroy_vec_on_exit, v._destroy_vec_on_exit);
828  std::swap(myFirstID_, v.myFirstID_);
829  std::swap(myNumIDs_, v.myNumIDs_);
830  std::swap(myCoefs_, v.myCoefs_);
831  std::swap(nonlocalIDs_, v.nonlocalIDs_);
832  std::swap(nonlocalElementSize_, v.nonlocalElementSize_);
833  std::swap(numNonlocalIDs_, v.numNonlocalIDs_);
834  std::swap(allocatedNonlocalLength_, v.allocatedNonlocalLength_);
835  std::swap(nonlocalCoefs_, v.nonlocalCoefs_);
836  std::swap(last_edit, v.last_edit);
837  std::swap(ignoreNonLocalEntries_, v.ignoreNonLocalEntries_);
838 }
std::unique_ptr< Epetra_Map > _map
Holds the distributed Map.
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
bool _destroy_vec_on_exit
This boolean value should only be set to false for the constructor which takes a Epetra Vec object...
unsigned char last_edit
Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add ...
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()

template<typename T>
Epetra_Vector* libMesh::EpetraVector< T >::vec ( )
inline
Returns
The raw Epetra_Vector pointer.
Note
This is generally not required in user-level code.
Don't do anything crazy like deleting the pointer, or very bad things will likely happen!

Definition at line 268 of file trilinos_epetra_vector.h.

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

Referenced by libMesh::EpetraMatrix< T >::get_diagonal(), and libMesh::NoxNonlinearSolver< Number >::solve().

268 { libmesh_assert(_vec); return _vec; }
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)

◆ zero()

template<typename T >
void libMesh::EpetraVector< T >::zero ( )
inlineoverridevirtual

Set all entries to zero.

Equivalent to v = 0, but more obvious and faster.

Implements libMesh::NumericVector< T >.

Definition at line 698 of file trilinos_epetra_vector.h.

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

699 {
700  libmesh_assert (this->initialized());
701  libmesh_assert (this->closed());
702 
703  _vec->PutScalar(0.0);
704 }
virtual bool initialized() const
Epetra_Vector * _vec
Actual Epetra vector datatype to hold vector entries.
libmesh_assert(ctx)
virtual bool closed() const

◆ zero_clone()

template<typename T >
std::unique_ptr< NumericVector< T > > libMesh::EpetraVector< 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 710 of file trilinos_epetra_vector.h.

References libMesh::AUTOMATIC.

Referenced by libMesh::EpetraVector< T >::add_vector().

711 {
712  std::unique_ptr<NumericVector<T>> cloned_vector =
713  std::make_unique<EpetraVector<T>>(this->comm(), AUTOMATIC);
714  cloned_vector->init(*this);
715  return cloned_vector;
716 }
const Parallel::Communicator & comm() const

Member Data Documentation

◆ _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::EpetraVector< T >::_destroy_vec_on_exit
private

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

Definition at line 286 of file trilinos_epetra_vector.h.

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

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

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

◆ _map

template<typename T>
std::unique_ptr<Epetra_Map> libMesh::EpetraVector< T >::_map
private

Holds the distributed Map.

Definition at line 280 of file trilinos_epetra_vector.h.

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

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

◆ _type

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

◆ _vec

template<typename T>
Epetra_Vector* libMesh::EpetraVector< T >::_vec
private

◆ allocatedNonlocalLength_

template<typename T>
int libMesh::EpetraVector< T >::allocatedNonlocalLength_
private

◆ ignoreNonLocalEntries_

template<typename T>
bool libMesh::EpetraVector< T >::ignoreNonLocalEntries_
private

◆ last_edit

template<typename T>
unsigned char libMesh::EpetraVector< T >::last_edit
private

Keep track of whether the last write operation on this vector was nothing (0) or a sum (1) or an add (2), so we can decide how to do the GlobalAssemble()

Definition at line 402 of file trilinos_epetra_vector.h.

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

◆ myCoefs_

template<typename T>
double* libMesh::EpetraVector< T >::myCoefs_
private

◆ myFirstID_

template<typename T>
int libMesh::EpetraVector< T >::myFirstID_
private

◆ myNumIDs_

template<typename T>
int libMesh::EpetraVector< T >::myNumIDs_
private

◆ nonlocalCoefs_

template<typename T>
double** libMesh::EpetraVector< T >::nonlocalCoefs_
private

◆ nonlocalElementSize_

template<typename T>
int* libMesh::EpetraVector< T >::nonlocalElementSize_
private

◆ nonlocalIDs_

template<typename T>
int* libMesh::EpetraVector< T >::nonlocalIDs_
private

◆ numNonlocalIDs_

template<typename T>
int libMesh::EpetraVector< T >::numNonlocalIDs_
private

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