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

This class provides a nice interface to the Laspack C-based data structures for serial vectors. More...

#include <laspack_matrix.h>

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

Public Member Functions

 LaspackVector (const Parallel::Communicator &comm, const ParallelType=AUTOMATIC)
 Dummy-Constructor. More...
 
 LaspackVector (const Parallel::Communicator &comm, const numeric_index_type n, const ParallelType=AUTOMATIC)
 Constructor. More...
 
 LaspackVector (const Parallel::Communicator &comm, const numeric_index_type n, const numeric_index_type n_local, const ParallelType=AUTOMATIC)
 Constructor. More...
 
 LaspackVector (const Parallel::Communicator &comm, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType=AUTOMATIC)
 Constructor. More...
 
LaspackVector< T > & operator= (const LaspackVector< T > &v)
 Copy assignment operator. More...
 
 LaspackVector (LaspackVector &&)=delete
 This class manages a C-style struct (QVector) manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor. More...
 
 LaspackVector (const LaspackVector &)=delete
 
LaspackVectoroperator= (LaspackVector &&)=delete
 
virtual ~LaspackVector ()
 
virtual void close () override
 Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across processors. More...
 
virtual void clear () override
 Restores the NumericVector<T> to a pristine state. 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 ptype=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 ptype=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 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 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 pointwise_divide (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
 Computes \( u_i \leftarrow \frac{v_{1,i}}{v_{2,i}} \) (summation not implied) i.e. More...
 
virtual void swap (NumericVector< T > &v) override
 Swaps the contents of this with v. More...
 
virtual std::size_t max_allowed_id () const override
 
virtual bool initialized () const
 
ParallelType type () const
 
ParallelTypetype ()
 
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
 
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...
 
virtual void add_vector (const T *v, const std::vector< numeric_index_type > &dof_indices)
 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...
 
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...
 
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. More...
 
void insert (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)
 Inserts the entries of v in *this at the locations specified by v. More...
 
void insert (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
 Inserts the entries of v in *this at the locations specified by v. More...
 
void insert (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
 Inserts the entries of v in *this at the locations specified by v. More...
 
void insert (const DenseSubVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
 Inserts the entries of v in *this at the locations specified by v. More...
 
virtual int compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
 
virtual int local_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
 
virtual int global_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
 
virtual void print (std::ostream &os=libMesh::out) const
 Prints the local contents of the vector, by default to libMesh::out. More...
 
template<>
void print (std::ostream &os) const
 
virtual void print_global (std::ostream &os=libMesh::out) const
 Prints the global contents of the vector, by default to libMesh::out. More...
 
template<>
void print_global (std::ostream &os) const
 
virtual void print_matlab (const std::string &="") const
 Print the contents of the vector in Matlab's sparse matrix format. More...
 
virtual void create_subvector (NumericVector< T > &, const std::vector< numeric_index_type > &) const
 Fills in subvector from 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, const SolverPackage solver_package=libMesh::default_solver_package())
 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 Attributes

QVector _vec
 Actual Laspack vector datatype to hold vector entries. More...
 

Friends

class LaspackLinearSolver< T >
 Make other Laspack datatypes friends. More...
 

Detailed Description

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

This class provides a nice interface to the Laspack C-based data structures for serial vectors.

All overridden virtual functions are documented in numeric_vector.h.

Author
Benjamin S. Kirk
Date
2002

Definition at line 42 of file laspack_matrix.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

◆ LaspackVector() [1/6]

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

Dummy-Constructor.

Dimension=0

Definition at line 256 of file laspack_vector.h.

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

258  : NumericVector<T>(comm, ptype)
259 {
260  this->_type = ptype;
261 }
const Parallel::Communicator & comm() const
ParallelType _type
Type of vector.

◆ LaspackVector() [2/6]

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

Constructor.

Set dimension to n and initialize all elements with zero.

Definition at line 267 of file laspack_vector.h.

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

270  : NumericVector<T>(comm, ptype)
271 {
272  this->init(n, n, false, ptype);
273 }
virtual void init(const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
Change the dimension of the vector to n.
const Parallel::Communicator & comm() const

◆ LaspackVector() [3/6]

template<typename T >
libMesh::LaspackVector< T >::LaspackVector ( const Parallel::Communicator comm,
const numeric_index_type  n,
const numeric_index_type  n_local,
const ParallelType  ptype = AUTOMATIC 
)
inline

Constructor.

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

Definition at line 279 of file laspack_vector.h.

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

283  : NumericVector<T>(comm, ptype)
284 {
285  this->init(n, n_local, false, ptype);
286 }
virtual void init(const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
Change the dimension of the vector to n.
const Parallel::Communicator & comm() const

◆ LaspackVector() [4/6]

template<typename T >
libMesh::LaspackVector< T >::LaspackVector ( const Parallel::Communicator comm,
const numeric_index_type  N,
const numeric_index_type  n_local,
const std::vector< numeric_index_type > &  ghost,
const ParallelType  ptype = 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 292 of file laspack_vector.h.

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

297  : NumericVector<T>(comm, ptype)
298 {
299  this->init(N, n_local, ghost, false, ptype);
300 }
virtual void init(const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
Change the dimension of the vector to n.
const Parallel::Communicator & comm() const

◆ LaspackVector() [5/6]

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

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

◆ LaspackVector() [6/6]

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

◆ ~LaspackVector()

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

Definition at line 306 of file laspack_vector.h.

307 {
308  this->clear ();
309 }
virtual void clear() override
Restores the NumericVector<T> to a pristine state.

Member Function Documentation

◆ abs()

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

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

Implements libMesh::NumericVector< T >.

Definition at line 298 of file laspack_vector.C.

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

299 {
300  libmesh_assert (this->initialized());
301 
302  const numeric_index_type n = this->size();
303 
304  for (numeric_index_type i=0; i!=n; ++i)
305  this->set(i,std::abs((*this)(i)));
306 }
virtual numeric_index_type size() const override
virtual bool initialized() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)

◆ add() [1/4]

template<typename T >
void libMesh::LaspackVector< T >::add ( const numeric_index_type  i,
const T  value 
)
inlineoverridevirtual

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 519 of file laspack_vector.h.

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

520 {
521  libmesh_assert (this->initialized());
522  libmesh_assert_less (i, this->size());
523 
524  std::scoped_lock lock(this->_numeric_vector_mutex);
525  V_AddCmp (&_vec, i+1, value);
526 
527 #ifndef NDEBUG
528  this->_is_closed = false;
529 #endif
530 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
virtual numeric_index_type size() const override
virtual bool initialized() const
libmesh_assert(ctx)
static const bool value
Definition: xdr_io.C:54
QVector _vec
Actual Laspack 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() [2/4]

template<typename T >
void libMesh::LaspackVector< 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 211 of file laspack_vector.C.

212 {
213 #ifndef NDEBUG
214  const bool was_closed = this->_is_closed;
215 #endif
216 
217  const numeric_index_type n = this->size();
218 
219  for (numeric_index_type i=0; i<n; i++)
220  this->add (i, v);
221 
222  // This is an embarrassingly parallel method, but set() isn't in
223  // general so set() overzealously marked us as non-closed
224 #ifndef NDEBUG
225  this->_is_closed = was_closed;
226 #endif
227 }
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
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::LaspackVector< 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 233 of file laspack_vector.C.

234 {
235  this->add (1., v);
236 }
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::LaspackVector< 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 241 of file laspack_vector.C.

References libMesh::libmesh_assert(), libMesh::make_range(), and libMesh::LaspackVector< T >::size().

242 {
243  // Make sure the vector passed in is really a LaspackVector
244  const LaspackVector * v = cast_ptr<const LaspackVector *>(&v_in);
245 
246 #ifndef NDEBUG
247  const bool was_closed = this->_is_closed;
248 #endif
249 
250  libmesh_assert(v);
251  libmesh_assert_equal_to (this->size(), v->size());
252 
253  for (auto i : make_range(v->size()))
254  this->add (i, a*(*v)(i));
255 
256 #ifndef NDEBUG
257  this->_is_closed = was_closed;
258 #endif
259 }
virtual numeric_index_type size() const override
LaspackVector(const Parallel::Communicator &comm, const ParallelType=AUTOMATIC)
Dummy-Constructor.
virtual void add(const numeric_index_type i, const T value) override
Adds value to the vector entry specified by i.
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:134
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ add_vector() [1/6]

template<typename T >
void libMesh::LaspackVector< 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 264 of file laspack_vector.C.

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

266 {
267  // Make sure the data passed in are really in Laspack types
268  const LaspackVector<T> * vec = cast_ptr<const LaspackVector<T> *>(&vec_in);
269  const LaspackMatrix<T> * mat = cast_ptr<const LaspackMatrix<T> *>(&mat_in);
270 
271  libmesh_assert(vec);
272  libmesh_assert(mat);
273 
274  // += mat*vec
275  AddAsgn_VV (&_vec, Mul_QV(const_cast<QMatrix*>(&mat->_QMat),
276  const_cast<QVector*>(&vec->_vec)));
277 }
libmesh_assert(ctx)
QVector _vec
Actual Laspack vector datatype to hold vector entries.

◆ add_vector() [2/6]

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

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

Definition at line 379 of file numeric_vector.C.

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector(), assemble(), LinearElasticity::assemble(), HDGProblem::assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), assemble_biharmonic(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_laplace(), assemble_matrix_and_rhs(), assemble_poisson(), assemble_shell(), assemble_stokes(), assemble_wave(), libMesh::LinearImplicitSystem::assembly(), assembly_with_dg_fem_context(), compute_residual(), periodic_bc_test_poisson(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), Biharmonic::JR::residual_and_jacobian(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::NewmarkSystem::update_rhs(), and libMesh::SparseMatrix< ValOut >::vector_mult_add().

381 {
382  libmesh_assert(v);
383 
384  for (auto i : index_range(dof_indices))
385  this->add (dof_indices[i], v[i]);
386 }
libmesh_assert(ctx)
virtual void add(const numeric_index_type i, const T value)=0
Adds value to the vector entry specified by i.
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:111

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

900 {
901  libmesh_assert(v.size() == dof_indices.size());
902  if (!v.empty())
903  this->add_vector(v.data(), dof_indices);
904 }
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 391 of file numeric_vector.C.

393 {
394  libmesh_assert(v.readable());
395 
396  const std::size_t n = dof_indices.size();
397  libmesh_assert_equal_to(v.size(), n);
398  for (numeric_index_type i=0; i != n; i++)
399  this->add (dof_indices[i], v(i));
400 }
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 910 of file numeric_vector.h.

912 {
913  libmesh_assert(v.size() == dof_indices.size());
914  if (!v.empty())
915  this->add_vector(&v(0), dof_indices);
916 }
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 405 of file numeric_vector.C.

407 {
408  libmesh_assert(this->compatible(v));
409 
410  a.vector_mult_add(*this,v);
411 }
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const

◆ add_vector_transpose()

template<typename T >
void libMesh::LaspackVector< 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 281 of file laspack_vector.C.

283 {
284  libmesh_not_implemented();
285 }

◆ build()

template<typename T >
std::unique_ptr< NumericVector< T > > libMesh::NumericVector< T >::build ( const Parallel::Communicator comm,
const SolverPackage  solver_package = libMesh::default_solver_package() 
)
staticinherited

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

Definition at line 50 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::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(), 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(), 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().

51 {
52  // Build the appropriate vector
53  switch (solver_package)
54  {
55 
56 #ifdef LIBMESH_HAVE_LASPACK
57  case LASPACK_SOLVERS:
58  return std::make_unique<LaspackVector<T>>(comm, AUTOMATIC);
59 #endif
60 
61 #ifdef LIBMESH_HAVE_PETSC
62  case PETSC_SOLVERS:
63  return std::make_unique<PetscVector<T>>(comm, AUTOMATIC);
64 #endif
65 
66 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
67  case TRILINOS_SOLVERS:
68  return std::make_unique<EpetraVector<T>>(comm, AUTOMATIC);
69 #endif
70 
71 #ifdef LIBMESH_HAVE_EIGEN
72  case EIGEN_SOLVERS:
73  return std::make_unique<EigenSparseVector<T>>(comm, AUTOMATIC);
74 #endif
75 
76  default:
77  return std::make_unique<DistributedVector<T>>(comm, AUTOMATIC);
78  }
79 }
const Parallel::Communicator & comm() const

◆ clear()

template<typename T >
void libMesh::LaspackVector< T >::clear ( )
inlineoverridevirtual

Restores the NumericVector<T> to a pristine state.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 402 of file laspack_vector.h.

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

403 {
404  if (this->initialized())
405  {
406  V_Destr (&_vec);
407  }
408 
409  this->_is_initialized = false;
410 #ifndef NDEBUG
411  this->_is_closed = false;
412 #endif
413 }
virtual bool initialized() const
bool _is_initialized
true once init() has been called.
QVector _vec
Actual Laspack 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...

◆ clone()

template<typename T >
std::unique_ptr< NumericVector< T > > libMesh::LaspackVector< 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 443 of file laspack_vector.h.

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

444 {
445  NumericVector<T> * cloned_vector = new LaspackVector<T>(this->comm());
446 
447  cloned_vector->init(*this, true);
448 
449  *cloned_vector = *this;
450 
451  return std::unique_ptr<NumericVector<T>>(cloned_vector);
452 }
const Parallel::Communicator & comm() const

◆ close()

template<typename T >
void libMesh::LaspackVector< 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 389 of file laspack_vector.h.

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

390 {
391  libmesh_assert (this->initialized());
392 
393 #ifndef NDEBUG
394  this->_is_closed = true;
395 #endif
396 }
virtual bool initialized() const
libmesh_assert(ctx)
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 164 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=().

164 { 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::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< 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::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::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), 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::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< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), libMesh::DofMap::distribute_dofs(), 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::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::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_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_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::DofMap::n_constrained_dofs(), 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::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::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::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(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), 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(), 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::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 109 of file numeric_vector.C.

111 {
112  libmesh_assert(this->compatible(other_vector));
113 
114  int first_different_i = std::numeric_limits<int>::max();
116 
117  while (first_different_i==std::numeric_limits<int>::max()
118  && i<last_local_index())
119  {
120  if (std::abs((*this)(i) - other_vector(i)) > threshold)
121  first_different_i = i;
122  else
123  i++;
124  }
125 
126  // Find the correct first differing index in parallel
127  this->comm().min(first_different_i);
128 
129  if (first_different_i == std::numeric_limits<int>::max())
130  return -1;
131 
132  return first_different_i;
133 }
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
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 423 of file numeric_vector.C.

424 {
425  return this->readable() && v.readable() &&
426  this->size() == v.size() &&
427  this->local_size() == v.local_size() &&
428  this->first_local_index() == v.first_local_index() &&
429  this->last_local_index() == v.last_local_index();
430 }
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::LaspackVector< T >::conjugate ( )
overridevirtual

Negates the imaginary component of each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 187 of file laspack_vector.C.

References libMesh::libmesh_conj().

188 {
189  const numeric_index_type n = this->size();
190 
191 #ifndef NDEBUG
192  const bool was_closed = this->_is_closed;
193 #endif
194 
195  for (numeric_index_type i=0; i<n; i++)
196  {
197  T v = (*this)(i);
198 
199  this->set(i, libmesh_conj(v) );
200  }
201 
202  // This is an embarrassingly parallel method, but set() isn't in
203  // general so set() overzealously marked us as non-closed
204 #ifndef NDEBUG
205  this->_is_closed = was_closed;
206 #endif
207 }
T libmesh_conj(T a)
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ create_subvector()

template<typename T>
virtual void libMesh::NumericVector< T >::create_subvector ( NumericVector< T > &  ,
const std::vector< numeric_index_type > &   
) 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.

Reimplemented in libMesh::PetscVector< T >, and libMesh::EpetraVector< T >.

Definition at line 725 of file numeric_vector.h.

727  {
728  libmesh_not_implemented();
729  }

◆ 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::LaspackVector< 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 309 of file laspack_vector.C.

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

310 {
311  libmesh_assert (this->initialized());
312 
313  // Make sure the NumericVector passed in is really a LaspackVector
314  const LaspackVector<T> * v = cast_ptr<const LaspackVector<T> *>(&v_in);
315  libmesh_assert(v);
316 
317  return Mul_VV (const_cast<QVector*>(&(this->_vec)),
318  const_cast<QVector*>(&(v->_vec)));
319 }
virtual bool initialized() const
libmesh_assert(ctx)
QVector _vec
Actual Laspack 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 351 of file numeric_vector.h.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ first_local_index()

template<typename T >
numeric_index_type libMesh::LaspackVector< 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 480 of file laspack_vector.h.

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

481 {
482  libmesh_assert (this->initialized());
483 
484  return 0;
485 }
virtual bool initialized() const
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 869 of file numeric_vector.h.

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

871 {
872  const std::size_t num = index.size();
873  for (std::size_t i=0; i<num; i++)
874  {
875  values[i] = (*this)(index[i]);
876  }
877 }

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

885 {
886  const std::size_t num = index.size();
887  values.resize(num);
888  if (!num)
889  return;
890 
891  this->get(index, values.data());
892 }

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

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

169 {
170  libmesh_assert(this->compatible(other_vector));
171 
172  int first_different_i = std::numeric_limits<int>::max();
174 
175  const Real my_norm = this->linfty_norm();
176  const Real other_norm = other_vector.linfty_norm();
177  const Real abs_threshold = std::max(my_norm, other_norm) * threshold;
178 
179  do
180  {
181  if (std::abs((*this)(i) - other_vector(i) ) > abs_threshold)
182  first_different_i = i;
183  else
184  i++;
185  }
186  while (first_different_i==std::numeric_limits<int>::max()
187  && i<last_local_index());
188 
189  // Find the correct first differing index in parallel
190  this->comm().min(first_different_i);
191 
192  if (first_different_i == std::numeric_limits<int>::max())
193  return -1;
194 
195  return first_different_i;
196 }
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
void min(const T &r, T &o, Request &req) const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
bool compatible(const NumericVector< T > &v) const
virtual numeric_index_type first_local_index() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual numeric_index_type last_local_index() const =0
virtual Real linfty_norm() const =0

◆ increment_constructor_count()

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ init() [1/4]

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

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

Referenced by libMesh::LaspackVector< T >::LaspackVector().

◆ init() [2/4]

template<typename T >
void libMesh::LaspackVector< 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 354 of file laspack_vector.h.

References libMesh::TriangleWrapper::init().

357 {
358  this->init(n,n,fast,ptype);
359 }
virtual void init(const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
Change the dimension of the vector to n.

◆ init() [3/4]

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

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

Implements libMesh::NumericVector< T >.

◆ init() [4/4]

template<class T >
void libMesh::LaspackVector< 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 379 of file laspack_vector.h.

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

381 {
382  this->init(other.size(),other.local_size(),fast,other.type());
383 }
virtual void init(const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=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 148 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().

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

◆ insert() [1/5]

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

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

Note that library implementations of this method are thread safe

Reimplemented in libMesh::PetscVector< T >, and libMesh::EpetraVector< T >.

Definition at line 84 of file numeric_vector.C.

Referenced by Biharmonic::JR::bounds().

86 {
87  libmesh_assert (v);
88 
89  for (auto i : index_range(dof_indices))
90  this->set (dof_indices[i], v[i]);
91 }
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:111

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

924 {
925  libmesh_assert(v.size() == dof_indices.size());
926  if (!v.empty())
927  this->insert(v.data(), dof_indices);
928 }
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 96 of file numeric_vector.C.

98 {
99  libmesh_assert_equal_to (V.size(), dof_indices.size());
100  libmesh_assert (V.readable());
101 
102  for (auto i : index_range(dof_indices))
103  this->set (dof_indices[i], V(i));
104 }
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:111

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

936 {
937  libmesh_assert(v.size() == dof_indices.size());
938  if (!v.empty())
939  this->insert(&v(0), dof_indices);
940 }
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 946 of file numeric_vector.h.

948 {
949  libmesh_assert(v.size() == dof_indices.size());
950  if (!v.empty())
951  this->insert(&v(0), dof_indices);
952 }
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::LaspackVector< 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 54 of file laspack_vector.C.

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

55 {
56  libmesh_assert (this->closed());
57 
58  return static_cast<Real>(l1Norm_V(const_cast<QVector*>(&_vec)));
59 }
libmesh_assert(ctx)
virtual bool closed() const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
QVector _vec
Actual Laspack vector datatype to hold vector entries.

◆ l2_norm()

template<typename T >
Real libMesh::LaspackVector< 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 64 of file laspack_vector.C.

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

65 {
66  libmesh_assert (this->closed());
67 
68  return static_cast<Real>(l2Norm_V(const_cast<QVector*>(&_vec)));
69 }
libmesh_assert(ctx)
virtual bool closed() const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
QVector _vec
Actual Laspack vector datatype to hold vector entries.

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

364 {
365  libmesh_assert(this->compatible(v));
366 
367  Real norm = 0;
368  for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
369  norm += TensorTools::norm_sq((*this)(i) - v(i));
370 
371  this->comm().sum(norm);
372 
373  return std::sqrt(norm);
374 }
void sum(T &r) const
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > sqrt(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:53
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:134
virtual numeric_index_type last_local_index() const =0

◆ last_local_index()

template<typename T >
numeric_index_type libMesh::LaspackVector< 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 491 of file laspack_vector.h.

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

492 {
493  libmesh_assert (this->initialized());
494 
495  return this->size();
496 }
virtual numeric_index_type size() const override
virtual bool initialized() const
libmesh_assert(ctx)

◆ linfty_norm()

template<typename T >
Real libMesh::LaspackVector< 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 74 of file laspack_vector.C.

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

75 {
76  libmesh_assert (this->closed());
77 
78  return static_cast<Real>(MaxNorm_V(const_cast<QVector*>(&_vec)));
79 }
libmesh_assert(ctx)
virtual bool closed() const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
QVector _vec
Actual Laspack vector datatype to hold vector entries.

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

139 {
140  libmesh_assert(this->compatible(other_vector));
141 
142  int first_different_i = std::numeric_limits<int>::max();
144 
145  do
146  {
147  if (std::abs((*this)(i) - other_vector(i)) > threshold *
148  std::max(std::abs((*this)(i)), std::abs(other_vector(i))))
149  first_different_i = i;
150  else
151  i++;
152  }
153  while (first_different_i==std::numeric_limits<int>::max()
154  && i<last_local_index());
155 
156  // Find the correct first differing index in parallel
157  this->comm().min(first_different_i);
158 
159  if (first_different_i == std::numeric_limits<int>::max())
160  return -1;
161 
162  return first_different_i;
163 }
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
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::LaspackVector< 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 469 of file laspack_vector.h.

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

470 {
471  libmesh_assert (this->initialized());
472 
473  return this->size();
474 }
virtual numeric_index_type size() const override
virtual bool initialized() const
libmesh_assert(ctx)

◆ localize() [1/5]

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

References libMesh::index_range().

458 {
459  v_local.resize(this->size());
460 
461  for (auto i : index_range(v_local))
462  v_local[i] = (*this)(i);
463 }
virtual numeric_index_type size() const override
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:111

◆ localize() [2/5]

template<typename T >
void libMesh::LaspackVector< 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 396 of file laspack_vector.C.

References libMesh::libmesh_assert().

397 {
398  // Make sure the NumericVector passed in is really a LaspackVector
399  LaspackVector<T> * v_local =
400  cast_ptr<LaspackVector<T> *>(&v_local_in);
401 
402  libmesh_assert(v_local);
403 
404  *v_local = *this;
405 }
libmesh_assert(ctx)

◆ localize() [3/5]

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

◆ localize() [4/5]

template<typename T >
void libMesh::LaspackVector< 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 426 of file laspack_vector.C.

References libMesh::index_range().

428 {
429  // LaspackVectors are serial, so we can just copy values
430  v_local.resize(indices.size());
431 
432  for (auto i : index_range(v_local))
433  v_local[i] = (*this)(indices[i]);
434 }
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:111

◆ localize() [5/5]

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

◆ localize_to_one()

template<typename T>
void libMesh::LaspackVector< 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 468 of file laspack_vector.C.

470 {
471  libmesh_assert_equal_to (pid, 0);
472 
473  this->localize (v_local);
474 }
virtual void localize(std::vector< T > &v_local) const override
Creates a copy of the global vector in the local vector v_local.

◆ max()

template<typename T >
Real libMesh::LaspackVector< T >::max ( ) const
overridevirtual
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 493 of file laspack_vector.C.

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

494 {
495  libmesh_assert (this->initialized());
496  if (!this->size())
497  return -std::numeric_limits<Real>::max();
498 
499  Real the_max = libmesh_real((*this)(0));
500 
501  const numeric_index_type n = this->size();
502 
503  for (numeric_index_type i=1; i<n; i++)
504  the_max = std::max (the_max, libmesh_real((*this)(i)));
505 
506  return the_max;
507 }
T libmesh_real(T a)
virtual numeric_index_type size() const override
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ max_allowed_id()

template<typename T >
std::size_t libMesh::LaspackVector< 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 573 of file laspack_vector.h.

574 {
575  // The QVector type declares a "size_t Dim;"
576  return std::numeric_limits<std::size_t>::max();
577 }

◆ min()

template<typename T >
Real libMesh::LaspackVector< T >::min ( ) const
overridevirtual
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 512 of file laspack_vector.C.

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

513 {
514  libmesh_assert (this->initialized());
515  if (!this->size())
516  return std::numeric_limits<Real>::max();
517 
518  Real the_min = libmesh_real((*this)(0));
519 
520  const numeric_index_type n = this->size();
521 
522  for (numeric_index_type i=1; i<n; i++)
523  the_min = std::min (the_min, libmesh_real((*this)(i)));
524 
525  return the_min;
526 }
T libmesh_real(T a)
virtual numeric_index_type size() const override
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ n_objects()

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

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

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

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::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::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::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_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::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::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::LaspackVector< 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 536 of file laspack_vector.h.

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

537 {
538  libmesh_assert (this->initialized());
539  libmesh_assert ( ((i >= this->first_local_index()) &&
540  (i < this->last_local_index())) );
541 
542 
543  return static_cast<T>(V_GetCmp(const_cast<QVector*>(&_vec), i+1));
544 }
virtual bool initialized() const
libmesh_assert(ctx)
virtual numeric_index_type last_local_index() const override
virtual numeric_index_type first_local_index() const override
QVector _vec
Actual Laspack vector datatype to hold vector entries.

◆ operator*=() [1/2]

template<typename T >
NumericVector< T > & libMesh::LaspackVector< 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 109 of file laspack_vector.C.

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

110 {
111  libmesh_assert_equal_to(size(), v.size());
112 
113 #ifndef NDEBUG
114  const bool was_closed = this->_is_closed;
115 #endif
116 
117  const numeric_index_type n = this->size();
118 
119  for (numeric_index_type i=0; i<n; i++)
120  this->set(i, (*this)(i) * v(i));
121 
122  // This is an embarrassingly parallel method, but set() isn't in
123  // general so set() overzealously marked us as non-closed
124 #ifndef NDEBUG
125  this->_is_closed = was_closed;
126 #endif
127 
128  return *this;
129 }
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

396 { 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::LaspackVector< 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 84 of file laspack_vector.C.

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

85 {
86  libmesh_assert (this->closed());
87 
88  this->add(1., v);
89 
90  return *this;
91 }
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::LaspackVector< 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 97 of file laspack_vector.C.

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

98 {
99  libmesh_assert (this->closed());
100 
101  this->add(-1., v);
102 
103  return *this;
104 }
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::LaspackVector< 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 134 of file laspack_vector.C.

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

135 {
136  libmesh_assert_equal_to(size(), v.size());
137 
138 #ifndef NDEBUG
139  const bool was_closed = this->_is_closed;
140 #endif
141 
142  const numeric_index_type n = this->size();
143 
144  for (numeric_index_type i=0; i<n; i++)
145  this->set(i, (*this)(i) / v(i));
146 
147  // This is an embarrassingly parallel method, but set() isn't in
148  // general so set() overzealously marked us as non-closed
149 #ifndef NDEBUG
150  this->_is_closed = was_closed;
151 #endif
152 
153  return *this;
154 }
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

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

414 { 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 >
LaspackVector< T > & libMesh::LaspackVector< T >::operator= ( const LaspackVector< T > &  v)

Copy assignment operator.

Calls Asgn_VV() to assign the contents of one vector to another.

Returns
A reference to *this as the derived type.

Definition at line 356 of file laspack_vector.C.

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

357 {
358  libmesh_assert (this->initialized());
359  libmesh_assert (v.closed());
360  libmesh_assert_equal_to (this->size(), v.size());
361 
362  if (v.size() != 0)
363  Asgn_VV (const_cast<QVector*>(&_vec),
364  const_cast<QVector*>(&v._vec)
365  );
366 
367 #ifndef NDEBUG
368  this->_is_closed = true;
369 #endif
370 
371  return *this;
372 }
virtual numeric_index_type size() const override
virtual bool initialized() const
libmesh_assert(ctx)
QVector _vec
Actual Laspack 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...

◆ operator=() [2/5]

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

◆ operator=() [3/5]

template<typename T >
NumericVector< T > & libMesh::LaspackVector< 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 325 of file laspack_vector.C.

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

326 {
327  libmesh_assert (this->initialized());
328  libmesh_assert (this->closed());
329 
330  V_SetAllCmp (&_vec, s);
331 
332  return *this;
333 }
virtual bool initialized() const
libmesh_assert(ctx)
virtual bool closed() const
QVector _vec
Actual Laspack vector datatype to hold vector entries.

◆ operator=() [4/5]

template<typename T >
NumericVector< T > & libMesh::LaspackVector< 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 339 of file laspack_vector.C.

References libMesh::libmesh_assert().

340 {
341  // Make sure the NumericVector passed in is really a LaspackVector
342  const LaspackVector<T> * v =
343  cast_ptr<const LaspackVector<T> *>(&v_in);
344 
345  libmesh_assert(v);
346 
347  *this = *v;
348 
349  return *this;
350 }
libmesh_assert(ctx)

◆ operator=() [5/5]

template<typename T >
NumericVector< T > & libMesh::LaspackVector< 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.

Implements libMesh::NumericVector< T >.

Definition at line 378 of file laspack_vector.C.

References libMesh::index_range().

379 {
384  if (this->size() == v.size())
385  for (auto i : index_range(v))
386  this->set (i, v[i]);
387 
388  else
389  libmesh_error_msg("this->size() = " << this->size() << " must be equal to v.size() = " << v.size());
390 
391  return *this;
392 }
virtual numeric_index_type size() const override
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:111

◆ pointwise_divide()

template<typename T >
void libMesh::LaspackVector< T >::pointwise_divide ( const NumericVector< T > &  vec1,
const NumericVector< T > &  vec2 
)
overridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 486 of file laspack_vector.C.

488 {
489  libmesh_not_implemented();
490 }

◆ pointwise_mult()

template<typename T >
void libMesh::LaspackVector< 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 479 of file laspack_vector.C.

481 {
482  libmesh_not_implemented();
483 }

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

980 {
981  libmesh_assert (this->initialized());
982  os << "Size\tglobal = " << this->size()
983  << "\t\tlocal = " << this->local_size() << std::endl;
984 
985  os << "#\tValue" << std::endl;
986  for (auto i : index_range(*this))
987  os << i << "\t" << (*this)(i) << std::endl;
988 }
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:111

◆ print() [2/2]

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

Definition at line 961 of file numeric_vector.h.

962 {
963  libmesh_assert (this->initialized());
964  os << "Size\tglobal = " << this->size()
965  << "\t\tlocal = " << this->local_size() << std::endl;
966 
967  // std::complex<>::operator<<() is defined, but use this form
968  os << "#\tReal part\t\tImaginary part" << std::endl;
969  for (auto i : index_range(*this))
970  os << i << "\t"
971  << (*this)(i).real() << "\t\t"
972  << (*this)(i).imag() << std::endl;
973 }
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:111

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

1017 {
1018  libmesh_assert (this->initialized());
1019 
1020  std::vector<T> v(this->size());
1021  this->localize(v);
1022 
1023  // Right now we only want one copy of the output
1024  if (this->processor_id())
1025  return;
1026 
1027  os << "Size\tglobal = " << this->size() << std::endl;
1028  os << "#\tValue" << std::endl;
1029  for (auto i : make_range(v.size()))
1030  os << i << "\t" << v[i] << std::endl;
1031 }
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:134
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 994 of file numeric_vector.h.

995 {
996  libmesh_assert (this->initialized());
997 
998  std::vector<Complex> v(this->size());
999  this->localize(v);
1000 
1001  // Right now we only want one copy of the output
1002  if (this->processor_id())
1003  return;
1004 
1005  os << "Size\tglobal = " << this->size() << std::endl;
1006  os << "#\tReal part\t\tImaginary part" << std::endl;
1007  for (auto i : make_range(v.size()))
1008  os << i << "\t"
1009  << v[i].real() << "\t\t"
1010  << v[i].imag() << std::endl;
1011 }
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:134
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>
virtual void libMesh::NumericVector< T >::print_matlab ( const std::string &  = "") const
inlinevirtualinherited

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

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

715  {
716  libmesh_not_implemented();
717  }

◆ 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::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_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::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::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::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(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), 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::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::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::SparsityPattern::Build::operator()(), 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::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::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::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), 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

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

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

417 {
418  return this->initialized() && this->closed();
419 }
virtual bool initialized() const
virtual bool closed() const

◆ reciprocal()

template<typename T >
void libMesh::LaspackVector< T >::reciprocal ( )
overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 159 of file laspack_vector.C.

160 {
161  const numeric_index_type n = this->size();
162 
163 #ifndef NDEBUG
164  const bool was_closed = this->_is_closed;
165 #endif
166 
167  for (numeric_index_type i=0; i<n; i++)
168  {
169  T v = (*this)(i);
170 
171  // Don't divide by zero!
172  libmesh_assert_not_equal_to (v, T(0));
173 
174  this->set(i, 1. / v);
175  }
176 
177  // This is an embarrassingly parallel method, but set() isn't in
178  // general so set() overzealously marked us as non-closed
179 #ifndef NDEBUG
180  this->_is_closed = was_closed;
181 #endif
182 }
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
bool _is_closed
Flag which tracks whether the vector&#39;s values are consistent on all processors after insertion or add...

◆ scale()

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

Scale each element of the vector by the given factor.

Implements libMesh::NumericVector< T >.

Definition at line 290 of file laspack_vector.C.

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

291 {
292  libmesh_assert (this->initialized());
293 
294  Asgn_VV(&_vec, Mul_SV (factor, &_vec));
295 }
virtual bool initialized() const
libmesh_assert(ctx)
QVector _vec
Actual Laspack vector datatype to hold vector entries.

◆ set()

template<typename T >
void libMesh::LaspackVector< T >::set ( const numeric_index_type  i,
const T  value 
)
inlineoverridevirtual

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 502 of file laspack_vector.h.

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

503 {
504  libmesh_assert (this->initialized());
505  libmesh_assert_less (i, this->size());
506 
507  std::scoped_lock lock(this->_numeric_vector_mutex);
508  V_SetCmp (&_vec, i+1, value);
509 
510 #ifndef NDEBUG
511  this->_is_closed = false;
512 #endif
513 }
std::mutex _numeric_vector_mutex
Mutex for performing thread-safe operations.
virtual numeric_index_type size() const override
virtual bool initialized() const
libmesh_assert(ctx)
static const bool value
Definition: xdr_io.C:54
QVector _vec
Actual Laspack 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...

◆ size()

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

Implements libMesh::NumericVector< T >.

Definition at line 458 of file laspack_vector.h.

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

Referenced by libMesh::LaspackVector< T >::add(), and libMesh::LaspackVector< T >::operator=().

459 {
460  libmesh_assert (this->initialized());
461 
462  return static_cast<numeric_index_type>(V_GetDim(const_cast<QVector*>(&_vec)));
463 }
virtual bool initialized() const
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
QVector _vec
Actual Laspack vector datatype to hold vector entries.

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

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

307 {
308  libmesh_assert (this->readable());
309 
310  const NumericVector<T> & v = *this;
311 
312  Real norm = 0;
313 
314  for (const auto & index : indices)
315  norm += std::abs(v(index));
316 
317  this->comm().sum(norm);
318 
319  return norm;
320 }
void sum(T &r) const
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
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 323 of file numeric_vector.C.

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

324 {
325  libmesh_assert (this->readable());
326 
327  const NumericVector<T> & v = *this;
328 
329  Real norm = 0;
330 
331  for (const auto & index : indices)
332  norm += TensorTools::norm_sq(v(index));
333 
334  this->comm().sum(norm);
335 
336  return std::sqrt(norm);
337 }
void sum(T &r) const
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > sqrt(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:53
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 340 of file numeric_vector.C.

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

341 {
342  libmesh_assert (this->readable());
343 
344  const NumericVector<T> & v = *this;
345 
346  Real norm = 0;
347 
348  for (const auto & index : indices)
349  {
350  Real value = std::abs(v(index));
351  if (value > norm)
352  norm = value;
353  }
354 
355  this->comm().max(norm);
356 
357  return norm;
358 }
const Parallel::Communicator & comm() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
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::LaspackVector< T >::sum ( ) const
overridevirtual
Returns
The sum of all values in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 37 of file laspack_vector.C.

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

38 {
39  libmesh_assert (this->closed());
40 
41  T _sum = 0;
42 
43  const numeric_index_type n = this->size();
44 
45  for (numeric_index_type i=0; i!=n; ++i)
46  _sum += (*this)(i);
47 
48  return _sum;
49 }
virtual numeric_index_type size() const override
dof_id_type numeric_index_type
Definition: id_types.h:99
libmesh_assert(ctx)
virtual bool closed() const

◆ swap()

template<typename T >
void libMesh::LaspackVector< 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 550 of file laspack_vector.h.

551 {
552  LaspackVector<T> & v = cast_ref<LaspackVector<T> &>(other);
553 
554  // This is all grossly dependent on Laspack version...
555 
556  std::swap(_vec.Name, v._vec.Name);
557  std::swap(_vec.Dim, v._vec.Dim);
558  std::swap(_vec.Instance, v._vec.Instance);
559  std::swap(_vec.LockLevel, v._vec.LockLevel);
560  std::swap(_vec.Multipl, v._vec.Multipl);
561  std::swap(_vec.OwnData, v._vec.OwnData);
562 
563  // This should still be O(1), since _vec.Cmp is just a pointer to
564  // data on the heap
565 
566  std::swap(_vec.Cmp, v._vec.Cmp);
567 }
QVector _vec
Actual Laspack vector datatype to hold vector entries.

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

Definition at line 158 of file numeric_vector.h.

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

◆ zero()

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

Set all entries to zero.

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

Implements libMesh::NumericVector< T >.

Definition at line 418 of file laspack_vector.h.

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

419 {
420  libmesh_assert (this->initialized());
421  libmesh_assert (this->closed());
422 
423  V_SetAllCmp (&_vec, 0.);
424 }
virtual bool initialized() const
libmesh_assert(ctx)
virtual bool closed() const
QVector _vec
Actual Laspack vector datatype to hold vector entries.

◆ zero_clone()

template<typename T >
std::unique_ptr< NumericVector< T > > libMesh::LaspackVector< 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 430 of file laspack_vector.h.

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

431 {
432  NumericVector<T> * cloned_vector = new LaspackVector<T>(this->comm());
433 
434  cloned_vector->init(*this);
435 
436  return std::unique_ptr<NumericVector<T>>(cloned_vector);
437 }
const Parallel::Communicator & comm() const

Friends And Related Function Documentation

◆ LaspackLinearSolver< T >

template<typename T>
friend class LaspackLinearSolver< T >
friend

Make other Laspack datatypes friends.

Definition at line 247 of file laspack_vector.h.

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

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

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

◆ _is_initialized

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

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

◆ _type

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

◆ _vec

template<typename T>
QVector libMesh::LaspackVector< T >::_vec
private

Actual Laspack vector datatype to hold vector entries.

Definition at line 242 of file laspack_vector.h.

Referenced by libMesh::LaspackVector< T >::add_vector(), libMesh::LaspackVector< T >::dot(), and libMesh::LaspackVector< T >::operator=().


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