#include <distributed_vector.h>

Inheritance diagram for libMesh::DistributedVector< T >:

[legend]

Public Member Functions
	DistributedVector (const Parallel::Communicator &comm, const ParallelType=AUTOMATIC)

	DistributedVector (const Parallel::Communicator &comm, const numeric_index_type n, const ParallelType ptype=AUTOMATIC)

	DistributedVector (const Parallel::Communicator &comm, const numeric_index_type n, const numeric_index_type n_local, const ParallelType ptype=AUTOMATIC)

	DistributedVector (const Parallel::Communicator &comm, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType ptype=AUTOMATIC)

DistributedVector &	operator= (const DistributedVector &)

	DistributedVector (DistributedVector &&)=default

	DistributedVector (const DistributedVector &)=default

DistributedVector &	operator= (DistributedVector &&)=default

virtual	~DistributedVector ()=default

virtual void	close () override

virtual void	clear () override

virtual void	zero () override

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

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

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override

virtual void	init (const numeric_index_type N, const bool fast=false, const ParallelType ptype=AUTOMATIC) override

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const bool fast=false, const ParallelType=AUTOMATIC) override

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

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

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

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

virtual Real	min () const override

virtual Real	max () const override

virtual T	sum () const override

virtual Real	l1_norm () const override

virtual Real	l2_norm () const override

virtual Real	linfty_norm () const override

virtual numeric_index_type	size () const override

virtual numeric_index_type	local_size () const override

virtual numeric_index_type	first_local_index () const override

virtual numeric_index_type	last_local_index () const override

virtual T	operator() (const numeric_index_type i) const override

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

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

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

virtual void	reciprocal () override

virtual void	conjugate () override

virtual void	set (const numeric_index_type i, const T value) override

virtual void	add (const numeric_index_type i, const T value) override

virtual void	add (const T s) override

virtual void	add (const NumericVector< T > &V) override

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

virtual void	add_vector (const NumericVector< T > &, const SparseMatrix< T > &) override

virtual void	add_vector_transpose (const NumericVector< T > &, const SparseMatrix< T > &) override

virtual void	scale (const T factor) override

virtual void	abs () override

virtual T	dot (const NumericVector< T > &V) const override

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

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

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

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

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

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

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

virtual void	swap (NumericVector< T > &v) override

virtual bool	initialized () const

ParallelType	type () const

ParallelType &	type ()

virtual bool	closed () const

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

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

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

virtual T	el (const numeric_index_type i) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	print (std::ostream &os=libMesh::out) const

template<>
void	print (std::ostream &os) const

virtual void	print_global (std::ostream &os=libMesh::out) const

template<>
void	print_global (std::ostream &os) const

virtual void	print_matlab (const std::string &="") const

virtual void	create_subvector (NumericVector< T > &, const std::vector< numeric_index_type > &) 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, const SolverPackage solver_package=libMesh::default_solver_package())

static std::string	get_info ()

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

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

Protected Member Functions
void	increment_constructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

Protected Attributes
bool	_is_closed

bool	_is_initialized

ParallelType	_type

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter = true

Private Attributes
std::vector< T >	_values

numeric_index_type	_global_size

numeric_index_type	_local_size

numeric_index_type	_first_local_index

numeric_index_type	_last_local_index

Detailed Description

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

This class provides a simple parallel, distributed vector datatype which is specific to libmesh. Offers some collective communication capabilities.

Note: The class will sill function without MPI, but only on one processor. All overridden virtual functions are documented in numeric_vector.h.

Author: Benjamin S. Kirk

Date: 2003

Definition at line 52 of file distributed_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 117 of file reference_counter.h.

Constructor & Destructor Documentation

◆ DistributedVector() [1/6]

template<typename T >

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

inlineexplicit

Dummy-Constructor. Dimension=0

Definition at line 260 of file distributed_vector.h.

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

                                                                    :
   NumericVector<T>(comm_in, ptype),
   _global_size      (0),
   _local_size       (0),
   _first_local_index(0),
   _last_local_index (0)
 {
   this->_type = ptype;
 }

◆ DistributedVector() [2/6]

template<typename T >

libMesh::DistributedVector< T >::DistributedVector	(	const Parallel::Communicator &	comm,
		const numeric_index_type	n,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineexplicit

Constructor. Set dimension to n and initialize all elements with zero.

Definition at line 275 of file distributed_vector.h.

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

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

◆ DistributedVector() [3/6]

template<typename T >

libMesh::DistributedVector< T >::DistributedVector	(	const Parallel::Communicator &	comm,
		const numeric_index_type	n,
		const numeric_index_type	n_local,
		const ParallelType	ptype = `AUTOMATIC`
	)

inline

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

Definition at line 287 of file distributed_vector.h.

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

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

◆ DistributedVector() [4/6]

template<typename T >

libMesh::DistributedVector< T >::DistributedVector	(	const Parallel::Communicator &	comm,
		const numeric_index_type	N,
		const numeric_index_type	n_local,
		const std::vector< numeric_index_type > &	ghost,
		const ParallelType	ptype = `AUTOMATIC`
	)

inline

Constructor. Set local dimension to n_local, the global dimension to n, but additionally reserve memory for the indices specified by the ghost argument.

Definition at line 300 of file distributed_vector.h.

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

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

◆ DistributedVector() [5/6]

template<typename T>

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

default

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

◆ DistributedVector() [6/6]

template<typename T>

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

default

◆ ~DistributedVector()

template<typename T>

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

virtualdefault

Member Function Documentation

◆ abs()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 260 of file distributed_vector.C.

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   for (numeric_index_type i=0; i<local_size(); i++)
     this->set(i,std::abs(_values[i]));
 }

◆ add() [1/4]

template<typename T >

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

inlineoverridevirtual

Adds value to each entry of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 579 of file distributed_vector.h.

References libMesh::initialized(), and value.

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
   libmesh_assert_less (i, size());
   libmesh_assert_less (i-first_local_index(), local_size());
 
   _values[i - _first_local_index] += value;
 }

◆ add() [2/4]

template<typename T >

void libMesh::DistributedVector< T >::add ( const T s )

overridevirtual

Adds s to each entry of the vector, $u_i \leftarrow u_i + s$

Implements libMesh::NumericVector< T >.

Definition at line 212 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   for (numeric_index_type i=0; i<local_size(); i++)
     _values[i] += v;
 }

◆ add() [3/4]

template<typename T >

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

overridevirtual

Adds v to this, $\vec{u} \leftarrow \vec{u} + \vec{v}$ . Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 225 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   add (1., v);
 }

◆ add() [4/4]

template<typename T >

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

overridevirtual

Vector addition with a scalar multiple, $\vec{u} \leftarrow \vec{u} + a\vec{v}$ . Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 237 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   add(a, v);
 }

◆ add_vector() [1/6]

template<typename T>

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

inlineoverridevirtual

Computes $\vec{u} \leftarrow \vec{u} + A \vec{v}$ , i.e. adds the product of a SparseMatrix A and a NumericVector v to this.

Implements libMesh::NumericVector< T >.

Definition at line 191 of file distributed_vector.h.

193 { libmesh_not_implemented(); }

◆ add_vector() [2/6]

template<typename T>

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

virtualinherited

Computes $\vec{u} \leftarrow \vec{u} + \vec{v}$ , where v is a pointer and each dof_indices[i] specifies where to add value v[i]. This should be overridden in subclasses for efficiency.

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

Definition at line 362 of file numeric_vector.C.

Referenced by libMesh::LinearImplicitSystem::assembly(), libMesh::NewmarkSystem::update_rhs(), and libMesh::SparseMatrix< ValOut >::vector_mult_add().

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

◆ add_vector() [3/6]

template<typename T>

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

inlineinherited

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

Definition at line 835 of file numeric_vector.h.

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

◆ add_vector() [4/6]

template<typename T>

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

virtualinherited

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

Definition at line 372 of file numeric_vector.C.

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

◆ add_vector() [5/6]

template<typename T>

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

inlineinherited

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

Definition at line 847 of file numeric_vector.h.

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

◆ add_vector() [6/6]

template<typename T>

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

inherited

Computes $\vec{u} \leftarrow \vec{u} + A \vec{v}$ , i.e. adds the product of a ShellMatrix A and a NumericVector v to this.

Definition at line 384 of file numeric_vector.C.

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

◆ add_vector_transpose()

template<typename T>

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

inlineoverridevirtual

Computes $\vec{u} \leftarrow \vec{u} + A^T \vec{v}$ , i.e. adds the product of the transpose of a SparseMatrix A and a NumericVector v to this.

Implements libMesh::NumericVector< T >.

Definition at line 195 of file distributed_vector.h.

197 { libmesh_not_implemented(); }

◆ build()

template<typename T >

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

staticinherited

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

Definition at line 48 of file numeric_vector.C.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::add_vector(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), and libMesh::CondensedEigenSystem::get_eigenpair().

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

◆ clear()

template<typename T >

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

inlineoverridevirtual

Restores the NumericVector<T> to a pristine state.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 442 of file distributed_vector.h.

References libMesh::libMeshPrivateData::_is_initialized.

 {
   _values.clear();
 
   _global_size =
     _local_size =
     _first_local_index =
     _last_local_index = 0;
 
 
   this->_is_closed = this->_is_initialized = false;
 }

◆ clone()

template<typename T >

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

inlineoverridevirtual

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

Note: This must be overridden in the derived classes.

Implements libMesh::NumericVector< T >.

Definition at line 485 of file distributed_vector.h.

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

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

◆ close()

template<typename T >

void libMesh::DistributedVector< T >::close ( )

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 431 of file distributed_vector.h.

References libMesh::initialized().

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

◆ closed()

template<typename T>

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

inlinevirtualinherited

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

Definition at line 165 of file numeric_vector.h.

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

165 { return _is_closed; }

libMesh::NumericVector::_is_closed

bool _is_closed

Definition: numeric_vector.h:712

◆ comm()

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

inlineinherited

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

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

90 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ compare()

template<typename T>

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

virtualinherited

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

Definition at line 104 of file numeric_vector.C.

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

◆ conjugate()

template<typename T >

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

overridevirtual

Negates the imaginary component of each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 198 of file distributed_vector.C.

References libMesh::libmesh_conj().

 {
   for (numeric_index_type i=0; i<local_size(); i++)
     {
       // Replace values by complex conjugate
       _values[i] = libmesh_conj(_values[i]);
     }
 }

◆ create_subvector()

template<typename T>

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

inlinevirtualinherited

Fills in subvector from this vector using the indices in rows. Similar to the create_submatrix() routine for the SparseMatrix class, it is currently only implemented for PetscVectors.

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

Definition at line 692 of file numeric_vector.h.

   {
     libmesh_not_implemented();
   }

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   _enable_print_counter = false;
   return;
 }

◆ dot()

template<typename T >

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

overridevirtual

Returns: $\vec{u} \cdot \vec{v}$ , the dot product of (*this) with the vector v.

Uses the complex-conjugate of v in the complex-valued case.

Implements libMesh::NumericVector< T >.

Definition at line 274 of file distributed_vector.C.

References libMesh::DistributedVector< T >::_values, libMesh::DistributedVector< T >::first_local_index(), and libMesh::DistributedVector< T >::last_local_index().

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   // Make sure the NumericVector passed in is really a DistributedVector
   const DistributedVector<T> * v = cast_ptr<const DistributedVector<T> *>(&V);
 
   // Make sure that the two vectors are distributed in the same way.
   libmesh_assert_equal_to ( this->first_local_index(), v->first_local_index() );
   libmesh_assert_equal_to ( this->last_local_index(), v->last_local_index()  );
 
   // The result of dotting together the local parts of the vector.
   T local_dot = 0;
 
   for (std::size_t i=0; i<this->local_size(); i++)
     local_dot += this->_values[i] * v->_values[i];
 
   // The local dot products are now summed via MPI
   this->comm().sum(local_dot);
 
   return local_dot;
 }

◆ el()

template<typename T>

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

inlinevirtualinherited

Returns: (*this)(i).

Definition at line 346 of file numeric_vector.h.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

◆ first_local_index()

template<typename T >

numeric_index_type libMesh::DistributedVector< T >::first_local_index ( ) const

inlineoverridevirtual

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

Note: The minimum for this index is 0.

Implements libMesh::NumericVector< T >.

Definition at line 523 of file distributed_vector.h.

References libMesh::initialized().

Referenced by libMesh::DistributedVector< T >::dot().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   return _first_local_index;
 }

◆ get() [1/2]

template<typename T>

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

inlinevirtualinherited

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

Reimplemented in libMesh::PetscVector< T >.

Definition at line 806 of file numeric_vector.h.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::AdjointRefinementEstimator::estimate_error(), and libMesh::FEMContext::pre_fe_reinit().

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

◆ get() [2/2]

template<typename T>

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

inlineinherited

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

Definition at line 820 of file numeric_vector.h.

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

◆ get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

◆ global_relative_compare()

template<typename T>

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

virtualinherited

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

Definition at line 169 of file numeric_vector.C.

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

◆ increment_constructor_count()

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

inlineprotectedinherited

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

Definition at line 181 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

inlineprotectedinherited

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

Definition at line 194 of file reference_counter.h.

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

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

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

◆ init() [1/4]

template<typename T >

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

inlineoverridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 314 of file distributed_vector.h.

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

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

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert_less_equal (n_local, n);
 
   if (ptype == AUTOMATIC)
     {
       if (n == n_local)
         this->_type = SERIAL;
       else
         this->_type = PARALLEL;
     }
   else
     this->_type = ptype;
 
   libmesh_assert ((this->_type==SERIAL && n==n_local) ||
                   this->_type==PARALLEL);
 
   // Clear the data structures if already initialized
   if (this->initialized())
     this->clear();
 
   // Initialize data structures
   _values.resize(n_local);
   _local_size  = n_local;
   _global_size = n;
 
   _first_local_index = 0;
 
 #ifdef LIBMESH_HAVE_MPI
 
   std::vector<numeric_index_type> local_sizes (this->n_processors(), 0);
 
   local_sizes[this->processor_id()] = n_local;
 
   this->comm().sum(local_sizes);
 
   // _first_local_index is the sum of _local_size
   // for all processor ids less than ours
   for (processor_id_type p=0; p!=this->processor_id(); p++)
     _first_local_index += local_sizes[p];
 
 
 #  ifdef DEBUG
   // Make sure all the local sizes sum up to the global
   // size, otherwise there is big trouble!
   numeric_index_type dbg_sum=0;
 
   for (processor_id_type p=0; p!=this->n_processors(); p++)
     dbg_sum += local_sizes[p];
 
   libmesh_assert_equal_to (dbg_sum, n);
 
 #  endif
 
 #else
 
   // No other options without MPI!
   if (n != n_local)
     libmesh_error_msg("ERROR:  MPI is required for n != n_local!");
 
 #endif
 
   _last_local_index = _first_local_index + n_local;
 
   // Set the initialized flag
   this->_is_initialized = true;
 
   // Zero the components unless directed otherwise
   if (!fast)
     this->zero();
 }

◆ init() [2/4]

template<typename T >

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

inlineoverridevirtual

Call init() with n_local = N.

Implements libMesh::NumericVector< T >.

Definition at line 420 of file distributed_vector.h.

References libMesh::TriangleWrapper::init().

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

◆ init() [3/4]

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 395 of file distributed_vector.h.

References libMesh::TriangleWrapper::init().

 {
   // TODO: we shouldn't ignore the ghost sparsity pattern
   this->init(n, n_local, fast, ptype);
 }

◆ init() [4/4]

template<class T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 410 of file distributed_vector.h.

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

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

◆ initialized()

template<typename T>

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

inlinevirtualinherited

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

Definition at line 149 of file numeric_vector.h.

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

149 { return _is_initialized; }

libMesh::NumericVector::_is_initialized

bool _is_initialized

Definition: numeric_vector.h:717

◆ insert() [1/5]

template<typename T>

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

virtualinherited

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

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

Definition at line 82 of file numeric_vector.C.

 {
   for (numeric_index_type i=0; i<dof_indices.size(); i++)
     this->set (dof_indices[i], v[i]);
 }

◆ insert() [2/5]

template<typename T>

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

inlineinherited

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

Definition at line 859 of file numeric_vector.h.

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

◆ insert() [3/5]

template<typename T>

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

virtualinherited

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

Definition at line 92 of file numeric_vector.C.

 {
   libmesh_assert_equal_to (V.size(), dof_indices.size());
 
   for (numeric_index_type i=0; i<dof_indices.size(); i++)
     this->set (dof_indices[i], V(i));
 }

◆ insert() [4/5]

template<typename T>

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

inlineinherited

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

Definition at line 871 of file numeric_vector.h.

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

◆ insert() [5/5]

template<typename T>

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

inlineinherited

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

Definition at line 883 of file numeric_vector.h.

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

◆ l1_norm()

template<typename T >

Real libMesh::DistributedVector< T >::l1_norm ( ) const

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 65 of file distributed_vector.C.

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

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   double local_l1 = 0.;
 
   for (numeric_index_type i=0; i<local_size(); i++)
     local_l1 += std::abs(_values[i]);
 
   this->comm().sum(local_l1);
 
   return local_l1;
 }

◆ l2_norm()

template<typename T >

Real libMesh::DistributedVector< T >::l2_norm ( ) const

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 87 of file distributed_vector.C.

References libMesh::initialized(), and libMesh::TensorTools::norm_sq().

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   double local_l2 = 0.;
 
   for (numeric_index_type i=0; i<local_size(); i++)
     local_l2 += TensorTools::norm_sq(_values[i]);
 
   this->comm().sum(local_l2);
 
   return std::sqrt(local_l2);
 }

◆ last_local_index()

template<typename T >

numeric_index_type libMesh::DistributedVector< T >::last_local_index ( ) const

inlineoverridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 536 of file distributed_vector.h.

References libMesh::initialized().

Referenced by libMesh::DistributedVector< T >::dot().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   return _last_local_index;
 }

◆ linfty_norm()

template<typename T >

Real libMesh::DistributedVector< T >::linfty_norm ( ) const

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 109 of file distributed_vector.C.

References std::abs(), libMesh::initialized(), std::max(), and libMesh::Real.

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   Real local_linfty = 0.;
 
   for (numeric_index_type i=0; i<local_size(); i++)
     local_linfty  = std::max(local_linfty,
                              static_cast<Real>(std::abs(_values[i]))
                              ); // Note we static_cast so that both
                                 // types are the same, as required
                                 // by std::max
 
   this->comm().max(local_linfty);
 
   return local_linfty;
 }

◆ local_relative_compare()

template<typename T>

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

virtualinherited

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

Definition at line 136 of file numeric_vector.C.

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

◆ local_size()

template<typename T >

numeric_index_type libMesh::DistributedVector< T >::local_size ( ) const

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 510 of file distributed_vector.h.

References libMesh::initialized().

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   return _local_size;
 }

◆ localize() [1/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 550 of file distributed_vector.C.

References libMesh::initialized().

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

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   v_local = this->_values;
 
   this->comm().allgather (v_local);
 
 #ifndef LIBMESH_HAVE_MPI
   libmesh_assert_equal_to (local_size(), size());
 #endif
 }

◆ localize() [2/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 377 of file distributed_vector.C.

References libMesh::DistributedVector< T >::_first_local_index, libMesh::DistributedVector< T >::_global_size, libMesh::NumericVector< T >::_is_closed, libMesh::NumericVector< T >::_is_initialized, libMesh::DistributedVector< T >::_last_local_index, libMesh::DistributedVector< T >::_local_size, libMesh::DistributedVector< T >::_values, and libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   DistributedVector<T> * v_local = cast_ptr<DistributedVector<T> *>(&v_local_in);
 
   v_local->_first_local_index = 0;
 
   v_local->_global_size =
     v_local->_local_size =
     v_local->_last_local_index = size();
 
   v_local->_is_initialized =
     v_local->_is_closed = true;
 
   // Call localize on the vector's values.  This will help
   // prevent code duplication
   localize (v_local->_values);
 
 #ifndef LIBMESH_HAVE_MPI
 
   libmesh_assert_equal_to (local_size(), size());
 
 #endif
 }

◆ localize() [3/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 409 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   // TODO: We don't yet support the send list; this is inefficient:
   localize (v_local_in);
 }

◆ localize() [4/5]

template<typename T >

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

overridevirtual

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

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

Example:

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

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

Implements libMesh::NumericVector< T >.

Definition at line 423 of file distributed_vector.C.

References libMesh::Parallel::pull_parallel_vector_data().

 {
   // Resize v_local so there is enough room to hold all the local values.
   v_local.resize(indices.size());
 
   // We need to know who has the values we want, so get everyone's _local_size
   std::vector<numeric_index_type> local_sizes;
   this->comm().allgather (_local_size, local_sizes);
 
   // Make a vector of partial sums of local sizes
   std::vector<numeric_index_type> local_size_sums(this->n_processors());
   local_size_sums[0] = local_sizes[0];
   for (numeric_index_type i=1; i<local_sizes.size(); i++)
     local_size_sums[i] = local_size_sums[i-1] + local_sizes[i];
 
   // We now fill in 'requested_ids' based on the indices.  Also keep
   // track of the local index (in the indices vector) for each of
   // these, since we need that when unpacking.
   std::map<processor_id_type, std::vector<numeric_index_type>>
     requested_ids, local_requested_ids;
 
   // We'll use this typedef a couple of times below.
   typedef typename std::vector<numeric_index_type>::iterator iter_t;
 
   // For each index in indices, determine which processor it is on.
   // This is an O(N*log(p)) algorithm that uses std::upper_bound().
   // Note: upper_bound() returns an iterator to the first entry which is
   // greater than the given value.
   for (numeric_index_type i=0; i<indices.size(); i++)
     {
       iter_t ub = std::upper_bound(local_size_sums.begin(),
                                    local_size_sums.end(),
                                    indices[i]);
 
       processor_id_type on_proc = cast_int<processor_id_type>
         (std::distance(local_size_sums.begin(), ub));
 
       requested_ids[on_proc].push_back(indices[i]);
       local_requested_ids[on_proc].push_back(i);
     }
 
   auto gather_functor =
     [this]
     (processor_id_type, const std::vector<dof_id_type> & ids,
      std::vector<T> & values)
     {
       // The first send/receive we did was for indices, the second one will be
       // for corresponding floating point values, so create storage for that now...
       const std::size_t ids_size = ids.size();
       values.resize(ids_size);
 
       for (std::size_t i=0; i != ids_size; i++)
         {
           // The index of the requested value
           const numeric_index_type requested_index = ids[i];
 
           // Transform into local numbering, and get requested value.
           values[i] = _values[requested_index - _first_local_index];
         }
     };
 
   auto action_functor =
     [& v_local, & local_requested_ids]
     (processor_id_type pid,
      const std::vector<dof_id_type> &,
      const std::vector<T> & values)
     {
       // Now write the received values to the appropriate place(s) in v_local
       for (std::size_t i=0, vsize = values.size(); i != vsize; i++)
         {
           libmesh_assert(local_requested_ids.count(pid));
           libmesh_assert_less(i, local_requested_ids[pid].size());
 
           // Get the index in v_local where this value needs to be inserted.
           const numeric_index_type local_requested_index =
             local_requested_ids[pid][i];
 
           // Actually set the value in v_local
           v_local[local_requested_index] = values[i];
         }
     };
 
   const T * ex = nullptr;
   Parallel::pull_parallel_vector_data
     (this->comm(), requested_ids, gather_functor, action_functor, ex);
 }

◆ localize() [5/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 514 of file distributed_vector.C.

References libMesh::DistributedVector< T >::_values, libMesh::DistributedVector< T >::init(), libMesh::DistributedVector< T >::localize(), and libMesh::PARALLEL.

 {
   // Only good for serial vectors
   libmesh_assert_equal_to (this->size(), this->local_size());
   libmesh_assert_greater (last_local_idx, first_local_idx);
   libmesh_assert_less_equal (send_list.size(), this->size());
   libmesh_assert_less (last_local_idx, this->size());
 
   const numeric_index_type my_size       = this->size();
   const numeric_index_type my_local_size = (last_local_idx - first_local_idx + 1);
 
   // Don't bother for serial cases
   if ((first_local_idx == 0) &&
       (my_local_size == my_size))
     return;
 
 
   // Build a parallel vector, initialize it with the local
   // parts of (*this)
   DistributedVector<T> parallel_vec(this->comm());
 
   parallel_vec.init (my_size, my_local_size, true, PARALLEL);
 
   // Copy part of *this into the parallel_vec
   for (numeric_index_type i=first_local_idx; i<=last_local_idx; i++)
     parallel_vec._values[i-first_local_idx] = _values[i];
 
   // localize like normal
   parallel_vec.localize (*this, send_list);
 }

◆ localize_to_one()

template<typename T >

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

overridevirtual

Creates a local copy of the global vector in v_local only on processor proc_id. By default the data is sent to processor 0. This method is useful for outputting data from one processor.

Implements libMesh::NumericVector< T >.

Definition at line 571 of file distributed_vector.C.

References libMesh::initialized().

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   v_local = this->_values;
 
   this->comm().gather (pid, v_local);
 
 #ifndef LIBMESH_HAVE_MPI
   libmesh_assert_equal_to (local_size(), size());
 #endif
 }

◆ max()

template<typename T >

Real libMesh::DistributedVector< T >::max ( ) const

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 617 of file distributed_vector.h.

References libMesh::initialized(), libMesh::libmesh_real(), std::max(), and libMesh::Real.

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   Real local_max = _values.size() ?
     libmesh_real(_values[0]) : -std::numeric_limits<Real>::max();
   for (numeric_index_type i = 1; i < _values.size(); ++i)
     local_max = std::max(libmesh_real(_values[i]), local_max);
 
   this->comm().max(local_max);
 
   return local_max;
 }

◆ min()

template<typename T >

Real libMesh::DistributedVector< T >::min ( ) const

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 594 of file distributed_vector.h.

References libMesh::initialized(), libMesh::libmesh_real(), std::max(), std::min(), and libMesh::Real.

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   Real local_min = _values.size() ?
     libmesh_real(_values[0]) : std::numeric_limits<Real>::max();
   for (numeric_index_type i = 1; i < _values.size(); ++i)
     local_min = std::min(libmesh_real(_values[i]), local_min);
 
   this->comm().min(local_min);
 
   return local_min;
 }

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:130

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

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

libMesh::Parallel::Communicator::size

processor_id_type size() const

Definition: communicator.h:175

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ operator()()

template<typename T >

T libMesh::DistributedVector< T >::operator() ( const numeric_index_type i ) const

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 549 of file distributed_vector.h.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
   libmesh_assert ( ((i >= first_local_index()) &&
                     (i <  last_local_index())) );
 
   return _values[i - _first_local_index];
 }

◆ operator*=()

template<typename T>

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

inlineinherited

Scales the vector by a, $\vec{u} \leftarrow a\vec{u}$ . Equivalent to u.scale(a)

Returns: A reference to *this.

Definition at line 391 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

◆ operator+=()

template<typename T >

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

overridevirtual

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

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 135 of file distributed_vector.C.

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

 {
   libmesh_assert (this->closed());
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   add(1., v);
 
   return *this;
 }

◆ operator-=()

template<typename T >

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

overridevirtual

Subtracts v from *this, $\vec{u} \leftarrow \vec{u} - \vec{v}$ . Equivalent to u.add(-1, v).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 150 of file distributed_vector.C.

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

 {
   libmesh_assert (this->closed());
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   add(-1., v);
 
   return *this;
 }

◆ operator/=() [1/2]

template<typename T >

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

overridevirtual

Computes the pointwise division of this vector's entries by another's, $u_i \leftarrow \frac{u_i}{v_i} \, \forall i$

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 165 of file distributed_vector.C.

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

 {
   libmesh_assert_equal_to(size(), v.size());
 
   const DistributedVector<T> & v_vec = cast_ref<const DistributedVector<T> &>(v);
 
   std::size_t val_size = _values.size();
 
   for (std::size_t i=0; i<val_size; i++)
     _values[i] = _values[i] / v_vec._values[i];
 
   return *this;
 }

◆ operator/=() [2/2]

template<typename T>

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

inlineinherited

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

Returns: A reference to *this.

Definition at line 400 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

◆ operator=() [1/5]

template<typename T >

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

Copy assignment operator. We cannot default this (although it essentially implements the default behavior) because the compiler-generated default attempts to automatically call the base class (NumericVector) copy assignment operator, which we have chosen to make pure virtual for other design reasons.

Definition at line 332 of file distributed_vector.C.

References libMesh::DistributedVector< T >::_first_local_index, libMesh::DistributedVector< T >::_global_size, libMesh::NumericVector< T >::_is_closed, libMesh::libMeshPrivateData::_is_initialized, libMesh::NumericVector< T >::_is_initialized, libMesh::DistributedVector< T >::_last_local_index, libMesh::DistributedVector< T >::_local_size, libMesh::DistributedVector< T >::_values, and libMesh::DistributedVector< T >::local_size().

 {
   this->_is_initialized    = v._is_initialized;
   this->_is_closed         = v._is_closed;
 
   _global_size       = v._global_size;
   _local_size        = v._local_size;
   _first_local_index = v._first_local_index;
   _last_local_index  = v._last_local_index;
 
   if (v.local_size() == this->local_size())
     _values = v._values;
 
   else
     libmesh_error_msg("v.local_size() = " << v.local_size() << " must be equal to this->local_size() = " << this->local_size());
 
   return *this;
 }

◆ operator=() [2/5]

template<typename T>

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

default

◆ operator=() [3/5]

template<typename T >

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

overridevirtual

Sets all entries of the vector to the value s.

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 302 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   for (std::size_t i=0; i<local_size(); i++)
     _values[i] = s;
 
   return *this;
 }

◆ operator=() [4/5]

template<typename T >

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

overridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 318 of file distributed_vector.C.

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

◆ operator=() [5/5]

template<typename T >

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

overridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 355 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   if (v.size() == local_size())
     _values = v;
 
   else if (v.size() == size())
     for (std::size_t i=first_local_index(); i<last_local_index(); i++)
       _values[i-first_local_index()] = v[i];
 
   else
     libmesh_error_msg("Incompatible sizes in DistributedVector::operator=");
 
   return *this;
 }

◆ pointwise_mult()

template<typename T >

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

overridevirtual

Computes $u_i \leftarrow u_i v_i$ (summation not implied) i.e. the pointwise (component-wise) product of vec1 and vec2, and stores the result in *this.

Implements libMesh::NumericVector< T >.

Definition at line 593 of file distributed_vector.C.

 {
   libmesh_not_implemented();
 }

◆ print() [1/2]

template<typename T >

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

inlinevirtualinherited

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

Definition at line 916 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 (numeric_index_type i=this->first_local_index(); i<this->last_local_index(); i++)
     os << i << "\t" << (*this)(i) << std::endl;
 }

◆ print() [2/2]

template<>

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

inlineinherited

Definition at line 898 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 (numeric_index_type i=this->first_local_index(); i<this->last_local_index(); i++)
     os << i << "\t"
        << (*this)(i).real() << "\t\t"
        << (*this)(i).imag() << std::endl;
 }

◆ print_global() [1/2]

template<typename T >

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

inlinevirtualinherited

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

Definition at line 953 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 (numeric_index_type i=0; i!=v.size(); i++)
     os << i << "\t" << v[i] << std::endl;
 }

◆ print_global() [2/2]

template<>

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

inlineinherited

Definition at line 931 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 (numeric_index_type i=0; i!=v.size(); i++)
     os << i << "\t"
        << v[i].real() << "\t\t"
        << v[i].imag() << std::endl;
 }

◆ print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

◆ print_matlab()

template<typename T>

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

inlinevirtualinherited

Print the contents of the vector in Matlab's sparse matrix format. Optionally prints the vector to the file named name. If name is not specified it is dumped to the screen.

Reimplemented in libMesh::PetscVector< T >.

Definition at line 681 of file numeric_vector.h.

   {
     libmesh_not_implemented();
   }

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

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

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

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

Definition: communicator.h:173

◆ reciprocal()

template<typename T >

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

overridevirtual

Computes the pointwise reciprocal, $u_i \leftarrow \frac{1}{u_i} \, \forall i$

Implements libMesh::NumericVector< T >.

Definition at line 183 of file distributed_vector.C.

 {
   for (numeric_index_type i=0; i<local_size(); i++)
     {
       // Don't divide by zero
       libmesh_assert_not_equal_to (_values[i], T(0));
 
       _values[i] = 1. / _values[i];
     }
 }

◆ scale()

template<typename T >

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

overridevirtual

Scale each element of the vector by the given factor.

Implements libMesh::NumericVector< T >.

Definition at line 249 of file distributed_vector.C.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   for (std::size_t i=0; i<local_size(); i++)
     _values[i] *= factor;
 }

◆ set()

template<typename T >

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

inlineoverridevirtual

Sets v(i) = value.

Implements libMesh::NumericVector< T >.

Definition at line 564 of file distributed_vector.h.

References libMesh::initialized(), and value.

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
   libmesh_assert_less (i, size());
   libmesh_assert_less (i-first_local_index(), local_size());
 
   _values[i - _first_local_index] = value;
 }

◆ size()

template<typename T >

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

inlineoverridevirtual

Returns: The size of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 497 of file distributed_vector.h.

References libMesh::initialized().

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   return _global_size;
 }

◆ subset_l1_norm()

template<class T >

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

virtualinherited

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

Note: The indices must necessarily live on this processor.

Definition at line 311 of file numeric_vector.C.

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

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

◆ subset_l2_norm()

template<class T >

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

virtualinherited

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

Note: The indices must necessarily live on this processor.

Definition at line 326 of file numeric_vector.C.

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

 {
   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);
 }

◆ subset_linfty_norm()

template<class T >

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

virtualinherited

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

Note: The indices must necessarily live on this processor.

Definition at line 341 of file numeric_vector.C.

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

 {
   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;
 }

◆ sum()

template<typename T >

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

overridevirtual

Returns: The sum of all values in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 43 of file distributed_vector.C.

References libMesh::initialized().

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   T local_sum = 0.;
 
   for (numeric_index_type i=0; i<local_size(); i++)
     local_sum += _values[i];
 
   this->comm().sum(local_sum);
 
   return local_sum;
 }

◆ swap()

template<typename T >

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

inlineoverridevirtual

Swaps the contents of this with v. There should be enough indirection in subclasses to make this an O(1) header-swap operation.

Reimplemented from libMesh::NumericVector< T >.

Definition at line 639 of file distributed_vector.h.

References libMesh::DistributedVector< T >::_first_local_index, libMesh::DistributedVector< T >::_global_size, libMesh::DistributedVector< T >::_last_local_index, libMesh::DistributedVector< T >::_local_size, libMesh::DistributedVector< T >::_values, and swap().

 {
   DistributedVector<T> & v = cast_ref<DistributedVector<T> &>(other);
 
   std::swap(_global_size, v._global_size);
   std::swap(_local_size, v._local_size);
   std::swap(_first_local_index, v._first_local_index);
   std::swap(_last_local_index, v._last_local_index);
 
   // This should be O(1) with any reasonable STL implementation
   std::swap(_values, v._values);
 }

◆ type() [1/2]

template<typename T>

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

inlineinherited

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

Definition at line 154 of file numeric_vector.h.

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

154 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

Definition: numeric_vector.h:722

◆ type() [2/2]

template<typename T>

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

inlineinherited

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

Definition at line 159 of file numeric_vector.h.

159 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

Definition: numeric_vector.h:722

◆ zero()

template<typename T >

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

inlineoverridevirtual

Set all entries to zero. Equivalent to v = 0, but more obvious and faster.

Implements libMesh::NumericVector< T >.

Definition at line 459 of file distributed_vector.h.

References libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (_values.size(), _local_size);
   libmesh_assert_equal_to ((_last_local_index - _first_local_index), _local_size);
 
   std::fill (_values.begin(),
              _values.end(),
              0.);
 }

◆ zero_clone()

template<typename T >

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

inlineoverridevirtual

Returns: A smart pointer to a copy of this vector with the same type, size, and partitioning, but with all zero entries.

Note: This must be overridden in the derived classes.

Implements libMesh::NumericVector< T >.

Definition at line 474 of file distributed_vector.h.

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

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

Member Data Documentation

◆ _communicator

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

protectedinherited

Definition at line 107 of file parallel_object.h.

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

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

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

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 141 of file reference_counter.h.

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

◆ _first_local_index

template<typename T>

numeric_index_type libMesh::DistributedVector< T >::_first_local_index

private

The first component stored locally.

Definition at line 247 of file distributed_vector.h.

Referenced by libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::DistributedVector< T >::swap().

◆ _global_size

template<typename T>

numeric_index_type libMesh::DistributedVector< T >::_global_size

private

The global vector size.

Definition at line 237 of file distributed_vector.h.

Referenced by libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::DistributedVector< T >::swap().

◆ _is_closed

template<typename T>

bool libMesh::NumericVector< T >::_is_closed

protectedinherited

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

Definition at line 712 of file numeric_vector.h.

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

◆ _is_initialized

template<typename T>

bool libMesh::NumericVector< T >::_is_initialized

protectedinherited

true once init() has been called.

Definition at line 717 of file numeric_vector.h.

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

◆ _last_local_index

template<typename T>

numeric_index_type libMesh::DistributedVector< T >::_last_local_index

private

The last component (+1) stored locally.

Definition at line 252 of file distributed_vector.h.

Referenced by libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::DistributedVector< T >::swap().

◆ _local_size

template<typename T>

numeric_index_type libMesh::DistributedVector< T >::_local_size

private

The local vector size.

Definition at line 242 of file distributed_vector.h.

Referenced by libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::DistributedVector< T >::swap().

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 130 of file reference_counter.h.

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

◆ _type

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

Type of vector.

Definition at line 722 of file numeric_vector.h.

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

◆ _values

template<typename T>

std::vector<T> libMesh::DistributedVector< T >::_values

private

Actual vector datatype to hold vector entries.

Definition at line 232 of file distributed_vector.h.

Referenced by libMesh::DistributedVector< T >::dot(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=(), and libMesh::DistributedVector< T >::swap().

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

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Attributes

Detailed Description

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

Member Typedef Documentation

◆ Counts

Constructor & Destructor Documentation

◆ DistributedVector() [1/6]

◆ DistributedVector() [2/6]

◆ DistributedVector() [3/6]

◆ DistributedVector() [4/6]

◆ DistributedVector() [5/6]

◆ DistributedVector() [6/6]

◆ ~DistributedVector()

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

◆ conjugate()

◆ create_subvector()

◆ disable_print_counter_info()

◆ dot()

◆ el()

◆ enable_print_counter_info()

◆ first_local_index()

◆ get() [1/2]

◆ get() [2/2]

◆ get_info()

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

◆ l1_norm()

◆ l2_norm()

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

◆ min()

◆ n_objects()

◆ n_processors()

◆ operator()()

◆ operator*=()

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