#include <Tpetra_Experimental_BlockCrsMatrix_decl.hpp>

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

Public Types
Public typedefs
typedef Scalar	scalar_type
	The type of entries in the matrix.
typedef LO	local_ordinal_type
	The type of local indices.
typedef GO	global_ordinal_type
	The type of global indices.
typedef Node	node_type
	The Kokkos Node type.
typedef ::Tpetra::Map< LO, GO, node_type >	map_type
typedef Tpetra::MultiVector < scalar_type, LO, GO, node_type >	mv_type
typedef Tpetra::CrsGraph< LO, GO, node_type >	crs_graph_type
typedef LittleBlock< Scalar, LO >	little_block_type
typedef LittleBlock< const Scalar, LO >	const_little_block_type
typedef LittleVector< Scalar, LO >	little_vec_type
typedef LittleVector< const Scalar, LO >	const_little_vec_type
Public Member Functions
virtual Teuchos::RCP< const Teuchos::Comm< int > >	getComm () const
	The communicator over which this matrix is distributed.
virtual Teuchos::RCP< Node >	getNode () const
	The Kokkos Node instance.
virtual global_size_t	getGlobalNumCols () const
	The global number of columns of this matrix.
virtual size_t	getNodeNumCols () const
	The number of columns needed to apply the forward operator on this node.
virtual GO	getIndexBase () const
	The index base for global indices in this matrix.
virtual global_size_t	getGlobalNumEntries () const
	The global number of stored (structurally nonzero) entries.
virtual size_t	getNodeNumEntries () const
	The local number of stored (structurally nonzero) entries.
virtual size_t	getNumEntriesInGlobalRow (GO globalRow) const
	The current number of entries on the calling process in the specified global row.
virtual global_size_t	getGlobalNumDiags () const
	The number of global diagonal entries, based on global row/column index comparisons.
virtual size_t	getNodeNumDiags () const
	The number of local diagonal entries, based on global row/column index comparisons.
virtual size_t	getGlobalMaxNumRowEntries () const
	The maximum number of entries across all rows/columns on all nodes.
virtual bool	hasColMap () const
	Whether this matrix has a well-defined column map.
virtual bool	isLowerTriangular () const
	Whether this matrix is lower triangular.
virtual bool	isUpperTriangular () const
	Whether this matrix is upper triangular.
virtual bool	isLocallyIndexed () const
	Whether matrix indices are locally indexed.
virtual bool	isGloballyIndexed () const
	Whether matrix indices are globally indexed.
virtual bool	isFillComplete () const
	Whether fillComplete() has been called.
virtual bool	supportsRowViews () const
	Whether this object implements getLocalRowView() and getGlobalRowView().
Constructors and destructor
	BlockCrsMatrix ()
	Default constructor: Makes an empty block matrix.
	BlockCrsMatrix (const crs_graph_type &graph, const LO blockSize)
	Constructor that takes a graph and a block size.
	BlockCrsMatrix (const crs_graph_type &graph, const map_type &domainPointMap, const map_type &rangePointMap, const LO blockSize)
	Constructor that takes a graph, domain and range point Maps, and a block size.
virtual	~BlockCrsMatrix ()
	Destructor (declared virtual for memory safety).
Implementation of Tpetra::Operator
Teuchos::RCP< const map_type >	getDomainMap () const
	Get the (point) domain Map of this matrix.
Teuchos::RCP< const map_type >	getRangeMap () const
	Get the (point) range Map of this matrix.
Teuchos::RCP< const map_type >	getRowMap () const
	get the (mesh) map for the rows of this block matrix.
Teuchos::RCP< const map_type >	getColMap () const
	get the (mesh) map for the columns of this block matrix.
global_size_t	getGlobalNumRows () const
	get the global number of block rows
size_t	getNodeNumRows () const
	get the local number of block rows
size_t	getNodeMaxNumRowEntries () const
	The maximum number of entries across all rows/columns on this node.
void	apply (const mv_type &X, mv_type &Y, Teuchos::ETransp mode=Teuchos::NO_TRANS, scalar_type alpha=Teuchos::ScalarTraits< scalar_type >::one(), scalar_type beta=Teuchos::ScalarTraits< scalar_type >::zero()) const
	For this matrix A, compute `Y := beta * Y + alpha * Op(A) * X`.
bool	hasTransposeApply () const
	Whether it is valid to apply the transpose or conjugate transpose of this matrix.
void	setAllToScalar (const Scalar &alpha)
	Set all matrix entries equal to `alpha`.
Implementation of Teuchos::Describable
std::string	description () const
	One-line description of this object.
void	describe (Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
	Print a description of this object to the given output stream.
Extraction Methods
virtual void	getGlobalRowCopy (GO GlobalRow, const Teuchos::ArrayView< GO > &Indices, const Teuchos::ArrayView< Scalar > &Values, size_t &NumEntries) const
	Get a copy of the given global row's entries.
virtual void	getGlobalRowView (GO GlobalRow, ArrayView< const GO > &indices, ArrayView< const Scalar > &values) const
	Get a constant, nonpersisting, globally indexed view of the given row of the matrix.
virtual void	getLocalDiagCopy (Vector< Scalar, LO, GO, Node > &diag) const
	Get a copy of the diagonal entries, distributed by the row Map.
Mathematical methods
virtual void	leftScale (const Vector< Scalar, LO, GO, Node > &x)
	Scale the RowMatrix on the left with the given Vector x.
virtual void	rightScale (const Vector< Scalar, LO, GO, Node > &x)
	Scale the RowMatrix on the right with the given Vector x.
virtual ScalarTraits< Scalar > ::magnitudeType	getFrobeniusNorm () const
	The Frobenius norm of the matrix.
Extraction Methods
virtual void	getLocalRowCopy (LOLocalRow, const Teuchos::ArrayView< LO > &Indices, const Teuchos::ArrayView< Scalar > &Values, size_t &NumEntries) const =0
	Get a copy of the given local row's entries.
Mathematical methods
virtual Teuchos::RCP < RowMatrix< Scalar, LO, GO, Node > >	add (const Scalar &alpha, const RowMatrix< Scalar, LO, GO, Node > &A, const Scalar &beta, const Teuchos::RCP< const Map< LO, GO, Node > > &domainMap=Teuchos::null, const Teuchos::RCP< const Map< LO, GO, Node > > &rangeMap=Teuchos::null, const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null) const
	Return a new RowMatrix which is the result of `betathis + alphaA`.
Implementation of Packable interface
virtual void	pack (const Teuchos::ArrayView< const LO > &exportLIDs, Teuchos::Array< char > &exports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t &constantNumPackets, Distributor &distor) const
	Pack this object's data for an Import or Export.
Pure virtual functions to be overridden by subclasses.
virtual void	apply (const MultiVector< Scalar, LO, GO, Node > &X, MultiVector< Scalar, LO, GO, Node > &Y, Teuchos::ETransp mode=Teuchos::NO_TRANS, Scalar alpha=Teuchos::ScalarTraits< Scalar >::one(), Scalar beta=Teuchos::ScalarTraits< Scalar >::zero()) const =0
	Computes the operator-multivector application.
Public methods for redistributing data
void	doImport (const SrcDistObject &source, const Import< LO, GO, Node > &importer, CombineMode CM)
	Import data into this object using an Import object ("forward mode").
void	doImport (const SrcDistObject &source, const Export< LO, GO, Node > &exporter, CombineMode CM)
	Import data into this object using an Export object ("reverse mode").
void	doExport (const SrcDistObject &source, const Export< LO, GO, Node > &exporter, CombineMode CM)
	Export data into this object using an Export object ("forward mode").
void	doExport (const SrcDistObject &source, const Import< LO, GO, Node > &importer, CombineMode CM)
	Export data into this object using an Import object ("reverse mode").
Attribute accessor methods
bool	isDistributed () const
	Whether this is a globally distributed object.
virtual Teuchos::RCP< const Map< LO, GO, Node > >	getMap () const
	The Map describing the parallel distribution of this object.
I/O methods
void	print (std::ostream &os) const
	Print this object to the given output stream.
Protected Types
typedef char	packet_type
	The type of each datum being sent or received in an Import or Export.
Protected Member Functions
virtual size_t	constantNumberOfPackets () const
	Whether the implementation's instance promises always to have a constant number of packets per LID, and if so, how many packets per LID there are.
virtual void	doTransfer (const SrcDistObject &src, CombineMode CM, size_t numSameIDs, const Teuchos::ArrayView< const LO > &permuteToLIDs, const Teuchos::ArrayView< const LO > &permuteFromLIDs, const Teuchos::ArrayView< const LO > &remoteLIDs, const Teuchos::ArrayView< const LO > &exportLIDs, Distributor &distor, ReverseOption revOp)
	Redistribute data across memory images.
virtual void	createViews () const
	Hook for creating a const view.
virtual void	createViewsNonConst (KokkosClassic::ReadWriteOption rwo)
	Hook for creating a nonconst view.
virtual void	releaseViews () const
	Hook for releasing views.
Implementation of DistObject (or DistObjectKA).
The methods here implement Tpetra::DistObject or Tpetra::DistObjectKA, depending on a configure-time option. 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.
virtual void	copyAndPermute (const Tpetra::SrcDistObject &source, size_t numSameIDs, const Teuchos::ArrayView< const LO > &permuteToLIDs, const Teuchos::ArrayView< const LO > &permuteFromLIDs)
	Perform copies and permutations that are local to this process.
virtual void	packAndPrepare (const Tpetra::SrcDistObject &source, const Teuchos::ArrayView< const LO > &exportLIDs, Teuchos::Array< packet_type > &exports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t &constantNumPackets, Tpetra::Distributor &distor)
	Perform any packing or preparation required for communication.
virtual void	unpackAndCombine (const Teuchos::ArrayView< const LO > &importLIDs, const Teuchos::ArrayView< const packet_type > &imports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, size_t constantNumPackets, Tpetra::Distributor &distor, Tpetra::CombineMode CM)
	Perform any unpacking and combining after communication.
Protected Attributes
Teuchos::RCP< const Map< LO, GO, Node > >	map_
	The Map over which this object is distributed.
Teuchos::Array< char >	imports_
	Buffer into which packed data are imported (received from other processes).
Teuchos::Array< size_t >	numImportPacketsPerLID_
	Number of packets to receive for each receive operation.
Teuchos::Array< char >	exports_
	Buffer from which packed data are exported (sent to other processes).
Teuchos::Array< size_t >	numExportPacketsPerLID_
	Number of packets to send for each send operation.
Methods for use only by experts
virtual void	removeEmptyProcessesInPlace (const Teuchos::RCP< const Map< LO, GO, Node > > &newMap)
	Remove processes which contain no elements in this object's Map.
void	removeEmptyProcessesInPlace (Teuchos::RCP< Tpetra::DistObject< PT, LO, GO, NT > > &input, const Teuchos::RCP< const Map< LO, GO, NT > > &newMap)
void	removeEmptyProcessesInPlace (Teuchos::RCP< Tpetra::DistObject< PT, LO, GO, NT > > &input)
Block operations
LO	getBlockSize () const
	The number of degrees of freedom per mesh point.
virtual Teuchos::RCP< const Tpetra::RowGraph< LO, GO, Node > >	getGraph () const
	Get the (mesh) graph.
crs_graph_type	getCrsGraph () const
void	applyBlock (const BlockMultiVector< Scalar, LO, GO, Node > &X, BlockMultiVector< Scalar, LO, GO, Node > &Y, Teuchos::ETransp mode=Teuchos::NO_TRANS, const Scalar alpha=Teuchos::ScalarTraits< Scalar >::one(), const Scalar beta=Teuchos::ScalarTraits< Scalar >::zero())
	Version of apply() that takes BlockMultiVector input and output.
void	gaussSeidelCopy (MultiVector< Scalar, LO, GO, Node > &X, const MultiVector< Scalar, LO, GO, Node > &B, const MultiVector< Scalar, LO, GO, Node > &D, const Scalar &dampingFactor, const ESweepDirection direction, const int numSweeps, const bool zeroInitialGuess) const
	Version of gaussSeidel(), with fewer requirements on X.
void	reorderedGaussSeidelCopy (MultiVector< Scalar, LO, GO, Node > &X, const MultiVector< Scalar, LO, GO, Node > &B, const MultiVector< Scalar, LO, GO, Node > &D, const ArrayView< LO > &rowIndices, const Scalar &dampingFactor, const ESweepDirection direction, const int numSweeps, const bool zeroInitialGuess) const
	Version of reorderedGaussSeidel(), with fewer requirements on X.
void	localGaussSeidel (const BlockMultiVector< Scalar, LO, GO, Node > &Residual, BlockMultiVector< Scalar, LO, GO, Node > &Solution, BlockCrsMatrix< Scalar, LO, GO, Node > &factorizedDiagonal, const int *factorizationPivots, const Scalar omega, const ESweepDirection direction) const
	Local Gauss-Seidel solve given a factorized diagonal.
LO	replaceLocalValues (const LO localRowInd, const LO colInds[], const Scalar vals[], const LO numColInds) const
	Replace values at the given column indices, in the given row.
LO	sumIntoLocalValues (const LO localRowInd, const LO colInds[], const Scalar vals[], const LO numColInds) const
	Sum into values at the given column indices, in the given row.
LO	getLocalRowView (const LO localRowInd, const LO &colInds, Scalar &vals, LO &numInds) const
	Get a view of the row, using local indices.
void	getLocalRowView (LO LocalRow, ArrayView< const LO > &indices, ArrayView< const Scalar > &values) const
	Get a constant, nonpersisting, locally indexed view of the given row of the matrix.
void	getLocalRowCopy (LO LocalRow, const ArrayView< LO > &Indices, const ArrayView< Scalar > &Values, size_t &NumEntries) const
little_block_type	getLocalBlock (const LO localRowInd, const LO localColInd) const
LO	getLocalRowOffsets (const LO localRowInd, ptrdiff_t offsets[], const LO colInds[], const LO numColInds) const
	Get relative offsets corresponding to the given row indices.
LO	replaceLocalValuesByOffsets (const LO localRowInd, const ptrdiff_t offsets[], const Scalar vals[], const LO numOffsets) const
	Like replaceLocalValues, but avoids computing row offsets.
LO	sumIntoLocalValuesByOffsets (const LO localRowInd, const ptrdiff_t offsets[], const Scalar vals[], const LO numOffsets) const
	Like sumIntoLocalValues, but avoids computing row offsets.
size_t	getNumEntriesInLocalRow (const LO localRowInd) const
	Return the number of entries in the given row on the calling process.
bool	localError () const
	Whether this object had an error on the calling process.
std::string	errorMessages () const
	The current stream of error messages.
void	getLocalDiagOffsets (Teuchos::ArrayRCP< size_t > &offsets) const
	Get offsets of the diagonal entries in the matrix.
void	getLocalDiagCopy (BlockCrsMatrix< Scalar, LO, GO, Node > &diag, const Teuchos::ArrayView< const size_t > &offsets) const
	Variant of getLocalDiagCopy() that uses precomputed offsets.
void	computeDiagonalGraph ()
	Computes the DiagonalGraph.
bool	isComputedDiagonalGraph () const
	Reports on whether the DiagonalGraph has been Computed.
Teuchos::RCP< crs_graph_type >	getDiagonalGraph () const
LO	absMaxLocalValues (const LO localRowInd, const LO colInds[], const Scalar vals[], const LO numColInds) const
	Like sumIntoLocalValues, but for the ABSMAX combine mode.
LO	absMaxLocalValuesByOffsets (const LO localRowInd, const ptrdiff_t offsets[], const Scalar vals[], const LO numOffsets) const
	Like sumIntoLocalValuesByOffsets, but for the ABSMAX combine mode.

Detailed Description

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>
class Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >

Author:: Mark Hoemmen

Date:: 13 Feb 2014, 24 Feb 2014

Template Parameters:

Scalar	The type of the numerical entries of the matrix. (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.

Please read the documentation of BlockMultiVector first.

This class stores values associated with the degrees of freedom of a single mesh point contiguously, in a getBlockSize() by getBlockSize() block, in row-major format.

Since this class requires a fill-complete Tpetra::CrsGraph for construction, it has a row and column Map already. This means that it only needs to provide access using local indices. Users are responsible for converting from global to local indices if necessary. Please be aware that the row Map and column Map may differ, so you may not use local row and column indices interchangeably.

For simplicity, this object only supports local indexing. It can do so because both of its constructors require a fill-complete Tpetra::CrsGraph, which therefore has both a row Map and a column Map.

Here is an example of how to fill into this object using direct views.

 int err = 0;
 // At least one entry, so &offsets[0] always makes sense.
 Teuchos::Array<ptrdiff_t> offsets (1);
 for (LO localRowInd = 0; localRowInd < localNumRows; ++localRowInd) {
   // Get a view of the current row.
   // You may modify the values, but not the column indices.
   const LO* localColInds;
   Scalar* vals;
   LO numEntries;
   err = A.getLocalRowView (localRowInd, localColInds, vals, numEntries);
   if (err != 0) {
     break;
   }

   // Modify the entries in the current row.
   for (LO k = 0; k < numEntries; ++k) {
     Scalar* const curBlock = vals[blockSize * blockSize * k];
     // Blocks are stored in row-major format.
     for (LO j = 0; j < blockSize; ++j) {
       for (LO i = 0; i < blockSize; ++i) {
         const Scalar curVal = curBlock[i + j * blockSize];
         // Some function f of the current value and mesh point
         curBlock[i + j * blockSize] = f (curVal, localColInds[k], ...);
       }
     }
   }
 }

Definition at line 126 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

Member Typedef Documentation

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

typedef char Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::packet_type [protected]

The type of each datum being sent or received in an Import or Export.

Note that this type does not always correspond to the Scalar template parameter of subclasses.

Reimplemented from Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 136 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

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

The type of entries in the matrix.

Reimplemented from Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 143 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

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

The type of local indices.

Reimplemented from Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 145 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

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

The type of global indices.

Reimplemented from Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 147 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

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

The Kokkos Node type.

Reimplemented from Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 149 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

Constructor & Destructor Documentation

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

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

Default constructor: Makes an empty block matrix.

Definition at line 57 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::BlockCrsMatrix	(	const crs_graph_type &	graph,
		const LO	blockSize
	)

Constructor that takes a graph and a block size.

The graph represents the mesh. This constructor computes the point Maps corresponding to the given graph's domain and range Maps. If you already have those point Maps, it is better to call the four-argument constructor.

Parameters:

graph	[in] A fill-complete graph.
blockSize	[in] Number of degrees of freedom per mesh point.

Definition at line 75 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::BlockCrsMatrix	(	const crs_graph_type &	graph,
		const map_type &	domainPointMap,
		const map_type &	rangePointMap,
		const LO	blockSize
	)

Constructor that takes a graph, domain and range point Maps, and a block size.

The graph represents the mesh. This constructor uses the given domain and range point Maps, rather than computing them. The given point Maps must be the same as the above two-argument constructor would have computed.

Definition at line 120 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

virtual Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::~BlockCrsMatrix ( ) [inline, virtual]

Destructor (declared virtual for memory safety).

Definition at line 191 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

Member Function Documentation

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

Teuchos::RCP< const typename BlockCrsMatrix< Scalar, LO, GO, Node >::map_type > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getDomainMap ( ) const [virtual]

Get the (point) domain Map of this matrix.

Implements Tpetra::Operator< Scalar, LO, GO, Node >.

Definition at line 166 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Teuchos::RCP< const typename BlockCrsMatrix< Scalar, LO, GO, Node >::map_type > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getRangeMap ( ) const [virtual]

Get the (point) range Map of this matrix.

Implements Tpetra::Operator< Scalar, LO, GO, Node >.

Definition at line 175 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Teuchos::RCP< const typename BlockCrsMatrix< Scalar, LO, GO, Node >::map_type > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getRowMap ( ) const [virtual]

get the (mesh) map for the rows of this block matrix.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 184 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Teuchos::RCP< const typename BlockCrsMatrix< Scalar, LO, GO, Node >::map_type > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getColMap ( ) const [virtual]

get the (mesh) map for the columns of this block matrix.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 192 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

global_size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalNumRows ( ) const [virtual]

get the global number of block rows

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 200 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNodeNumRows ( ) const [virtual]

get the local number of block rows

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 208 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNodeMaxNumRowEntries ( ) const [virtual]

The maximum number of entries across all rows/columns on this node.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 216 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::apply	(	const mv_type &	X,
		mv_type &	Y,
		Teuchos::ETransp	mode = `Teuchos::NO_TRANS`,
		scalar_type	alpha = `Teuchos::ScalarTraits<scalar_type>::one ()`,
		scalar_type	beta = `Teuchos::ScalarTraits<scalar_type>::zero ()`
	)		const

For this matrix A, compute Y := beta * Y + alpha * Op(A) * X.

Op(A) is A if mode is Teuchos::NO_TRANS, the transpose of A if mode is Teuchos::TRANS, and the conjugate transpose of A if mode is Teuchos::CONJ_TRANS.

If alpha is zero, ignore X's entries on input; if beta is zero, ignore Y's entries on input. This follows the BLAS convention, and only matters if X resp. Y have Inf or NaN entries.

Definition at line 224 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::hasTransposeApply ( ) const [inline, virtual]

Whether it is valid to apply the transpose or conjugate transpose of this matrix.

Reimplemented from Tpetra::Operator< Scalar, LO, GO, Node >.

Definition at line 235 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::setAllToScalar ( const Scalar & alpha )

Set all matrix entries equal to alpha.

Definition at line 317 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

std::string Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::description ( ) const [virtual]

One-line description of this object.

Reimplemented from Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 1905 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::describe	(	Teuchos::FancyOStream &	out,
		const Teuchos::EVerbosityLevel	verbLevel
	)		const `[virtual]`

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

Parameters:

out	[out] Output stream to which to print. Valid values include Teuchos::VERB_DEFAULT, Teuchos::VERB_NONE, Teuchos::VERB_LOW, Teuchos::VERB_MEDIUM, Teuchos::VERB_HIGH, and Teuchos::VERB_EXTREME.
verbLevel	[in] Verbosity level at which to print.

Warning:: If verbLevel is Teuchos::VERB_EXTREME, this method has collective semantics over the matrix's communicator.

The following pseudocode shows how to wrap your std::ostream object in a Teuchos::FancyOStream, and pass it into this method:

 Tpetra::Experimental::BlockCrsMatrix<...> A (...);
 // ...
 std::ostream& yourObject = ...;
 Teuchos::RCP<Teuchos::FancyOStream> wrappedStream =
   Teuchos::getFancyOStream (Teuchos::rcpFromRef (yourObject));
 const Teuchos::EVerbosityLevel verbLevel = ...;
 A.describe (*wrappedStream, verbLevel);

Reimplemented from Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 1929 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getBlockSize ( ) const [inline]

The number of degrees of freedom per mesh point.

Definition at line 283 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

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

Teuchos::RCP< const Tpetra::RowGraph< LO, GO, Node > > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGraph ( ) const [virtual]

Get the (mesh) graph.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2325 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::applyBlock	(	const BlockMultiVector< Scalar, LO, GO, Node > &	X,
		BlockMultiVector< Scalar, LO, GO, Node > &	Y,
		Teuchos::ETransp	mode = `Teuchos::NO_TRANS`,
		const Scalar	alpha = `Teuchos::ScalarTraits<Scalar>::one ()`,
		const Scalar	beta = `Teuchos::ScalarTraits<Scalar>::zero ()`
	)

Version of apply() that takes BlockMultiVector input and output.

This method is deliberately not marked const, because it may do lazy initialization of temporary internal block multivectors.

Definition at line 289 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::gaussSeidelCopy	(	MultiVector< Scalar, LO, GO, Node > &	X,
		const MultiVector< Scalar, LO, GO, Node > &	B,
		const MultiVector< Scalar, LO, GO, Node > &	D,
		const Scalar &	dampingFactor,
		const ESweepDirection	direction,
		const int	numSweeps,
		const bool	zeroInitialGuess
	)		const

Version of gaussSeidel(), with fewer requirements on X.

Not Implemented

Definition at line 622 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::reorderedGaussSeidelCopy	(	MultiVector< Scalar, LO, GO, Node > &	X,
		const MultiVector< Scalar, LO, GO, Node > &	B,
		const MultiVector< Scalar, LO, GO, Node > &	D,
		const ArrayView< LO > &	rowIndices,
		const Scalar &	dampingFactor,
		const ESweepDirection	direction,
		const int	numSweeps,
		const bool	zeroInitialGuess
	)		const

Version of reorderedGaussSeidel(), with fewer requirements on X.

Not Implemented

Definition at line 640 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::localGaussSeidel	(	const BlockMultiVector< Scalar, LO, GO, Node > &	Residual,
		BlockMultiVector< Scalar, LO, GO, Node > &	Solution,
		BlockCrsMatrix< Scalar, LO, GO, Node > &	factorizedDiagonal,
		const int *	factorizationPivots,
		const Scalar	omega,
		const ESweepDirection	direction
	)		const

Local Gauss-Seidel solve given a factorized diagonal.

This method computes the smoothing of A*X = B, where A is *this (the block matrix), B is the residual and X is the approximate solution. It requires a factorized diagonal and pivots (partial pivoting in LAPACK coming from GETRF) to be passed in. It takes an SOR relaxation factor. Valid sweep directions are Forward, Backward, or Symmetric.

Definition at line 507 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::replaceLocalValues	(	const LO	localRowInd,
		const LO	colInds[],
		const Scalar	vals[],
		const LO	numColInds
	)		const

Replace values at the given column indices, in the given row.

Parameters:

localRowInd	[in] Local index of the row in which to replace.
colInds	[in] Local column ind{ex,ices} at which to replace values. colInds[k] is the local column index whose new values start at vals[getBlockSize() * getBlockSize() * k], and colInds has length at least numColInds. This method will only access the first numColInds entries of colInds.
vals	[in] The new values to use at the given column indices.
numColInds	[in] The number of entries of colInds.

Returns:: The number of valid column indices in colInds. This method succeeded if and only if the return value equals the input argument numColInds.

Definition at line 333 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::sumIntoLocalValues	(	const LO	localRowInd,
		const LO	colInds[],
		const Scalar	vals[],
		const LO	numColInds
	)		const

Sum into values at the given column indices, in the given row.

Parameters:

localRowInd	[in] Local index of the row into which to sum.
colInds	[in] Local column ind{ex,ices} at which to sum into values. colInds[k] is the local column index whose new values start at vals[getBlockSize() * getBlockSize() * k], and colInds has length at least numColInds. This method will only access the first numColInds entries of colInds.
vals	[in] The new values to sum into at the given column indices.
numColInds	[in] The number of entries of colInds.

Returns:: The number of valid column indices in colInds. This method succeeded if and only if the return value equals the input argument numColInds.

Definition at line 731 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getLocalRowView	(	const LO	localRowInd,
		const LO *&	colInds,
		Scalar *&	vals,
		LO &	numInds
	)		const

Get a view of the row, using local indices.

Since this object has a graph (which we assume is fill complete on input to the constructor), it has a column Map, and it stores column indices as local indices. This means you can view the column indices as local indices directly. However, you may not view them as global indices directly, since the column indices are not stored that way in the graph.

Definition at line 771 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getLocalRowView	(	LO	LocalRow,
		ArrayView< const LO > &	indices,
		ArrayView< const Scalar > &	values
	)		const `[virtual]`

Get a constant, nonpersisting, locally indexed view of the given row of the matrix.

The returned views of the column indices and values are not guaranteed to persist beyond the lifetime of this. Furthermore, some RowMatrix implementations allow changing the values, or the indices and values. Any such changes invalidate the returned views.

This method only gets the entries in the given row that are stored on the calling process. Note that if the matrix has an overlapping row Map, it is possible that the calling process does not store all the entries in that row.

Precondition:: isLocallyIndexed () && supportsRowViews ()

Postcondition:: indices.size () == getNumEntriesInGlobalRow (LocalRow)

Parameters:

LocalRow	[in] Local index of the row.
Indices	[out] Local indices of the columns corresponding to values.
Values	[out] Matrix values.

If LocalRow does not belong to this node, then indices is set to null.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2278 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getLocalRowOffsets	(	const LO	localRowInd,
		ptrdiff_t	offsets[],
		const LO	colInds[],
		const LO	numColInds
	)		const

Get relative offsets corresponding to the given row indices.

The point of this method is to precompute the results of searching for the offsets corresponding to the given column indices. You may then reuse these search results in replaceLocalValuesByOffsets or sumIntoLocalValuesByOffsets.

Offsets are block offsets; they are for column indices, not for values.

Parameters:

localRowInd	[in] Local index of the row.
offsets	[out] On output: relative offsets corresponding to the given column indices. Must have at least numColInds entries.
colInds	[in] The local column indices for which to compute offsets. Must have at least numColInds entries. This method will only read the first numColsInds entries.
numColInds	[in] Number of entries in colInds to read.

Returns:: The number of valid column indices in colInds. This method succeeded if and only if the return value equals the input argument numColInds.

Definition at line 807 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::replaceLocalValuesByOffsets	(	const LO	localRowInd,
		const ptrdiff_t	offsets[],
		const Scalar	vals[],
		const LO	numOffsets
	)		const

Like replaceLocalValues, but avoids computing row offsets.

Returns:: The number of valid column indices in colInds. This method succeeded if and only if the return value equals the input argument numColInds.

Definition at line 840 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::sumIntoLocalValuesByOffsets	(	const LO	localRowInd,
		const ptrdiff_t	offsets[],
		const Scalar	vals[],
		const LO	numOffsets
	)		const

Like sumIntoLocalValues, but avoids computing row offsets.

Returns:: The number of valid column indices in colInds. This method succeeded if and only if the return value equals the input argument numColInds.

Definition at line 916 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNumEntriesInLocalRow ( const LO localRowInd ) const [virtual]

Return the number of entries in the given row on the calling process.

If the given local row index is invalid, this method (sensibly) returns zero, since the calling process trivially does not own any entries in that row.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 954 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::localError ( ) const [inline]

Whether this object had an error on the calling process.

Import and Export operations using this object as the target of the Import or Export may incur local errors, if some process encounters an LID in its list which is not a valid mesh row local index on that process. In that case, we don't want to throw an exception, because not all processes may throw an exception; this can result in deadlock or put Tpetra in an incorrect state, due to lack of consistency across processes. Instead, we set a local error flag and ignore the incorrect data. When unpacking, we do the same with invalid column indices. If you want to check whether some process experienced an error, you must do a reduction or all-reduce over this flag. Every time you initiate a new Import or Export with this object as the target, we clear this flag. (Note to developers: we clear it at the beginning of checkSizes().)

Definition at line 493 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

std::string Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::errorMessages ( ) const [inline]

The current stream of error messages.

This is only nonempty on the calling process if localError() returns true. In that case, it stores a stream of human-readable, endline-separated error messages encountered during an Import or Export cycle. Every time you initiate a new Import or Export with this object as the target, we clear this stream. (Note to developers: we clear it at the beginning of checkSizes().)

If you want to print this, you are responsible for ensuring that it is valid for the calling MPI process to print to whatever output stream you use. On some MPI implementations, you may need to send the string to Process 0 for printing.

Definition at line 511 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getLocalDiagOffsets ( Teuchos::ArrayRCP< size_t > & offsets ) const

Get offsets of the diagonal entries in the matrix.

Warning:: This method is only for expert users.; We make no promises about backwards compatibility for this method. It may disappear or change at any time.; This method must be called collectively. We reserve the right to do extra checking in a debug build that will require collectives.

Precondition:: The matrix must be locally indexed (which means that it has a column Map).; All diagonal entries of the matrix's graph must be populated on this process. Results are undefined otherwise.

Postcondition:: offsets.size() == getNodeNumRows()

This method creates an array of offsets of the local diagonal entries in the matrix. This array is suitable for use in the two-argument version of getLocalDiagCopy(). However, its contents are not defined in any other context. For example, you should not rely on offsets[i] being the index of the diagonal entry in the views returned by getLocalRowView(). This may be the case, but it need not be. (For example, we may choose to optimize the lookups down to the optimized storage level, in which case the offsets will be computed with respect to the underlying storage format, rather than with respect to the views.)

If the matrix has a const ("static") graph, and if that graph is fill complete, then the offsets array remains valid through calls to fillComplete() and resumeFill(). "Invalidates" means that you must call this method again to recompute the offsets.

Definition at line 373 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getLocalDiagCopy	(	BlockCrsMatrix< Scalar, LO, GO, Node > &	diag,
		const Teuchos::ArrayView< const size_t > &	offsets
	)		const

Variant of getLocalDiagCopy() that uses precomputed offsets.

This method uses the offsets of the diagonal entries, as precomputed by getLocalDiagOffsets(), to speed up copying the diagonal of the matrix.

If the matrix has a const ("static") graph, and if that graph is fill complete, then the offsets array remains valid through calls to fillComplete() and resumeFill().

Definition at line 659 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::computeDiagonalGraph ( )

Computes the DiagonalGraph.

Definition at line 455 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

template<class Scalar = BlockMultiVector<>::scalar_type, class LO = typename BlockMultiVector<Scalar>::local_ordinal_type, class GO = typename BlockMultiVector<Scalar, LO>::global_ordinal_type, class Node = typename BlockMultiVector<Scalar, LO, GO>::node_type>

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::isComputedDiagonalGraph ( ) const [inline]

Reports on whether the DiagonalGraph has been Computed.

Definition at line 566 of file Tpetra_Experimental_BlockCrsMatrix_decl.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::absMaxLocalValues	(	const LO	localRowInd,
		const LO	colInds[],
		const Scalar	vals[],
		const LO	numColInds
	)		const `[protected]`

Like sumIntoLocalValues, but for the ABSMAX combine mode.

Definition at line 690 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

LO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::absMaxLocalValuesByOffsets	(	const LO	localRowInd,
		const ptrdiff_t	offsets[],
		const Scalar	vals[],
		const LO	numOffsets
	)		const `[protected]`

Like sumIntoLocalValuesByOffsets, but for the ABSMAX combine mode.

Definition at line 878 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::checkSizes ( const Tpetra::SrcDistObject & source ) [protected, virtual]

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

Returns:: True if they are compatible, else false.

Implements Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 1319 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::copyAndPermute	(	const Tpetra::SrcDistObject &	source,
		size_t	numSameIDs,
		const Teuchos::ArrayView< const LO > &	permuteToLIDs,
		const Teuchos::ArrayView< const LO > &	permuteFromLIDs
	)		`[protected, virtual]`

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.

Implements Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 1385 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::packAndPrepare	(	const Tpetra::SrcDistObject &	source,
		const Teuchos::ArrayView< const LO > &	exportLIDs,
		Teuchos::Array< packet_type > &	exports,
		const Teuchos::ArrayView< size_t > &	numPacketsPerLID,
		size_t &	constantNumPackets,
		Tpetra::Distributor &	distor
	)		`[protected, virtual]`

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.

Implements Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 1532 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::unpackAndCombine	(	const Teuchos::ArrayView< const LO > &	importLIDs,
		const Teuchos::ArrayView< const packet_type > &	imports,
		const Teuchos::ArrayView< size_t > &	numPacketsPerLID,
		size_t	constantNumPackets,
		Tpetra::Distributor &	distor,
		Tpetra::CombineMode	CM
	)		`[protected, virtual]`

Perform any unpacking and combining after communication.

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.

Implements Tpetra::DistObject< char, LO, GO, Node >.

Definition at line 1776 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Teuchos::RCP< const Teuchos::Comm< int > > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getComm ( ) const [virtual]

The communicator over which this matrix is distributed.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2105 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Teuchos::RCP< Node > Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNode ( ) const [virtual]

The Kokkos Node instance.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2113 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

global_size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalNumCols ( ) const [virtual]

The global number of columns of this matrix.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2122 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNodeNumCols ( ) const [virtual]

The number of columns needed to apply the forward operator on this node.

This is the same as the number of elements listed in the column Map. It is not necessarily the same as the number of domain Map elements owned by the calling process.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2130 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

GO Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getIndexBase ( ) const [virtual]

The index base for global indices in this matrix.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2138 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

global_size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalNumEntries ( ) const [virtual]

The global number of stored (structurally nonzero) entries.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2146 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNodeNumEntries ( ) const [virtual]

The local number of stored (structurally nonzero) entries.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2154 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNumEntriesInGlobalRow ( GO globalRow ) const [virtual]

The current number of entries on the calling process in the specified global row.

Note that if the row Map is overlapping, then the calling process might not necessarily store all the entries in the row. Some other process might have the rest of the entries.

Returns:: Teuchos::OrdinalTraits<size_t>::invalid() if the specified global row does not belong to this graph, else the number of entries.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2162 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

global_size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalNumDiags ( ) const [virtual]

The number of global diagonal entries, based on global row/column index comparisons.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2170 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getNodeNumDiags ( ) const [virtual]

The number of local diagonal entries, based on global row/column index comparisons.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2178 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

size_t Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalMaxNumRowEntries ( ) const [virtual]

The maximum number of entries across all rows/columns on all nodes.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2186 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::hasColMap ( ) const [virtual]

Whether this matrix has a well-defined column map.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2194 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::isLowerTriangular ( ) const [virtual]

Whether this matrix is lower triangular.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2202 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::isUpperTriangular ( ) const [virtual]

Whether this matrix is upper triangular.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2210 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::isLocallyIndexed ( ) const [virtual]

Whether matrix indices are locally indexed.

A RowMatrix may store column indices either as global indices (of type GO), or as local indices (of type LO). In some cases (for example, if the column Map has not been computed), it is not possible to switch from global to local indices without extra work. Furthermore, some operations only work for one or the other case.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2218 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::isGloballyIndexed ( ) const [virtual]

Whether matrix indices are globally indexed.

A RowMatrix may store column indices either as global indices (of type GO), or as local indices (of type LO). In some cases (for example, if the column Map has not been computed), it is not possible to switch from global to local indices without extra work. Furthermore, some operations only work for one or the other case.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2226 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::isFillComplete ( ) const [virtual]

Whether fillComplete() has been called.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2234 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

bool Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::supportsRowViews ( ) const [virtual]

Whether this object implements getLocalRowView() and getGlobalRowView().

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2242 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalRowCopy	(	GO	GlobalRow,
		const Teuchos::ArrayView< GO > &	Indices,
		const Teuchos::ArrayView< Scalar > &	Values,
		size_t &	NumEntries
	)		const `[virtual]`

Get a copy of the given global row's entries.

This method only gets the entries in the given row that are stored on the calling process. Note that if the matrix has an overlapping row Map, it is possible that the calling process does not store all the entries in that row.

Parameters:

GlobalRow	[in] Global index of the row.
Indices	[out] Global indices of the columns corresponding to values.
Values	[out] Matrix values.
NumEntries	[out] Number of stored entries on the calling process; length of Indices and Values.

This method throws std::runtime_error if either Indices or Values is not large enough to hold the data associated with row GlobalRow. If GlobalRow does not belong to the calling process, then the method sets NumIndices to Teuchos::OrdinalTraits<size_t>::invalid(), and does not modify Indices or Values.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2251 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getGlobalRowView	(	GO	GlobalRow,
		ArrayView< const GO > &	indices,
		ArrayView< const Scalar > &	values
	)		const `[virtual]`

Get a constant, nonpersisting, globally indexed view of the given row of the matrix.

The returned views of the column indices and values are not guaranteed to persist beyond the lifetime of this. Furthermore, some RowMatrix implementations allow changing the values, or the indices and values. Any such changes invalidate the returned views.

This method only gets the entries in the given row that are stored on the calling process. Note that if the matrix has an overlapping row Map, it is possible that the calling process does not store all the entries in that row.

Precondition:: isGloballyIndexed () && supportsRowViews ()

Postcondition:: indices.size () == getNumEntriesInGlobalRow (GlobalRow)

Parameters:

GlobalRow	[in] Global index of the row.
Indices	[out] Global indices of the columns corresponding to values.
Values	[out] Matrix values.

If GlobalRow does not belong to this node, then indices is set to null.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2265 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getLocalDiagCopy ( Tpetra::Vector< Scalar, LO, GO, Node > & diag ) const [virtual]

Get a copy of the diagonal entries, distributed by the row Map.

On input, the Vector's Map must be the same as the row Map of the matrix. (That is, this->getRowMap ()->isSameAs (* (diag.getMap ())) == true.)

On return, the entries of diag are filled with the diagonal entries of the matrix stored on this process. Note that if the row Map is overlapping, multiple processes may own the same diagonal element. You may combine these overlapping diagonal elements by doing an Export from the row Map Vector to a range Map Vector.

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2292 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::leftScale ( const Vector< Scalar, LO, GO, Node > & x ) [virtual]

Scale the RowMatrix on the left with the given Vector x.

On return, for all entries i,j in the matrix, $A(i,j) = x(i)*A(i,j)$ .

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2303 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

void Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::rightScale ( const Vector< Scalar, LO, GO, Node > & x ) [virtual]

Scale the RowMatrix on the right with the given Vector x.

On return, for all entries i,j in the matrix, $A(i,j) = x(j)*A(i,j)$ .

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2314 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

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

Teuchos::ScalarTraits< Scalar >::magnitudeType Tpetra::Experimental::BlockCrsMatrix< Scalar, LO, GO, Node >::getFrobeniusNorm ( ) const [virtual]

The Frobenius norm of the matrix.

This method computes and returns the Frobenius norm of the matrix. The Frobenius norm $\|A\|_F$ for the matrix $A$ is defined as $\|A\|_F = \sqrt{ \sum_{i,j} |\a_{ij}|^2 }$ . It has the same value as the Euclidean norm of a vector made by stacking the columns of $A$ .

Implements Tpetra::RowMatrix< Scalar, LO, GO, Node >.

Definition at line 2333 of file Tpetra_Experimental_BlockCrsMatrix_def.hpp.

virtual void Tpetra::RowMatrix< Scalar, LO , GO , Node >::getLocalRowCopy	(	LO	LocalRow,
		const Teuchos::ArrayView< LO > &	Indices,
		const Teuchos::ArrayView< Scalar > &	Values,
		size_t &	NumEntries
	)		const `[pure virtual, inherited]`

Get a copy of the given local row's entries.

This method only gets the entries in the given row that are stored on the calling process. Note that if the matrix has an overlapping row Map, it is possible that the calling process does not store all the entries in that row.

Parameters:

LocalRow	[in] Local index of the row.
Indices	[out] Local indices of the columns corresponding to values.
Values	[out] Matrix values.
NumEntries	[out] Number of stored entries on the calling process; length of Indices and Values.

This method throws std::runtime_error if either Indices or Values is not large enough to hold the data associated with row LocalRow. If LocalRow does not belong to the calling process, then the method sets NumIndices to Teuchos::OrdinalTraits<size_t>::invalid(), and does not modify Indices or Values.

virtual Teuchos::RCP<RowMatrix<Scalar, LO , GO , Node> > Tpetra::RowMatrix< Scalar, LO , GO , Node >::add	(	const Scalar &	alpha,
		const RowMatrix< Scalar, LO , GO , Node > &	A,
		const Scalar &	beta,
		const Teuchos::RCP< const Map< LO , GO , Node > > &	domainMap = `Teuchos::null`,
		const Teuchos::RCP< const Map< LO , GO , Node > > &	rangeMap = `Teuchos::null`,
		const Teuchos::RCP< Teuchos::ParameterList > &	params = `Teuchos::null`
	)		const `[virtual, inherited]`

Return a new RowMatrix which is the result of beta*this + alpha*A.

The new RowMatrix is actually a CrsMatrix (which see). Note that RowMatrix is a read-only interface (not counting the left and right scale methods), so it is impossible to implement an in-place add using just that interface.

For brevity, call this matrix B, and the result matrix C. C's row Map will be identical to B's row Map. It is correct, though less efficient, for A and B not to have the same row Maps. We could make C's row Map the union of the two row Maps in that case. However, we don't want row Maps to grow for a repeated sequence of additions with matrices with different row Maps. Furthermore, the fact that the user called this method on B, rather than on A, suggests a preference for using B's distribution. The most reasonable thing to do, then, is to use B's row Map for C.

A and B must have identical or congruent communicators. This method must be called as a collective over B's communicator.

The parameters are optional and may be null. Here are the parameters that this function accepts:

"Call fillComplete" (bool): If true, call fillComplete on the result matrix C. This is true by default.
"Constructor parameters" (sublist): If provided, give these parameters to C's constructor.
"fillComplete parameters" (sublist): If provided, and if "Call fillComplete" is true, then give these parameters to C's fillComplete call.

It is not strictly necessary that a RowMatrix always have a domain and range Map. For example, a CrsMatrix does not have a domain and range Map until after its first fillComplete call. Neither A nor B need to have a domain and range Map in order to call add(). If at least one of them has a domain and range Map, you need not supply a domain and range Map to this method. If you ask this method to call fillComplete on C (it does by default), it will supply the any missing domain or range Maps from either B's or A's (in that order) domain and range Maps. If neither A nor B have a domain and range Map, and if you ask this method to call fillComplete, then you must supply both a domain Map and a range Map to this method.

This method comes with a default implementation, since the RowMatrix interface suffices for implementing it. Subclasses (like CrsMatrix) may override this implementation, for example to improve its performance, given additional knowledge about the subclass. Subclass implementations may need to do a dynamic cast on A in order to know its type.

virtual void Tpetra::RowMatrix< Scalar, LO , GO , Node >::pack	(	const Teuchos::ArrayView< const LO > &	exportLIDs,
		Teuchos::Array< char > &	exports,
		const Teuchos::ArrayView< size_t > &	numPacketsPerLID,
		size_t &	constantNumPackets,
		Distributor &	distor
	)		const `[virtual, inherited]`

Pack this object's data for an Import or Export.

Warning:: To be called only by the packAndPrepare method of appropriate classes of DistObject.

Subclasses may override this method to speed up or otherwise improve the implementation by exploiting more specific details of the subclass.

Implements Tpetra::Packable< char, LO >.

virtual void Tpetra::Operator< Scalar, LO , GO , Node >::apply	(	const MultiVector< Scalar, LO , GO , Node > &	X,
		MultiVector< Scalar, LO , GO , Node > &	Y,
		Teuchos::ETransp	mode = `Teuchos::NO_TRANS`,
		Scalar	alpha = `Teuchos::ScalarTraits<Scalar>::one()`,
		Scalar	beta = `Teuchos::ScalarTraits<Scalar>::zero()`
	)		const `[pure virtual, inherited]`

Computes the operator-multivector application.

Loosely, performs $Y = \alpha \cdot A^{\textrm{mode}} \cdot X + \beta \cdot Y$ . However, the details of operation vary according to the values of alpha and beta. Specifically

if beta == 0, apply() must overwrite Y, so that any values in Y (including NaNs) are ignored.
if alpha == 0, apply() may short-circuit the operator, so that any values in X (including NaNs) are ignored.

void Tpetra::DistObject< char , LO , GO , Node >::doImport	(	const SrcDistObject< char, LO, GO, Node > &	source,
		const Import< LO , GO , 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.

void Tpetra::DistObject< char , LO , GO , Node >::doImport	(	const SrcDistObject< char, LO, GO, Node > &	source,
		const Export< LO , GO , 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.

void Tpetra::DistObject< char , LO , GO , Node >::doExport	(	const SrcDistObject< char, LO, GO, Node > &	source,
		const Export< LO , GO , 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.

void Tpetra::DistObject< char , LO , GO , Node >::doExport	(	const SrcDistObject< char, LO, GO, Node > &	source,
		const Import< LO , GO , 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.

bool Tpetra::DistObject< char , LO , GO , 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.

virtual Teuchos::RCP<const Map<LO ,GO ,Node> > Tpetra::DistObject< char , LO , GO , Node >::getMap ( ) const [inline, virtual, inherited]

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 316 of file Tpetra_DistObject_decl.hpp.

void Tpetra::DistObject< char , LO , GO , 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.

virtual void Tpetra::DistObject< char , LO , GO , Node >::removeEmptyProcessesInPlace ( const Teuchos::RCP< const Map< LO , GO , Node > > & newMap ) [virtual, inherited]

Remove processes which contain no elements 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 elements ("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.

virtual size_t Tpetra::DistObject< char , LO , GO , Node >::constantNumberOfPackets ( ) const [protected, virtual, inherited]

Whether the implementation's instance promises always to have a constant number of packets per LID, 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 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.

virtual void Tpetra::DistObject< char , LO , GO , Node >::doTransfer	(	const SrcDistObject< char, LO, GO, Node > &	src,
		CombineMode	CM,
		size_t	numSameIDs,
		const Teuchos::ArrayView< const LO > &	permuteToLIDs,
		const Teuchos::ArrayView< const LO > &	permuteFromLIDs,
		const Teuchos::ArrayView< const LO > &	remoteLIDs,
		const Teuchos::ArrayView< const LO > &	exportLIDs,
		Distributor &	distor,
		ReverseOption	revOp
	)		`[protected, virtual, inherited]`

Redistribute data across memory images.

Parameters:

src	[in] The source object, to redistribute into the target object, which is `*this` object.
CM	[in] The combine mode that describes how to combine values that map to the same global ID on the same process.
permuteToLIDs	[in] See copyAndPermute().
permuteFromLIDs	[in] See copyAndPermute().
remoteLIDs	[in] List of entries (as local IDs) in the destination object to receive from other processes.
exportLIDs	[in] See packAndPrepare().
distor	[in/out] The Distributor object that knows how to redistribute data.
revOp	[in] Whether to do a forward or reverse mode redistribution.

virtual void Tpetra::DistObject< char , LO , GO , Node >::createViews ( ) const [protected, virtual, inherited]

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.

virtual void Tpetra::DistObject< char , LO , GO , Node >::createViewsNonConst ( KokkosClassic::ReadWriteOption rwo ) [protected, virtual, inherited]

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

virtual void Tpetra::DistObject< char , LO , GO , Node >::releaseViews ( ) const [protected, virtual, inherited]

Hook for releasing views.

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.

Member Data Documentation

Teuchos::RCP<const Map<LO ,GO ,Node> > Tpetra::DistObject< char , LO , GO , Node >::map_ [protected, inherited]

The Map over which this object is distributed.

Definition at line 611 of file Tpetra_DistObject_decl.hpp.

Teuchos::Array<char > Tpetra::DistObject< char , LO , GO , Node >::imports_ [protected, inherited]

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

Definition at line 615 of file Tpetra_DistObject_decl.hpp.

Teuchos::Array<size_t> Tpetra::DistObject< char , LO , GO , Node >::numImportPacketsPerLID_ [protected, inherited]

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

Definition at line 627 of file Tpetra_DistObject_decl.hpp.

Teuchos::Array<char > Tpetra::DistObject< char , LO , GO , Node >::exports_ [protected, inherited]

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

Definition at line 630 of file Tpetra_DistObject_decl.hpp.

Teuchos::Array<size_t> Tpetra::DistObject< char , LO , GO , Node >::numExportPacketsPerLID_ [protected, inherited]

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

Definition at line 642 of file Tpetra_DistObject_decl.hpp.

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Methods for use only by experts

Block operations

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation