MultiVector for multiple degrees of freedom per mesh point. More...

#include <Tpetra_Experimental_BlockMultiVector_decl.hpp>

Inheritance diagram for Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >:

Public Types
typedef Kokkos::Device < typename device_type::execution_space, buffer_memory_space >	buffer_device_type
	Kokkos::Device specialization for communication buffers. More...

Typedefs to facilitate template metaprogramming.
typedef Tpetra::Map< LO, GO, Node >	map_type
	The specialization of Tpetra::Map that this class uses. More...

typedef Tpetra::MultiVector < Scalar, LO, GO, Node >	mv_type
	The specialization of Tpetra::MultiVector that this class uses. More...

typedef Scalar	scalar_type
	The type of entries in the matrix. More...

typedef mv_type::impl_scalar_type	impl_scalar_type
	The implementation type of entries in the matrix. More...

typedef LO	local_ordinal_type
	The type of local indices. More...

typedef GO	global_ordinal_type
	The type of global indices. More...

typedef Node::device_type	device_type
	The Kokkos Device type. More...

typedef Node	node_type
	The Kokkos Node type. More...

typedef Kokkos::View < impl_scalar_type *, Kokkos::LayoutRight, device_type, Kokkos::MemoryTraits < Kokkos::Unmanaged > >	little_vec_type
	"Block view" of all degrees of freedom at a mesh point, for a single column of the MultiVector. More...

typedef Kokkos::View< const impl_scalar_type *, Kokkos::LayoutRight, device_type, Kokkos::MemoryTraits < Kokkos::Unmanaged > >	const_little_vec_type
	"Const block view" of all degrees of freedom at a mesh point, for a single column of the MultiVector. More...

Typedefs
typedef device_type::execution_space	execution_space
	The Kokkos execution space. More...

Public Member Functions
Constructors
	BlockMultiVector (const map_type &meshMap, const LO blockSize, const LO numVecs)
	Constructor that takes a mesh Map, a block size, and a number of vectors (columns). More...

	BlockMultiVector (const map_type &meshMap, const map_type &pointMap, const LO blockSize, const LO numVecs)
	Constructor that takes a mesh Map, a point Map, a block size, and a number of vectors (columns). More...

	BlockMultiVector (const mv_type &X_mv, const map_type &meshMap, const LO blockSize)
	View an existing MultiVector. More...

	BlockMultiVector (const BlockMultiVector< Scalar, LO, GO, Node > &X, const map_type &newMeshMap, const map_type &newPointMap, const size_t offset=0)
	View an existing BlockMultiVector using a different mesh Map, supplying the corresponding point Map. More...

	BlockMultiVector (const BlockMultiVector< Scalar, LO, GO, Node > &X, const map_type &newMeshMap, const size_t offset=0)
	View an existing BlockMultiVector using a different mesh Map; compute the new point Map. More...

	BlockMultiVector ()
	Default constructor. More...

Coarse-grained operations
void	putScalar (const Scalar &val)
	Fill all entries with the given value `val`. More...

void	scale (const Scalar &val)
	Multiply all entries in place by the given value `val`. More...

void	update (const Scalar &alpha, const BlockMultiVector< Scalar, LO, GO, Node > &X, const Scalar &beta)
	Update: `this = betathis + alphaX`. More...

void	blockWiseMultiply (const Scalar &alpha, const Kokkos::View< const impl_scalar_type ***, device_type, Kokkos::MemoryUnmanaged > &D, const BlockMultiVector< Scalar, LO, GO, Node > &X)
	`this := alpha D * X`, where D is a block diagonal matrix. More...

void	blockJacobiUpdate (const Scalar &alpha, const Kokkos::View< const impl_scalar_type ***, device_type, Kokkos::MemoryUnmanaged > &D, const BlockMultiVector< Scalar, LO, GO, Node > &X, BlockMultiVector< Scalar, LO, GO, Node > &Z, const Scalar &beta)
	Block Jacobi update $Y = \beta * Y + \alpha D (X - Z)$ . More...

Implementation of "dual view semantics"
template<class TargetMemorySpace >
void	sync ()
	Update data to the given target memory space, only if data in the "other" space have been marked as modified. More...

template<class TargetMemorySpace >
bool	need_sync () const
	Whether this object needs synchronization to the given memory space. More...

template<class TargetMemorySpace >
void	modify ()
	Mark data as modified on the given memory space. More...

Fine-grained data access
bool	replaceLocalValues (const LO localRowIndex, const LO colIndex, const Scalar vals[]) const
	Replace all values at the given mesh point, using local row and column indices. More...

bool	replaceGlobalValues (const GO globalRowIndex, const LO colIndex, const Scalar vals[]) const
	Replace all values at the given mesh point, using a global index. More...

bool	sumIntoLocalValues (const LO localRowIndex, const LO colIndex, const Scalar vals[]) const
	Sum into all values at the given mesh point, using a local index. More...

bool	sumIntoGlobalValues (const GO globalRowIndex, const LO colIndex, const Scalar vals[]) const
	Sum into all values at the given mesh point, using a global index. More...

bool	getLocalRowView (const LO localRowIndex, const LO colIndex, Scalar *&vals) const
	Get a writeable view of the entries at the given mesh point, using a local index. More...

bool	getGlobalRowView (const GO globalRowIndex, const LO colIndex, Scalar *&vals) const
	Get a writeable view of the entries at the given mesh point, using a global index. More...

little_vec_type::HostMirror	getLocalBlock (const LO localRowIndex, const LO colIndex) const
	Get a host view of the degrees of freedom at the given mesh point. More...

Public methods for redistributing data
void	doImport (const SrcDistObject &source, const Import< LocalOrdinal, GlobalOrdinal, Node > &importer, CombineMode CM)
	Import data into this object using an Import object ("forward mode"). More...

void	doImport (const SrcDistObject &source, const Export< LocalOrdinal, GlobalOrdinal, Node > &exporter, CombineMode CM)
	Import data into this object using an Export object ("reverse mode"). More...

void	doExport (const SrcDistObject &source, const Export< LocalOrdinal, GlobalOrdinal, Node > &exporter, CombineMode CM)
	Export data into this object using an Export object ("forward mode"). More...

void	doExport (const SrcDistObject &source, const Import< LocalOrdinal, GlobalOrdinal, Node > &importer, CombineMode CM)
	Export data into this object using an Import object ("reverse mode"). More...

Attribute accessor methods
bool	isDistributed () const
	Whether this is a globally distributed object. More...

virtual Teuchos::RCP< const map_type >	getMap () const
	The Map describing the parallel distribution of this object. More...

I/O methods
void	print (std::ostream &os) const
	Print this object to the given output stream. More...

Implementation of Teuchos::Describable
virtual std::string	description () const
	One-line descriptiion of this object. More...

virtual void	describe (Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const
	Print a descriptiion of this object to the given output stream. More...

Methods for use only by experts
virtual void	removeEmptyProcessesInPlace (const Teuchos::RCP< const map_type > &newMap)
	Remove processes which contain no entries in this object's Map. More...

Protected Types
enum	ReverseOption
	Whether the data transfer should be performed in forward or reverse mode. More...

typedef device_type::memory_space	buffer_memory_space
	Kokkos memory space for communication buffers. More...

Protected Member Functions
impl_scalar_type *	getRawPtr () const
	Raw pointer to the MultiVector's data. More...

size_t	getStrideX () const
	Stride between consecutive local entries in the same column. More...

size_t	getStrideY () const
	Stride between consecutive local entries in the same row. More...

bool	isValidLocalMeshIndex (const LO meshLocalIndex) const
	True if and only if `meshLocalIndex` is a valid local index in the mesh Map. More...

virtual size_t	constantNumberOfPackets () const
	Whether the implementation's instance promises always to have a constant number of packets per LID (local index), and if so, how many packets per LID there are. More...

virtual void	doTransfer (const SrcDistObject &src, const ::Tpetra::Details::Transfer< local_ordinal_type, global_ordinal_type, node_type > &transfer, const char modeString[], const ReverseOption revOp, const CombineMode CM)
	Redistribute data across memory images. More...

virtual bool	reallocArraysForNumPacketsPerLid (const size_t numExportLIDs, const size_t numImportLIDs)
	Reallocate numExportPacketsPerLID_ and/or numImportPacketsPerLID_, if necessary. More...

virtual void	createViews () const
	Hook for creating a const view. More...

virtual void	createViewsNonConst (KokkosClassic::ReadWriteOption rwo)
	Hook for creating a nonconst view. More...

virtual void	releaseViews () const
	Hook for releasing views. More...

bool	reallocImportsIfNeeded (const size_t newSize, const bool debug=false)
	Reallocate imports_ if needed. More...

Implementation of Tpetra::DistObject.
The methods here implement Tpetra::DistObject. They let BlockMultiVector participate in Import and Export operations. Users don't have to worry about these methods.
virtual bool	checkSizes (const Tpetra::SrcDistObject &source)
	Compare the source and target (this) objects for compatibility. More...

virtual void	copyAndPermute (const Tpetra::SrcDistObject &source, size_t numSameIDs, const Teuchos::ArrayView< const LO > &permuteToLIDs, const Teuchos::ArrayView< const LO > &permuteFromLIDs)

virtual void	packAndPrepare (const Tpetra::SrcDistObject &source, const Teuchos::ArrayView< const LO > &exportLIDs, Teuchos::Array< impl_scalar_type > &exports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t &constantNumPackets, Tpetra::Distributor &distor)

virtual void	unpackAndCombine (const Teuchos::ArrayView< const LO > &importLIDs, const Teuchos::ArrayView< const impl_scalar_type > &imports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t constantNumPackets, Tpetra::Distributor &distor, Tpetra::CombineMode CM)

Methods implemented by subclasses and used by doTransfer().
The doTransfer() method uses the subclass' implementations of these methods to implement data transfer. Subclasses of DistObject must implement these methods. This is an instance of the Template Method Pattern. ("Template" here doesn't mean "C++ template"; it means "pattern with holes that are filled in by the subclass' method implementations.")
virtual bool	useNewInterface ()
	Whether the subclass implements the "old" or "new" (Kokkos-friendly) interface. More...

virtual void	copyAndPermute (const SrcDistObject &source, size_t numSameIDs, const Teuchos::ArrayView< const local_ordinal_type > &permuteToLIDs, const Teuchos::ArrayView< const local_ordinal_type > &permuteFromLIDs)
	Perform copies and permutations that are local to this process. More...

virtual void	copyAndPermuteNew (const SrcDistObject &source, const size_t numSameIDs, const Kokkos::DualView< const local_ordinal_type , device_type > &permuteToLIDs, const Kokkos::DualView< const local_ordinal_type , device_type > &permuteFromLIDs)

virtual void	packAndPrepare (const SrcDistObject &source, const Teuchos::ArrayView< const local_ordinal_type > &exportLIDs, Teuchos::Array< packet_type > &exports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t &constantNumPackets, Distributor &distor)
	Perform any packing or preparation required for communication. More...

virtual void	packAndPrepareNew (const SrcDistObject &source, const Kokkos::DualView< const local_ordinal_type , device_type > &exportLIDs, Kokkos::DualView< packet_type , buffer_device_type > &exports, const Kokkos::DualView< size_t *, buffer_device_type > &numPacketsPerLID, size_t &constantNumPackets, Distributor &distor)

virtual void	unpackAndCombine (const Teuchos::ArrayView< const local_ordinal_type > &importLIDs, const Teuchos::ArrayView< const packet_type > &imports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t constantNumPackets, Distributor &distor, CombineMode CM)
	Perform any unpacking and combining after communication (old version that uses Teuchos memory management classes to hold data). More...

virtual void	unpackAndCombineNew (const Kokkos::DualView< const local_ordinal_type , device_type > &importLIDs, const Kokkos::DualView< const packet_type , buffer_device_type > &imports, const Kokkos::DualView< const size_t *, buffer_device_type > &numPacketsPerLID, const size_t constantNumPackets, Distributor &distor, const CombineMode CM)
	Perform any unpacking and combining after communication (new version that uses Kokkos data structures to hold data). More...

Protected Attributes
mv_type	mv_
	The Tpetra::MultiVector used to represent the data. More...

Teuchos::RCP< const map_type >	map_
	The Map over which this object is distributed. More...

Kokkos::DualView< packet_type *, buffer_device_type >	imports_
	Buffer into which packed data are imported (received from other processes). More...

Kokkos::DualView< size_t *, buffer_device_type >	numImportPacketsPerLID_
	Number of packets to receive for each receive operation. More...

Kokkos::DualView< packet_type *, buffer_device_type >	exports_
	Buffer from which packed data are exported (sent to other processes). More...

Kokkos::DualView< size_t *, buffer_device_type >	numExportPacketsPerLID_
	Number of packets to send for each send operation. More...

Access to Maps, the block size, and a MultiVector view.
map_type	getPointMap () const
	Get this BlockMultiVector's (previously computed) point Map. More...

LO	getBlockSize () const
	Get the number of degrees of freedom per mesh point. More...

LO	getNumVectors () const
	Get the number of columns (vectors) in the BlockMultiVector. More...

mv_type	getMultiVectorView () const
	Get a Tpetra::MultiVector that views this BlockMultiVector's data. More...

static map_type	makePointMap (const map_type &meshMap, const LO blockSize)
	Create and return the point Map corresponding to the given mesh Map and block size. More...

Detailed Description

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>
class Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >

MultiVector for multiple degrees of freedom per mesh point.

Author: Mark Hoemmen

Template Parameters

Scalar	The type of each entry of the block multivector. (You can use real-valued or complex-valued types here, unlike in Epetra, where the scalar type is always `double`.)
LO	The type of local indices. See the documentation of the first template parameter of Map for requirements.
GO	The type of global indices. See the documentation of the second template parameter of Map for requirements.
Node	The Kokkos Node type. See the documentation of the third template parameter of Map for requirements.

BlockMultiVector is like Tpetra::MultiVector, but its interface supports multiple degrees of freedom per mesh point. You can specify a mesh point by its local or global index, and read or write the values at that point. Every mesh point must have the same number of degrees of freedom. We call the number of degrees of freedom per mesh point the block size.

BlockMultiVector has view semantics. This means that the copy constructor and assignment operator (operator=) all do shallow copies. If you want to create a deep copy, call createCopy(); if you want to copy deeply between two BlockMultiVector objects, call deep_copy().

The replace*, sumInto*, and get* methods all are meant to be thread-safe. They don't throw exceptions on error; instead, they return an error code. They are marked "const" because Kokkos requires this in order to use them in parallel kernels. "Const" is legitimate here, even though some of these methods may modify entries of the vector. This is because they do not change any constants or pointers (e.g., they do not reallocate memory).

BlockMultiVector stores entries in a column corresponding to degrees of freedom for the same mesh point contiguously. This is not strictly necessary; we could generalize so that they are stored in a strided fashion, or even take away the layout assumption and only allow access to entries by copy (e.g., getLocalRowCopy() instead of getLocalRowView()).

Here is how you are supposed to use this class:

Fill the BlockMultiVector.
Do global assembly with BlockMultiVector, if necessary. (It implements Tpetra::DistObject, so you can use it with Import or Export.)
Call getMultiVectorView() to get a Tpetra::MultiVector which views the BlockMultiVector's data.
Give the Tpetra::MultiVector to Trilinos' solvers.

Note that BlockMultiVector is not a subclass of Tpetra::MultiVector. I did this on purpose, for simplicity. You should really think of BlockMultiVector as an in-place reinterpretation of a Tpetra::MultiVector.

This is the first Tpetra class to assume view semantics of all Tpetra objects. In particular, it assumes that Map has have view semantics, so that its copy constructor and assignment operator do shallow copies, and its default constructor (that takes no arguments) compiles and succeeds, creating a meaningful empty object.

Design philosophy of the new block objects:

Each mesh point has the same number of degrees of freedom
A BlockMultiVector views a MultiVector, but is not a MultiVector (that is, BlockMultiVector is not a subclass of MultiVector)

Point 1 means that users fill by mesh points, not degrees of freedom. Thus, they mainly care about the distribution of mesh points, not so much about what GID we assign to which degree of freedom. The latter is just another Map (the "point Map") from their perspective, if they care at all. Preconditioners that respect the block structure also just want the mesh Map. Iterative linear solvers treat the matrix and preconditioner as black-box operators. This means that they only care about the domain and range point Maps.

The latter motivates Point 2. BlockMultiVector views a MultiVector, and iterative solvers (and users) can access the MultiVector and work with it directly, along with its (point) Map. It doesn't make sense for BlockMultiVector to implement MultiVector, because the desired fill interfaces of the two classes are different.

Definition at line 147 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

Member Typedef Documentation

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Tpetra::Map<LO, GO, Node> Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::map_type

The specialization of Tpetra::Map that this class uses.

Definition at line 162 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Tpetra::MultiVector<Scalar, LO, GO, Node> Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::mv_type

The specialization of Tpetra::MultiVector that this class uses.

Definition at line 164 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Scalar Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::scalar_type

The type of entries in the matrix.

Definition at line 167 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef mv_type::impl_scalar_type Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::impl_scalar_type

The implementation type of entries in the matrix.

Letting scalar_type and impl_scalar_type differ addresses Tpetra's work-around to deal with missing device macros and volatile overloads in types like std::complex<T>.

Definition at line 173 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef LO Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::local_ordinal_type

The type of local indices.

Definition at line 175 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef GO Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::global_ordinal_type

The type of global indices.

Definition at line 177 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Node::device_type Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::device_type

The Kokkos Device type.

Definition at line 179 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Node Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::node_type

The Kokkos Node type.

Definition at line 182 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Kokkos::View<impl_scalar_type*, Kokkos::LayoutRight, device_type, Kokkos::MemoryTraits<Kokkos::Unmanaged> > Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::little_vec_type

"Block view" of all degrees of freedom at a mesh point, for a single column of the MultiVector.

A "block view" lets you address all degrees of freedom at a mesh point. You don't have to use this class to access the degrees of freedom. If you do choose to use this class, it implements operator()(LO i), so you can access and modify its entries.

The preferred way to refer to the little_vec_type and const_little_vec_type types, is to get them from the typedefs below. This is because different specializations of BlockVector reserve the right to use different types to implement little_vec_type or const_little_vec_type. This was our porting strategy circa 2014 to move from "classic" Tpetra to the Kokkos refactor version.

Definition at line 203 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef Kokkos::View<const impl_scalar_type*, Kokkos::LayoutRight, device_type, Kokkos::MemoryTraits<Kokkos::Unmanaged> > Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::const_little_vec_type

"Const block view" of all degrees of freedom at a mesh point, for a single column of the MultiVector.

This is just like little_vec_type, except that you can't modify its entries.

Definition at line 214 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

typedef device_type::execution_space Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::execution_space

inherited

The Kokkos execution space.

Definition at line 372 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::buffer_memory_space

protectedinherited

Kokkos memory space for communication buffers.

See #1088 for why this is not just device_type::memory_space.

Definition at line 693 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::buffer_device_type

inherited

Kokkos::Device specialization for communication buffers.

See #1088 for why this is not just device_type::device_type.

This needs to be public so that I can declare functions like packAndPrepareWithOwningPIDs.

Warning: This is an implementation detail. DO NOT DEPEND ON IT. It may disappear or change at any time.

Definition at line 710 of file Tpetra_DistObject_decl.hpp.

Member Enumeration Documentation

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

enum Tpetra::Classes::DistObject::ReverseOption

protectedinherited

Whether the data transfer should be performed in forward or reverse mode.

"Reverse mode" means calling doExport() with an Import object, or calling doImport() with an Export object. "Forward mode" means calling doExport() with an Export object, or calling doImport() with an Import object.

Definition at line 605 of file Tpetra_DistObject_decl.hpp.

Constructor & Destructor Documentation

template<class Scalar , class LO, class GO , class Node >

Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::BlockMultiVector	(	const map_type &	meshMap,
		const LO	blockSize,
		const LO	numVecs
	)

Constructor that takes a mesh Map, a block size, and a number of vectors (columns).

Parameters

meshMap	[in] Map that describes the distribution of mesh points (rather than the distribution of unknowns for those mesh points).
blockSize	[in] The number of degrees of freedom per mesh point. We assume that this is the same for all mesh points in the above Map.
numVecs	[in] Number of vectors (columns) in the MultiVector.

The mesh Map describes the distribution of mesh points. Its corresponding point Map describes the distribution of degrees of freedom corresponding to those mesh points. If you have already computed the point Map corresponding to the above mesh Map, then it is more efficient to call the four-argument constructor below, that takes both the mesh Map and the point Map.

There are two ways to get the point Map corresponding to a given mesh Map and block size. You may either call the class method makePointMap(), or you may call this three-argument constructor, and then call getPointMap().

The point Map enables reinterpretation of a BlockMultiVector as a standard Tpetra::MultiVector. This lets users solve linear systems with Trilinos' solvers and preconditioners, that expect vectors as Tpetra::MultiVector instances.

Definition at line 125 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar , class LO, class GO , class Node >

Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::BlockMultiVector	(	const map_type &	meshMap,
		const map_type &	pointMap,
		const LO	blockSize,
		const LO	numVecs
	)

Constructor that takes a mesh Map, a point Map, a block size, and a number of vectors (columns).

See the documentation of the three-argument constructor above.

Definition at line 141 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar , class LO, class GO , class Node >

Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::BlockMultiVector	(	const mv_type &	X_mv,
		const map_type &	meshMap,
		const LO	blockSize
	)

View an existing MultiVector.

Parameters

X_mv	[in/out] The MultiVector to view. It MUST have view semantics; otherwise this constructor throws. Its Map must be the same (in the sense of isSameAs) as the point Map corresponding to the given mesh Map and block size.
meshMap	[in] The mesh Map to use for interpreting the given MultiVector (in place) as a BlockMultiVector.
blockSize	[in] The number of degrees of freedom per mesh point. We assume that this is the same for all mesh points.

Definition at line 158 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node>

Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::BlockMultiVector	(	const BlockMultiVector< Scalar, LO, GO, Node > &	X,
		const map_type &	newMeshMap,
		const map_type &	newPointMap,
		const size_t	offset = `0`
	)

View an existing BlockMultiVector using a different mesh Map, supplying the corresponding point Map.

This method corresponds to MultiVector's "offset view" constructor.

Definition at line 217 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node>

Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::BlockMultiVector	(	const BlockMultiVector< Scalar, LO, GO, Node > &	X,
		const map_type &	newMeshMap,
		const size_t	offset = `0`
	)

View an existing BlockMultiVector using a different mesh Map; compute the new point Map.

This method corresponds to MultiVector's "offset view" constructor.

Definition at line 234 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node>

Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::BlockMultiVector ( )

Default constructor.

Creates an empty BlockMultiVector. An empty BlockMultiVector has zero rows, and block size zero.

Definition at line 250 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

Member Function Documentation

template<class Scalar , class LO, class GO , class Node >

BlockMultiVector< Scalar, LO, GO, Node >::map_type Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::makePointMap	(	const map_type &	meshMap,
		const LO	blockSize
	)

static

Create and return the point Map corresponding to the given mesh Map and block size.

This is a class ("static") method so that you can make and reuse a point Map for creating different BlockMultiVector instances, using the more efficient four-argument constructor.

Definition at line 262 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

map_type Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getPointMap ( ) const

inline

Get this BlockMultiVector's (previously computed) point Map.

It is always valid to call this method. A BlockMultiVector always has a point Map. We do not compute the point Map lazily.

Definition at line 319 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

LO Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getBlockSize ( ) const

inline

Get the number of degrees of freedom per mesh point.

Definition at line 324 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

LO Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getNumVectors ( ) const

inline

Get the number of columns (vectors) in the BlockMultiVector.

Definition at line 329 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar , class LO , class GO , class Node >

BlockMultiVector< Scalar, LO, GO, Node >::mv_type Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getMultiVectorView ( ) const

Get a Tpetra::MultiVector that views this BlockMultiVector's data.

This is how you can give a BlockMultiVector to Trilinos' solvers and preconditioners.

Definition at line 104 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO , class GO , class Node >

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::putScalar ( const Scalar & val )

Fill all entries with the given value val.

Definition at line 641 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO , class GO , class Node >

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::scale ( const Scalar & val )

Multiply all entries in place by the given value val.

Definition at line 648 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node>

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::update	(	const Scalar &	alpha,
		const BlockMultiVector< Scalar, LO, GO, Node > &	X,
		const Scalar &	beta
	)

Update: this = beta*this + alpha*X.

Update this BlockMultiVector with scaled values of X. If beta is zero, overwrite *this unconditionally, even if it contains NaN entries. It is legal for the input X to alias this MultiVector.

Definition at line 655 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node>

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::blockWiseMultiply	(	const Scalar &	alpha,
		const Kokkos::View< const impl_scalar_type ***, device_type, Kokkos::MemoryUnmanaged > &	D,
		const BlockMultiVector< Scalar, LO, GO, Node > &	X
	)

*this := alpha * D * X, where D is a block diagonal matrix.

Compute *this := alpha * D * X, where D is a block diagonal matrix, stored as a 3-D Kokkos::View. This method is the block analog of Tpetra::MultiVector::elementWiseMultiply, and is likewise useful for implementing (block) Jacobi.

Parameters

alpha	[in] Coefficient by which to scale the result. We treat alpha = 0 as a special case, following the BLAS rules. That is, if alpha = 0, this method does `this->putScalar(0)`.
D	[in] Block diagonal, as a 3-D Kokkos::View. The leftmost index indicates which block, the middle index the row within a block, and the rightmost index the column within a block.
pivots	[in] Pivots (from LU factorization of the blocks)
X	[in] Input Block(Multi)Vector; may alias `*this`.

D is really the inverse of some BlockCrsMatrix's block diagonal. You may compute the inverse of each block however you like. One way is to use GETRF, then GETRI.

Definition at line 848 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node>

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::blockJacobiUpdate	(	const Scalar &	alpha,
		const Kokkos::View< const impl_scalar_type ***, device_type, Kokkos::MemoryUnmanaged > &	D,
		const BlockMultiVector< Scalar, LO, GO, Node > &	X,
		BlockMultiVector< Scalar, LO, GO, Node > &	Z,
		const Scalar &	beta
	)

Block Jacobi update $Y = \beta * Y + \alpha D (X - Z)$ .

This method computes the block Jacobi update $Y = \beta * Y + \alpha D (X - Z)$ , where Y is *this<>, D the (explicitly stored) inverse block diagonal of a BlockCrsMatrix A, and . The method may use Z as scratch space.

Folks who optimize sparse matrix-vector multiply kernels tend not to write special-purpose kernels like this one. Thus, this kernel consolidates all the other code that block Jacobi needs, while exploiting the existing sparse matrix-vector multiply kernel in BlockCrsMatrix. That consolidation minimizes thread-parallel kernel launch overhead.


Parameters

  
    alpha [in] Coefficient of the "block scaled" term. We treat alpha = 0 as a special case, following the BLAS rules. That is, if alpha = 0, this method does Y = beta * Y. 
    D [in] Block diagonal, as a 3-D Kokkos::View. The leftmost index indicates which block, the middle index the row within a block, and the rightmost index the column within a block. 
    X [in] The first of two block (multi)vectors whose difference is "block scaled" 
    Z [in/out] On input: The second of two block (multi)vectors whose difference is "block scaled." This method may use Z as scratch space. 
    beta [in] Coefficient of Y. We treat beta = 0 as a special case, following the BLAS rules. That is, if beta = 0, the initial contents of Y are ignored.

Definition at line 880 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

template<class TargetMemorySpace >

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::sync ( )

inline

Update data to the given target memory space, only if data in the "other" space have been marked as modified.

If TargetMemorySpace is the same as this object's memory space, then copy data from host to device. Otherwise, copy data from device to host. In either case, only copy if the source of the copy has been modified.

This is a one-way synchronization only. If the target of the copy has been modified, this operation will discard those modifications. It will also reset both device and host modified flags.

Note: This method doesn't know on its own whether you modified the data in either memory space. You must manually mark the MultiVector as modified in the space in which you modified it, by calling the modify() method with the appropriate template parameter.

Definition at line 449 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

template<class TargetMemorySpace >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::need_sync ( ) const

inline

Whether this object needs synchronization to the given memory space.

Definition at line 455 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

template<class TargetMemorySpace >

void Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::modify ( )

inline

Mark data as modified on the given memory space.

If TargetDeviceType::memory_space is the same as this object's memory space, then mark the device's data as modified. Otherwise, mark the host's data as modified.

Definition at line 465 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar, class LO, class GO , class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::replaceLocalValues	(	const LO	localRowIndex,
		const LO	colIndex,
		const Scalar	vals[]
	)		const

Replace all values at the given mesh point, using local row and column indices.

Parameters

localRowIndex	[in] Local index of the mesh point.
colIndex	[in] Column (vector) to modify.
vals	[in] Input values with which to replace whatever existing values are at the mesh point.

Returns: true if successful, else false. This method will not succeed if the given local index of the mesh point is invalid on the calling process.

Note: This method, the other "replace" and "sumInto" methods, and the view methods, are marked const. This is because they do not change pointers. They do, of course, change the values in the BlockMultiVector, but that does not require marking the methods as nonconst.

Definition at line 321 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::replaceGlobalValues	(	const GO	globalRowIndex,
		const LO	colIndex,
		const Scalar	vals[]
	)		const

Replace all values at the given mesh point, using a global index.

Parameters

globalRowIndex	[in] Global index of the mesh point.
colIndex	[in] Column (vector) to modify.
vals	[in] Input values with which to sum into whatever existing values are at the mesh point.

Returns: true if successful, else false. This method will not succeed if the given global index of the mesh point is invalid on the calling process.

Definition at line 336 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO , class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::sumIntoLocalValues	(	const LO	localRowIndex,
		const LO	colIndex,
		const Scalar	vals[]
	)		const

Sum into all values at the given mesh point, using a local index.

Parameters

localRowIndex	[in] Local index of the mesh point.
colIndex	[in] Column (vector) to modify.
vals	[in] Input values with which to replace whatever existing values are at the mesh point.

Returns: true if successful, else false. This method will not succeed if the given local index of the mesh point is invalid on the calling process.

Definition at line 365 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::sumIntoGlobalValues	(	const GO	globalRowIndex,
		const LO	colIndex,
		const Scalar	vals[]
	)		const

Sum into all values at the given mesh point, using a global index.

Parameters

globalRowIndex	[in] Global index of the mesh point.
colIndex	[in] Column (vector) to modify.
vals	[in] Input values with which to replace whatever existing values are at the mesh point.

Returns: true if successful, else false. This method will not succeed if the given global index of the mesh point is invalid on the calling process.

Definition at line 380 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO , class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getLocalRowView	(	const LO	localRowIndex,
		const LO	colIndex,
		Scalar *&	vals
	)		const

Get a writeable view of the entries at the given mesh point, using a local index.

Parameters

localRowIndex	[in] Local index of the mesh point.
colIndex	[in] Column (vector) to view.
vals	[out] View of the entries at the given mesh point.

Returns: true if successful, else false. This method will not succeed if the given local index of the mesh point is invalid on the calling process.

Definition at line 396 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar, class LO, class GO, class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getGlobalRowView	(	const GO	globalRowIndex,
		const LO	colIndex,
		Scalar *&	vals
	)		const

Get a writeable view of the entries at the given mesh point, using a global index.

Parameters

globalRowIndex	[in] Global index of the mesh point.
colIndex	[in] Column (vector) to view.
vals	[out] View of the entries at the given mesh point.

Returns: true if successful, else false. This method will not succeed if the given global index of the mesh point is invalid on the calling process.

Definition at line 410 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar , class LO, class GO , class Node >

BlockMultiVector< Scalar, LO, GO, Node >::little_vec_type::HostMirror Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getLocalBlock	(	const LO	localRowIndex,
		const LO	colIndex
	)		const

Get a host view of the degrees of freedom at the given mesh point.

Warning: This method's interface may change or disappear at any time. Please do not rely on it in your code yet.

Prefer using auto to let the compiler compute the return type. This gives us the freedom to change this type in the future. If you insist not to use auto, then please use the little_vec_type typedef to deduce the correct return type; don't try to hard-code the return type yourself.

Definition at line 425 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar , class LO , class GO , class Node >

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::checkSizes ( const Tpetra::SrcDistObject & source )

protectedvirtual

Compare the source and target (this) objects for compatibility.

Returns: True if they are compatible, else false.

Implements Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >.

Definition at line 482 of file Tpetra_Experimental_BlockMultiVector_def.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

impl_scalar_type* Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getRawPtr ( ) const

inlineprotected

Raw pointer to the MultiVector's data.

Definition at line 602 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

size_t Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getStrideX ( ) const

inlineprotected

Stride between consecutive local entries in the same column.

Definition at line 607 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

size_t Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::getStrideY ( ) const

inlineprotected

Stride between consecutive local entries in the same row.

Definition at line 612 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

bool Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::isValidLocalMeshIndex ( const LO meshLocalIndex ) const

inlineprotected

True if and only if meshLocalIndex is a valid local index in the mesh Map.

Definition at line 618 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Packet , class LocalOrdinal, class GlobalOrdinal, class Node>

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::doImport	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	source,
		const Import< LocalOrdinal, GlobalOrdinal, Node > &	importer,
		CombineMode	CM
	)

inherited

Import data into this object using an Import object ("forward mode").

The input DistObject is always the source of the data redistribution operation, and the *this object is always the target.

If you don't know the difference between forward and reverse mode, then you probably want forward mode. Use this method with your precomputed Import object if you want to do an Import, else use doExport() with a precomputed Export object.

Parameters

source	[in] The "source" object for redistribution.
importer	[in] Precomputed data redistribution plan. Its source Map must be the same as the input DistObject's Map, and its target Map must be the same as `this->getMap()`.
CM	[in] How to combine incoming data with the same global index.

Definition at line 252 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal, class GlobalOrdinal, class Node>

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::doImport	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	source,
		const Export< LocalOrdinal, GlobalOrdinal, Node > &	exporter,
		CombineMode	CM
	)

inherited

Import data into this object using an Export object ("reverse mode").

The input DistObject is always the source of the data redistribution operation, and the *this object is always the target.

If you don't know the difference between forward and reverse mode, then you probably want forward mode. Use the version of doImport() that takes a precomputed Import object in that case.

Parameters

source	[in] The "source" object for redistribution.
exporter	[in] Precomputed data redistribution plan. Its target Map must be the same as the input DistObject's Map, and its source Map must be the same as `this->getMap()`. (Note the difference from forward mode.)
CM	[in] How to combine incoming data with the same global index.

Definition at line 336 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal, class GlobalOrdinal, class Node>

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::doExport	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	source,
		const Export< LocalOrdinal, GlobalOrdinal, Node > &	exporter,
		CombineMode	CM
	)

inherited

Export data into this object using an Export object ("forward mode").

The input DistObject is always the source of the data redistribution operation, and the *this object is always the target.

If you don't know the difference between forward and reverse mode, then you probably want forward mode. Use this method with your precomputed Export object if you want to do an Export, else use doImport() with a precomputed Import object.

Parameters

source	[in] The "source" object for redistribution.
exporter	[in] Precomputed data redistribution plan. Its source Map must be the same as the input DistObject's Map, and its target Map must be the same as `this->getMap()`.
CM	[in] How to combine incoming data with the same global index.

Definition at line 294 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal, class GlobalOrdinal, class Node>

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::doExport	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	source,
		const Import< LocalOrdinal, GlobalOrdinal, Node > &	importer,
		CombineMode	CM
	)

inherited

Export data into this object using an Import object ("reverse mode").

The input DistObject is always the source of the data redistribution operation, and the *this object is always the target.

If you don't know the difference between forward and reverse mode, then you probably want forward mode. Use the version of doExport() that takes a precomputed Export object in that case.

Parameters

source	[in] The "source" object for redistribution.
importer	[in] Precomputed data redistribution plan. Its target Map must be the same as the input DistObject's Map, and its source Map must be the same as `this->getMap()`. (Note the difference from forward mode.)
CM	[in] How to combine incoming data with the same global index.

Definition at line 378 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

bool Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::isDistributed ( ) const

inherited

Whether this is a globally distributed object.

For a definition of "globally distributed" (and its opposite, "locally replicated"), see the documentation of Map's isDistributed() method.

Definition at line 420 of file Tpetra_DistObject_def.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

virtual Teuchos::RCP<const map_type> Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::getMap ( ) const

inlinevirtualinherited

The Map describing the parallel distribution of this object.

Note that some Tpetra objects might be distributed using multiple Map objects. For example, CrsMatrix has both a row Map and a column Map. It is up to the subclass to decide which Map to use when invoking the DistObject constructor.

Definition at line 510 of file Tpetra_DistObject_decl.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::print ( std::ostream & os ) const

inherited

Print this object to the given output stream.

We generally assume that all MPI processes can print to the given stream.

Definition at line 1609 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

std::string Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::description ( ) const

virtualinherited

One-line descriptiion of this object.

We declare this method virtual so that subclasses of DistObject may override it.

Reimplemented in Tpetra::Classes::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LO, GO, Node >, Tpetra::Classes::CrsGraph< LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::CrsGraph< LO, GO, node_type >, Tpetra::Details::CooMatrix< SC, LO, GO, NT >, Tpetra::Classes::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, and Tpetra::Experimental::Classes::BlockCrsMatrix< Scalar, LO, GO, Node >.

Definition at line 127 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::describe	(	Teuchos::FancyOStream &	out,
		const Teuchos::EVerbosityLevel	verbLevel = `Teuchos::Describable::verbLevel_default`
	)		const

virtualinherited

Print a descriptiion of this object to the given output stream.

We declare this method virtual so that subclasses of Distobject may override it.

Reimplemented in Tpetra::Classes::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LO, GO, Node >, Tpetra::Classes::CrsGraph< LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::CrsGraph< LO, GO, node_type >, Tpetra::Details::CooMatrix< SC, LO, GO, NT >, Tpetra::Classes::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, and Tpetra::Experimental::Classes::BlockCrsMatrix< Scalar, LO, GO, Node >.

Definition at line 147 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::removeEmptyProcessesInPlace ( const Teuchos::RCP< const map_type > & newMap )

virtualinherited

Remove processes which contain no entries in this object's Map.

Warning: This method is ONLY for use by experts. We highly recommend using the nonmember function of the same name defined in this file.; We make NO promises of backwards compatibility. This method may change or disappear at any time.

On input, this object is distributed over the Map returned by getMap() (the "original Map," with its communicator, the "original communicator"). The input newMap of this method must be the same as the result of calling getMap()->removeEmptyProcesses(). On processes in the original communicator which contain zero entries ("excluded processes," as opposed to "included processes"), the input newMap must be Teuchos::null (which is what getMap()->removeEmptyProcesses() returns anyway).

On included processes, reassign this object's Map (that would be returned by getMap()) to the input newMap, and do any work that needs to be done to restore correct semantics. On excluded processes, free any data that needs freeing, and do any other work that needs to be done to restore correct semantics.

This method has collective semantics over the original communicator. On exit, the only method of this object which is safe to call on excluded processes is the destructor. This implies that subclasses' destructors must not contain communication operations.

Returns: The object's new Map. Its communicator is a new communicator, distinct from the old Map's communicator, which contains a subset of the processes in the old communicator.

Note: The name differs from Map's method removeEmptyProcesses(), in order to emphasize that the operation on DistObject happens in place, modifying the input, whereas the operation removeEmptyProcess() on Map does not modify the input.; To implementers of DistObject subclasses: The default implementation of this class throws std::logic_error.

Reimplemented in Tpetra::Classes::MultiVector< Scalar, LO, GO, Node >.

Definition at line 214 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

size_t Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::constantNumberOfPackets ( ) const

protectedvirtualinherited

Whether the implementation's instance promises always to have a constant number of packets per LID (local index), and if so, how many packets per LID there are.

If this method returns zero, the instance says that it might possibly have a different number of packets for each LID (local index) to send or receive. If it returns nonzero, the instance promises that the number of packets is the same for all LIDs, and that the return value is this number of packets per LID.

The default implementation of this method returns zero. This does not affect the behavior of doTransfer() in any way. If a nondefault implementation returns nonzero, doTransfer() will use this information to avoid unnecessary allocation and / or resizing of arrays.

Reimplemented in Tpetra::Classes::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LO, GO, Node >, and Tpetra::Details::CooMatrix< SC, LO, GO, NT >.

Definition at line 427 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::doTransfer	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	src,
		const ::Tpetra::Details::Transfer< local_ordinal_type, global_ordinal_type, node_type > &	transfer,
		const char	modeString[],
		const ReverseOption	revOp,
		const CombineMode	CM
	)

protectedvirtualinherited

Redistribute data across memory images.

Parameters

src	[in] The source object, to redistribute into the target object, which is `*this` object.
transfer	[in] The Export or Import object representing the communication pattern. (Details::Transfer is the common base class of these two objects.)
modeString	[in] Human-readable string, for verbose debugging output and error output, explaining what function called this method. Example: "doImport (forward)", "doExport (reverse)".
revOp	[in] Whether to do a forward or reverse mode redistribution.
CM	[in] The combine mode that describes how to combine values that map to the same global ID on the same process.

Definition at line 434 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

bool Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::reallocArraysForNumPacketsPerLid	(	const size_t	numExportLIDs,
		const size_t	numImportLIDs
	)

protectedvirtualinherited

Reallocate numExportPacketsPerLID_ and/or numImportPacketsPerLID_, if necessary.

Parameters

numExportLIDs	[in] Number of entries in the exportLIDs input array argument of doTransfer().
numImportLIDs	[in] Number of entries in the remoteLIDs input array argument of doTransfer().

Returns: Whether we actually reallocated either of the arrays.

Warning: This is an implementation detail of doTransferOld() and doTransferNew(). This needs to be protected, but that doesn't mean users should call this method.

Definition at line 617 of file Tpetra_DistObject_def.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

virtual bool Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::useNewInterface ( )

inlineprotectedvirtualinherited

Whether the subclass implements the "old" or "new" (Kokkos-friendly) interface.

The "old" interface consists of copyAndPermute, packAndPrepare, and unpackAndCombine. The "new" interface consists of copyAndPermuteNew, packAndPrepareNew, and unpackAndCombineNew. We prefer the new interface, because it facilitates thread parallelization using Kokkos data structures.

At some point, we will remove the old interface, and rename the "new" interface (by removing "New" from the methods' names), so that it becomes the only interface.

Reimplemented in Tpetra::Classes::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Tpetra::Classes::MultiVector< Scalar, LO, GO, Node >, and Tpetra::Details::CooMatrix< SC, LO, GO, NT >.

Definition at line 761 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

virtual void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::copyAndPermute	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	source,
		size_t	numSameIDs,
		const Teuchos::ArrayView< const local_ordinal_type > &	permuteToLIDs,
		const Teuchos::ArrayView< const local_ordinal_type > &	permuteFromLIDs
	)

inlineprotectedvirtualinherited

Perform copies and permutations that are local to this process.

Parameters

source	[in] On entry, the source object, from which we are distributing. We distribute to the destination object, which is `*this` object.
numSameIDs	[in] The umber of elements that are the same on the source and destination (this) objects. These elements are owned by the same process in both the source and destination objects. No permutation occurs.
numPermuteIDs	[in] The number of elements that are locally permuted between the source and destination objects.
permuteToLIDs	[in] List of the elements that are permuted. They are listed by their LID in the destination object.
permuteFromLIDs	[in] List of the elements that are permuted. They are listed by their LID in the source object.

Reimplemented in Tpetra::Classes::CrsGraph< LocalOrdinal, GlobalOrdinal, Node >, and Tpetra::Classes::CrsGraph< LO, GO, node_type >.

Definition at line 781 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

virtual void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::packAndPrepare	(	const SrcDistObject< Packet, LocalOrdinal, GlobalOrdinal, Node > &	source,
		const Teuchos::ArrayView< const local_ordinal_type > &	exportLIDs,
		Teuchos::Array< packet_type > &	exports,
		const Teuchos::ArrayView< size_t > &	numPacketsPerLID,
		size_t &	constantNumPackets,
		Distributor &	distor
	)

inlineprotectedvirtualinherited

Perform any packing or preparation required for communication.

Parameters

source	[in] Source object for the redistribution.
exportLIDs	[in] List of the entries (as local IDs in the source object) we will be sending to other images.
exports	[out] On exit, the buffer for data to send.
numPacketsPerLID	[out] On exit, the implementation of this method must do one of two things: set numPacketsPerLID[i] to contain the number of packets to be exported for exportLIDs[i] and set constantNumPackets to zero, or set constantNumPackets to a nonzero value. If the latter, the implementation need not fill numPacketsPerLID.
constantNumPackets	[out] On exit, 0 if numPacketsPerLID has variable contents (different size for each LID). If nonzero, then it is expected that the number of packets per LID is constant, and that constantNumPackets is that value.
distor	[in] The Distributor object we are using.

Definition at line 816 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

virtual void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::unpackAndCombine	(	const Teuchos::ArrayView< const local_ordinal_type > &	importLIDs,
		const Teuchos::ArrayView< const packet_type > &	imports,
		const Teuchos::ArrayView< size_t > &	numPacketsPerLID,
		size_t	constantNumPackets,
		Distributor &	distor,
		CombineMode	CM
	)

inlineprotectedvirtualinherited

Perform any unpacking and combining after communication (old version that uses Teuchos memory management classes to hold data).

Parameters

importLIDs	[in] List of the entries (as LIDs in the destination object) we received from other images.
imports	[in] Buffer containing data we received.
numPacketsPerLID	[in] If constantNumPackets is zero, then numPacketsPerLID[i] contains the number of packets imported for importLIDs[i].
constantNumPackets	[in] If nonzero, then numPacketsPerLID is constant (same value in all entries) and constantNumPackets is that value. If zero, then numPacketsPerLID[i] is the number of packets imported for importLIDs[i].
distor	[in] The Distributor object we are using.
CM	[in] The combine mode to use when combining the imported entries with existing entries.

Definition at line 857 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

virtual void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::unpackAndCombineNew	(	const Kokkos::DualView< const local_ordinal_type *, device_type > &	importLIDs,
		const Kokkos::DualView< const packet_type *, buffer_device_type > &	imports,
		const Kokkos::DualView< const size_t *, buffer_device_type > &	numPacketsPerLID,
		const size_t	constantNumPackets,
		Distributor &	distor,
		const CombineMode	CM
	)

inlineprotectedvirtualinherited

Perform any unpacking and combining after communication (new version that uses Kokkos data structures to hold data).

The imports input argument controls whether this method should unpack on host or unpack on device.

Parameters

importLIDs	[in] List of the entries (as LIDs in the destination object) we received from other images.
imports	[in] Buffer containing data we received.
numPacketsPerLID	[in] If constantNumPackets is zero, then numPacketsPerLID[i] contains the number of packets imported for importLIDs[i].
constantNumPackets	[in] If nonzero, then numPacketsPerLID is constant (same value in all entries) and constantNumPackets is that value. If zero, then numPacketsPerLID[i] is the number of packets imported for importLIDs[i].
distor	[in] The Distributor object we are using.
CM	[in] The combine mode to use when combining the imported entries with existing entries.

Definition at line 891 of file Tpetra_DistObject_decl.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::createViews ( ) const

protectedvirtualinherited

Hook for creating a const view.

doTransfer() calls this on the source object. By default, it does nothing, but the source object can use this as a hint to fetch data from a compute buffer on an off-CPU device (such as a GPU) into host memory.

Definition at line 1624 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::createViewsNonConst ( KokkosClassic::ReadWriteOption rwo )

protectedvirtualinherited

Hook for creating a nonconst view.

doTransfer() calls this on the destination (*this) object. By default, it does nothing, but the destination object can use this as a hint to fetch data from a compute buffer on an off-CPU device (such as a GPU) into host memory.

Parameters

rwo [in] Whether to create a write-only or a read-and-write view. For Kokkos Node types where compute buffers live in a separate memory space (e.g., in the device memory of a discrete accelerator like a GPU), a write-only view only requires copying from host memory to the compute buffer, whereas a read-and-write view requires copying both ways (once to read, from the compute buffer to host memory, and once to write, back to the compute buffer).

Definition at line 1630 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

void Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::releaseViews ( ) const

protectedvirtualinherited

Hook for releasing views.

Note: This is no longer called (and is therefore no longer needed) for subclasses for which useNewInterface() returns true.

doTransfer() calls this on both the source and destination objects, once it no longer needs to access that object's data. By default, this method does nothing. Implementations may use this as a hint to free host memory which is a view of a compute buffer, once the host memory view is no longer needed. Some implementations may prefer to mirror compute buffers in host memory; for these implementations, releaseViews() may do nothing.

Definition at line 1636 of file Tpetra_DistObject_def.hpp.

template<class Packet , class LocalOrdinal , class GlobalOrdinal , class Node >

bool Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::reallocImportsIfNeeded	(	const size_t	newSize,
		const bool	debug = `false`
	)

protectedinherited

Reallocate imports_ if needed.

This unfortunately must be declared protected, for the same reason that imports_ is declared protected.

Parameters

newSize	[in] New size of imports_.
debug	[in] Whether to print (copious) debug output to stderr.

Returns: Whether we actually reallocated.

We don't need a "reallocExportsIfNeeded" method, because exports_ always gets passed into packAndPrepareNew() by nonconst reference. Thus, that method can resize the DualView without needing to call other DistObject methods.

Definition at line 592 of file Tpetra_DistObject_def.hpp.

Member Data Documentation

template<class Scalar = ::Tpetra::Details::DefaultTypes::scalar_type, class LO = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GO = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

mv_type Tpetra::Experimental::Classes::BlockMultiVector< Scalar, LO, GO, Node >::mv_

protected

The Tpetra::MultiVector used to represent the data.

Definition at line 636 of file Tpetra_Experimental_BlockMultiVector_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Teuchos::RCP<const map_type> Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::map_

protectedinherited

The Map over which this object is distributed.

Definition at line 942 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Kokkos::DualView<packet_type*, buffer_device_type> Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::imports_

protectedinherited

Buffer into which packed data are imported (received from other processes).

Unfortunately, I had to declare these protected, because CrsMatrix uses them at one point. Please, nobody else use them.

Definition at line 951 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Kokkos::DualView<size_t*, buffer_device_type> Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::numImportPacketsPerLID_

protectedinherited

Number of packets to receive for each receive operation.

This array is used in Distributor::doPosts() (and doReversePosts()) when starting the ireceive operation.

This may be ignored in doTransfer() if constantNumPackets is nonzero, indicating a constant number of packets per LID. (For example, MultiVector sets the constantNumPackets output argument of packAndPrepare() to the number of columns in the multivector.)

Unfortunately, I had to declare this protected, because CrsMatrix uses it at one point. Please, nobody else use it.

Definition at line 983 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Kokkos::DualView<packet_type*, buffer_device_type> Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::exports_

protectedinherited

Buffer from which packed data are exported (sent to other processes).

Unfortunately, I had to declare this protected, because CrsMatrix uses it at one point. Please, nobody else use it.

Definition at line 990 of file Tpetra_DistObject_decl.hpp.

template<class Packet, class LocalOrdinal = ::Tpetra::Details::DefaultTypes::local_ordinal_type, class GlobalOrdinal = ::Tpetra::Details::DefaultTypes::global_ordinal_type, class Node = ::Tpetra::Details::DefaultTypes::node_type>

Kokkos::DualView<size_t*, buffer_device_type> Tpetra::Classes::DistObject< Packet, LocalOrdinal, GlobalOrdinal, Node >::numExportPacketsPerLID_

protectedinherited

Number of packets to send for each send operation.

This array is used in Distributor::doPosts() (and doReversePosts()) for preparing for the send operation.

This may be ignored in doTransfer() if constantNumPackets is nonzero, indicating a constant number of packets per LID. (For example, MultiVector sets the constantNumPackets output argument of packAndPrepare() to the number of columns in the multivector.)

Unfortunately, I had to declare this protected, because CrsMatrix uses them at one point. Please, nobody else use it.

Definition at line 1005 of file Tpetra_DistObject_decl.hpp.

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

alpha	[in] Coefficient of the "block scaled" term. We treat alpha = 0 as a special case, following the BLAS rules. That is, if alpha = 0, this method does Y = beta * Y.
D	[in] Block diagonal, as a 3-D Kokkos::View. The leftmost index indicates which block, the middle index the row within a block, and the rightmost index the column within a block.
X	[in] The first of two block (multi)vectors whose difference is "block scaled"
Z	[in/out] On input: The second of two block (multi)vectors whose difference is "block scaled." This method may use Z as scratch space.
beta	[in] Coefficient of Y. We treat beta = 0 as a special case, following the BLAS rules. That is, if beta = 0, the initial contents of Y are ignored.

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Access to Maps, the block size, and a MultiVector view.

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation