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

#include <trilinos_epetra_vector.h>

Inheritance diagram for libMesh::EpetraVector< T >:

Public Member Functions
	EpetraVector (const Parallel::Communicator &comm, const ParallelType type=AUTOMATIC)
	Dummy-Constructor. More...

	EpetraVector (const Parallel::Communicator &comm, const numeric_index_type n, const ParallelType type=AUTOMATIC)
	Constructor. More...

	EpetraVector (const Parallel::Communicator &comm, const numeric_index_type n, const numeric_index_type n_local, const ParallelType type=AUTOMATIC)
	Constructor. More...

	EpetraVector (const Parallel::Communicator &comm, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType type=AUTOMATIC)
	Constructor. More...

	EpetraVector (Epetra_Vector &v, const Parallel::Communicator &comm)
	Constructor. More...

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

	EpetraVector (const EpetraVector &)=delete

EpetraVector &	operator= (const EpetraVector &)=delete

EpetraVector &	operator= (EpetraVector &&)=delete

virtual	~EpetraVector ()

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

virtual void	clear () noexcept override
	clear() is called from the destructor, so it should not throw. More...

virtual void	zero () override
	Set all entries to zero. More...

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

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

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

virtual void	init (const numeric_index_type N, const bool fast=false, const ParallelType type=AUTOMATIC) override
	Call `init()` with n_local = N. More...

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

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

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

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

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

virtual Real	min () const override

virtual Real	max () const override

virtual T	sum () const override

virtual Real	l1_norm () const override

virtual Real	l2_norm () const override

virtual Real	linfty_norm () const override

virtual numeric_index_type	size () const override

virtual numeric_index_type	local_size () const override

virtual numeric_index_type	first_local_index () const override

virtual numeric_index_type	last_local_index () const override

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

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

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

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

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

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

virtual void	conjugate () override
	Negates the imaginary component of each entry in the vector. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual std::size_t	max_allowed_id () const override

Epetra_Vector *	vec ()

virtual bool	initialized () const

ParallelType	type () const

ParallelType &	type ()

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

virtual bool	closed () const

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

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

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

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

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

virtual T	el (const numeric_index_type i) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool	readable () const

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

const Parallel::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`. More...

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

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

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

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

static void	disable_print_counter_info ()

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

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

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

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

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

ParallelType	_type
	Type of vector. More...

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

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...

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

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

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

Private Member Functions
int	SumIntoGlobalValues (int numIDs, const int GIDs, const double values)
	Accumulate values into the vector, adding them to any values that already exist for the specified indices. More...

int	SumIntoGlobalValues (const Epetra_IntSerialDenseVector &GIDs, const Epetra_SerialDenseVector &values)
	Accumulate values into the vector, adding them to any values that already exist for the specified GIDs. More...

int	ReplaceGlobalValues (int numIDs, const int GIDs, const double values)
	Copy values into the vector overwriting any values that already exist for the specified indices. More...

int	ReplaceGlobalValues (const Epetra_IntSerialDenseVector &GIDs, const Epetra_SerialDenseVector &values)
	Copy values into the vector, replacing any values that already exist for the specified GIDs. More...

int	SumIntoGlobalValues (int numIDs, const int GIDs, const int numValuesPerID, const double *values)

int	ReplaceGlobalValues (int numIDs, const int GIDs, const int numValuesPerID, const double *values)

int	GlobalAssemble (Epetra_CombineMode mode=Add)
	Gather any overlapping/shared data into the non-overlapping partitioning defined by the Map that was passed to this vector at construction time. More...

void	setIgnoreNonLocalEntries (bool flag)
	Set whether or not non-local data values should be ignored. More...

void	FEoperatorequals (const EpetraVector &source)

int	inputValues (int numIDs, const int GIDs, const double values, bool accumulate)

int	inputValues (int numIDs, const int GIDs, const int numValuesPerID, const double *values, bool accumulate)

int	inputNonlocalValue (int GID, double value, bool accumulate)

int	inputNonlocalValues (int GID, int numValues, const double *values, bool accumulate)

void	destroyNonlocalData ()

Private Attributes
Epetra_Vector *	_vec
	Actual Epetra vector datatype to hold vector entries. More...

std::unique_ptr< Epetra_Map >	_map
	Holds the distributed Map. More...

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

int	myFirstID_

int	myNumIDs_

double *	myCoefs_

int *	nonlocalIDs_

int *	nonlocalElementSize_

int	numNonlocalIDs_

int	allocatedNonlocalLength_

double **	nonlocalCoefs_

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

bool	ignoreNonLocalEntries_

Detailed Description

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

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

All overridden virtual functions are documented in numeric_vector.h.

Author: Derek R. Gaston

Date: 2008

Definition at line 65 of file trilinos_epetra_vector.h.

Member Typedef Documentation

◆ Counts

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

◆ EpetraVector() [1/7]

template<typename T >

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

inlineexplicit

Dummy-Constructor.

Dimension=0

Definition at line 414 of file trilinos_epetra_vector.h.

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

                                                         :
   NumericVector<T>(comm, type),
   _destroy_vec_on_exit(true),
   myFirstID_(0),
   myNumIDs_(0),
   myCoefs_(nullptr),
   nonlocalIDs_(nullptr),
   nonlocalElementSize_(nullptr),
   numNonlocalIDs_(0),
   allocatedNonlocalLength_(0),
   nonlocalCoefs_(nullptr),
   last_edit(0),
   ignoreNonLocalEntries_(false)
 {
   this->_type = type;
 }

◆ EpetraVector() [2/7]

template<typename T >

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

inlineexplicit

Constructor.

Set dimension to n and initialize all elements with zero.

Definition at line 436 of file trilinos_epetra_vector.h.

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

                                                         :
   NumericVector<T>(comm, type),
   _destroy_vec_on_exit(true),
   myFirstID_(0),
   myNumIDs_(0),
   myCoefs_(nullptr),
   nonlocalIDs_(nullptr),
   nonlocalElementSize_(nullptr),
   numNonlocalIDs_(0),
   allocatedNonlocalLength_(0),
   nonlocalCoefs_(nullptr),
   last_edit(0),
   ignoreNonLocalEntries_(false)
 
 {
   this->init(n, n, false, type);
 }

◆ EpetraVector() [3/7]

template<typename T >

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

inline

Constructor.

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

Definition at line 460 of file trilinos_epetra_vector.h.

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

                                                         :
   NumericVector<T>(comm, type),
   _destroy_vec_on_exit(true),
   myFirstID_(0),
   myNumIDs_(0),
   myCoefs_(nullptr),
   nonlocalIDs_(nullptr),
   nonlocalElementSize_(nullptr),
   numNonlocalIDs_(0),
   allocatedNonlocalLength_(0),
   nonlocalCoefs_(nullptr),
   last_edit(0),
   ignoreNonLocalEntries_(false)
 {
   this->init(n, n_local, false, type);
 }

◆ EpetraVector() [4/7]

template<typename T >

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

inline

Constructor.

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

Definition at line 526 of file trilinos_epetra_vector.h.

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

                                                         :
   NumericVector<T>(comm, AUTOMATIC),
   _destroy_vec_on_exit(true),
   myFirstID_(0),
   myNumIDs_(0),
   myCoefs_(nullptr),
   nonlocalIDs_(nullptr),
   nonlocalElementSize_(nullptr),
   numNonlocalIDs_(0),
   allocatedNonlocalLength_(0),
   nonlocalCoefs_(nullptr),
   last_edit(0),
   ignoreNonLocalEntries_(false)
 {
   this->init(n, n_local, ghost, false, type);
 }

◆ EpetraVector() [5/7]

template<typename T >

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

inline

Constructor.

Creates a EpetraVector assuming you already have a valid Epetra Vec object. In this case, v is NOT destroyed by the EpetraVector constructor when this object goes out of scope. This allows ownership of v to remain with the original creator, and to simply provide additional functionality with the EpetraVector.

Definition at line 485 of file trilinos_epetra_vector.h.

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

                                                                  :
   NumericVector<T>(comm, AUTOMATIC),
   _destroy_vec_on_exit(false),
   myFirstID_(0),
   myNumIDs_(0),
   myCoefs_(nullptr),
   nonlocalIDs_(nullptr),
   nonlocalElementSize_(nullptr),
   numNonlocalIDs_(0),
   allocatedNonlocalLength_(0),
   nonlocalCoefs_(nullptr),
   last_edit(0),
   ignoreNonLocalEntries_(false)
 {
   _vec = &v;
 
   this->_type = PARALLEL; // FIXME - need to determine this from v!
 
   myFirstID_ = _vec->Map().MinMyGID();
   myNumIDs_ = _vec->Map().NumMyElements();
 
   _map = std::make_unique<Epetra_Map>
     (_vec->GlobalLength(),
      _vec->MyLength(),
      0, // IndexBase = 0 for C/C++, 1 for Fortran.
      Epetra_MpiComm (this->comm().get()));
 
   //Currently we impose the restriction that NumVectors==1, so we won't
   //need the LDA argument when calling ExtractView. Hence the "dummy" arg.
   int dummy;
   _vec->ExtractView(&myCoefs_, &dummy);
 
   this->_is_closed = true;
   this->_is_initialized = true;
 }

◆ EpetraVector() [6/7]

template<typename T>

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

delete

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

◆ EpetraVector() [7/7]

template<typename T>

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

delete

◆ ~EpetraVector()

template<typename T >

libMesh::EpetraVector< T >::~EpetraVector ( )

inlinevirtual

Definition at line 562 of file trilinos_epetra_vector.h.

 {
   this->clear ();
 }

Member Function Documentation

◆ abs()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 325 of file trilinos_epetra_vector.C.

 {
   _vec->Abs(*_vec);
 }

◆ add() [1/4]

template<typename T >

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

overridevirtual

Adds value to the vector entry specified by i.

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

Implements libMesh::NumericVector< T >.

Definition at line 214 of file trilinos_epetra_vector.C.

References value.

 {
   int i = static_cast<int> (i_in);
   T value = value_in;
 
   libmesh_assert_less (i_in, this->size());
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   SumIntoGlobalValues(1, &i, &value);
 
   this->_is_closed = false;
 }

◆ add() [2/4]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 271 of file trilinos_epetra_vector.C.

 {
   const unsigned int nl = _vec->MyLength();
 
   T * values = _vec->Values();
 
   for (unsigned int i=0; i<nl; i++)
     values[i]+=v_in;
 
   this->_is_closed = false;
 }

◆ add() [3/4]

template<typename T >

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

overridevirtual

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

Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 285 of file trilinos_epetra_vector.C.

 {
   this->add (1., v);
 }

◆ add() [4/4]

template<typename T >

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

overridevirtual

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

Equivalent to calling operator+=().

Implements libMesh::NumericVector< T >.

Definition at line 292 of file trilinos_epetra_vector.C.

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

 {
   const EpetraVector<T> * v = cast_ptr<const EpetraVector<T> *>(&v_in);
 
   libmesh_assert_equal_to (this->size(), v->size());
 
   _vec->Update(a_in,*v->_vec, 1.);
 }

◆ add_vector() [1/6]

template<typename T >

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

overridevirtual

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

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

Reimplemented from libMesh::NumericVector< T >.

Definition at line 230 of file trilinos_epetra_vector.C.

References libMesh::numeric_trilinos_cast().

 {
   libmesh_assert_equal_to (sizeof(numeric_index_type), sizeof(int));
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   SumIntoGlobalValues (cast_int<numeric_index_type>(dof_indices.size()),
                        numeric_trilinos_cast(dof_indices.data()),
                        const_cast<T *>(v));
 }

◆ add_vector() [2/6]

template<typename T >

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

overridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 245 of file trilinos_epetra_vector.C.

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

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

◆ add_vector() [3/6]

template<typename T>

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

inlineinherited

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

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

Definition at line 959 of file numeric_vector.h.

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

inherited

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

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

Definition at line 660 of file numeric_vector.C.

 {
   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 DenseVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

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

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

Definition at line 971 of file numeric_vector.h.

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

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

◆ add_vector_transpose()

template<typename T >

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

overridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 262 of file trilinos_epetra_vector.C.

 {
   libmesh_not_implemented();
 }

◆ build()

template<typename T >

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

staticinherited

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

Definition at line 61 of file numeric_vector.C.

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

◆ clear()

template<typename T >

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

inlineoverridevirtualnoexcept

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

Reimplemented from libMesh::NumericVector< T >.

Definition at line 676 of file trilinos_epetra_vector.h.

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

 {
   if (this->initialized())
     {
       // We might just be an interface to a user-provided _vec
       if (this->_destroy_vec_on_exit)
         {
           delete _vec;
           _vec = nullptr;
         }
 
       // But we currently always own our own _map
       _map.reset();
     }
 
   this->_is_closed = this->_is_initialized = false;
 }

◆ clone()

template<typename T >

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

inlineoverridevirtual

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

Note: This must be overridden in the derived classes.

Implements libMesh::NumericVector< T >.

Definition at line 722 of file trilinos_epetra_vector.h.

References libMesh::AUTOMATIC.

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

◆ close()

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 652 of file trilinos_epetra_vector.h.

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

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

 {
   libmesh_assert (this->initialized());
 
   // Are we adding or inserting?
   unsigned char global_last_edit = last_edit;
   this->comm().max(global_last_edit);
   libmesh_assert(!last_edit || last_edit == global_last_edit);
 
   if (global_last_edit == 1)
     this->GlobalAssemble(Insert);
   else if (global_last_edit == 2)
     this->GlobalAssemble(Add);
   else
     libmesh_assert(!global_last_edit);
 
   this->_is_closed = true;
   this->last_edit = 0;
 }

◆ closed()

template<typename T>

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

inlinevirtualinherited

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

Definition at line 182 of file numeric_vector.h.

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

182 { return _is_closed; }

libMesh::NumericVector::_is_closed

bool _is_closed

Flag which tracks whether the vector's values are consistent on all processors after insertion or add...

Definition: numeric_vector.h:831

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:120

◆ compare()

template<typename T>

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

virtualinherited

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

Definition at line 153 of file numeric_vector.C.

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

◆ compatible()

template<typename T>

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

inherited

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

Definition at line 692 of file numeric_vector.C.

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

◆ conjugate()

template<typename T >

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

overridevirtual

Negates the imaginary component of each entry in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 206 of file trilinos_epetra_vector.C.

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

◆ create_subvector()

template<typename T>

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

inlinevirtualinherited

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

Similar to the create_submatrix() routine for the SparseMatrix class, it is currently only implemented for PetscVectors. The boolean parameter communicates whether the supplied vector of rows corresponds to all the rows that should be used in the subvector's index set, e.g. whether the rows correspond to the global collective. If the rows supplied are only the local indices, then the boolean parameter should be set to false

Reimplemented in libMesh::PetscVector< T >.

Definition at line 762 of file numeric_vector.h.

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

   {
     libmesh_not_implemented();
   }

◆ destroyNonlocalData()

template<typename T >

void libMesh::EpetraVector< T >::destroyNonlocalData ( )

private

Definition at line 906 of file trilinos_epetra_vector.C.

 {
   if (allocatedNonlocalLength_ > 0) {
     delete [] nonlocalIDs_;
     delete [] nonlocalElementSize_;
     nonlocalIDs_ = nullptr;
     nonlocalElementSize_ = nullptr;
     for (int i=0; i<numNonlocalIDs_; ++i) {
       delete [] nonlocalCoefs_[i];
     }
     delete [] nonlocalCoefs_;
     nonlocalCoefs_ = nullptr;
     numNonlocalIDs_ = 0;
     allocatedNonlocalLength_ = 0;
   }
   return;
 }

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = false;
   return;
 }

◆ dot()

template<typename T >

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

overridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 332 of file trilinos_epetra_vector.C.

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

 {
   const EpetraVector<T> * v = cast_ptr<const EpetraVector<T> *>(&v_in);
 
   T result=0.0;
 
   _vec->Dot(*v->_vec, &result);
 
   return result;
 }

◆ el()

template<typename T>

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

inlinevirtualinherited

Returns: (*this)(i).

Definition at line 375 of file numeric_vector.h.

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

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

◆ FEoperatorequals()

template<typename T >

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

private

Definition at line 878 of file trilinos_epetra_vector.C.

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

 {
   (*_vec) = *(source._vec);
 
   destroyNonlocalData();
 
   if (source.allocatedNonlocalLength_ > 0) {
     allocatedNonlocalLength_ = source.allocatedNonlocalLength_;
     numNonlocalIDs_ = source.numNonlocalIDs_;
     nonlocalIDs_ = new int[allocatedNonlocalLength_];
     nonlocalElementSize_ = new int[allocatedNonlocalLength_];
     nonlocalCoefs_ = new double *[allocatedNonlocalLength_];
     for (int i=0; i<numNonlocalIDs_; ++i) {
       int elemSize = source.nonlocalElementSize_[i];
       nonlocalCoefs_[i] = new double[elemSize];
       nonlocalIDs_[i] = source.nonlocalIDs_[i];
       nonlocalElementSize_[i] = elemSize;
       for (int j=0; j<elemSize; ++j) {
         nonlocalCoefs_[i][j] = source.nonlocalCoefs_[i][j];
       }
     }
   }
 }

◆ first_local_index()

template<typename T >

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

inlineoverridevirtual

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

Note: The minimum for this index is 0.

Implements libMesh::NumericVector< T >.

Definition at line 755 of file trilinos_epetra_vector.h.

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

 {
   libmesh_assert (this->initialized());
 
   return _vec->Map().MinMyGID();
 }

◆ get() [1/2]

template<typename T>

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

inlinevirtualinherited

Access multiple components at once.

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

Reimplemented in libMesh::PetscVector< T >.

Definition at line 930 of file numeric_vector.h.

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

 {
   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 944 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 & [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
 }

◆ get_subvector()

template<typename T>

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

inlinevirtualinherited

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

Similar to the create_submatrix() routine for the SparseMatrix class, it is currently only implemented for PetscVectors.

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

Definition at line 776 of file numeric_vector.h.

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

   {
     libmesh_not_implemented();
   }

◆ global_relative_compare()

template<typename T>

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

virtualinherited

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

Definition at line 211 of file numeric_vector.C.

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

◆ GlobalAssemble()

template<typename T >

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

private

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

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

Definition at line 832 of file trilinos_epetra_vector.C.

 {
   //In this method we need to gather all the non-local (overlapping) data
   //that's been input on each processor, into the (probably) non-overlapping
   //distribution defined by the map that 'this' vector was constructed with.
 
   //We don't need to do anything if there's only one processor or if
   //ignoreNonLocalEntries_ is true.
   if (_vec->Map().Comm().NumProc() < 2 || ignoreNonLocalEntries_) {
     return(0);
   }
 
 
 
   //First build a map that describes the data in nonlocalIDs_/nonlocalCoefs_.
   //We'll use the arbitrary distribution constructor of Map.
 
   Epetra_BlockMap sourceMap(-1, numNonlocalIDs_,
                             nonlocalIDs_, nonlocalElementSize_,
                             _vec->Map().IndexBase(), _vec->Map().Comm());
 
   //Now build a vector to hold our nonlocalCoefs_, and to act as the source-
   //vector for our import operation.
   Epetra_MultiVector nonlocalVector(sourceMap, 1);
 
   int i,j;
   for (i=0; i<numNonlocalIDs_; ++i) {
     for (j=0; j<nonlocalElementSize_[i]; ++j) {
       nonlocalVector.ReplaceGlobalValue(nonlocalIDs_[i], j, 0,
                                         nonlocalCoefs_[i][j]);
     }
   }
 
   Epetra_Export exporter(sourceMap, _vec->Map());
 
   EPETRA_CHK_ERR( _vec->Export(nonlocalVector, exporter, mode) );
 
   destroyNonlocalData();
 
   return(0);
 }

◆ increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ init() [1/4]

template<typename T >

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

inlineoverridevirtual

Change the dimension of the vector to n.

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

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

Implements libMesh::NumericVector< T >.

Definition at line 571 of file trilinos_epetra_vector.h.

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

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

 {
   // We default to allocating n_local local storage
   numeric_index_type my_n_local = n_local;
 
   if (type == AUTOMATIC)
     {
       if (n == n_local)
         this->_type = SERIAL;
       else
         this->_type = PARALLEL;
     }
   else if (type == GHOSTED)
     {
       // We don't yet support GHOSTED Epetra vectors, so to get the
       // same functionality we need a SERIAL vector with local
       // storage allocated for every entry.
       this->_type = SERIAL;
       my_n_local = n;
     }
   else
     this->_type = type;
 
   libmesh_assert ((this->_type==SERIAL && n==my_n_local) ||
                   this->_type==PARALLEL);
 
   _map = std::make_unique<Epetra_Map>
     (static_cast<int>(n),
      my_n_local,
      0,
      Epetra_MpiComm (this->comm().get()));
 
   _vec = new Epetra_Vector(*_map);
 
   myFirstID_ = _vec->Map().MinMyGID();
   myNumIDs_ = _vec->Map().NumMyElements();
 
   // Currently we impose the restriction that NumVectors==1, so we won't
   // need the LDA argument when calling ExtractView. Hence the "dummy" arg.
   int dummy;
   _vec->ExtractView(&myCoefs_, &dummy);
 
   this->_is_initialized = true;
   this->_is_closed = true;
   this->last_edit = 0;
 
   if (fast == false)
     this->zero ();
 }

◆ init() [2/4]

template<typename T >

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

inlineoverridevirtual

Call init() with n_local = N.

Implements libMesh::NumericVector< T >.

Definition at line 641 of file trilinos_epetra_vector.h.

References libMesh::TriangleWrapper::init().

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

◆ init() [3/4]

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 627 of file trilinos_epetra_vector.h.

References libMesh::TriangleWrapper::init().

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

◆ init() [4/4]

template<class T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 552 of file trilinos_epetra_vector.h.

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

 {
   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::System::add_vector(), libMesh::ImplicitSystem::assemble(), libMesh::PetscVector< libMesh::Number >::create_subvector(), and libMesh::PetscVector< libMesh::Number >::init().

149 { return _is_initialized; }

libMesh::NumericVector::_is_initialized

bool _is_initialized

true once init() has been called.

Definition: numeric_vector.h:836

◆ inputNonlocalValue()

template<typename T >

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

private

Definition at line 730 of file trilinos_epetra_vector.C.

References value.

 {
   int insertPoint = -1;
 
   //find offset of GID in nonlocalIDs_
   int offset = Epetra_Util_binary_search(GID, nonlocalIDs_, numNonlocalIDs_,
                                          insertPoint);
   if (offset >= 0) {
     //if offset >= 0
     //  put value in nonlocalCoefs_[offset][0]
 
     if (accumulate) {
       nonlocalCoefs_[offset][0] += value;
     }
     else {
       nonlocalCoefs_[offset][0] = value;
     }
   }
   else {
     //else
     //  insert GID in nonlocalIDs_
     //  insert 1   in nonlocalElementSize_
     //  insert value in nonlocalCoefs_
 
     int tmp1 = numNonlocalIDs_;
     int tmp2 = allocatedNonlocalLength_;
     int tmp3 = allocatedNonlocalLength_;
     EPETRA_CHK_ERR( Epetra_Util_insert(GID, insertPoint, nonlocalIDs_,
                                        tmp1, tmp2) );
     --tmp1;
     EPETRA_CHK_ERR( Epetra_Util_insert(1, insertPoint, nonlocalElementSize_,
                                        tmp1, tmp3) );
     double * values = new double[1];
     values[0] = value;
     EPETRA_CHK_ERR( Epetra_Util_insert(values, insertPoint, nonlocalCoefs_,
                                        numNonlocalIDs_, allocatedNonlocalLength_) );
   }
 
   return(0);
 }

◆ inputNonlocalValues()

template<typename T >

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

private

Definition at line 773 of file trilinos_epetra_vector.C.

References libMesh::err.

 {
   int insertPoint = -1;
 
   //find offset of GID in nonlocalIDs_
   int offset = Epetra_Util_binary_search(GID, nonlocalIDs_, numNonlocalIDs_,
                                          insertPoint);
   if (offset >= 0) {
     //if offset >= 0
     //  put value in nonlocalCoefs_[offset][0]
 
     if (numValues != nonlocalElementSize_[offset]) {
       libMesh::err << "Epetra_FEVector ERROR: block-size for GID " << GID << " is "
                    << numValues<<" which doesn't match previously set block-size of "
                    << nonlocalElementSize_[offset] << std::endl;
       return(-1);
     }
 
     if (accumulate) {
       for (int j=0; j<numValues; ++j) {
         nonlocalCoefs_[offset][j] += values[j];
       }
     }
     else {
       for (int j=0; j<numValues; ++j) {
         nonlocalCoefs_[offset][j] = values[j];
       }
     }
   }
   else {
     //else
     //  insert GID in nonlocalIDs_
     //  insert numValues   in nonlocalElementSize_
     //  insert values in nonlocalCoefs_
 
     int tmp1 = numNonlocalIDs_;
     int tmp2 = allocatedNonlocalLength_;
     int tmp3 = allocatedNonlocalLength_;
     EPETRA_CHK_ERR( Epetra_Util_insert(GID, insertPoint, nonlocalIDs_,
                                        tmp1, tmp2) );
     --tmp1;
     EPETRA_CHK_ERR( Epetra_Util_insert(numValues, insertPoint, nonlocalElementSize_,
                                        tmp1, tmp3) );
     double * newvalues = new double[numValues];
     for (int j=0; j<numValues; ++j) {
       newvalues[j] = values[j];
     }
     EPETRA_CHK_ERR( Epetra_Util_insert(newvalues, insertPoint, nonlocalCoefs_,
                                        numNonlocalIDs_, allocatedNonlocalLength_) );
   }
 
   return(0);
 }

◆ inputValues() [1/2]

template<typename T >

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

private

Definition at line 650 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

 {
   if (accumulate) {
     libmesh_assert(last_edit == 0 || last_edit == 2);
     last_edit = 2;
   } else {
     libmesh_assert(last_edit == 0 || last_edit == 1);
     last_edit = 1;
   }
 
   //Important note!! This method assumes that there is only 1 point
   //associated with each element.
 
   for (int i=0; i<numIDs; ++i) {
     if (_vec->Map().MyGID(GIDs[i])) {
       if (accumulate) {
         _vec->SumIntoGlobalValue(GIDs[i], 0, 0, values[i]);
       }
       else {
         _vec->ReplaceGlobalValue(GIDs[i], 0, 0, values[i]);
       }
     }
     else {
       if (!ignoreNonLocalEntries_) {
         EPETRA_CHK_ERR( inputNonlocalValue(GIDs[i], values[i], accumulate) );
       }
     }
   }
 
   return(0);
 }

◆ inputValues() [2/2]

template<typename T >

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

private

Definition at line 687 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

 {
   if (accumulate) {
     libmesh_assert(last_edit == 0 || last_edit == 2);
     last_edit = 2;
   } else {
     libmesh_assert(last_edit == 0 || last_edit == 1);
     last_edit = 1;
   }
 
   int offset=0;
   for (int i=0; i<numIDs; ++i) {
     int numValues = numValuesPerID[i];
     if (_vec->Map().MyGID(GIDs[i])) {
       if (accumulate) {
         for (int j=0; j<numValues; ++j) {
           _vec->SumIntoGlobalValue(GIDs[i], j, 0, values[offset+j]);
         }
       }
       else {
         for (int j=0; j<numValues; ++j) {
           _vec->ReplaceGlobalValue(GIDs[i], j, 0, values[offset+j]);
         }
       }
     }
     else {
       if (!ignoreNonLocalEntries_) {
         EPETRA_CHK_ERR( inputNonlocalValues(GIDs[i], numValues,
                                             &(values[offset]), accumulate) );
       }
     }
     offset += numValues;
   }
 
   return(0);
 }

◆ insert() [1/5]

template<typename T >

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

overridevirtual

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

Note that library implementations of this method are thread safe

Reimplemented from libMesh::NumericVector< T >.

Definition at line 304 of file trilinos_epetra_vector.C.

References libMesh::numeric_trilinos_cast().

 {
   libmesh_assert_equal_to (sizeof(numeric_index_type), sizeof(int));
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   ReplaceGlobalValues (cast_int<numeric_index_type>(dof_indices.size()),
                        numeric_trilinos_cast(dof_indices.data()),
                        const_cast<T *>(v));
   this->_is_closed = false;
 }

◆ insert() [2/5]

template<typename T>

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

inlineinherited

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

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

Definition at line 983 of file numeric_vector.h.

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

inherited

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

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

Definition at line 140 of file numeric_vector.C.

 {
   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 DenseVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

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

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

Definition at line 995 of file numeric_vector.h.

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

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

Definition at line 1007 of file numeric_vector.h.

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

◆ l1_norm()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 69 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
 
   Real value;
 
   _vec->Norm1(&value);
 
   return value;
 }

◆ l1_norm_diff()

template<class T>

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

inherited

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

Definition at line 632 of file numeric_vector.C.

 {
   libmesh_assert(this->compatible(v));
 
   Real norm = 0;
   for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
     norm += libMesh::l1_norm_diff((*this)(i), v(i));
 
   this->comm().sum(norm);
 
   return norm;
 }

◆ l2_norm()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 81 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
 
   Real value;
 
   _vec->Norm2(&value);
 
   return value;
 }

◆ l2_norm_diff()

template<class T>

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

inherited

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

Definition at line 616 of file numeric_vector.C.

 {
   libmesh_assert(this->compatible(v));
 
   Real norm = 0;
   for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
     norm += TensorTools::norm_sq((*this)(i) - v(i));
 
   this->comm().sum(norm);
 
   return std::sqrt(norm);
 }

◆ last_local_index()

template<typename T >

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

inlineoverridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 766 of file trilinos_epetra_vector.h.

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

 {
   libmesh_assert (this->initialized());
 
   return _vec->Map().MaxMyGID()+1;
 }

◆ linfty_norm()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 93 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
 
   Real value;
 
   _vec->NormInf(&value);
 
   return value;
 }

◆ local_relative_compare()

template<typename T>

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

virtualinherited

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

Definition at line 181 of file numeric_vector.C.

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

◆ local_size()

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 746 of file trilinos_epetra_vector.h.

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

 {
   libmesh_assert (this->initialized());
 
   return _vec->MyLength();
 }

◆ localize() [1/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 532 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

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

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   const unsigned int n  = this->size();
   const unsigned int nl = this->local_size();
 
   libmesh_assert(this->_vec);
 
   v_local.clear();
   v_local.reserve(n);
 
   // build up my local part
   for (unsigned int i=0; i<nl; i++)
     v_local.push_back((*this->_vec)[i]);
 
   this->comm().allgather (v_local);
 }

◆ localize() [2/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 420 of file trilinos_epetra_vector.C.

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

 {
   EpetraVector<T> * v_local = cast_ptr<EpetraVector<T> *>(&v_local_in);
 
   Epetra_Map rootMap = Epetra_Util::Create_Root_Map( *_map, -1);
   v_local->_vec->ReplaceMap(rootMap);
 
   Epetra_Import importer(v_local->_vec->Map(), *_map);
   v_local->_vec->Import(*_vec, importer, Insert);
 }

◆ localize() [3/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 434 of file trilinos_epetra_vector.C.

 {
   // TODO: optimize to sync only the send list values
   this->localize(v_local_in);
 
   //   EpetraVector<T> * v_local =
   //   cast_ptr<EpetraVector<T> *>(&v_local_in);
 
   //   libmesh_assert(this->_map.get());
   //   libmesh_assert(v_local->_map.get());
   //   libmesh_assert_equal_to (v_local->local_size(), this->size());
   //   libmesh_assert_less_equal (send_list.size(), v_local->size());
 
   //   Epetra_Import importer (*v_local->_map, *this->_map);
 
   //   v_local->_vec->Import (*this->_vec, importer, Insert);
 }

◆ localize() [4/5]

template<typename T >

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

overridevirtual

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

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

Example:

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

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

Implements libMesh::NumericVector< T >.

Definition at line 456 of file trilinos_epetra_vector.C.

References libMesh::index_range().

 {
   // Create a "replicated" map for importing values.  This is
   // equivalent to creating a general Epetra_Map with
   // NumGlobalElements == NumMyElements.
   Epetra_LocalMap import_map(static_cast<int>(indices.size()),
                              /*IndexBase=*/0,
                              _map->Comm());
 
   // Get a pointer to the list of global elements for the map, and set
   // all the values from indices.
   int * import_map_global_elements = import_map.MyGlobalElements();
   for (auto i : index_range(indices))
     import_map_global_elements[i] = indices[i];
 
   // Create a new EpetraVector to import values into.
   Epetra_Vector import_vector(import_map);
 
   // Set up an "Import" object which associates the two maps.
   Epetra_Import import_object(import_map, *_map);
 
   // Import the values
   import_vector.Import(*_vec, import_object, Insert);
 
   // Get a pointer to the imported values array and the length of the
   // array.
   T * values = import_vector.Values();
   int import_vector_length = import_vector.MyLength();
 
   // Copy the imported values into v_local
   v_local.resize(import_vector_length);
   for (int i=0; i<import_vector_length; ++i)
     v_local[i] = values[i];
 }

◆ localize() [5/5]

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 495 of file trilinos_epetra_vector.C.

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

 {
   // 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 unsigned int my_size       = this->size();
   const unsigned int 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)
   EpetraVector<T> parallel_vec(this->comm(), PARALLEL);
 
   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.set(i,this->el(i));
 
   // localize like normal
   parallel_vec.close();
   parallel_vec.localize (*this, send_list);
   this->close();
 }

◆ localize_to_one()

template<typename T >

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

overridevirtual

Creates a local copy of the global vector in v_local only on processor proc_id.

By default the data is sent to processor 0. This method is useful for outputting data from one processor.

Implements libMesh::NumericVector< T >.

Definition at line 555 of file trilinos_epetra_vector.C.

References libMesh::libmesh_assert().

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   const unsigned int n  = this->size();
   const unsigned int nl = this->local_size();
 
   libmesh_assert_less (pid, this->n_processors());
   libmesh_assert(this->_vec);
 
   v_local.clear();
   v_local.reserve(n);
 
 
   // build up my local part
   for (unsigned int i=0; i<nl; i++)
     v_local.push_back((*this->_vec)[i]);
 
   this->comm().gather (pid, v_local);
 }

◆ max()

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 804 of file trilinos_epetra_vector.h.

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

 {
   libmesh_assert (this->initialized());
 
   T value;
 
   _vec->MaxValue(&value);
 
   return value;
 }

◆ max_allowed_id()

template<typename T >

std::size_t libMesh::EpetraVector< T >::max_allowed_id ( ) const

inlineoverridevirtual

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

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

Implements libMesh::NumericVector< T >.

Definition at line 844 of file trilinos_epetra_vector.h.

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

◆ min()

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 789 of file trilinos_epetra_vector.h.

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

 {
   libmesh_assert (this->initialized());
 
   T value;
 
   _vec->MinValue(&value);
 
   return value;
 }

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:132

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

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

◆ operator()()

template<typename T >

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

inlineoverridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 776 of file trilinos_epetra_vector.h.

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

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

◆ operator*=() [1/2]

template<typename T >

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

overridevirtual

Computes the component-wise multiplication of this vector's entries by another's, \( u_i \leftarrow u_i v_i \, \forall i\).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 131 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
   libmesh_assert_equal_to(size(), v.size());
 
   const EpetraVector<T> & v_vec = cast_ref<const EpetraVector<T> &>(v);
 
   _vec->Multiply(1.0, *v_vec._vec, *_vec, 0.0);
 
   return *this;
 }

◆ operator*=() [2/2]

template<typename T>

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

inlineinherited

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

Equivalent to u.scale(a)

Returns: A reference to *this.

Definition at line 420 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

Scale each element of the vector by the given factor.

◆ operator+=()

template<typename T >

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

overridevirtual

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

Equivalent to u.add(1, v).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 106 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
 
   this->add(1., v);
 
   return *this;
 }

◆ operator-=()

template<typename T >

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

overridevirtual

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

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

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 119 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
 
   this->add(-1., v);
 
   return *this;
 }

◆ operator/=() [1/2]

template<typename T >

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

overridevirtual

Computes the component-wise division of this vector's entries by another's, \( u_i \leftarrow \frac{u_i}{v_i} \, \forall i\).

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 146 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
   libmesh_assert_equal_to(size(), v.size());
 
   const EpetraVector<T> & v_vec = cast_ref<const EpetraVector<T> &>(v);
 
   _vec->ReciprocalMultiply(1.0, *v_vec._vec, *_vec, 0.0);
 
   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 438 of file numeric_vector.h.

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

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

Scale each element of the vector by the given factor.

◆ operator=() [1/5]

template<typename T>

EpetraVector& libMesh::EpetraVector< T >::operator= ( const EpetraVector< T > & )

delete

◆ operator=() [2/5]

template<typename T>

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

delete

◆ operator=() [3/5]

template<typename T >

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

overridevirtual

Sets all entries of the vector to the value s.

Returns: A reference to *this.

Implements libMesh::NumericVector< T >.

Definition at line 357 of file trilinos_epetra_vector.C.

 {
   _vec->PutScalar(s_in);
 
   return *this;
 }

◆ operator=() [4/5]

template<typename T >

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

overridevirtual

This looks like a copy assignment operator, but note that, unlike normal copy assignment operators, it is pure virtual.

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

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

Implements libMesh::NumericVector< T >.

Definition at line 368 of file trilinos_epetra_vector.C.

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

◆ operator=() [5/5]

template<typename T >

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

overridevirtual

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

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

Case 1: The vector is the same size of The global vector. Only add the local components.

Case 2: The vector is the same size as our local piece. Insert directly to the local piece.

Implements libMesh::NumericVector< T >.

Definition at line 383 of file trilinos_epetra_vector.C.

 {
   T * values = _vec->Values();
 
   if (this->size() == v.size())
     {
       const unsigned int nl=this->local_size();
       const unsigned int fli=this->first_local_index();
 
       for (unsigned int i=0;i<nl;i++)
         values[i]=v[fli+i];
     }
 
   else
     {
       libmesh_assert_equal_to (v.size(), this->local_size());
 
       const unsigned int nl=this->local_size();
 
       for (unsigned int i=0;i<nl;i++)
         values[i]=v[i];
     }
 
   return *this;
 }

◆ pointwise_divide()

template<typename T>

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

pure virtualinherited

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

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

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

◆ pointwise_mult()

template<typename T >

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

overridevirtual

Computes \( u_i \leftarrow u_i v_i \) (summation not implied) i.e.

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

Implements libMesh::NumericVector< T >.

Definition at line 345 of file trilinos_epetra_vector.C.

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

 {
   const EpetraVector<T> * v1 = cast_ptr<const EpetraVector<T> *>(&vec1);
   const EpetraVector<T> * v2 = cast_ptr<const EpetraVector<T> *>(&vec2);
 
   _vec->Multiply(1.0, *v1->_vec, *v2->_vec, 0.0);
 }

◆ print() [1/2]

template<typename T >

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

inlinevirtualinherited

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

Definition at line 1040 of file numeric_vector.h.

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

◆ print() [2/2]

template<>

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

inlineinherited

Definition at line 1022 of file numeric_vector.h.

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

◆ print_global() [1/2]

template<typename T >

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

inlinevirtualinherited

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

Definition at line 1077 of file numeric_vector.h.

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

◆ print_global() [2/2]

template<>

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

inlineinherited

Definition at line 1055 of file numeric_vector.h.

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

◆ print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_matlab()

template<typename T >

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

virtualinherited

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

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

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

Definition at line 245 of file numeric_vector.C.

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

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

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

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

TIMPI::Communicator::rank

processor_id_type rank() const

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:120

◆ read_matlab()

template<typename T >

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

virtualinherited

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

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

Definition at line 297 of file numeric_vector.C.

 {
   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 = (filename.rfind(".gz") == filename.size() - 3);
 
   // 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
 }

◆ readable()

template<typename T >

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

inherited

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

Definition at line 685 of file numeric_vector.C.

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

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

◆ reciprocal()

template<typename T >

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

overridevirtual

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

Implements libMesh::NumericVector< T >.

Definition at line 178 of file trilinos_epetra_vector.C.

 {
   // The Epetra::reciprocal() function takes a constant reference to *another* vector,
   // and fills _vec with its reciprocal.  Does that mean we can't pass *_vec as the
   // argument?
   // _vec->reciprocal( *_vec );
 
   // Alternatively, compute the reciprocal by hand... see also the add(T) member that does this...
   const unsigned int nl = _vec->MyLength();
 
   T * values = _vec->Values();
 
   for (unsigned int i=0; i<nl; i++)
     {
       // Don't divide by zero (maybe only check this in debug mode?)
       libmesh_error_msg_if(std::abs(values[i]) < std::numeric_limits<T>::min(),
                            "Error, divide by zero in DistributedVector<T>::reciprocal()!");
 
       values[i] = 1. / values[i];
     }
 
   // Leave the vector in a closed state...
   this->close();
 }

◆ ReplaceGlobalValues() [1/3]

template<typename T >

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

private

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

Definition at line 619 of file trilinos_epetra_vector.C.

 {
   return( inputValues( numIDs, GIDs, values, false) );
 }

◆ ReplaceGlobalValues() [2/3]

template<typename T >

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

private

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

Parameters

GIDs	List of global ids. Must be the same length as the accompanying list of values.
values	List of coefficient values. Must be the same length as the accompanying list of GIDs.

Definition at line 628 of file trilinos_epetra_vector.C.

 {
   if (GIDs.Length() != values.Length()) {
     return(-1);
   }
 
   return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), false) );
 }

◆ ReplaceGlobalValues() [3/3]

template<typename T >

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

private

Definition at line 640 of file trilinos_epetra_vector.C.

 {
   return( inputValues( numIDs, GIDs, numValuesPerID, values, false) );
 }

◆ restore_subvector()

template<typename T>

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

inlinevirtualinherited

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

This is currently only implemented for PetscVectors.

Reimplemented in libMesh::PetscVector< T >.

Definition at line 786 of file numeric_vector.h.

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

   {
     libmesh_not_implemented();
   }

◆ scale()

template<typename T >

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

overridevirtual

Scale each element of the vector by the given factor.

Implements libMesh::NumericVector< T >.

Definition at line 319 of file trilinos_epetra_vector.C.

 {
   _vec->Scale(factor_in);
 }

◆ set()

template<typename T >

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

overridevirtual

Sets v(i) = value.

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

Implements libMesh::NumericVector< T >.

Definition at line 162 of file trilinos_epetra_vector.C.

References value.

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

 {
   int i = static_cast<int> (i_in);
   T value = value_in;
 
   libmesh_assert_less (i_in, this->size());
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   ReplaceGlobalValues(1, &i, &value);
 
   this->_is_closed = false;
 }

◆ set_type()

template<typename T >

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

inherited

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

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

Definition at line 97 of file numeric_vector.C.

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

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

◆ setIgnoreNonLocalEntries()

template<typename T>

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

inlineprivate

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

Definition at line 358 of file trilinos_epetra_vector.h.

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

   {
     ignoreNonLocalEntries_ = flag;
   }

◆ size()

template<typename T >

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

inlineoverridevirtual

Returns: The size of the vector.

Implements libMesh::NumericVector< T >.

Definition at line 735 of file trilinos_epetra_vector.h.

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

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

 {
   libmesh_assert (this->initialized());
 
   return _vec->GlobalLength();
 }

◆ subset_l1_norm()

template<class T >

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

virtualinherited

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

Note: The indices must necessarily live on this processor.

Definition at line 559 of file numeric_vector.C.

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

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

◆ subset_l2_norm()

template<class T >

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

virtualinherited

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

Note: The indices must necessarily live on this processor.

Definition at line 576 of file numeric_vector.C.

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

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

◆ subset_linfty_norm()

template<class T >

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

virtualinherited

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

Note: The indices must necessarily live on this processor.

Definition at line 593 of file numeric_vector.C.

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

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

◆ sum()

template<typename T >

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

overridevirtual

Returns: The sum of all values in the vector.

Implements libMesh::NumericVector< T >.

Definition at line 50 of file trilinos_epetra_vector.C.

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

 {
   libmesh_assert(this->closed());
 
   const unsigned int nl = _vec->MyLength();
 
   T sum=0.0;
 
   T * values = _vec->Values();
 
   for (unsigned int i=0; i<nl; i++)
     sum += values[i];
 
   this->comm().sum(sum);
 
   return sum;
 }

◆ SumIntoGlobalValues() [1/3]

template<typename T >

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

private

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

Definition at line 588 of file trilinos_epetra_vector.C.

 {
   return( inputValues( numIDs, GIDs, values, true) );
 }

◆ SumIntoGlobalValues() [2/3]

template<typename T >

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

private

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

Parameters

GIDs	List of global ids. Must be the same length as the accompanying list of values.
values	List of coefficient values. Must be the same length as the accompanying list of GIDs.

Definition at line 597 of file trilinos_epetra_vector.C.

 {
   if (GIDs.Length() != values.Length()) {
     return(-1);
   }
 
   return( inputValues( GIDs.Length(), GIDs.Values(), values.Values(), true) );
 }

◆ SumIntoGlobalValues() [3/3]

template<typename T >

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

private

Definition at line 609 of file trilinos_epetra_vector.C.

 {
   return( inputValues( numIDs, GIDs, numValuesPerID, values, true) );
 }

◆ swap()

template<typename T >

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

inlineoverridevirtual

Swaps the contents of this with v.

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

Reimplemented from libMesh::NumericVector< T >.

Definition at line 819 of file trilinos_epetra_vector.h.

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

 {
   NumericVector<T>::swap(other);
 
   EpetraVector<T> & v = cast_ref<EpetraVector<T> &>(other);
 
   std::swap(_vec, v._vec);
   _map.swap(v._map);
   std::swap(_destroy_vec_on_exit, v._destroy_vec_on_exit);
   std::swap(myFirstID_, v.myFirstID_);
   std::swap(myNumIDs_, v.myNumIDs_);
   std::swap(myCoefs_, v.myCoefs_);
   std::swap(nonlocalIDs_, v.nonlocalIDs_);
   std::swap(nonlocalElementSize_, v.nonlocalElementSize_);
   std::swap(numNonlocalIDs_, v.numNonlocalIDs_);
   std::swap(allocatedNonlocalLength_, v.allocatedNonlocalLength_);
   std::swap(nonlocalCoefs_, v.nonlocalCoefs_);
   std::swap(last_edit, v.last_edit);
   std::swap(ignoreNonLocalEntries_, v.ignoreNonLocalEntries_);
 }

◆ 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::System::add_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DofMap::constrain_element_residual(), libMesh::PetscVector< libMesh::Number >::create_subvector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DofMap::heterogeneously_constrain_element_jacobian_and_residual(), libMesh::DofMap::heterogeneously_constrain_element_residual(), libMesh::DistributedVector< T >::init(), libMesh::LaspackVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< libMesh::Number >::localize(), libMesh::System::project_vector(), and libMesh::System::read_serialized_vector().

154 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

Type of vector.

Definition: numeric_vector.h:841

◆ type() [2/2]

template<typename T>

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

inlineinherited

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

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

Definition at line 164 of file numeric_vector.h.

164 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

Type of vector.

Definition: numeric_vector.h:841

◆ vec()

template<typename T>

Epetra_Vector* libMesh::EpetraVector< T >::vec ( )

inline

Returns: The raw Epetra_Vector pointer.

Note: This is generally not required in user-level code.; Don't do anything crazy like deleting the pointer, or very bad things will likely happen!

Definition at line 268 of file trilinos_epetra_vector.h.

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

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

268 { libmesh_assert(_vec); return _vec; }

libMesh::EpetraVector::_vec

Epetra_Vector * _vec

Actual Epetra vector datatype to hold vector entries.

Definition: trilinos_epetra_vector.h:275

libMesh::libmesh_assert

libmesh_assert(ctx)

◆ zero()

template<typename T >

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

inlineoverridevirtual

Set all entries to zero.

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

Implements libMesh::NumericVector< T >.

Definition at line 698 of file trilinos_epetra_vector.h.

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

 {
   libmesh_assert (this->initialized());
   libmesh_assert (this->closed());
 
   _vec->PutScalar(0.0);
 }

◆ zero_clone()

template<typename T >

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

inlineoverridevirtual

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

Note: This must be overridden in the derived classes.

Implements libMesh::NumericVector< T >.

Definition at line 710 of file trilinos_epetra_vector.h.

References libMesh::AUTOMATIC.

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

 {
   std::unique_ptr<NumericVector<T>> cloned_vector =
     std::make_unique<EpetraVector<T>>(this->comm(), AUTOMATIC);
   cloned_vector->init(*this);
   return cloned_vector;
 }

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(), and libMesh::StaticCondensationDofMap::reinit().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _destroy_vec_on_exit

template<typename T>

bool libMesh::EpetraVector< T >::_destroy_vec_on_exit

private

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

Definition at line 286 of file trilinos_epetra_vector.h.

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

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _is_closed

template<typename T>

bool libMesh::NumericVector< T >::_is_closed

protectedinherited

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

Definition at line 831 of file numeric_vector.h.

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

◆ _is_initialized

template<typename T>

bool libMesh::NumericVector< T >::_is_initialized

protectedinherited

true once init() has been called.

Definition at line 836 of file numeric_vector.h.

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

◆ _map

template<typename T>

std::unique_ptr<Epetra_Map> libMesh::EpetraVector< T >::_map

private

Holds the distributed Map.

Definition at line 280 of file trilinos_epetra_vector.h.

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

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _numeric_vector_mutex

template<typename T>

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

protectedinherited

Mutex for performing thread-safe operations.

Definition at line 846 of file numeric_vector.h.

◆ _type

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

Type of vector.

Definition at line 841 of file numeric_vector.h.

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

◆ _vec

template<typename T>

Epetra_Vector* libMesh::EpetraVector< T >::_vec

private

Actual Epetra vector datatype to hold vector entries.

Definition at line 275 of file trilinos_epetra_vector.h.

Referenced by libMesh::EpetraVector< T >::add(), libMesh::EpetraVector< T >::add_vector(), libMesh::EpetraVector< T >::dot(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::EpetraVector< T >::FEoperatorequals(), libMesh::EpetraVector< T >::localize(), libMesh::EpetraVector< T >::pointwise_mult(), libMesh::EpetraVector< T >::swap(), and libMesh::EpetraVector< T >::vec().

◆ allocatedNonlocalLength_

template<typename T>

int libMesh::EpetraVector< T >::allocatedNonlocalLength_

private

Definition at line 394 of file trilinos_epetra_vector.h.

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

◆ ignoreNonLocalEntries_

template<typename T>

bool libMesh::EpetraVector< T >::ignoreNonLocalEntries_

private

Definition at line 404 of file trilinos_epetra_vector.h.

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

◆ last_edit

template<typename T>

unsigned char libMesh::EpetraVector< T >::last_edit

private

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

Definition at line 402 of file trilinos_epetra_vector.h.

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

◆ myCoefs_

template<typename T>

double* libMesh::EpetraVector< T >::myCoefs_

private

Definition at line 389 of file trilinos_epetra_vector.h.

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

◆ myFirstID_

template<typename T>

int libMesh::EpetraVector< T >::myFirstID_

private

Definition at line 387 of file trilinos_epetra_vector.h.

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

◆ myNumIDs_

template<typename T>

int libMesh::EpetraVector< T >::myNumIDs_

private

Definition at line 388 of file trilinos_epetra_vector.h.

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

◆ nonlocalCoefs_

template<typename T>

double** libMesh::EpetraVector< T >::nonlocalCoefs_

private

Definition at line 395 of file trilinos_epetra_vector.h.

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

◆ nonlocalElementSize_

template<typename T>

int* libMesh::EpetraVector< T >::nonlocalElementSize_

private

Definition at line 392 of file trilinos_epetra_vector.h.

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

◆ nonlocalIDs_

template<typename T>

int* libMesh::EpetraVector< T >::nonlocalIDs_

private

Definition at line 391 of file trilinos_epetra_vector.h.

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

◆ numNonlocalIDs_

template<typename T>

int libMesh::EpetraVector< T >::numNonlocalIDs_

private

Definition at line 393 of file trilinos_epetra_vector.h.

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

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

include/numerics/trilinos_epetra_vector.h
src/numerics/trilinos_epetra_vector.C

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

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

Member Typedef Documentation

◆ Counts

Constructor & Destructor Documentation

◆ EpetraVector() [1/7]

◆ EpetraVector() [2/7]

◆ EpetraVector() [3/7]

◆ EpetraVector() [4/7]

◆ EpetraVector() [5/7]

◆ EpetraVector() [6/7]

◆ EpetraVector() [7/7]

◆ ~EpetraVector()

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

◆ destroyNonlocalData()

◆ disable_print_counter_info()

◆ dot()

◆ el()

◆ enable_print_counter_info()

◆ FEoperatorequals()

◆ first_local_index()

◆ get() [1/2]

◆ get() [2/2]

◆ get_info()

◆ get_subvector()

◆ global_relative_compare()

◆ GlobalAssemble()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ init() [1/4]

◆ init() [2/4]

◆ init() [3/4]

◆ init() [4/4]

◆ initialized()

◆ inputNonlocalValue()

◆ inputNonlocalValues()

◆ inputValues() [1/2]

◆ inputValues() [2/2]

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ l1_norm()

◆ l1_norm_diff()

◆ l2_norm()

◆ l2_norm_diff()

◆ last_local_index()

◆ linfty_norm()

◆ local_relative_compare()

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