libMesh::EigenSparseVector< T > Class Template Reference

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

#include <eigen_sparse_matrix.h>

Inheritance diagram for libMesh::EigenSparseVector< T >:

Public Types
typedef EigenSV	DataType
	Convenient typedefs. More...

Public Member Functions
	EigenSparseVector (const Parallel::Communicator &comm_in, const ParallelType=AUTOMATIC)
	Dummy-Constructor. More...
	EigenSparseVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const ParallelType=AUTOMATIC)
	Constructor. More...
	EigenSparseVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const numeric_index_type n_local, const ParallelType=AUTOMATIC)
	Constructor. More...
	EigenSparseVector (const Parallel::Communicator &comm_in, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType=AUTOMATIC)
	Constructor. More...
EigenSparseVector< T > &	operator= (const EigenSparseVector< T > &v)
	Copy assignment operator. More...
	EigenSparseVector (EigenSparseVector &&)=default
	The 5 special functions can be defaulted for this class, as it does not manage any memory itself. More...
	EigenSparseVector (const EigenSparseVector &)=default
EigenSparseVector &	operator= (EigenSparseVector &&)=default
virtual	~EigenSparseVector ()=default
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 tha 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_in) 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_in) 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 each entry of the vector. 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	swap (NumericVector< T > &v) override
	Swaps the contents of this with v. More...
DataType &	vec ()
	References to the underlying Eigen data types. More...
const DataType &	vec () const
virtual bool	initialized () const
ParallelType	type () const
ParallelType &	type ()
virtual bool	closed () const
virtual Real	subset_l1_norm (const std::set< numeric_index_type > &indices) const
virtual Real	subset_l2_norm (const std::set< numeric_index_type > &indices) const
virtual Real	subset_linfty_norm (const std::set< numeric_index_type > &indices) const
virtual T	el (const numeric_index_type i) const
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...
virtual 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...
virtual 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...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< NumericVector< T > >	build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
	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=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)
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name)
	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...
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
DataType	_vec
	Actual Eigen::SparseVector<> we are wrapping. More...

Friends
class	EigenSparseMatrix< T >
	Make other Eigen datatypes friends. More...
class	EigenSparseLinearSolver< T >

Detailed Description

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

This class provides a nice interface to the Eigen 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 eigen_sparse_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 117 of file reference_counter.h.

DataType

template<typename T>

typedef EigenSV libMesh::EigenSparseVector< T >::DataType

Convenient typedefs.

Definition at line 109 of file eigen_sparse_vector.h.

Constructor & Destructor Documentation

EigenSparseVector() [1/6]

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector ( const Parallel::Communicator &  comm_in, const ParallelType  ptype = AUTOMATIC  )

inlineexplicit

Dummy-Constructor.

Dimension=0

Definition at line 257 of file eigen_sparse_vector.h.

  : NumericVector<T>(comm_in, ptype)
{
  this->_type = ptype;
}

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

EigenSparseVector() [2/6]

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector ( const Parallel::Communicator &  comm_in, const numeric_index_type  n, const ParallelType  ptype = AUTOMATIC  )

inlineexplicit

Constructor.

Set dimension to n and initialize all elements with zero.

Definition at line 268 of file eigen_sparse_vector.h.

  : NumericVector<T>(comm_in, ptype)
{
  this->init(n, n, false, ptype);
}

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

EigenSparseVector() [3/6]

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector ( const Parallel::Communicator &  comm_in, 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 280 of file eigen_sparse_vector.h.

  : NumericVector<T>(comm_in, ptype)
{
  this->init(n, n_local, false, ptype);
}

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

EigenSparseVector() [4/6]

template<typename T >

libMesh::EigenSparseVector< T >::EigenSparseVector ( const Parallel::Communicator &  comm_in, const numeric_index_type  N, const numeric_index_type  n_local, const std::vector< numeric_index_type > &  ghost, const ParallelType  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 293 of file eigen_sparse_vector.h.

  : NumericVector<T>(comm_in, ptype)
{
  this->init(N, n_local, ghost, false, ptype);
}

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

EigenSparseVector() [5/6]

template<typename T>

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

default

The 5 special functions can be defaulted for this class, as it does not manage any memory itself.

EigenSparseVector() [6/6]

template<typename T>

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

default

~EigenSparseVector()

template<typename T>

virtual libMesh::EigenSparseVector< T >::~EigenSparseVector ( )

virtualdefault

Member Function Documentation

abs()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 242 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
 
  const numeric_index_type n = this->size();
 
  for (numeric_index_type i=0; i!=n; ++i)
    this->set(i,std::abs((*this)(i)));
}

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

add() [1/4]

template<typename T >

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

inlineoverridevirtual

Adds value to each entry of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 489 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->size());
 
  _vec[static_cast<eigen_idx_type>(i)] += value;
 
  this->_is_closed = false;
}

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

add() [2/4]

template<typename T >

void libMesh::EigenSparseVector< 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 176 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
 
  const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
  _vec += v._vec;
}

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

add() [3/4]

template<typename T >

void libMesh::EigenSparseVector< 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 188 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
 
  const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
  _vec += v._vec*a;
}

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

add() [4/4]

template<typename T >

void libMesh::EigenSparseVector< 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 165 of file eigen_sparse_vector.C.

{
  _vec += EigenSV::Constant(this->size(), v);
 
  this->_is_closed = false;
}

add_vector() [1/6]

template<typename T>

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

inlineinherited

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

Definition at line 862 of file numeric_vector.h.

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

add_vector() [2/6]

template<typename T>

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

inherited

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

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

Definition at line 385 of file numeric_vector.C.

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

add_vector() [3/6]

template<typename T >

void libMesh::EigenSparseVector< 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 200 of file eigen_sparse_vector.C.

{
  // Make sure the data passed in are really in Eigen types
  const EigenSparseVector<T> * e_vec = cast_ptr<const EigenSparseVector<T> *>(&vec_in);
  const EigenSparseMatrix<T> * mat = cast_ptr<const EigenSparseMatrix<T> *>(&mat_in);
 
  libmesh_assert(e_vec);
  libmesh_assert(mat);
 
  _vec += mat->_mat*e_vec->_vec;
}

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

add_vector() [4/6]

template<typename T>

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

virtualinherited

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

Definition at line 373 of file numeric_vector.C.

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

add_vector() [5/6]

template<typename T>

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

inlineinherited

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

Definition at line 850 of file numeric_vector.h.

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

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

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

Definition at line 363 of file numeric_vector.C.

{
  for (auto i : index_range(dof_indices))
    this->add (dof_indices[i], v[i]);
}

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

add_vector_transpose()

template<typename T >

void libMesh::EigenSparseVector< 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 216 of file eigen_sparse_vector.C.

{
  // Make sure the data passed in are really in Eigen types
  const EigenSparseVector<T> * e_vec = cast_ptr<const EigenSparseVector<T> *>(&vec_in);
  const EigenSparseMatrix<T> * mat = cast_ptr<const EigenSparseMatrix<T> *>(&mat_in);
 
  libmesh_assert(e_vec);
  libmesh_assert(mat);
 
  _vec += mat->_mat.transpose()*e_vec->_vec;
}

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

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

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

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::RBEIMConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMConstruction::initialize_rb_construction(), main(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), DiagonalMatrixTest::testNumerics(), SystemsTest::testProjectCubeWithMeshFunction(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), and libMesh::RBConstruction::update_residual_terms().

clear()

template<typename T >

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

inlineoverridevirtual

Restores the NumericVector<T> to a pristine state.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 385 of file eigen_sparse_vector.h.

{
  _vec.resize(0);
 
  this->_is_initialized = false;
  this->_is_closed = false;
}

References libMesh::libMeshPrivateData::_is_initialized.

clone()

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::EigenSparseVector< 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 419 of file eigen_sparse_vector.h.

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

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

close()

template<typename T >

void libMesh::EigenSparseVector< 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 374 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
 
  this->_is_closed = true;
}

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

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

{ return _is_closed; }

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

comm()

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

inlineinherited

Returns

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

Definition at line 94 of file parallel_object.h.

  { return _communicator; }

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::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), 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::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), 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::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), 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::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::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), 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::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), 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_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_preconditioner_apply(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), 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(), 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_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(), 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(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), 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::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), 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::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), 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::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().

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

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

conjugate()

template<typename T >

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

overridevirtual

Negates the imaginary component of each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 157 of file eigen_sparse_vector.C.

{
  _vec = _vec.conjugate();
}

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

Definition at line 707 of file numeric_vector.h.

  {
    libmesh_not_implemented();
  }

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

dot()

template<typename T >

T libMesh::EigenSparseVector< 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 255 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
 
  // Make sure the NumericVector passed in is really a EigenSparseVector
  const EigenSparseVector<T> * v = cast_ptr<const EigenSparseVector<T> *>(&v_in);
  libmesh_assert(v);
 
  return _vec.dot(v->_vec);
}

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

el()

template<typename T>

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

inlinevirtualinherited

Returns

(*this)(i).

Definition at line 352 of file numeric_vector.h.

{ return (*this)(i); }

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

first_local_index()

template<typename T >

numeric_index_type libMesh::EigenSparseVector< 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 453 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
 
  return 0;
}

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

get() [1/2]

template<typename T>

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

inlineinherited

Access multiple components at once.

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

Definition at line 835 of file numeric_vector.h.

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

get() [2/2]

template<typename T>

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

Definition at line 821 of file numeric_vector.h.

{
  const std::size_t num = index.size();
  for (std::size_t i=0; i<num; i++)
    {
      values[i] = (*this)(index[i]);
    }
}

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), compute_residual(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::RBConstructionBase< CondensedEigenSystem >::generate_training_parameters_deterministic(), libMesh::RBConstructionBase< CondensedEigenSystem >::generate_training_parameters_random(), libMesh::RBConstructionBase< CondensedEigenSystem >::initialize_training_parameters(), libMesh::RBConstructionBase< CondensedEigenSystem >::load_training_set(), libMesh::FEMContext::pre_fe_reinit(), and libMesh::System::project_vector().

get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & pr : _counts)
    {
      const std::string name(pr.first);
      const unsigned int creations    = pr.second.first;
      const unsigned int destructions = pr.second.second;
 
      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

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

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

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

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

increment_constructor_count()

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

inlineprotectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

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

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

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

increment_destructor_count()

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

inlineprotectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

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

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

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

init() [1/4]

template<typename T >

void libMesh::EigenSparseVector< 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 339 of file eigen_sparse_vector.h.

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

References libMesh::TriangleWrapper::init().

init() [2/4]

template<typename T >

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

inlineoverridevirtual

Change the dimension of the vector to n.

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

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

Implements libMesh::NumericVector< T >.

Definition at line 307 of file eigen_sparse_vector.h.

{
  // Eigen vectors only for serial cases,
  // but can provide a "parallel" vector on one processor.
  if (n != n_local)
    libmesh_error_msg("Error: EigenSparseVectors can only be used in serial!");
 
  this->_type = SERIAL;
 
  // Clear initialized vectors
  if (this->initialized())
    this->clear();
 
  _vec.resize(n);
 
  this->_is_initialized = true;
  this->_is_closed = true;
 
  // Optionally zero out all components
  if (fast == false)
    this->zero ();
 
  return;
}

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

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

init() [3/4]

template<typename T>

virtual void libMesh::EigenSparseVector< 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  ptype = AUTOMATIC  )

overridevirtual

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

Implements libMesh::NumericVector< T >.

init() [4/4]

template<class T >

void libMesh::EigenSparseVector< 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 364 of file eigen_sparse_vector.h.

{
  this->init(other.size(),other.local_size(),fast,other.type());
}

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

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

{ return _is_initialized; }

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

insert() [1/5]

template<typename T>

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

inlineinherited

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

Definition at line 898 of file numeric_vector.h.

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

insert() [2/5]

template<typename T>

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

inlineinherited

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

Definition at line 886 of file numeric_vector.h.

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

insert() [3/5]

template<typename T>

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

virtualinherited

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

Definition at line 93 of file numeric_vector.C.

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

insert() [4/5]

template<typename T>

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

inlineinherited

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

Definition at line 874 of file numeric_vector.h.

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

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

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

Definition at line 83 of file numeric_vector.C.

{
  for (auto i : index_range(dof_indices))
    this->set (dof_indices[i], v[i]);
}

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

l1_norm()

template<typename T >

Real libMesh::EigenSparseVector< 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 48 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
  libmesh_assert (this->initialized());
 
  return _vec.lpNorm<1>();
}

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

l2_norm()

template<typename T >

Real libMesh::EigenSparseVector< 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 59 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
  libmesh_assert (this->initialized());
 
  return _vec.lpNorm<2>();
}

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

last_local_index()

template<typename T >

numeric_index_type libMesh::EigenSparseVector< 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 464 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
 
  return this->size();
}

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

linfty_norm()

template<typename T >

Real libMesh::EigenSparseVector< 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 70 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
  libmesh_assert (this->initialized());
 
  return _vec.lpNorm<Eigen::Infinity>();
}

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

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.

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

local_size()

template<typename T >

numeric_index_type libMesh::EigenSparseVector< 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 442 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
 
  return this->size();
}

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

localize() [1/5]

template<typename T>

virtual void libMesh::EigenSparseVector< 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() [2/5]

template<typename T >

void libMesh::EigenSparseVector< 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 336 of file eigen_sparse_vector.C.

{
  // Make sure the NumericVector passed in is really a EigenSparseVector
  EigenSparseVector<T> * v_local =
    cast_ptr<EigenSparseVector<T> *>(&v_local_in);
 
  libmesh_assert(v_local);
 
  *v_local = *this;
}

References libMesh::libmesh_assert().

localize() [3/5]

template<typename T>

virtual void libMesh::EigenSparseVector< 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::EigenSparseVector< 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 394 of file eigen_sparse_vector.C.

{
  v_local.resize(this->size());
 
  for (auto i : index_range(v_local))
    v_local[i] = (*this)(i);
}

References libMesh::index_range().

localize() [5/5]

template<typename T >

void libMesh::EigenSparseVector< 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 366 of file eigen_sparse_vector.C.

{
  // EigenSparseVectors are serial, so we can just copy values
  v_local.resize(indices.size());
 
  for (auto i : index_range(v_local))
    v_local[i] = (*this)(indices[i]);
}

References libMesh::index_range().

localize_to_one()

template<typename T>

void libMesh::EigenSparseVector< 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 406 of file eigen_sparse_vector.C.

{
  libmesh_assert_equal_to (pid, 0);
 
  this->localize (v_local);
}

max()

template<typename T >

Real libMesh::EigenSparseVector< 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 426 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
  if (!this->size())
    return -std::numeric_limits<Real>::max();
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
  Real the_max = libmesh_real((*this)(0));
 
  const numeric_index_type n = this->size();
 
  for (numeric_index_type i=1; i<n; i++)
    the_max = std::max (the_max, libmesh_real((*this)(i)));
 
  return the_max;
#else
  return libmesh_real(_vec.maxCoeff());
#endif
}

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

min()

template<typename T >

Real libMesh::EigenSparseVector< 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 449 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
  if (!this->size())
    return std::numeric_limits<Real>::max();
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
  Real the_min = libmesh_real((*this)(0));
 
  const numeric_index_type n = this->size();
 
  for (numeric_index_type i=1; i<n; i++)
    the_min = std::min (the_min, libmesh_real((*this)(i)));
 
  return the_min;
#else
  return libmesh_real(_vec.minCoeff());
#endif
}

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

n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by 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::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_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::partition(), 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(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::VTKIO::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().

operator()()

template<typename T >

T libMesh::EigenSparseVector< 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 503 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
  libmesh_assert ( ((i >= this->first_local_index()) &&
                    (i <  this->last_local_index())) );
 
  return _vec[static_cast<eigen_idx_type>(i)];
}

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

operator*=() [1/2]

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 110 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
  libmesh_assert_equal_to(size(), v_in.size());
 
  const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
  _vec = _vec.cwiseProduct(v._vec);
 
  return *this;
}

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

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

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

operator+=()

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 81 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
 
  const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
  _vec += v._vec;
 
  return *this;
}

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

operator-=()

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 96 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
 
  const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
  _vec -= v._vec;
 
  return *this;
}

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

operator/=() [1/2]

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 125 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
  libmesh_assert_equal_to(size(), v_in.size());
 
  const EigenSparseVector<T> & v = cast_ref<const EigenSparseVector<T> &>(v_in);
 
  _vec = _vec.cwiseQuotient(v._vec);
 
  return *this;
}

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

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

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

operator=() [1/5]

template<typename T >

EigenSparseVector< T > & libMesh::EigenSparseVector< T >::operator=

(

const EigenSparseVector< T > &

v

)

Copy assignment operator.

Does some state checks before copying the underlying Eigen data type.

Returns

A reference to *this as the derived type.

Definition at line 301 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
  libmesh_assert (v.closed());
  libmesh_assert_equal_to (this->size(), v.size());
 
  _vec = v._vec;
 
  this->_is_closed = true;
 
  return *this;
}

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

operator=() [2/5]

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 284 of file eigen_sparse_vector.C.

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

References libMesh::libmesh_assert().

operator=() [3/5]

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 318 of file eigen_sparse_vector.C.

{
  if (this->size() == v.size())
    for (auto i : index_range(v))
      this->set (i, v[i]);
 
  else
    libmesh_error_msg("this->size() = " << this->size() << " must be equal to v.size() = " << v.size());
 
  return *this;
}

References libMesh::index_range().

operator=() [4/5]

template<typename T >

NumericVector< T > & libMesh::EigenSparseVector< 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 270 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
  libmesh_assert (this->closed());
 
  _vec.fill(s);
 
  return *this;
}

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

operator=() [5/5]

template<typename T>

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

default

pointwise_mult()

template<typename T >

void libMesh::EigenSparseVector< 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 417 of file eigen_sparse_vector.C.

{
  libmesh_not_implemented();
}

print() [1/2]

template<>

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

inlineinherited

Definition at line 913 of file numeric_vector.h.

{
  libmesh_assert (this->initialized());
  os << "Size\tglobal =  " << this->size()
     << "\t\tlocal =  " << this->local_size() << std::endl;
 
  // std::complex<>::operator<<() is defined, but use this form
  os << "#\tReal part\t\tImaginary part" << std::endl;
  for (auto i : index_range(*this))
    os << i << "\t"
       << (*this)(i).real() << "\t\t"
       << (*this)(i).imag() << std::endl;
}

print() [2/2]

template<typename T >

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

inlinevirtualinherited

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

Definition at line 931 of file numeric_vector.h.

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

print_global() [1/2]

template<>

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

inlineinherited

Definition at line 946 of file numeric_vector.h.

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

print_global() [2/2]

template<typename T >

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

inlinevirtualinherited

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

Definition at line 968 of file numeric_vector.h.

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

print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

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

  {
    libmesh_not_implemented();
  }

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), 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::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), 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_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), 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::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::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::DofMap::last_dof(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), 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::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::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), 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::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), 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::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), 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::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::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), 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().

reciprocal()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 141 of file eigen_sparse_vector.C.

{
#ifndef NDEBUG
  const numeric_index_type n = this->size();
 
  for (numeric_index_type i=0; i<n; i++)
    // Don't divide by zero!
    libmesh_assert_not_equal_to ((*this)(i), T(0));
#endif
 
  _vec = _vec.cwiseInverse();
}

scale()

template<typename T >

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

overridevirtual

Scale each element of the vector by the given factor.

Implements libMesh::NumericVector< T >.

Definition at line 232 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->initialized());
 
  _vec *= factor;
}

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

set()

template<typename T >

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

inlineoverridevirtual

Sets v(i) = value.

Implements libMesh::NumericVector< T >.

Definition at line 475 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
  libmesh_assert_less (i, this->size());
 
  _vec[static_cast<eigen_idx_type>(i)] = value;
 
  this->_is_closed = false;
}

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

size()

template<typename T >

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

inlineoverridevirtual

Returns

The size of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 431 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
 
  return static_cast<numeric_index_type>(_vec.size());
}

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

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

subset_l1_norm()

template<class T >

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

virtualinherited

Returns

The \( \ell_1 \)-norm of the vector, i.e. the sum of the absolute values for the specified entries in the vector.

Note

The indices must necessarily live on this processor.

Definition at line 312 of file numeric_vector.C.

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

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

subset_l2_norm()

template<class T >

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

virtualinherited

Returns

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

Note

The indices must necessarily live on this processor.

Definition at line 327 of file numeric_vector.C.

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

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

subset_linfty_norm()

template<class T >

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

virtualinherited

Returns

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

Note

The indices must necessarily live on this processor.

Definition at line 342 of file numeric_vector.C.

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

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

sum()

template<typename T >

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

overridevirtual

Returns

The sum of all values in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 37 of file eigen_sparse_vector.C.

{
  libmesh_assert (this->closed());
  libmesh_assert (this->initialized());
 
  return _vec.sum();
}

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

swap()

template<typename T >

void libMesh::EigenSparseVector< 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 516 of file eigen_sparse_vector.h.

{
  EigenSparseVector<T> & v = cast_ref<EigenSparseVector<T> &>(other);
 
  _vec.swap(v._vec);
 
  std::swap (this->_is_closed,      v._is_closed);
  std::swap (this->_is_initialized, v._is_initialized);
  std::swap (this->_type,           v._type);
}

References libMesh::libMeshPrivateData::_is_initialized, libMesh::EigenSparseVector< T >::swap(), and swap().

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

type() [1/2]

template<typename T>

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

inlineinherited

Returns

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

Definition at line 165 of file numeric_vector.h.

{ return _type; }

type() [2/2]

template<typename T>

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

inlineinherited

Returns

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

Definition at line 160 of file numeric_vector.h.

{ return _type; }

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

vec() [1/2]

template<typename T>

DataType& libMesh::EigenSparseVector< T >::vec ( )

inline

References to the underlying Eigen data types.

Note

This is generally not required in user-level code.

Definition at line 234 of file eigen_sparse_vector.h.

{ return _vec; }

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

vec() [2/2]

template<typename T>

const DataType& libMesh::EigenSparseVector< T >::vec ( ) const

inline

Definition at line 235 of file eigen_sparse_vector.h.

{ return _vec; }

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

zero()

template<typename T >

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

inlineoverridevirtual

Set all entries to zero.

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

Implements libMesh::NumericVector< T >.

Definition at line 396 of file eigen_sparse_vector.h.

{
  libmesh_assert (this->initialized());
  libmesh_assert (this->closed());
 
  _vec.setZero();
}

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

zero_clone()

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::EigenSparseVector< 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 408 of file eigen_sparse_vector.h.

{
  NumericVector<T> * cloned_vector = new EigenSparseVector<T>(this->comm());
  cloned_vector->init(*this);
  return std::unique_ptr<NumericVector<T>>(cloned_vector);
}

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

Friends And Related Function Documentation

EigenSparseLinearSolver< T >

template<typename T>

friend class EigenSparseLinearSolver< T >

friend

Definition at line 248 of file eigen_sparse_vector.h.

EigenSparseMatrix< T >

template<typename T>

friend class EigenSparseMatrix< T >

friend

Make other Eigen datatypes friends.

Definition at line 247 of file eigen_sparse_vector.h.

Member Data Documentation

_communicator

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

protectedinherited

Definition at line 112 of file parallel_object.h.

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

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

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

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 141 of file reference_counter.h.

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

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

true once init() has been called.

Definition at line 732 of file numeric_vector.h.

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

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

_n_objects

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

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 130 of file reference_counter.h.

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

_type

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

Type of vector.

Definition at line 737 of file numeric_vector.h.

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

_vec

template<typename T>

DataType libMesh::EigenSparseVector< T >::_vec

private

Actual Eigen::SparseVector<> we are wrapping.

Definition at line 242 of file eigen_sparse_vector.h.

Referenced by libMesh::EigenSparseVector< T >::add(), libMesh::EigenSparseVector< T >::add_vector(), libMesh::EigenSparseVector< T >::add_vector_transpose(), libMesh::EigenSparseVector< T >::dot(), libMesh::EigenSparseMatrix< T >::get_diagonal(), libMesh::EigenSparseVector< T >::operator+=(), libMesh::EigenSparseVector< T >::operator-=(), libMesh::EigenSparseVector< T >::operator=(), and libMesh::EigenSparseVector< T >::vec().

---

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

• include/numerics/eigen_sparse_matrix.h
• include/numerics/eigen_sparse_vector.h
• src/numerics/eigen_sparse_vector.C