Provides a uniform interface to vector storage schemes for different linear algebra libraries. More...

#include <numeric_vector.h>

Inheritance diagram for libMesh::NumericVector< T >:

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

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

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

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

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

	NumericVector (NumericVector &&)=default
	These 3 special functions can be defaulted for this class, as it does not manage any memory itself.

	NumericVector (const NumericVector &)=default

NumericVector &	operator= (NumericVector &&)=default

virtual	~NumericVector ()=default
	While this class doesn't manage any memory, the derived class might and users may be deleting through a pointer to this base class.

virtual bool	initialized () const

ParallelType	type () const

bool	is_effectively_serial () const

bool	is_effectively_ghosted () const

ParallelType &	type ()

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

virtual bool	closed () const

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

virtual void	clear ()
	Restores the `NumericVector<T>` to a pristine state.

virtual void	zero ()=0
	Set all entries to zero.

virtual std::unique_ptr< NumericVector< T > >	zero_clone () const =0

virtual std::unique_ptr< NumericVector< T > >	clone () const =0

virtual void	init (const numeric_index_type n, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC)=0
	Change the dimension of the vector to `n`.

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

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

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

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

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

virtual Real	min () const =0

virtual Real	max () const =0

virtual T	sum () const =0

virtual Real	l1_norm () const =0

virtual Real	l2_norm () const =0

virtual Real	linfty_norm () const =0

virtual Real	subset_l1_norm (const std::set< numeric_index_type > &indices) const

virtual Real	subset_l2_norm (const std::set< numeric_index_type > &indices) const

virtual Real	subset_linfty_norm (const std::set< numeric_index_type > &indices) const

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

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

virtual numeric_index_type	size () const =0

virtual numeric_index_type	local_size () const =0

virtual numeric_index_type	first_local_index () const =0

virtual numeric_index_type	last_local_index () const =0

virtual T	operator() (const numeric_index_type i) const =0

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	add_vector (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Computes \( \vec{u} \leftarrow \vec{u} + \vec{v} \), where `v` is a std::vector and each `dof_indices`[i] specifies where to add value `v`[i].

void	add_vector (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Computes \( \vec{u} \leftarrow \vec{u} + \vec{v} \), where `v` is a NumericVector and each `dof_indices`[i] specifies where to add value `v(i)`.

void	add_vector (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	Computes \( \vec{u} \leftarrow \vec{u} + \vec{v} \), where `v` is a DenseVector and each `dof_indices`[i] specifies where to add value `v(i)`.

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

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

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

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

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

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

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

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

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

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

virtual T	dot (const NumericVector< T > &v) const =0

virtual void	localize (std::vector< T > &v_local) const =0
	Creates a copy of the global vector in the local vector `v_local`.

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

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

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

virtual void	localize (const numeric_index_type first_local_idx, const numeric_index_type last_local_idx, const std::vector< numeric_index_type > &send_list)=0
	Updates a local vector with selected values from neighboring processors, as defined by `send_list`.

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

virtual int	compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const

virtual int	local_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const

virtual int	global_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const

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

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

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

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

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

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

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

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

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

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

virtual std::size_t	max_allowed_id () const =0

bool	readable () const

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

void	print (std::ostream &os) const

void	print_global (std::ostream &os) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< NumericVector< T > >	build (const Parallel::Communicator &comm, SolverPackage solver_package=libMesh::default_solver_package(), ParallelType parallel_type=AUTOMATIC)
	Builds a `NumericVector` on the processors in communicator `comm` using the linear solver package specified by `solver_package`.

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

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

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

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

static void	disable_print_counter_info ()

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

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

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

Protected Attributes
bool	_is_closed
	Flag which tracks whether the vector's values are consistent on all processors after insertion or addition of values has occurred on some or all processors.

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

ParallelType	_type
	Type of vector.

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

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.

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

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

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

Friends
std::ostream &	operator<< (std::ostream &os, const NumericVector< T > &v)
	Same as above but allows you to use stream syntax.

Detailed Description

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

Provides a uniform interface to vector storage schemes for different linear algebra libraries.

Note: This class is the abstract base class for different implementations of numeric vectors. Most of the time you should use a System object to create numeric vectors. If this is not desired, you can instantiate one of the derived classes (PetscVector, EigenSparseVector, etc.) or use the NumericVector::build method. When creating the vector yourself, make sure that you initialize the vector properly (NumericVector::init).

Author: Benjamin S. Kirk

Date: 2003

Definition at line 68 of file numeric_vector.h.

Member Typedef Documentation

◆ Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

◆ NumericVector() [1/6]

template<typename T >

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

inlineexplicit

Dummy-Constructor.

Dimension=0

Definition at line 893 of file numeric_vector.h.

                                                           :
  ParallelObject(comm_in),
  _is_closed(false),
  _is_initialized(false),
  _type(ptype)
{
}

◆ NumericVector() [2/6]

template<typename T >

libMesh::NumericVector< T >::NumericVector	(	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 906 of file numeric_vector.h.

                                                           :
  ParallelObject(comm_in),
  _is_closed(false),
  _is_initialized(false),
  _type(ptype)
{
  libmesh_not_implemented(); // Abstract base class!
  // init(n, n, false, ptype);
}

◆ NumericVector() [3/6]

template<typename T >

libMesh::NumericVector< T >::NumericVector	(	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 922 of file numeric_vector.h.

                                                           :
  ParallelObject(comm_in),
  _is_closed(false),
  _is_initialized(false),
  _type(ptype)
{
  libmesh_not_implemented(); // Abstract base class!
  // init(n, n_local, false, ptype);
}

◆ NumericVector() [4/6]

template<typename T >

libMesh::NumericVector< T >::NumericVector	(	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 939 of file numeric_vector.h.

                                                           :
  ParallelObject(comm_in),
  _is_closed(false),
  _is_initialized(false),
  _type(ptype)
{
  libmesh_not_implemented(); // Abstract base class!
  // init(n, n_local, ghost, false, ptype);
}

◆ NumericVector() [5/6]

template<typename T >

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

default

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

◆ NumericVector() [6/6]

template<typename T >

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

default

◆ ~NumericVector()

template<typename T >

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

virtualdefault

While this class doesn't manage any memory, the derived class might and users may be deleting through a pointer to this base class.

Member Function Documentation

◆ abs()

template<typename T >

virtual void libMesh::NumericVector< T >::abs ( )

pure virtual

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

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

◆ add() [1/4]

template<typename T >

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

pure virtual

Adds value to the vector entry specified by i.

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

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

Referenced by add_M_C_K_helmholtz(), libMesh::NewmarkSolver::advance_timestep(), libMesh::ContinuationSystem::apply_predictor(), libMesh::AdvectionSystem::assemble_claw_rhs(), assemble_wave(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::ContinuationSystem::continuation_solve(), libMesh::TransientRBConstruction::enrich_RB_space(), fill_dirichlet_bc(), AssembleOptimization::gradient(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::NewtonSolver::line_search(), main(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), LaplaceYoung::postcheck(), libMesh::NewtonSolver::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::NewmarkSystem::update_rhs(), libMesh::ContinuationSystem::update_solution(), libMesh::NewmarkSystem::update_u_v_a(), and libMesh::TensorShellMatrix< T >::vector_mult_add().

◆ add() [2/4]

template<typename T >

virtual void libMesh::NumericVector< T >::add ( const NumericVector< T > & v )

pure virtual

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

Equivalent to calling operator+=().

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

◆ add() [3/4]

template<typename T >

virtual void libMesh::NumericVector< T >::add	(	const T	a,
		const NumericVector< T > &	v
	)

pure virtual

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

Equivalent to calling operator+=().

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

◆ add() [4/4]

template<typename T >

virtual void libMesh::NumericVector< T >::add ( const T s )

pure virtual

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

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

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

inline

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

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

Definition at line 1008 of file numeric_vector.h.

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

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

◆ add_vector() [2/6]

template<typename T >

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

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

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

Definition at line 716 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

◆ add_vector() [3/6]

template<typename T >

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

pure virtual

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

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

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

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

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

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

Definition at line 702 of file numeric_vector.C.

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

◆ add_vector() [5/6]

template<typename T >

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

inline

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

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

Definition at line 996 of file numeric_vector.h.

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

References libMesh::libmesh_assert().

◆ add_vector() [6/6]

template<typename T >

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

virtual

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

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

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

Definition at line 690 of file numeric_vector.C.

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

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

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

◆ add_vector_transpose()

template<typename T >

virtual void libMesh::NumericVector< T >::add_vector_transpose	(	const NumericVector< T > &	v,
		const SparseMatrix< T > &	A
	)

pure virtual

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.

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

◆ build()

template<typename T >

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

static

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

Definition at line 61 of file numeric_vector.C.

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

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

◆ clear()

template<typename T >

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

inlinevirtual

Restores the NumericVector<T> to a pristine state.

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

Definition at line 957 of file numeric_vector.h.

{
  _is_closed      = false;
  _is_initialized = false;
}

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), and libMesh::System::project_vector().

◆ clone()

template<typename T >

virtual std::unique_ptr< NumericVector< T > > libMesh::NumericVector< T >::clone ( ) const

pure virtual

Returns: A copy of this vector wrapped in a smart pointer.

Note: This must be overridden in the derived classes.

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

Referenced by libMesh::NewmarkSolver::advance_timestep(), libMesh::Euler2Solver::integrate_adjoint_refinement_error_estimate(), libMesh::EulerSolver::integrate_adjoint_refinement_error_estimate(), HeatSystem::perturb_accumulate_residuals(), libMesh::System::project_vector(), libMesh::FileSolutionHistory::retrieve(), libMesh::TwostepTimeSolver::solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

◆ close()

template<typename T >

virtual void libMesh::NumericVector< T >::close ( )

pure virtual

Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across processors.

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

Referenced by add_M_C_K_helmholtz(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), assemble(), AssembleOptimization::assemble_A_and_F(), assemble_func(), assemble_matrix_and_rhs(), libMesh::ImplicitSystem::assemble_residual_derivatives(), assemble_shell(), assemble_temperature_jump(), libMesh::FEMSystem::assembly(), libMesh::LinearImplicitSystem::assembly(), libMesh::VariationalSmootherSystem::assembly(), libMesh::StaticCondensation::backwards_substitution(), libMesh::System::boundary_project_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ContinuationSystem::continuation_solve(), libMesh::AdjointRefinementEstimator::estimate_error(), form_functionA(), form_functionB(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::NewtonSolver::line_search(), periodic_bc_test_poisson(), HeatSystem::perturb_accumulate_residuals(), libMesh::System::project_vector(), libMesh::System::project_vector(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::System::read_serialized_vector(), run_timestepping(), ParsedFEMFunctionTest::setUp(), libMesh::NewtonSolver::solve(), libMesh::NoxNonlinearSolver< T >::solve(), libMesh::ContinuationSystem::solve_tangent(), SystemsTest::testProjectScalarCoarsening(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::NewmarkSystem::update_rhs(), libMesh::ContinuationSystem::update_solution(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), libMesh::ImplicitSystem::weighted_sensitivity_solve(), and libMesh::RBConstruction::zero_constrained_dofs_on_vector().

◆ closed()

template<typename T >

virtual bool libMesh::NumericVector< T >::closed ( ) const

inlinevirtual

Returns: true if the vector is closed and ready for computation, false otherwise.

Definition at line 210 of file numeric_vector.h.

210{ return _is_closed; }

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

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

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ compare()

template<typename T >

int libMesh::NumericVector< T >::compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtual

Returns: -1 when this is equivalent to other_vector (up to the given threshold), or the first index where abs(a[i]-b[i]) exceeds the threshold.

Definition at line 153 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

◆ compatible()

template<typename T >

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

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

Definition at line 734 of file numeric_vector.C.

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

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

◆ conjugate()

template<typename T >

virtual void libMesh::NumericVector< T >::conjugate ( )

pure virtual

Negates the imaginary component of each entry in the vector.

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

◆ create_subvector()

template<typename T >

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

inlinevirtual

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

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

This is currently only implemented for PetscVector and EigenSparseVector.

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

Definition at line 794 of file numeric_vector.h.

  {
    libmesh_not_implemented();
  }

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

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ dot()

template<typename T >

virtual T libMesh::NumericVector< T >::dot ( const NumericVector< T > & v ) const

pure virtual

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.

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

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::RBSCMConstruction::Aq_inner_product(), libMesh::RBSCMConstruction::B_inner_product(), libMesh::ContinuationSystem::continuation_solve(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), AssembleOptimization::objective(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::ContinuationSystem::solve_tangent(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBConstruction::truth_solve(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), and libMesh::ContinuationSystem::update_solution().

◆ el()

template<typename T >

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

inlinevirtual

Returns: (*this)(i).

Definition at line 403 of file numeric_vector.h.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ first_local_index()

template<typename T >

virtual numeric_index_type libMesh::NumericVector< T >::first_local_index ( ) const

pure virtual

Returns: The index of the first vector element actually stored on this processor.

Note: The minimum for this index is 0.

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

Referenced by libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::NumericVector< T >::compatible(), libMesh::PetscLinearSolver< T >::create_complement_is(), AssembleOptimization::equality_constraints(), libMesh::DofMap::extract_local_vector(), libMesh::index_range(), AssembleOptimization::inequality_constraints(), libMesh::VectorSetAction< Val >::insert(), libMesh::DofMap::max_constraint_error(), and SystemsTest::testProjectScalarCoarsening().

◆ get() [1/2]

template<typename T >

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

inline

Access multiple components at once.

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

Definition at line 981 of file numeric_vector.h.

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

◆ get() [2/2]

template<typename T >

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

inlinevirtual

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

Definition at line 967 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(), libMesh::System::add_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), compute_residual(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::HDGProblem::jacobian(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::FEMContext::pre_fe_reinit(), libMesh::System::project_vector(), libMesh::System::request_vector(), libMesh::System::request_vector(), libMesh::HDGProblem::residual(), libMesh::System::restrict_vectors(), libMesh::StaticCondensation::set_local_vectors(), libMesh::System::solve_for_unconstrained_dofs(), and libMesh::System::vector_name().

◆ get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

References libMesh::ReferenceCounter::_counts.

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

◆ get_subvector()

template<typename T >

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

inlinevirtual

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

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

This is currently only implemented for PetscVector and EigenSparseVector.

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

Definition at line 810 of file numeric_vector.h.

  {
    libmesh_not_implemented();
  }

Referenced by libMesh::StaticCondensation::apply(), libMesh::CondensedEigenSystem::copy_sub_to_super(), libMesh::CondensedEigenSystem::copy_super_to_sub(), and NumericVectorTest< DerivedClass >::Subvectors().

◆ global_relative_compare()

template<typename T >

int libMesh::NumericVector< T >::global_relative_compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtual

Returns: -1 when this is equivalent to other_vector (up to the given global relative threshold), or the first index where abs(a[i]-b[i])/max_j(a[j],b[j]) exceeds the threshold.

Definition at line 211 of file numeric_vector.C.

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

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

◆ increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ init() [1/4]

template<typename T >

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

pure virtual

Call init() with n_local = N.

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

◆ init() [2/4]

template<typename T >

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

pure virtual

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.

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

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::LaspackMatrix< T >::get_diagonal(), libMesh::TimeSolver::init_data(), main(), and libMesh::System::project_vector().

◆ init() [3/4]

template<typename T >

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

pure virtual

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

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

◆ init() [4/4]

template<typename T >

virtual void libMesh::NumericVector< T >::init	(	const NumericVector< T > &	other,
		const bool	fast = `false`
	)

pure virtual

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

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

◆ initialized()

template<typename T >

virtual bool libMesh::NumericVector< T >::initialized ( ) const

inlinevirtual

Returns: true if the vector has been initialized, false otherwise.

Definition at line 149 of file numeric_vector.h.

149{ return _is_initialized; }

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

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

◆ insert() [1/5]

template<typename T >

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

inline

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

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

Definition at line 1044 of file numeric_vector.h.

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

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

◆ insert() [2/5]

template<typename T >

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

inline

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

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

Definition at line 1032 of file numeric_vector.h.

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

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

◆ insert() [3/5]

template<typename T >

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

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

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

Definition at line 140 of file numeric_vector.C.

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

◆ insert() [4/5]

template<typename T >

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

inline

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

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

Definition at line 1020 of file numeric_vector.h.

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

References libMesh::libmesh_assert().

◆ insert() [5/5]

template<typename T >

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

virtual

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

Note that library implementations of this method are thread safe

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

Definition at line 128 of file numeric_vector.C.

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

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

Referenced by libMesh::StaticCondensation::backwards_substitution(), and Biharmonic::JR::bounds().

◆ is_effectively_ghosted()

template<typename T >

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

inline

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

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

Definition at line 181 of file numeric_vector.h.

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

libMesh::ParallelObject::n_processors

processor_id_type n_processors() const

Definition parallel_object.h:103

libMesh::GHOSTED

@ GHOSTED

Definition enum_parallel_type.h:37

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

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

◆ is_effectively_serial()

template<typename T >

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

inline

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

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

Definition at line 168 of file numeric_vector.h.

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

libMesh::SERIAL

@ SERIAL

Definition enum_parallel_type.h:35

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

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

◆ l1_norm()

template<typename T >

virtual Real libMesh::NumericVector< T >::l1_norm ( ) const

pure virtual

Returns: The \( \ell_1 \)-norm of the vector, i.e. the sum of the absolute values of the entries.

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

Referenced by libMesh::FEMSystem::assembly(), libMesh::System::calculate_norm(), and libMesh::l1_norm().

◆ l1_norm_diff()

template<class T >

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

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

Definition at line 653 of file numeric_vector.C.

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

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

Referenced by libMesh::l1_norm_diff().

◆ l2_norm()

template<typename T >

virtual Real libMesh::NumericVector< T >::l2_norm ( ) const

pure virtual

Returns: The \( \ell_2 \)-norm of the vector, i.e. the square root of the sum of the squares of the entries.

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

Referenced by libMesh::System::calculate_norm(), libMesh::ContinuationSystem::continuation_solve(), libMesh::RBConstruction::enrich_basis_from_rhs_terms(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::NewtonSolver::line_search(), libMesh::NewtonSolver::solve(), libMesh::ContinuationSystem::solve_tangent(), and libMesh::ContinuationSystem::update_solution().

◆ l2_norm_diff()

template<class T >

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

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

Definition at line 616 of file numeric_vector.C.

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

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

◆ last_local_index()

template<typename T >

virtual numeric_index_type libMesh::NumericVector< T >::last_local_index ( ) const

pure virtual

Returns: The index+1 of the last vector element actually stored on this processor.

Note: The maximum for this index is size().

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

Referenced by libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::NumericVector< T >::compatible(), libMesh::PetscLinearSolver< T >::create_complement_is(), AssembleOptimization::equality_constraints(), libMesh::DofMap::extract_local_vector(), libMesh::index_range(), AssembleOptimization::inequality_constraints(), libMesh::VectorSetAction< Val >::insert(), libMesh::DofMap::max_constraint_error(), and SystemsTest::testProjectScalarCoarsening().

◆ linfty_norm()

template<typename T >

virtual Real libMesh::NumericVector< T >::linfty_norm ( ) const

pure virtual

Returns: The \( \ell_{\infty} \)-norm of the vector, i.e. the maximum absolute value of the entries of the vector.

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

Referenced by libMesh::System::calculate_norm(), and libMesh::NumericVector< T >::global_relative_compare().

◆ local_relative_compare()

template<typename T >

int libMesh::NumericVector< T >::local_relative_compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtual

Returns: -1 when this is equivalent to other_vector, (up to the given local relative threshold), or the first index where abs(a[i]-b[i])/max(a[i],b[i]) exceeds the threshold.

Definition at line 181 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

◆ local_size()

template<typename T >

virtual numeric_index_type libMesh::NumericVector< T >::local_size ( ) const

pure virtual

Returns: The local size of the vector, i.e. index_stop - index_start.

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

Referenced by libMesh::System::calculate_norm(), libMesh::NumericVector< T >::compatible(), libMesh::CondensedEigenSystem::copy_sub_to_super(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::LaspackVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::System::project_vector(), libMesh::PetscLinearSolver< T >::shell_solve_common(), libMesh::PetscLinearSolver< T >::solve_base(), and libMesh::System::solve_for_unconstrained_dofs().

◆ localize() [1/5]

template<typename T >

virtual void libMesh::NumericVector< T >::localize	(	const numeric_index_type	first_local_idx,
		const numeric_index_type	last_local_idx,
		const std::vector< numeric_index_type > &	send_list
	)

pure virtual

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

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

◆ localize() [2/5]

template<typename T >

virtual void libMesh::NumericVector< T >::localize ( NumericVector< T > & v_local ) const

pure virtual

Same, but fills a NumericVector<T> instead of a std::vector.

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

◆ localize() [3/5]

template<typename T >

virtual void libMesh::NumericVector< T >::localize	(	NumericVector< T > &	v_local,
		const std::vector< numeric_index_type > &	send_list
	)		const

pure virtual

Creates a local vector v_local containing only information relevant to this processor, as defined by the send_list.

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

◆ localize() [4/5]

template<typename T >

virtual void libMesh::NumericVector< T >::localize ( std::vector< T > & v_local ) const

pure virtual

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

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

Referenced by libMesh::AdaptiveTimeSolver::adjoint_advance_timestep(), libMesh::UnsteadySolver::adjoint_advance_timestep(), libMesh::AdaptiveTimeSolver::advance_timestep(), libMesh::UnsteadySolver::advance_timestep(), libMesh::System::calculate_norm(), AssembleOptimization::equality_constraints(), libMesh::AdjointRefinementEstimator::estimate_error(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), main(), LinearElasticityWithContact::move_mesh(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::System::project_vector(), libMesh::SecondOrderUnsteadySolver::reinit(), libMesh::UnsteadySolver::reinit(), libMesh::UnsteadySolver::retrieve_timestep(), libMesh::RBConstruction::set_context_solution_vec(), libMesh::UnsteadySolver::update(), libMesh::MeshOutput< MT >::write_nodal_data(), and libMesh::Nemesis_IO_Helper::write_nodal_solution().

◆ localize() [5/5]

template<typename T >

virtual void libMesh::NumericVector< T >::localize	(	std::vector< T > &	v_local,
		const std::vector< numeric_index_type > &	indices
	)		const

pure virtual

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.

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

◆ localize_to_one()

template<typename T >

virtual void libMesh::NumericVector< T >::localize_to_one	(	std::vector< T > &	v_local,
		const processor_id_type	proc_id = `0`
	)		const

pure virtual

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.

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

◆ max()

template<typename T >

virtual Real libMesh::NumericVector< T >::max ( ) const

pure virtual

Returns: The maximum entry in the vector, or the maximum real part in the case of complex numbers.

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

◆ max_allowed_id()

template<typename T >

virtual std::size_t libMesh::NumericVector< T >::max_allowed_id ( ) const

pure virtual

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

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

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

◆ min()

template<typename T >

virtual Real libMesh::NumericVector< T >::min ( ) const

pure virtual

Returns: The minimum entry in the vector, or the minimum real part in the case of complex numbers.

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

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

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

◆ operator()()

template<typename T >

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

pure virtual

Returns: A copy of the ith entry of the vector.

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

◆ operator*=() [1/2]

template<typename T >

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

pure virtual

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.

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

◆ operator*=() [2/2]

template<typename T >

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

inline

Scales the vector by a, \( \vec{u} \leftarrow a\vec{u} \).

Equivalent to u.scale(a)

Returns: A reference to *this.

Definition at line 448 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

Scale each element of the vector by the given factor.

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

◆ operator+=()

template<typename T >

virtual NumericVector< T > & libMesh::NumericVector< T >::operator+= ( const NumericVector< T > & v )

pure virtual

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

Equivalent to u.add(1, v).

Returns: A reference to *this.

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

◆ operator-=()

template<typename T >

virtual NumericVector< T > & libMesh::NumericVector< T >::operator-= ( const NumericVector< T > & v )

pure virtual

Subtracts v from *this, \( \vec{u} \leftarrow \vec{u} - \vec{v} \).

Equivalent to u.add(-1, v).

Returns: A reference to *this.

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

◆ operator/=() [1/2]

template<typename T >

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

pure virtual

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.

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

◆ operator/=() [2/2]

template<typename T >

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

inline

Scales the vector by 1/a, \( \vec{u} \leftarrow \frac{1}{a}\vec{u} \).

Equivalent to u.scale(1./a)

Returns: A reference to *this.

Definition at line 466 of file numeric_vector.h.

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

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

◆ operator=() [1/4]

template<typename T >

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

pure virtual

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.

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

◆ operator=() [2/4]

template<typename T >

virtual NumericVector< T > & libMesh::NumericVector< T >::operator= ( const std::vector< T > & v )

pure virtual

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

Returns: A reference to *this as the base type.

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

◆ operator=() [3/4]

template<typename T >

virtual NumericVector< T > & libMesh::NumericVector< T >::operator= ( const T s )

pure virtual

Sets all entries of the vector to the value s.

Returns: A reference to *this.

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

◆ operator=() [4/4]

template<typename T >

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

default

◆ pointwise_divide()

template<typename T >

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

pure virtual

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

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

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

◆ pointwise_mult()

template<typename T >

virtual void libMesh::NumericVector< T >::pointwise_mult	(	const NumericVector< T > &	vec1,
		const NumericVector< T > &	vec2
	)

pure virtual

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.

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

Referenced by libMesh::TensorShellMatrix< T >::get_diagonal().

◆ print() [1/2]

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

inline

Definition at line 1059 of file numeric_vector.h.

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

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

◆ print() [2/2]

template<typename T >

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

inlinevirtual

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

Definition at line 1077 of file numeric_vector.h.

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

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

◆ print_global() [1/2]

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

inline

Definition at line 1092 of file numeric_vector.h.

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

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

◆ print_global() [2/2]

template<typename T >

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

inlinevirtual

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

Definition at line 1114 of file numeric_vector.h.

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

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

◆ print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_matlab()

template<typename T >

void libMesh::NumericVector< T >::print_matlab ( const std::string & filename = "" ) const

virtual

Print the contents of the vector in Matlab's sparse matrix format.

Optionally prints the vector to the file named name. If name is not specified it is dumped to the screen.

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

Definition at line 245 of file numeric_vector.C.

{
  parallel_object_only();
 
  libmesh_assert (this->initialized());
 
  const numeric_index_type first_dof = this->first_local_index(),
                           end_dof   = this->last_local_index();
 
  // We'll print the vector from processor 0 to make sure
  // it's serialized properly
  if (this->processor_id() == 0)
    {
      std::unique_ptr<std::ofstream> file;
 
      if (filename != "")
        file = std::make_unique<std::ofstream>(filename.c_str());
 
      std::ostream & os = (filename == "") ? libMesh::out : *file;
 
      // Print a header similar to PETSC_VIEWER_ASCII_MATLAB
      os << "%Vec Object: () " << this->n_processors() << " MPI processes\n"
         << "%  type: " << (this->n_processors() > 1 ? "mpi" : "seq") << "\n"
         << "Vec = [\n";
 
      for (numeric_index_type i : make_range(end_dof))
        os << (*this)(i) << '\n';
 
      std::vector<T> cbuf;
      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          this->comm().receive(p, cbuf);
 
          for (auto c : cbuf)
            os << c << '\n';
        }
 
      os << "];\n" << std::endl;
    }
  else
    {
      std::vector<T> cbuf(end_dof - first_dof);
 
      for (numeric_index_type i : make_range(end_dof - first_dof))
        cbuf[i] = (*this)(first_dof+i);
      this->comm().send(0,cbuf);
    }
}

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

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

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

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

◆ read_matlab()

template<typename T >

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

virtual

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

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

Definition at line 297 of file numeric_vector.C.

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

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

◆ readable()

template<typename T >

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

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

Definition at line 727 of file numeric_vector.C.

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

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

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

◆ reciprocal()

template<typename T >

virtual void libMesh::NumericVector< T >::reciprocal ( )

pure virtual

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

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

◆ restore_subvector()

template<typename T >

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

inlinevirtual

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

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

This is currently only implemented for PetscVector and EigenSparseVector.

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

Definition at line 823 of file numeric_vector.h.

  {
    libmesh_not_implemented();
  }

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

◆ scale()

template<typename T >

virtual void libMesh::NumericVector< T >::scale ( const T factor )

pure virtual

Scale each element of the vector by the given factor.

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

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ContinuationSystem::continuation_solve(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::NumericVector< T >::operator*=(), libMesh::NumericVector< T >::operator/=(), libMesh::ContinuationSystem::solve_tangent(), libMesh::RBConstruction::update_residual_terms(), libMesh::NewmarkSystem::update_u_v_a(), and libMesh::TensorShellMatrix< T >::vector_mult().

◆ set()

template<typename T >

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

pure virtual

Sets v(i) = value.

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

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

Referenced by assemble_shell(), libMesh::EquationSystems::build_parallel_solution_vector(), AssembleOptimization::equality_constraints(), libMesh::LaspackMatrix< T >::get_diagonal(), AssembleOptimization::inequality_constraints(), libMesh::VectorSetAction< Val >::insert(), libMesh::VectorSetAction< Val >::insert(), AssembleOptimization::lower_and_upper_bounds(), main(), libMesh::System::project_vector(), libMesh::System::project_vector(), libMesh::System::read_SCALAR_dofs(), ParsedFEMFunctionTest::setUp(), SystemsTest::testProjectScalarCoarsening(), libMesh::RBConstruction::zero_constrained_dofs_on_vector(), and libMesh::System::zero_variable().

◆ set_type()

template<typename T >

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

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

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

Definition at line 97 of file numeric_vector.C.

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

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

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

◆ size()

template<typename T >

virtual numeric_index_type libMesh::NumericVector< T >::size ( ) const

pure virtual

Returns: The size of the vector.

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

Referenced by libMesh::NumericVector< Number >::build(), libMesh::System::calculate_norm(), libMesh::NumericVector< T >::compatible(), AssembleOptimization::equality_constraints(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::DofMap::extract_local_vector(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::LaspackVector< T >::init(), libMesh::EpetraVector< T >::init(), main(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedVector< T >::operator*=(), libMesh::LaspackVector< T >::operator*=(), libMesh::EpetraVector< T >::operator*=(), libMesh::EigenSparseVector< T >::operator*=(), libMesh::DistributedVector< T >::operator/=(), libMesh::LaspackVector< T >::operator/=(), libMesh::EpetraVector< T >::operator/=(), libMesh::EigenSparseVector< T >::operator/=(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::System::project_vector(), libMesh::PetscLinearSolver< T >::shell_solve_common(), libMesh::System::solve_for_unconstrained_dofs(), and libMesh::System::write_serialized_vector().

◆ subset_l1_norm()

template<class T >

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

virtual

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

Note: The indices must necessarily live on this processor.

Definition at line 559 of file numeric_vector.C.

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

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

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

◆ subset_l2_norm()

template<class T >

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

virtual

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

Note: The indices must necessarily live on this processor.

Definition at line 576 of file numeric_vector.C.

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

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

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

◆ subset_linfty_norm()

template<class T >

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

virtual

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

Note: The indices must necessarily live on this processor.

Definition at line 593 of file numeric_vector.C.

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

References libMesh::libmesh_assert().

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

◆ sum()

template<typename T >

virtual T libMesh::NumericVector< T >::sum ( ) const

pure virtual

Returns: The sum of all values in the vector.

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

◆ swap()

template<typename T >

void libMesh::NumericVector< T >::swap ( NumericVector< T > & v )

inlinevirtual

Swaps the contents of this with v.

There should be enough indirection in subclasses to make this an O(1) header-swap operation.

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

Definition at line 1135 of file numeric_vector.h.

{
  std::swap(_is_closed, v._is_closed);
  std::swap(_is_initialized, v._is_initialized);
  std::swap(_type, v._type);
}

References libMesh::NumericVector< T >::_is_closed, libMesh::NumericVector< T >::_is_initialized, and libMesh::NumericVector< T >::_type.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::add_vector(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::Euler2Solver::integrate_adjoint_refinement_error_estimate(), libMesh::EulerSolver::integrate_adjoint_refinement_error_estimate(), main(), libMesh::PetscVector< T >::swap(), and libMesh::EpetraVector< T >::swap().

◆ type() [1/2]

template<typename T >

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

inline

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

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

Definition at line 192 of file numeric_vector.h.

192{ return _type; }

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

◆ type() [2/2]

template<typename T >

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

inline

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

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

Definition at line 158 of file numeric_vector.h.

158{ return _type; }

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

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

◆ zero()

template<typename T >

virtual void libMesh::NumericVector< T >::zero ( )

pure virtual

Set all entries to zero.

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

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

Referenced by add_M_C_K_helmholtz(), libMesh::StaticCondensation::apply(), apply_initial(), libMesh::ImplicitSystem::assemble(), AssembleOptimization::assemble_A_and_F(), libMesh::RBConstruction::assemble_all_output_vectors(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::RBConstruction::assemble_Fq_vector(), libMesh::ExplicitSystem::assemble_qoi_derivative(), libMesh::FEMSystem::assemble_qoi_derivative(), libMesh::FEMSystem::assembly(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::ContinuationSystem::continuation_solve(), libMesh::TransientRBConstruction::enrich_RB_space(), AssembleOptimization::equality_constraints(), AssembleOptimization::gradient(), AssembleOptimization::inequality_constraints(), libMesh::NewmarkSystem::initial_conditions(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::HDGProblem::residual(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::DiagonalMatrix< T >::restore_original_nonzero_pattern(), libMesh::NewtonSolver::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NewmarkSystem::update_rhs(), libMesh::SparseMatrix< T >::vector_mult(), and libMesh::SumShellMatrix< T >::vector_mult().

◆ zero_clone()

template<typename T >

virtual std::unique_ptr< NumericVector< T > > libMesh::NumericVector< T >::zero_clone ( ) const

pure virtual

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.

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

Referenced by libMesh::SumShellMatrix< T >::get_diagonal(), AssembleOptimization::objective(), libMesh::NewtonSolver::solve(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

Friends And Related Symbol Documentation

◆ operator<<

template<typename T >

std::ostream & operator<<	(	std::ostream &	os,
		const NumericVector< T > &	v
	)

friend

Same as above but allows you to use stream syntax.

Definition at line 755 of file numeric_vector.h.

  {
    v.print_global(os);
    return os;
  }

Member Data Documentation

◆ _communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

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

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _is_closed

template<typename T >

bool libMesh::NumericVector< T >::_is_closed

protected

Flag which tracks whether the vector's values are consistent on all processors after insertion or addition of values has occurred on some or all processors.

Definition at line 868 of file numeric_vector.h.

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

◆ _is_initialized

template<typename T >

bool libMesh::NumericVector< T >::_is_initialized

protected

true once init() has been called.

Definition at line 873 of file numeric_vector.h.

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

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _numeric_vector_mutex

template<typename T >

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

protected

Mutex for performing thread-safe operations.

Definition at line 883 of file numeric_vector.h.

◆ _type

template<typename T >

ParallelType libMesh::NumericVector< T >::_type

protected

Type of vector.

Definition at line 878 of file numeric_vector.h.

Referenced by libMesh::PetscVector< T >::create_subvector(), libMesh::DistributedVector< T >::DistributedVector(), libMesh::EigenSparseVector< T >::EigenSparseVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::PetscVector< T >::init(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::LaspackVector< T >::LaspackVector(), libMesh::PetscVector< T >::PetscVector(), libMesh::PetscVector< T >::PetscVector(), libMesh::NumericVector< T >::swap(), libMesh::EigenSparseVector< T >::swap(), libMesh::NumericVector< T >::type(), and libMesh::NumericVector< T >::type().

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

examples/vector_fe/vector_fe_ex5/vector_fe_ex5.C
include/numerics/numeric_vector.h
src/numerics/numeric_vector.C

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Counts

Constructor & Destructor Documentation

◆ NumericVector() [1/6]

◆ NumericVector() [2/6]

◆ NumericVector() [3/6]

◆ NumericVector() [4/6]

◆ NumericVector() [5/6]

◆ NumericVector() [6/6]

◆ ~NumericVector()

Member Function Documentation

◆ abs()

◆ add() [1/4]

◆ add() [2/4]

◆ add() [3/4]

◆ add() [4/4]

◆ add_vector() [1/6]

◆ add_vector() [2/6]

◆ add_vector() [3/6]

◆ add_vector() [4/6]

◆ add_vector() [5/6]

◆ add_vector() [6/6]

◆ add_vector_transpose()

◆ build()

◆ clear()

◆ clone()

◆ close()

◆ closed()

◆ comm()

◆ compare()

◆ compatible()

◆ conjugate()

◆ create_subvector()

◆ disable_print_counter_info()

◆ dot()

◆ el()

◆ enable_print_counter_info()

◆ first_local_index()

◆ get() [1/2]

◆ get() [2/2]

◆ get_info()

◆ get_subvector()

◆ global_relative_compare()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ init() [1/4]

◆ init() [2/4]

◆ init() [3/4]

◆ init() [4/4]

◆ initialized()

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ is_effectively_ghosted()

◆ is_effectively_serial()

◆ l1_norm()

◆ l1_norm_diff()

◆ l2_norm()

◆ l2_norm_diff()

◆ last_local_index()

◆ linfty_norm()

◆ local_relative_compare()

◆ local_size()

◆ localize() [1/5]

◆ localize() [2/5]

◆ localize() [3/5]

◆ localize() [4/5]

◆ localize() [5/5]

◆ localize_to_one()

◆ max()