Inheritance diagram for PyTrilinos.Epetra.VbrMatrix:

Collaboration diagram for PyTrilinos.Epetra.VbrMatrix:

Public Member Functions
def	PutScalar
def	Scale
def	DirectSubmitBlockEntry
def	BeginInsertGlobalValues
def	BeginInsertMyValues
def	BeginReplaceGlobalValues
def	BeginReplaceMyValues
def	BeginSumIntoGlobalValues
def	BeginSumIntoMyValues
def	SubmitBlockEntry
def	EndSubmitEntries
def	ReplaceDiagonalValues
def	FillComplete
def	Filled
def	ExtractGlobalBlockRowPointers
def	ExtractMyBlockRowPointers
def	BeginExtractGlobalBlockRowCopy
def	BeginExtractMyBlockRowCopy
def	ExtractEntryCopy
def	BeginExtractGlobalBlockRowView
def	BeginExtractMyBlockRowView
def	ExtractEntryView
def	ExtractGlobalBlockRowView
def	ExtractMyBlockRowView
def	ExtractDiagonalCopy
def	BeginExtractBlockDiagonalCopy
def	ExtractBlockDiagonalEntryCopy
def	BeginExtractBlockDiagonalView
def	ExtractBlockDiagonalEntryView
def	Multiply1
def	Multiply
def	Solve
def	InvRowSums
def	LeftScale
def	InvColSums
def	RightScale
def	OptimizeStorage
def	StorageOptimized
def	IndicesAreGlobal
def	IndicesAreLocal
def	IndicesAreContiguous
def	LowerTriangular
def	UpperTriangular
def	NoDiagonal
def	NormInf
def	NormOne
def	NormFrobenius
def	MaxRowDim
def	MaxColDim
def	GlobalMaxRowDim
def	GlobalMaxColDim
def	NumMyRows
def	NumMyCols
def	NumMyNonzeros
def	NumGlobalRows
def	NumGlobalRows64
def	NumGlobalCols
def	NumGlobalCols64
def	NumGlobalNonzeros
def	NumGlobalNonzeros64
def	NumMyBlockRows
def	NumMyBlockCols
def	NumMyBlockDiagonals
def	NumMyDiagonals
def	NumGlobalBlockRows
def	NumGlobalBlockRows64
def	NumGlobalBlockCols
def	NumGlobalBlockCols64
def	NumGlobalBlockEntries64
def	NumGlobalBlockDiagonals
def	NumGlobalBlockDiagonals64
def	NumGlobalDiagonals
def	NumGlobalDiagonals64
def	NumGlobalBlockEntries
def	NumAllocatedGlobalBlockEntries
def	MaxNumBlockEntries
def	GlobalMaxNumBlockEntries
def	NumMyBlockEntries
def	NumAllocatedMyBlockEntries
def	MaxNumNonzeros
def	GlobalMaxNumNonzeros
def	IndexBase
def	Graph
def	Importer
def	Exporter
def	DomainMap
def	RangeMap
def	RowMap
def	ColMap
def	Comm
def	LRID
def	GRID
def	GRID64
def	LCID
def	GCID
def	GCID64
def	MyGRID
def	MyLRID
def	MyGCID
def	MyLCID
def	MyGlobalBlockRow
def	Label
def	SetUseTranspose
def	Apply
def	ApplyInverse
def	HasNormInf
def	UseTranspose
def	OperatorDomainMap
def	OperatorRangeMap
def	ExtractGlobalRowCopy
def	ExtractMyRowCopy
def	NumMyRowEntries
def	MaxNumEntries
def	Map
def	RowMatrixRowMap
def	RowMatrixColMap
def	RowMatrixImporter
def	BlockImportMap
def	TransformToLocal
def	__init__
Public Attributes
	this

Detailed Description

Epetra_VbrMatrix: A class for the construction and use of real-valued
double-precision variable block-row sparse matrices.

The Epetra_VbrMatrix class is a sparse variable block row matrix
object. This matrix can be used in a parallel setting, with data
distribution described by Epetra_Map attributes. The structure or
graph of the matrix is defined by an Epetra_CrsGraph attribute.

In addition to coefficient access, the primary operations provided by
Epetra_VbrMatrix are matrix times vector and matrix times multi-vector
multiplication.

Creating and filling Epetra_VbrMatrix objects

Constructing Epetra_VbrMatrix objects is a multi-step process. The
basic steps are as follows: Create Epetra_VbrMatrix instance via one
of the constructors: Constructor that accepts one Epetra_Map object, a
row-map defining the distribution of matrix rows.

Constructor that accepts two Epetra_Map objects. (The second map is a
column-map, and describes the set of column-indices that appear in
each processor's portion of the matrix. Generally these are
overlapping sets -- column-indices may appear on more than one
processor.)

Constructor that accepts an Epetra_CrsGraph object, defining the non-
zero structure of the matrix.

Input coefficient values (more detail on this below).

Complete construction by calling FillComplete.

Note that even after FillComplete() has been called, it is possible to
update existing matrix entries but it is not possible to create new
entries.

Using Epetra_VbrMatrix as an Epetra_RowMatrix

Although Epetra_VbrMatrix does inherit from Epetra_RowMatrix, a design
flaw in the inheritance structure of Epetra prohibits the use of an
Epetra_VbrMatrix object as an Epetra_RowMatrix in some important
situations. Therefore we recommend the use of the Epetra_VbrRowMatrix
class to wrap an Epetra_VbrMatrix object for use as an
Epetra_RowMatrix. The Epetra_VbrRowMatrix object does not duplicate
data in the Epetra_VbrMatrix object, but uses it to satisfy the
Epetra_RowMatrix interface.

Epetra_Map attributes

Epetra_VbrMatrix objects have four Epetra_Map attributes, which are
held by the Epetra_CrsGraph attribute.

The Epetra_Map attributes can be obtained via these accessor methods:
RowMap() Describes the numbering and distribution of the rows of the
matrix. The row-map exists and is valid for the entire life of the
matrix. The set of matrix rows is defined by the row-map and may not
be changed. Rows may not be inserted or deleted by the user. The only
change that may be made is that the user can replace the row-map with
a compatible row-map (which is the same except for re-numbering) by
calling the ReplaceRowMap() method.

ColMap() Describes the set of column-indices that appear in the rows
in each processor's portion of the matrix. Unless provided by the user
at construction time, a valid column-map doesn't exist until
FillComplete() is called.

RangeMap() Describes the range of the matrix operator. e.g., for a
matrix-vector product operation, the result vector's map must be
compatible with the range-map of this matrix. The range-map is usually
the same as the row-map. The range-map is set equal to the row-map at
matrix creation time, but may be specified by the user when
FillComplete() is called.

DomainMap() Describes the domain of the matrix operator. The domain-
map can be specified by the user when FillComplete() is called. Until
then, it is set equal to the row-map.

It is important to note that while the row-map and the range-map are
often the same, the column-map and the domain-map are almost never the
same. The set of entries in a distributed column-map almost always
form overlapping sets, with entries being associated with more than
one processor. A domain-map, on the other hand, must be a 1-to-1 map,
with entries being associated with only a single processor.

Local versus Global Indices

Epetra_VbrMatrix has query functions IndicesAreLocal() and
IndicesAreGlobal(), which are used to determine whether the underlying
Epetra_CrsGraph attribute's column-indices have been transformed into
a local index space or not. (This transformation occurs when the
method Epetra_CrsGraph::FillComplete() is called, which happens when
the method Epetra_VbrMatrix::FillComplete() is called.) The state of
the indices in the graph determines the behavior of many
Epetra_VbrMatrix methods. If an Epetra_VbrMatrix instance is
constructed using one of the constructors that does not accept a pre-
existing Epetra_CrsGraph object, then an Epetra_CrsGraph attribute is
created internally and its indices remain untransformed (
IndicesAreGlobal()==true) until Epetra_VbrMatrix::FillComplete() is
called. The query function Epetra_VbrMatrix::Filled() returns true if
Epetra_VbrMatrix::FillComplete() has been called.

Inputting coefficient values

The process for inputting block-entry coefficients is as follows:
Indicate that values for a specified row are about to be provided by
calling one of these methods which specify a block-row and a list of
block-column-indices:  BeginInsertGlobalValues()

BeginInsertMyValues()

BeginReplaceGlobalValues()

BeginReplaceMyValues()

BeginSumIntoGlobalValues()

BeginSumIntoMyValues()

Loop over the list of block-column-indices and pass each block-entry
to the matrix using the method SubmitBlockEntry().

Complete the process for the specified block-row by calling the method
EndSubmitEntries().

Note that the 'GlobalValues' methods have the precondition that
IndicesAreGlobal() must be true, and the 'MyValues' methods have the
precondition that IndicesAreLocal() must be true. Furthermore, the
'SumInto' and 'Replace' methods may only be used to update matrix
entries which already exist, and the 'Insert' methods may only be used
if IndicesAreContiguous() is false.

Counting Floating Point Operations

Each Epetra_VbrMatrix object keeps track of the number of serial
floating point operations performed using the specified object as the
this argument to the function. The Flops() function returns this
number as a double precision number. Using this information, in
conjunction with the Epetra_Time class, one can get accurate parallel
performance numbers. The ResetFlops() function resets the floating
point counter.

C++ includes: Epetra_VbrMatrix.h

Constructor & Destructor Documentation

def PyTrilinos.Epetra.VbrMatrix.__init__	(	self,
		args
	)

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, int
    numBlockEntriesPerRow) -> VbrMatrix

  VbrMatrix constructor with implicit column map and constant number
  of block entries per row.


__init__(self, Epetra_DataAccess CV, BlockMap rowMap, BlockMap colMap,
    int numBlockEntriesPerRow) -> VbrMatrix

  VbrMatrix constructor with specified column map and constant number
  of block entries per row.



__init__(self, Epetra_DataAccess CV, CrsGraph graph) -> VbrMatrix

  CrsGraph constructor.


__init__(self, VbrMatrix matrix) -> VbrMatrix

  Copy constructor.


__init__(self, Epetra_DataAccess CV, BlockMap rowMap, PySequence
    numBlockEntriesPerRow) -> VbrMatrix

  VbrMatrix constructor with implicit column map and variable number
  of block entries per row.



__init__(self, Epetra_DataAccess CV, BlockMap rowMap, BlockMap colMap,
    PySequence numBlockEntriesPerRow) -> VbrMatrix

  VbrMatrix constructor with specified column map and variable number
  of block entries per row.



Epetra_VbrMatrix::Epetra_VbrMatrix(const Epetra_VbrMatrix &Matrix)

Copy constructor.

Reimplemented from PyTrilinos.Epetra.CompObject.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

Member Function Documentation

def PyTrilinos.Epetra.VbrMatrix.Apply	(	self,
		args
	)

Apply(VbrMatrix self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_VbrMatrix::Apply(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_Operator applied to a
Epetra_MultiVector X in Y.

Parameters:
-----------

In:  X - A Epetra_MultiVector of dimension NumVectors to multiply with
matrix.

Out:  Y -A Epetra_MultiVector of dimension NumVectors containing
result.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.Operator.

def PyTrilinos.Epetra.VbrMatrix.ApplyInverse	(	self,
		args
	)

ApplyInverse(VbrMatrix self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_VbrMatrix::ApplyInverse(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_Operator inverse applied to an
Epetra_MultiVector X in Y.

In this implementation, we use several existing attributes to
determine how virtual method ApplyInverse() should call the concrete
method Solve(). We pass in the UpperTriangular(), the
Epetra_VbrMatrix::UseTranspose(), and NoDiagonal() methods. The most
notable warning is that if a matrix has no diagonal values we assume
that there is an implicit unit diagonal that should be accounted for
when doing a triangular solve.

Parameters:
-----------

In:  X - A Epetra_MultiVector of dimension NumVectors to solve for.

Out:  Y -A Epetra_MultiVector of dimension NumVectors containing
result.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.Operator.

def PyTrilinos.Epetra.VbrMatrix.BeginExtractBlockDiagonalCopy	(	self,
		args
	)

BeginExtractBlockDiagonalCopy(VbrMatrix self, int MaxNumBlockDiagonalEntries, int & NumBlockDiagonalEntries, int * RowColDims) -> int

int Epetra_VbrMatrix::BeginExtractBlockDiagonalCopy(int
MaxNumBlockDiagonalEntries, int &NumBlockDiagonalEntries, int
*RowColDims) const

Initiates a copy of the block diagonal entries to user-provided
arrays.

Parameters:
-----------

In:  MaxNumBlockDiagonalEntries - Length of user-provided RowColDims
array.

Out:  NumBlockDiagonalEntries - Number of block diagonal entries that
can actually be extracted.

Out:  RowColDim - List of row and column dimension for corresponding
block diagonal entries.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginExtractBlockDiagonalView	(	self,
		args
	)

BeginExtractBlockDiagonalView(VbrMatrix self, int & NumBlockDiagonalEntries, int *& RowColDims) -> int

int Epetra_VbrMatrix::BeginExtractBlockDiagonalView(int
&NumBlockDiagonalEntries, int *&RowColDims) const

Initiates a view of the block diagonal entries.

Parameters:
-----------

Out:  NumBlockDiagonalEntries - Number of block diagonal entries that
can be viewed.

Out:  RowColDim - Pointer to list of row and column dimension for
corresponding block diagonal entries.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginExtractGlobalBlockRowCopy	(	self,
		args
	)

BeginExtractGlobalBlockRowCopy(VbrMatrix self, int BlockRow, int MaxNumBlockEntries, int & RowDim, int & NumBlockEntries, int * BlockIndices, 
    int * ColDims) -> int

int
Epetra_VbrMatrix::BeginExtractGlobalBlockRowCopy(int BlockRow, int
MaxNumBlockEntries, int &RowDim, int &NumBlockEntries, int
*BlockIndices, int *ColDims) const

Initiates a copy of the specified global row in user-provided arrays.

Parameters:
-----------

In:  BlockRow - Global block row to extract.

In:  MaxNumBlockEntries - Length of user-provided BlockIndices,
ColDims, and LDAs arrays.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries actually extracted.

Out:  BlockIndices - Extracted global column indices for the
corresponding block entries.

Out:  ColDim - List of column dimensions for each corresponding block
entry that will be extracted.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginExtractGlobalBlockRowView	(	self,
		args
	)

BeginExtractGlobalBlockRowView(VbrMatrix self, int BlockRow, int & RowDim, int & NumBlockEntries, int *& BlockIndices) -> int

int
Epetra_VbrMatrix::BeginExtractGlobalBlockRowView(int BlockRow, int
&RowDim, int &NumBlockEntries, int *&BlockIndices) const

Initiates a view of the specified global row, only works if matrix
indices are in global mode.

Parameters:
-----------

In:  BlockRow - Global block row to view.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries to be viewed.

Out:  BlockIndices - Pointer to global column indices for the
corresponding block entries.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginExtractMyBlockRowCopy	(	self,
		args
	)

BeginExtractMyBlockRowCopy(VbrMatrix self, int BlockRow, int MaxNumBlockEntries, int & RowDim, int & NumBlockEntries, int * BlockIndices, 
    int * ColDims) -> int

int Epetra_VbrMatrix::BeginExtractMyBlockRowCopy(int BlockRow, int
MaxNumBlockEntries, int &RowDim, int &NumBlockEntries, int
*BlockIndices, int *ColDims) const

Initiates a copy of the specified local row in user-provided arrays.

Parameters:
-----------

In:  BlockRow - Local block row to extract.

In:  MaxNumBlockEntries - Length of user-provided BlockIndices,
ColDims, and LDAs arrays.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries actually extracted.

Out:  BlockIndices - Extracted local column indices for the
corresponding block entries.

Out:  ColDim - List of column dimensions for each corresponding block
entry that will be extracted.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginExtractMyBlockRowView	(	self,
		args
	)

BeginExtractMyBlockRowView(VbrMatrix self, int BlockRow, int & RowDim, int & NumBlockEntries, int *& BlockIndices) -> int

int Epetra_VbrMatrix::BeginExtractMyBlockRowView(int BlockRow, int
&RowDim, int &NumBlockEntries, int *&BlockIndices) const

Initiates a view of the specified local row, only works if matrix
indices are in local mode.

Parameters:
-----------

In:  BlockRow - Local block row to view.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries to be viewed.

Out:  BlockIndices - Pointer to local column indices for the
corresponding block entries.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginInsertGlobalValues	(	self,
		args
	)

BeginInsertGlobalValues(VbrMatrix self, int BlockRow, int NumBlockEntries) -> int

int
Epetra_VbrMatrix::BeginInsertGlobalValues(int BlockRow, int
NumBlockEntries, int *BlockIndices)

Initiate insertion of a list of elements in a given global row of the
matrix, values are inserted via SubmitEntry().

Parameters:
-----------

In:  BlockRow - Block Row number (in global coordinates) to put
elements.

In:  NumBlockEntries - Number of entries.

In:  Indices - Global column indices corresponding to values.

Integer error code, set to 0 if successful.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

def PyTrilinos.Epetra.VbrMatrix.BeginInsertMyValues	(	self,
		args
	)

BeginInsertMyValues(VbrMatrix self, int BlockRow, int NumBlockEntries) -> int

int
Epetra_VbrMatrix::BeginInsertMyValues(int BlockRow, int
NumBlockEntries, int *BlockIndices)

Initiate insertion of a list of elements in a given local row of the
matrix, values are inserted via SubmitEntry().

Parameters:
-----------

In:  BlockRow - Block Row number (in local coordinates) to put
elements.

In:  NumBlockEntries - Number of entries.

In:  Indices - Local column indices corresponding to values.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginReplaceGlobalValues	(	self,
		args
	)

BeginReplaceGlobalValues(VbrMatrix self, int BlockRow, int NumBlockEntries) -> int

int Epetra_VbrMatrix::BeginReplaceGlobalValues(int BlockRow, int
NumBlockEntries, int *BlockIndices)

Initiate replacement of current values with this list of entries for a
given global row of the matrix, values are replaced via SubmitEntry()

Parameters:
-----------

In:  Row - Block Row number (in global coordinates) to put elements.

In:  NumBlockEntries - Number of entries.

In:  Indices - Global column indices corresponding to values.

Integer error code, set to 0 if successful.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

def PyTrilinos.Epetra.VbrMatrix.BeginReplaceMyValues	(	self,
		args
	)

BeginReplaceMyValues(VbrMatrix self, int BlockRow, int NumBlockEntries) -> int

int
Epetra_VbrMatrix::BeginReplaceMyValues(int BlockRow, int
NumBlockEntries, int *BlockIndices)

Initiate replacement of current values with this list of entries for a
given local row of the matrix, values are replaced via SubmitEntry()

Parameters:
-----------

In:  Row - Block Row number (in local coordinates) to put elements.

In:  NumBlockEntries - Number of entries.

In:  Indices - Local column indices corresponding to values.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BeginSumIntoGlobalValues	(	self,
		args
	)

BeginSumIntoGlobalValues(VbrMatrix self, int BlockRow, int NumBlockEntries) -> int

int Epetra_VbrMatrix::BeginSumIntoGlobalValues(int BlockRow, int
NumBlockEntries, int *BlockIndices)

Initiate summing into current values with this list of entries for a
given global row of the matrix, values are replaced via SubmitEntry()

Parameters:
-----------

In:  Row - Block Row number (in global coordinates) to put elements.

In:  NumBlockEntries - Number of entries.

In:  Indices - Global column indices corresponding to values.

Integer error code, set to 0 if successful.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

def PyTrilinos.Epetra.VbrMatrix.BeginSumIntoMyValues	(	self,
		args
	)

BeginSumIntoMyValues(VbrMatrix self, int BlockRow, int NumBlockEntries) -> int

int
Epetra_VbrMatrix::BeginSumIntoMyValues(int BlockRow, int
NumBlockEntries, int *BlockIndices)

Initiate summing into current values with this list of entries for a
given local row of the matrix, values are replaced via SubmitEntry()

Parameters:
-----------

In:  Row - Block Row number (in local coordinates) to put elements.

In:  NumBlockEntries - Number of entries.

In:  Indices - Local column indices corresponding to values.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.BlockImportMap	(	self,
		args
	)

BlockImportMap(VbrMatrix self) -> BlockMap

const
Epetra_BlockMap& Epetra_VbrMatrix::BlockImportMap() const

Use BlockColMap() instead.

def PyTrilinos.Epetra.VbrMatrix.ColMap	(	self,
		args
	)

ColMap(VbrMatrix self) -> BlockMap

const
Epetra_BlockMap& Epetra_VbrMatrix::ColMap() const

Returns the ColMap as an Epetra_BlockMap (the Epetra_Map base class)
needed for implementing Epetra_RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.Comm	(	self,
		args
	)

Comm(VbrMatrix self) -> Comm

const Epetra_Comm&
Epetra_VbrMatrix::Comm() const

Fills a matrix with rows from a source matrix based on the specified
importer.

Returns a pointer to the Epetra_Comm communicator associated with this
matrix.

Reimplemented from PyTrilinos.Epetra.DistObject.

def PyTrilinos.Epetra.VbrMatrix.DirectSubmitBlockEntry	(	self,
		args
	)

DirectSubmitBlockEntry(VbrMatrix self, int GlobalBlockRow, int GlobalBlockCol, double const * values, int LDA, int NumRows, 
    int NumCols, bool sum_into) -> int

int
Epetra_VbrMatrix::DirectSubmitBlockEntry(int GlobalBlockRow, int
GlobalBlockCol, const double *values, int LDA, int NumRows, int
NumCols, bool sum_into)

Submit a block-entry directly into the matrix (without using a
begin/end sequence)

Experimental method which allows submitting a block-entry without
first calling BeginInsertGlobalValues. This method copies the input
data directly into the matrix storage. The block-entry is specified by
global block-row and block-col indices.

def PyTrilinos.Epetra.VbrMatrix.DomainMap	(	self,
		args
	)

DomainMap(VbrMatrix self) -> BlockMap

const
Epetra_BlockMap& Epetra_VbrMatrix::DomainMap() const

Returns the Epetra_BlockMap object associated with the domain of this
matrix operator.

def PyTrilinos.Epetra.VbrMatrix.EndSubmitEntries	(	self,
		args
	)

EndSubmitEntries(VbrMatrix self) -> int

int
Epetra_VbrMatrix::EndSubmitEntries()

Completes processing of all data passed in for the current block row.

This function completes the processing of all block entries submitted
via SubmitBlockEntry(). It also checks to make sure that
SubmitBlockEntry was called the correct number of times as specified
by the Begin routine that initiated the entry process.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

def PyTrilinos.Epetra.VbrMatrix.Exporter	(	self,
		args
	)

Exporter(VbrMatrix self) -> Export

const
Epetra_Export* Epetra_VbrMatrix::Exporter() const

Returns the Epetra_Export object that contains the export operations
for distributed operations.

def PyTrilinos.Epetra.VbrMatrix.ExtractBlockDiagonalEntryCopy	(	self,
		args
	)

ExtractBlockDiagonalEntryCopy(VbrMatrix self, int SizeOfValues, double * Values, int LDA, bool SumInto) -> int

int Epetra_VbrMatrix::ExtractBlockDiagonalEntryCopy(int
SizeOfValues, double *Values, int LDA, bool SumInto) const

Extract a copy of a block diagonal entry from the matrix.

Once BeginExtractBlockDiagonalCopy() is called, you can extract the
block diagonal entries one-entry- at-a-time. The entries will be
extracted in ascending order.

Parameters:
-----------

In:  SizeOfValues - Amount of memory associated with Values. This must
be at least as big as LDA*NumCol, where NumCol is the column dimension
of the block entry being copied

InOut:  Values - Starting location where the block entry will be
copied.

In:  LDA - Specifies the stride that will be used when copying columns
into Values.

In:  SumInto - If set to true, the block entry values will be summed
into existing values.

def PyTrilinos.Epetra.VbrMatrix.ExtractBlockDiagonalEntryView	(	self,
		args
	)

ExtractBlockDiagonalEntryView(VbrMatrix self, double *& Values, int & LDA) -> int

int Epetra_VbrMatrix::ExtractBlockDiagonalEntryView(double *&Values,
int &LDA) const

Extract a view of a block diagonal entry from the matrix.

Once BeginExtractBlockDiagonalView() is called, you can extract a view
of the block diagonal entries one- entry-at-a-time. The views will be
extracted in ascending order.

Parameters:
-----------

Out:  Values - Pointer to internal copy of block entry.

Out:  LDA - Column stride of Values.

def PyTrilinos.Epetra.VbrMatrix.ExtractDiagonalCopy	(	self,
		args
	)

ExtractDiagonalCopy(VbrMatrix self, Epetra_Vector Diagonal) -> int

int
Epetra_VbrMatrix::ExtractDiagonalCopy(Epetra_Vector &Diagonal) const

Returns a copy of the main diagonal in a user-provided vector.

Parameters:
-----------

Out:  Diagonal - Extracted main diagonal.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.ExtractEntryCopy	(	self,
		args
	)

ExtractEntryCopy(VbrMatrix self, int SizeOfValues, double * Values, int LDA, bool SumInto) -> int

int
Epetra_VbrMatrix::ExtractEntryCopy(int SizeOfValues, double *Values,
int LDA, bool SumInto) const

Extract a copy of an entry from the block row specified by one of the
BeginExtract routines.

Once BeginExtractGlobalBlockRowCopy() or BeginExtractMyBlockRowCopy()
is called, you can extract the block entries of specified block row
one-entry-at-a-time. The entries will be extracted in an order
corresponding to the BlockIndices list that was returned by the
BeginExtract routine.

Parameters:
-----------

In:  SizeOfValues - Amount of memory associated with Values. This must
be at least as big as LDA*NumCol, where NumCol is the column dimension
of the block entry being copied

InOut:  Values - Starting location where the block entry will be
copied.

In:  LDA - Specifies the stride that will be used when copying columns
into Values.

In:  SumInto - If set to true, the block entry values will be summed
into existing values.

def PyTrilinos.Epetra.VbrMatrix.ExtractEntryView	(	self,
		args
	)

ExtractEntryView(VbrMatrix self) -> int

int
Epetra_VbrMatrix::ExtractEntryView(Epetra_SerialDenseMatrix *&entry)
const

Returns a pointer to the current block entry.

After a call to BeginExtractGlobal() or
BlockRowViewBeginExtractMyBlockRowView(), ExtractEntryView() can be
called up to NumBlockEntries times to get each block entry in the
specified block row.

Parameters:
-----------

InOut:  entry - A pointer that will be set to the current block entry.

def PyTrilinos.Epetra.VbrMatrix.ExtractGlobalBlockRowPointers	(	self,
		args
	)

ExtractGlobalBlockRowPointers(VbrMatrix self, int BlockRow, int MaxNumBlockEntries, int & RowDim, int & NumBlockEntries, int * BlockIndices, 
    Epetra_SerialDenseMatrix **& Values) -> int

int Epetra_VbrMatrix::ExtractGlobalBlockRowPointers(int BlockRow,
int MaxNumBlockEntries, int &RowDim, int &NumBlockEntries, int
*BlockIndices, Epetra_SerialDenseMatrix **&Values) const

Copy the block indices into user-provided array, set pointers for rest
of data for specified global block row.

This function provides the lightest weight approach to accessing a
global block row when the matrix may be be stored in local or global
index space. In other words, this function will always work because
the block indices are returned in user-provided space. All other array
arguments are independent of whether or not indices are local or
global. Other than the BlockIndices array, all other array argument
are returned as pointers to internal data.

Parameters:
-----------

In:  BlockRow - Global block row to extract.

In:  MaxNumBlockEntries - Length of user-provided BlockIndices array.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries actually extracted.

Out:  BlockIndices - Extracted global column indices for the
corresponding block entries.

Out:  Values - Pointer to list of pointers to block entries. Note that
the actual values are not copied.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.ExtractGlobalBlockRowView	(	self,
		args
	)

ExtractGlobalBlockRowView(VbrMatrix self, int BlockRow, int & RowDim, int & NumBlockEntries, int *& BlockIndices, Epetra_SerialDenseMatrix **& Values) -> int

int Epetra_VbrMatrix::ExtractGlobalBlockRowView(int BlockRow, int
&RowDim, int &NumBlockEntries, int *&BlockIndices,
Epetra_SerialDenseMatrix **&Values) const

Initiates a view of the specified global row, only works if matrix
indices are in global mode.

Parameters:
-----------

In:  BlockRow - Global block row to view.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries to be viewed.

Out:  BlockIndices - Pointer to global column indices for the
corresponding block entries.

Out:  Values - Pointer to an array of pointers to the block entries in
the specified block row.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.ExtractGlobalRowCopy	(	self,
		args
	)

ExtractGlobalRowCopy(VbrMatrix self, int GlobalRow, int Length, int & NumEntries, double * Values, int * Indices) -> int

int
Epetra_VbrMatrix::ExtractGlobalRowCopy(int GlobalRow, int Length, int
&NumEntries, double *Values, int *Indices) const

Returns a copy of the specified global row in user-provided arrays.

Parameters:
-----------

In:  GlobalRow - Global row to extract.

In:  Length - Length of Values and Indices.

Out:  NumEntries - Number of nonzero entries extracted.

Out:  Values - Extracted values for this row.

Out:  Indices - Extracted global column indices for the corresponding
values.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.ExtractMyBlockRowPointers	(	self,
		args
	)

ExtractMyBlockRowPointers(VbrMatrix self, int BlockRow, int MaxNumBlockEntries, int & RowDim, int & NumBlockEntries, int * BlockIndices, 
    Epetra_SerialDenseMatrix **& Values) -> int

int Epetra_VbrMatrix::ExtractMyBlockRowPointers(int BlockRow, int
MaxNumBlockEntries, int &RowDim, int &NumBlockEntries, int
*BlockIndices, Epetra_SerialDenseMatrix **&Values) const

Copy the block indices into user-provided array, set pointers for rest
of data for specified local block row.

This function provides the lightest weight approach to accessing a
local block row when the matrix may be be stored in local or global
index space. In other words, this function will always work because
the block indices are returned in user-provided space. All other array
arguments are independent of whether or not indices are local or
global. Other than the BlockIndices array, all other array argument
are returned as pointers to internal data.

Parameters:
-----------

In:  BlockRow - Local block row to extract.

In:  MaxNumBlockEntries - Length of user-provided BlockIndices array.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries actually extracted.

Out:  BlockIndices - Extracted local column indices for the
corresponding block entries.

Out:  Values - Pointer to list of pointers to block entries. Note that
the actual values are not copied.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.ExtractMyBlockRowView	(	self,
		args
	)

ExtractMyBlockRowView(VbrMatrix self, int BlockRow, int & RowDim, int & NumBlockEntries, int *& BlockIndices, Epetra_SerialDenseMatrix **& Values) -> int

int
Epetra_VbrMatrix::ExtractMyBlockRowView(int BlockRow, int &RowDim, int
&NumBlockEntries, int *&BlockIndices, Epetra_SerialDenseMatrix
**&Values) const

Initiates a view of the specified local row, only works if matrix
indices are in local mode.

Parameters:
-----------

In:  BlockRow - Local block row to view.

Out:  RowDim - Number of equations in the requested block row.

Out:  NumBlockEntries - Number of nonzero entries to be viewed.

Out:  BlockIndices - Pointer to local column indices for the
corresponding block entries.

Out:  Values - Pointer to an array of pointers to the block entries in
the specified block row.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.ExtractMyRowCopy	(	self,
		args
	)

ExtractMyRowCopy(VbrMatrix self, int MyRow, int Length, int & NumEntries, double * Values, int * Indices) -> int

int
Epetra_VbrMatrix::ExtractMyRowCopy(int MyRow, int Length, int
&NumEntries, double *Values, int *Indices) const

Returns a copy of the specified local row in user-provided arrays.

Parameters:
-----------

In:  MyRow - Local row to extract.

In:  Length - Length of Values and Indices.

Out:  NumEntries - Number of nonzero entries extracted.

Out:  Values - Extracted values for this row.

Out:  Indices - Extracted local column indices for the corresponding
values.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.FillComplete	(	self,
		args
	)

FillComplete(VbrMatrix self) -> int
FillComplete(VbrMatrix self, BlockMap DomainMap, BlockMap RangeMap) -> int

int
Epetra_VbrMatrix::FillComplete(const Epetra_BlockMap &DomainMap, const
Epetra_BlockMap &RangeMap)

Signal that data entry is complete, perform transformations to local
index space.

def PyTrilinos.Epetra.VbrMatrix.Filled	(	self,
		args
	)

Filled(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::Filled() const

If FillComplete() has been called, this query returns true, otherwise
it returns false.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.GCID	(	self,
		args
	)

GCID(VbrMatrix self, int LCID_in) -> int

int
Epetra_VbrMatrix::GCID(int LCID_in) const

Returns the global column index for give local column index, returns
IndexBase-1 if we don't have this local column.

def PyTrilinos.Epetra.VbrMatrix.GCID64	(	self,
		args
	)

GCID64(VbrMatrix self, int LCID_in) -> long long

long long
Epetra_VbrMatrix::GCID64(int LCID_in) const

def PyTrilinos.Epetra.VbrMatrix.GlobalMaxColDim	(	self,
		args
	)

GlobalMaxColDim(VbrMatrix self) -> int

int
Epetra_VbrMatrix::GlobalMaxColDim() const

Returns the maximum column dimension of all block entries across all
processors.

def PyTrilinos.Epetra.VbrMatrix.GlobalMaxNumBlockEntries	(	self,
		args
	)

GlobalMaxNumBlockEntries(VbrMatrix self) -> int

int Epetra_VbrMatrix::GlobalMaxNumBlockEntries() const

Returns the maximum number of nonzero entries across all rows on this
processor.

def PyTrilinos.Epetra.VbrMatrix.GlobalMaxNumNonzeros	(	self,
		args
	)

GlobalMaxNumNonzeros(VbrMatrix self) -> int

int
Epetra_VbrMatrix::GlobalMaxNumNonzeros() const

Returns the maximum number of nonzero entries across all block rows on
all processors.

This function returns the max over all processor of MaxNumNonzeros().

def PyTrilinos.Epetra.VbrMatrix.GlobalMaxRowDim	(	self,
		args
	)

GlobalMaxRowDim(VbrMatrix self) -> int

int
Epetra_VbrMatrix::GlobalMaxRowDim() const

Returns the maximum row dimension of all block entries across all
processors.

def PyTrilinos.Epetra.VbrMatrix.Graph	(	self,
		args
	)

Graph(VbrMatrix self) -> CrsGraph

const
Epetra_CrsGraph& Epetra_VbrMatrix::Graph() const

Returns a pointer to the Epetra_CrsGraph object associated with this
matrix.

def PyTrilinos.Epetra.VbrMatrix.GRID	(	self,
		args
	)

GRID(VbrMatrix self, int LRID_in) -> int

int
Epetra_VbrMatrix::GRID(int LRID_in) const

Returns the global row index for give local row index, returns
IndexBase-1 if we don't have this local row.

def PyTrilinos.Epetra.VbrMatrix.GRID64	(	self,
		args
	)

GRID64(VbrMatrix self, int LRID_in) -> long long

long long
Epetra_VbrMatrix::GRID64(int LRID_in) const

def PyTrilinos.Epetra.VbrMatrix.HasNormInf	(	self,
		args
	)

HasNormInf(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::HasNormInf() const

Returns true because this class can compute an Inf-norm.

Reimplemented from PyTrilinos.Epetra.Operator.

def PyTrilinos.Epetra.VbrMatrix.Importer	(	self,
		args
	)

Importer(VbrMatrix self) -> Import

const
Epetra_Import* Epetra_VbrMatrix::Importer() const

Returns the Epetra_Import object that contains the import operations
for distributed operations.

def PyTrilinos.Epetra.VbrMatrix.IndexBase	(	self,
		args
	)

IndexBase(VbrMatrix self) -> int

int
Epetra_VbrMatrix::IndexBase() const

Returns the index base for row and column indices for this graph.

def PyTrilinos.Epetra.VbrMatrix.IndicesAreContiguous	(	self,
		args
	)

IndicesAreContiguous(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::IndicesAreContiguous() const

If matrix indices are packed into single array (done in
OptimizeStorage()) return true, otherwise false.

def PyTrilinos.Epetra.VbrMatrix.IndicesAreGlobal	(	self,
		args
	)

IndicesAreGlobal(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::IndicesAreGlobal() const

If matrix indices has not been transformed to local, this query
returns true, otherwise it returns false.

def PyTrilinos.Epetra.VbrMatrix.IndicesAreLocal	(	self,
		args
	)

IndicesAreLocal(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::IndicesAreLocal() const

If matrix indices has been transformed to local, this query returns
true, otherwise it returns false.

def PyTrilinos.Epetra.VbrMatrix.InvColSums	(	self,
		args
	)

InvColSums(VbrMatrix self, Epetra_Vector x) -> int

int
Epetra_VbrMatrix::InvColSums(Epetra_Vector &x) const

Computes the sum of absolute values of the columns of the
Epetra_VbrMatrix, results returned in x.

The vector x will return such that x[j] will contain the inverse of
sum of the absolute values of the this matrix will be sca such that
A(i,j) = x(j)*A(i,j) where i denotes the global row number of A and j
denotes the global column number of A. Using the resulting vector from
this function as input to RighttScale() will make the one norm of the
resulting matrix exactly 1.

Parameters:
-----------

Out:  x -A Epetra_Vector containing the column sums of the this
matrix.

WARNING:  It is assumed that the distribution of x is the same as the
rows of this.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.InvRowSums	(	self,
		args
	)

InvRowSums(VbrMatrix self, Epetra_Vector x) -> int

int
Epetra_VbrMatrix::InvRowSums(Epetra_Vector &x) const

Computes the sum of absolute values of the rows of the
Epetra_VbrMatrix, results returned in x.

The vector x will return such that x[i] will contain the inverse of
sum of the absolute values of the this matrix will be scaled such that
A(i,j) = x(i)*A(i,j) where i denotes the global row number of A and j
denotes the global column number of A. Using the resulting vector from
this function as input to LeftScale() will make the infinity norm of
the resulting matrix exactly 1.

Parameters:
-----------

Out:  x -A Epetra_Vector containing the row sums of the this matrix.

WARNING:  It is assumed that the distribution of x is the same as the
rows of this.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.Label	(	self,
		args
	)

Label(VbrMatrix self) -> char const *

const char*
Epetra_VbrMatrix::Label() const

Returns a character string describing the operator.

Reimplemented from PyTrilinos.Epetra.Object.

def PyTrilinos.Epetra.VbrMatrix.LCID	(	self,
		args
	)

LCID(VbrMatrix self, int GCID_in) -> int
LCID(VbrMatrix self, long long GCID_in) -> int

int
Epetra_VbrMatrix::LCID(long long GCID_in) const

def PyTrilinos.Epetra.VbrMatrix.LeftScale	(	self,
		args
	)

LeftScale(VbrMatrix self, Epetra_Vector x) -> int

int
Epetra_VbrMatrix::LeftScale(const Epetra_Vector &x)

Scales the Epetra_VbrMatrix on the left with a Epetra_Vector x.

The this matrix will be scaled such that A(i,j) = x(i)*A(i,j) where i
denotes the row number of A and j denotes the column number of A.

Parameters:
-----------

In:  x -A Epetra_Vector to solve for.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.LowerTriangular	(	self,
		args
	)

LowerTriangular(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::LowerTriangular() const

If matrix is lower triangular in local index space, this query returns
true, otherwise it returns false.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.LRID	(	self,
		args
	)

LRID(VbrMatrix self, int GRID_in) -> int
LRID(VbrMatrix self, long long GRID_in) -> int

int
Epetra_VbrMatrix::LRID(long long GRID_in) const

def PyTrilinos.Epetra.VbrMatrix.Map	(	self,
		args
	)

Map(VbrMatrix self) -> BlockMap

const Epetra_BlockMap&
Epetra_VbrMatrix::Map() const

Map() method inherited from Epetra_DistObject.

Reimplemented from PyTrilinos.Epetra.DistObject.

def PyTrilinos.Epetra.VbrMatrix.MaxColDim	(	self,
		args
	)

MaxColDim(VbrMatrix self) -> int

int
Epetra_VbrMatrix::MaxColDim() const

Returns the maximum column dimension of all block entries on this
processor.

def PyTrilinos.Epetra.VbrMatrix.MaxNumBlockEntries	(	self,
		args
	)

MaxNumBlockEntries(VbrMatrix self) -> int

int
Epetra_VbrMatrix::MaxNumBlockEntries() const

Returns the maximum number of nonzero entries across all rows on this
processor.

def PyTrilinos.Epetra.VbrMatrix.MaxNumEntries	(	self,
		args
	)

MaxNumEntries(VbrMatrix self) -> int

int
Epetra_VbrMatrix::MaxNumEntries() const

Returns the maximum of NumMyRowEntries() over all rows.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.MaxNumNonzeros	(	self,
		args
	)

MaxNumNonzeros(VbrMatrix self) -> int

int
Epetra_VbrMatrix::MaxNumNonzeros() const

Returns the maximum number of nonzero entries across all block rows on
this processor.

Let ki = the number of nonzero values in the ith block row of the
VbrMatrix object. For example, if the ith block row had 5 block
entries and the size of each entry was 4-by-4, ki would be 80. Then
this function return the max over all ki for all row on this
processor.

def PyTrilinos.Epetra.VbrMatrix.MaxRowDim	(	self,
		args
	)

MaxRowDim(VbrMatrix self) -> int

int
Epetra_VbrMatrix::MaxRowDim() const

Returns the maximum row dimension of all block entries on this
processor.

def PyTrilinos.Epetra.VbrMatrix.Multiply	(	self,
		args
	)

Multiply(VbrMatrix self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_VbrMatrix::Multiply(bool TransA, const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_VbrMatrix multiplied by a
Epetra_MultiVector X in Y.

Parameters:
-----------

In:  TransA -If true, multiply by the transpose of matrix, otherwise
just use matrix.

In:  X - A Epetra_MultiVector of dimension NumVectors to multiply with
matrix.

Out:  Y -A Epetra_MultiVector of dimension NumVectorscontaining
result.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.Multiply1	(	self,
		args
	)

Multiply1(VbrMatrix self, bool TransA, Epetra_Vector x, Epetra_Vector y) -> int

int
Epetra_VbrMatrix::Multiply1(bool TransA, const Epetra_Vector &x,
Epetra_Vector &y) const

Returns the result of a Epetra_VbrMatrix multiplied by a Epetra_Vector
x in y.

Parameters:
-----------

In:  TransA - If true, multiply by the transpose of matrix, otherwise
just use matrix.

In:  x - A Epetra_Vector to multiply by.

Out:  y - A Epetra_Vector containing result.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.MyGCID	(	self,
		args
	)

MyGCID(VbrMatrix self, int GCID_in) -> bool
MyGCID(VbrMatrix self, long long GCID_in) -> bool

bool
Epetra_VbrMatrix::MyGCID(long long GCID_in) const

def PyTrilinos.Epetra.VbrMatrix.MyGlobalBlockRow	(	self,
		args
	)

MyGlobalBlockRow(VbrMatrix self, int GID) -> bool
MyGlobalBlockRow(VbrMatrix self, long long GID) -> bool

bool
Epetra_VbrMatrix::MyGlobalBlockRow(long long GID) const

def PyTrilinos.Epetra.VbrMatrix.MyGRID	(	self,
		args
	)

MyGRID(VbrMatrix self, int GRID_in) -> bool
MyGRID(VbrMatrix self, long long GRID_in) -> bool

bool
Epetra_VbrMatrix::MyGRID(long long GRID_in) const

def PyTrilinos.Epetra.VbrMatrix.MyLCID	(	self,
		args
	)

MyLCID(VbrMatrix self, int LCID_in) -> bool

bool
Epetra_VbrMatrix::MyLCID(int LCID_in) const

Returns true if the LRID passed in belongs to the calling processor in
this map, otherwise returns false.

def PyTrilinos.Epetra.VbrMatrix.MyLRID	(	self,
		args
	)

MyLRID(VbrMatrix self, int LRID_in) -> bool

bool
Epetra_VbrMatrix::MyLRID(int LRID_in) const

Returns true if the LRID passed in belongs to the calling processor in
this map, otherwise returns false.

def PyTrilinos.Epetra.VbrMatrix.NoDiagonal	(	self,
		args
	)

NoDiagonal(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::NoDiagonal() const

If matrix has no diagonal entries based on global row/column index
comparisons, this query returns true, otherwise it returns false.

def PyTrilinos.Epetra.VbrMatrix.NormFrobenius	(	self,
		args
	)

NormFrobenius(VbrMatrix self) -> double

double
Epetra_VbrMatrix::NormFrobenius() const

Returns the frobenius norm of the global matrix.

def PyTrilinos.Epetra.VbrMatrix.NormInf	(	self,
		args
	)

NormInf(VbrMatrix self) -> double

double
Epetra_VbrMatrix::NormInf() const

Returns the infinity norm of the global matrix.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NormOne	(	self,
		args
	)

NormOne(VbrMatrix self) -> double

double
Epetra_VbrMatrix::NormOne() const

Returns the one norm of the global matrix.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumAllocatedGlobalBlockEntries	(	self,
		args
	)

NumAllocatedGlobalBlockEntries(VbrMatrix self, int Row) -> int

int
Epetra_VbrMatrix::NumAllocatedGlobalBlockEntries(int Row) const

Returns the allocated number of nonzero Block entries in specified
global row on this processor.

def PyTrilinos.Epetra.VbrMatrix.NumAllocatedMyBlockEntries	(	self,
		args
	)

NumAllocatedMyBlockEntries(VbrMatrix self, int Row) -> int

int Epetra_VbrMatrix::NumAllocatedMyBlockEntries(int Row) const

Returns the allocated number of nonzero Block entries in specified
local row on this processor.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockCols	(	self,
		args
	)

NumGlobalBlockCols(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalBlockCols() const

Returns the number of global Block matrix columns.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockCols64	(	self,
		args
	)

NumGlobalBlockCols64(VbrMatrix self) -> long long

long
long Epetra_VbrMatrix::NumGlobalBlockCols64() const

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockDiagonals	(	self,
		args
	)

NumGlobalBlockDiagonals(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalBlockDiagonals() const

Returns the number of global nonzero block diagonal entries, based on
global row/column index comparisions.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockDiagonals64	(	self,
		args
	)

NumGlobalBlockDiagonals64(VbrMatrix self) -> long long

long long Epetra_VbrMatrix::NumGlobalBlockDiagonals64() const

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockEntries	(	self,
		args
	)

NumGlobalBlockEntries(VbrMatrix self) -> int
NumGlobalBlockEntries(VbrMatrix self, int Row) -> int

int
Epetra_VbrMatrix::NumGlobalBlockEntries(int Row) const

Returns the current number of nonzero Block entries in specified
global row on this processor.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockEntries64	(	self,
		args
	)

NumGlobalBlockEntries64(VbrMatrix self) -> long long

long long Epetra_VbrMatrix::NumGlobalBlockEntries64() const

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockRows	(	self,
		args
	)

NumGlobalBlockRows(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalBlockRows() const

Returns the number of global Block matrix rows.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalBlockRows64	(	self,
		args
	)

NumGlobalBlockRows64(VbrMatrix self) -> long long

long
long Epetra_VbrMatrix::NumGlobalBlockRows64() const

def PyTrilinos.Epetra.VbrMatrix.NumGlobalCols	(	self,
		args
	)

NumGlobalCols(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalCols() const

Returns the number of global matrix columns.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalCols64	(	self,
		args
	)

NumGlobalCols64(VbrMatrix self) -> long long

long long
Epetra_VbrMatrix::NumGlobalCols64() const

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalDiagonals	(	self,
		args
	)

NumGlobalDiagonals(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalDiagonals() const

Returns the number of global nonzero diagonal entries, based on global
row/column index comparisions.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalDiagonals64	(	self,
		args
	)

NumGlobalDiagonals64(VbrMatrix self) -> long long

long
long Epetra_VbrMatrix::NumGlobalDiagonals64() const

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalNonzeros	(	self,
		args
	)

NumGlobalNonzeros(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalNonzeros() const

Returns the number of nonzero entries in the global matrix.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalNonzeros64	(	self,
		args
	)

NumGlobalNonzeros64(VbrMatrix self) -> long long

long
long Epetra_VbrMatrix::NumGlobalNonzeros64() const

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalRows	(	self,
		args
	)

NumGlobalRows(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumGlobalRows() const

Returns the number of global matrix rows.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumGlobalRows64	(	self,
		args
	)

NumGlobalRows64(VbrMatrix self) -> long long

long long
Epetra_VbrMatrix::NumGlobalRows64() const

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumMyBlockCols	(	self,
		args
	)

NumMyBlockCols(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyBlockCols() const

Returns the number of Block matrix columns owned by the calling
processor.

def PyTrilinos.Epetra.VbrMatrix.NumMyBlockDiagonals	(	self,
		args
	)

NumMyBlockDiagonals(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyBlockDiagonals() const

Returns the number of local nonzero block diagonal entries, based on
global row/column index comparisons.

def PyTrilinos.Epetra.VbrMatrix.NumMyBlockEntries	(	self,
		args
	)

NumMyBlockEntries(VbrMatrix self) -> int
NumMyBlockEntries(VbrMatrix self, int Row) -> int

int
Epetra_VbrMatrix::NumMyBlockEntries(int Row) const

Returns the current number of nonzero Block entries in specified local
row on this processor.

def PyTrilinos.Epetra.VbrMatrix.NumMyBlockRows	(	self,
		args
	)

NumMyBlockRows(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyBlockRows() const

Returns the number of Block matrix rows owned by the calling
processor.

def PyTrilinos.Epetra.VbrMatrix.NumMyCols	(	self,
		args
	)

NumMyCols(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyCols() const

Returns the number of matrix columns owned by the calling processor.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumMyDiagonals	(	self,
		args
	)

NumMyDiagonals(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyDiagonals() const

Returns the number of local nonzero diagonal entries, based on global
row/column index comparisons.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumMyNonzeros	(	self,
		args
	)

NumMyNonzeros(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyNonzeros() const

Returns the number of nonzero entriesowned by the calling processor .

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumMyRowEntries	(	self,
		args
	)

NumMyRowEntries(VbrMatrix self, int MyRow, int & NumEntries) -> int

int
Epetra_VbrMatrix::NumMyRowEntries(int MyRow, int &NumEntries) const

Return the current number of values stored for the specified local
row.

Parameters:
-----------

In:  MyRow - Local row.

Out:  NumEntries - Number of nonzero values.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.NumMyRows	(	self,
		args
	)

NumMyRows(VbrMatrix self) -> int

int
Epetra_VbrMatrix::NumMyRows() const

Returns the number of matrix rows owned by the calling processor.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.OperatorDomainMap	(	self,
		args
	)

OperatorDomainMap(VbrMatrix self) -> Map

const
Epetra_Map& Epetra_VbrMatrix::OperatorDomainMap() const

Returns the Epetra_Map object associated with the domain of this
matrix operator.

Reimplemented from PyTrilinos.Epetra.Operator.

def PyTrilinos.Epetra.VbrMatrix.OperatorRangeMap	(	self,
		args
	)

OperatorRangeMap(VbrMatrix self) -> Map

const
Epetra_Map& Epetra_VbrMatrix::OperatorRangeMap() const

Returns the Epetra_Map object associated with the range of this matrix
operator.

Reimplemented from PyTrilinos.Epetra.Operator.

def PyTrilinos.Epetra.VbrMatrix.OptimizeStorage	(	self,
		args
	)

OptimizeStorage(VbrMatrix self) -> int

int
Epetra_VbrMatrix::OptimizeStorage()

Eliminates memory that is used for construction. Make consecutive row
index sections contiguous.

def PyTrilinos.Epetra.VbrMatrix.PutScalar	(	self,
		args
	)

PutScalar(VbrMatrix self, double ScalarConstant) -> int

int
Epetra_VbrMatrix::PutScalar(double ScalarConstant)

Initialize all values in graph of the matrix with constant value.

Parameters:
-----------

In:  ScalarConstant - Value to use.

Integer error code, set to 0 if successful.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

def PyTrilinos.Epetra.VbrMatrix.RangeMap	(	self,
		args
	)

RangeMap(VbrMatrix self) -> BlockMap

const
Epetra_BlockMap& Epetra_VbrMatrix::RangeMap() const

Returns the Epetra_BlockMap object associated with the range of this
matrix operator.

def PyTrilinos.Epetra.VbrMatrix.ReplaceDiagonalValues	(	self,
		args
	)

ReplaceDiagonalValues(VbrMatrix self, Epetra_Vector Diagonal) -> int

int
Epetra_VbrMatrix::ReplaceDiagonalValues(const Epetra_Vector &Diagonal)

Replaces diagonal values of the with those in the user-provided
vector.

This routine is meant to allow replacement of { existing} diagonal
values. If a diagonal value does not exist for a given row, the
corresponding value in the input Epetra_Vector will be ignored and the
return code will be set to 1.

The Epetra_Map associated with the input Epetra_Vector must be
compatible with the RowMap of the matrix.

Parameters:
-----------

Diagonal:  (In) - New values to be placed in the main diagonal.

Integer error code, set to 0 if successful, 1 of one or more diagonal
entries not present in matrix.

def PyTrilinos.Epetra.VbrMatrix.RightScale	(	self,
		args
	)

RightScale(VbrMatrix self, Epetra_Vector x) -> int

int
Epetra_VbrMatrix::RightScale(const Epetra_Vector &x)

Scales the Epetra_VbrMatrix on the right with a Epetra_Vector x.

The this matrix will be scaled such that A(i,j) = x(j)*A(i,j) where i
denotes the global row number of A and j denotes the global column
number of A.

Parameters:
-----------

In:  x -The Epetra_Vector used for scaling this.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.RowMap	(	self,
		args
	)

RowMap(VbrMatrix self) -> BlockMap

const
Epetra_BlockMap& Epetra_VbrMatrix::RowMap() const

Returns the RowMap object as an Epetra_BlockMap (the Epetra_Map base
class) needed for implementing Epetra_RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.RowMatrixColMap	(	self,
		args
	)

RowMatrixColMap(VbrMatrix self) -> Map

const
Epetra_Map& Epetra_VbrMatrix::RowMatrixColMap() const

Returns the Epetra_Map object associated with columns of this matrix.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.RowMatrixImporter	(	self,
		args
	)

RowMatrixImporter(VbrMatrix self) -> Import

const
Epetra_Import* Epetra_VbrMatrix::RowMatrixImporter() const

Returns the Epetra_Import object that contains the import operations
for distributed operations.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.RowMatrixRowMap	(	self,
		args
	)

RowMatrixRowMap(VbrMatrix self) -> Map

const
Epetra_Map& Epetra_VbrMatrix::RowMatrixRowMap() const

Returns the EpetraMap object associated with the rows of this matrix.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.Scale	(	self,
		args
	)

Scale(VbrMatrix self, double ScalarConstant) -> int

int
Epetra_VbrMatrix::Scale(double ScalarConstant)

Multiply all values in the matrix by a constant value (in place: A <-
ScalarConstant * A).

Parameters:
-----------

In:  ScalarConstant - Value to use.

Integer error code, set to 0 if successful.

def PyTrilinos.Epetra.VbrMatrix.SetUseTranspose	(	self,
		args
	)

SetUseTranspose(VbrMatrix self, bool UseTranspose_in) -> int

int
Epetra_VbrMatrix::SetUseTranspose(bool UseTranspose_in)

If set true, transpose of this operator will be applied.

This flag allows the transpose of the given operator to be used
implicitly. Setting this flag affects only the Apply() and
ApplyInverse() methods. If the implementation of this interface does
not support transpose use, this method should return a value of -1.

Parameters:
-----------

In:  UseTranspose -If true, multiply by the transpose of operator,
otherwise just use operator.

Always returns 0.

Reimplemented from PyTrilinos.Epetra.Operator.

def PyTrilinos.Epetra.VbrMatrix.Solve	(	self,
		args
	)

Solve(VbrMatrix self, bool Upper, bool Trans, bool UnitDiagonal, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_VbrMatrix::Solve(bool Upper, bool Trans, bool UnitDiagonal,
const Epetra_MultiVector &X, Epetra_MultiVector &Y) const

Returns the result of a Epetra_VbrMatrix multiplied by a
Epetra_MultiVector X in Y.

Parameters:
-----------

In:  Upper -If true, solve Ux = y, otherwise solve Lx = y.

In:  Trans -If true, solve transpose problem.

In:  UnitDiagonal -If true, assume diagonal is unit (whether it's
stored or not).

In:  X - A Epetra_MultiVector of dimension NumVectors to solve for.

Out:  Y -A Epetra_MultiVector of dimension NumVectors containing
result.

Integer error code, set to 0 if successful.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.StorageOptimized	(	self,
		args
	)

StorageOptimized(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::StorageOptimized() const

If OptimizeStorage() has been called, this query returns true,
otherwise it returns false.

def PyTrilinos.Epetra.VbrMatrix.SubmitBlockEntry	(	self,
		args
	)

SubmitBlockEntry(VbrMatrix self, double * Values, int LDA, int NumRows, int NumCols) -> int
SubmitBlockEntry(VbrMatrix self, Epetra_SerialDenseMatrix Mat) -> int

int
Epetra_VbrMatrix::SubmitBlockEntry(Epetra_SerialDenseMatrix &Mat)

Submit a block entry to the indicated block row and column specified
in the Begin routine.

Reimplemented in PyTrilinos.Epetra.FEVbrMatrix.

def PyTrilinos.Epetra.VbrMatrix.TransformToLocal	(	self,
		args
	)

TransformToLocal(VbrMatrix self) -> int
TransformToLocal(VbrMatrix self, BlockMap DomainMap, BlockMap RangeMap) -> int

int
Epetra_VbrMatrix::TransformToLocal(const Epetra_BlockMap *DomainMap,
const Epetra_BlockMap *RangeMap)

Use FillComplete(const Epetra_BlockMap& DomainMap, const
Epetra_BlockMap& RangeMap) instead.

def PyTrilinos.Epetra.VbrMatrix.UpperTriangular	(	self,
		args
	)

UpperTriangular(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::UpperTriangular() const

If matrix is upper triangular in local index space, this query returns
true, otherwise it returns false.

Reimplemented from PyTrilinos.Epetra.RowMatrix.

def PyTrilinos.Epetra.VbrMatrix.UseTranspose	(	self,
		args
	)

UseTranspose(VbrMatrix self) -> bool

bool
Epetra_VbrMatrix::UseTranspose() const

Returns the current UseTranspose setting.

Reimplemented from PyTrilinos.Epetra.Operator.

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

Epetra.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation