PyTrilinos::Epetra::CrsGraph Class Reference

Inheritance diagram for PyTrilinos::Epetra::CrsGraph:

Inheritance graph
[legend]
Collaboration diagram for PyTrilinos::Epetra::CrsGraph:

Collaboration graph
[legend]

List of all members.

Public Member Functions

def InsertGlobalIndices
def RemoveGlobalIndices
def InsertMyIndices
def RemoveMyIndices
def FillComplete
def OptimizeStorage
def Filled
def StorageOptimized
def IndicesAreGlobal
def IndicesAreLocal
def LowerTriangular
def UpperTriangular
def NoDiagonal
def MyGlobalRow
def HaveColMap
def NumMyRows
def NumGlobalRows
def NumMyCols
def NumGlobalCols
def NumGlobalNonzeros
def NumGlobalDiagonals
def NumMyDiagonals
def NumMyBlockRows
def NumGlobalBlockRows
def NumMyBlockCols
def NumGlobalBlockCols
def NumMyBlockDiagonals
def NumGlobalBlockDiagonals
def NumGlobalEntries
def NumMyEntries
def MaxRowDim
def GlobalMaxRowDim
def MaxColDim
def GlobalMaxColDim
def NumMyNonzeros
def NumGlobalIndices
def NumAllocatedGlobalIndices
def MaxNumIndices
def GlobalMaxNumIndices
def MaxNumNonzeros
def GlobalMaxNumNonzeros
def NumMyIndices
def NumAllocatedMyIndices
def IndexBase
def RowMap
def ReplaceRowMap
def ReplaceColMap
def ColMap
def DomainMap
def RangeMap
def Importer
def Exporter
def Comm
def LRID
def GRID
def LCID
def GCID
def MyGRID
def MyLRID
def MyGCID
def MyLCID
def PrintGraphData
def ImportMap
def TransformToLocal
def ReferenceCount
def DataPtr
def SortGhostsAssociatedWithEachProcessor
def __init__
def ExtractGlobalRowCopy
def __getitem__
def ExtractMyRowCopy
def InsertGlobalIndices
def RemoveGlobalIndices
def InsertMyIndices
def RemoveMyIndices
def FillComplete
def OptimizeStorage
def Filled
def StorageOptimized
def IndicesAreGlobal
def IndicesAreLocal
def LowerTriangular
def UpperTriangular
def NoDiagonal
def MyGlobalRow
def HaveColMap
def NumMyRows
def NumGlobalRows
def NumMyCols
def NumGlobalCols
def NumGlobalNonzeros
def NumGlobalDiagonals
def NumMyDiagonals
def NumMyBlockRows
def NumGlobalBlockRows
def NumMyBlockCols
def NumGlobalBlockCols
def NumMyBlockDiagonals
def NumGlobalBlockDiagonals
def NumGlobalEntries
def NumMyEntries
def MaxRowDim
def GlobalMaxRowDim
def MaxColDim
def GlobalMaxColDim
def NumMyNonzeros
def NumGlobalIndices
def NumAllocatedGlobalIndices
def MaxNumIndices
def GlobalMaxNumIndices
def MaxNumNonzeros
def GlobalMaxNumNonzeros
def NumMyIndices
def NumAllocatedMyIndices
def IndexBase
def RowMap
def ReplaceRowMap
def ReplaceColMap
def ColMap
def DomainMap
def RangeMap
def Importer
def Exporter
def Comm
def LRID
def GRID
def LCID
def GCID
def MyGRID
def MyLRID
def MyGCID
def MyLCID
def PrintGraphData
def ImportMap
def TransformToLocal
def ReferenceCount
def DataPtr
def SortGhostsAssociatedWithEachProcessor
def __init__
def ExtractGlobalRowCopy
def __getitem__
def ExtractMyRowCopy

Public Attributes

 this


Detailed Description

Epetra_CrsGraph: A class for constructing and using sparse compressed
row graphs.

Epetra_CrsGraph enables the piecewise construction and use of sparse
matrix graphs (the integer structure without values) where entries are
intended for row access.

Epetra_CrsGraph is an attribute of all Epetra row-based matrix
classes, defining their nonzero structure and also holding their
Epetra_Map attributes.

Constructing Epetra_CrsGraph objects

Constructing Epetra_CrsGraph objects is a multi-step process. The
basic steps are as follows: Create Epetra_CrsGraph instance, including
some initial storage, via constructor. In addition to the copy
constructor, Epetra_CrsGraph has four different constructors. All four
of these constructors have an argument, StaticProfile, which by
default is set to false. If it is set to true, then the profile (the
number of indices per row as defined by NumIndicesPerRow) will be
rigidly enforced. Although this takes away flexibility, it allows a
single array to be allocated for all indices. This decreases memory
fragmentation and improves performance across many operations. A more
detailed discussion of the StaticProfile option is found below. User-
provided row map, variable nonzero profile: This constructor is used
to define the row distribution of the graph and specify a varying
number of nonzero entries per row. It is best to use this constructor
when the user will be inserting entries using global index values and
wants every column index to be included in the graph. Note that in
this case, the column map will be built for the user when
FillComplete() is called. This constructor is also appropriate for
when there is a large variation in the number of indices per row. If
this is not the case, the next constructor may be more convenient to
use.

User-provided row map, fixed nonzero profile: This constructor is used
to define the row distribution of the graph and specify a fixed number
of nonzero entries per row. It is best to use this constructor when
the user will be inserting entries using global index values and wants
every column index to be included in the graph. Note that in this
case, the column map will be built for the user when FillComplete() is
called. This constructor is also appropriate for when there is little
or no variation in the number of indices per row.

User-provided row map, user-provided column map and variable nonzero
profile: This constructor is used to define the row and column
distribution of the graph, and specify a varying number of nonzero
entries per row. It is best to use this constructor when the user will
be inserting entries and already knows which columns of the matrix
should be included on each processor. Note that in this case, the
column map will not be built for the user when FillComplete() is
called. Also, if the user attempts to insert a column index whose GID
is not part of the column map on that process, the index will be
discarded. This property can be used to "filter out" column entries
that should be ignored. This constructor is also appropriate for when
there is a large variation in the number of indices per row. If this
is not the case, the next constructor may be more convenient to use.

User-provided row map, user-provided column map and fixed nonzero
profile: This constructor is used to define the row and column
distribution of the graph, and specify a fixed number of nonzero
entries per row. It is best to use this constructor when the user will
be inserting entries and already knows which columns of the matrix
should be included on each processor. Note that in this case, the
column map will not be built for the user when FillComplete() is
called. Also, if the user attempts to insert a column index whose GID
is not part of the column map on that process, the index will be
discarded. This constructor is also appropriate for when there is
little or no variation in the number of indices per row.

Enter row and column entry information via calls to the
InsertGlobalIndices method.

Complete construction via FillComplete call, which performs the
following tasks: Transforms indices to local index space (after this,
IndicesAreLocal()==true)

Sorts column-indices within each row

Compresses out any redundant indices within rows

Computes global data such as num-nonzeros, maximum row-lengths, etc.

(Optional) Optimize the graph storage via a call to OptimizeStorage.

Performance Enhancement Issues

The Epetra_CrsGraph class attempts to address four basic types of
situations, depending on the user's primary concern:

Simple, flexible construction over minimal memory use or control of
column indices: In this case the user wants to provide only a row
distribution of the graph and insert indices without worrying about
memory allocation performance. This type of user is best served by the
constructor that requires only a row map, and a fixed number of
indices per row. In fact, setting NumIndicesPerRow=0 is probably the
best option.

Stronger control over memory allocation performance and use over
flexibility and simplicity: In this case the user explicitly set
StaticProfile to true and will provide values, either a single global
int or an array of int's, for NumIndicesPerRow, such that the actual
number of indices submitted to the graph will not exceed the
estimates. Because we know that NumIndicesPerRow will not be exceeded,
we can pre-allocate all of the storage for the graph as a single
array. This is typically much more efficient.

Explicit control over column indices: In this case the user prescribes
the column map. Given the column map, any index that is submitted for
entry into the graph will be included only if they are present in the
list of GIDs for the column map on the processor that submits the
index. This feature allows the user to define a filter such that only
certain columns will be kept. The user also prescribes the local
ordering via this technique, since the ordering of GIDs in the column
map imposes the local ordering.

Construction using local indices only: In some situations, users may
want to build a graph using local index values only. In this case, the
user must explicitly assign GIDs. This is done by prescribing the
column map, in the same way as the previous situation.

Notes: In all but the most advanced uses, users will typically not
specify the column map. In other words, graph entries will be
submitted using GIDs not LIDs and all entries that are submitted are
intended to be inserted into the graph.

If a user is not particularly worried about performance, or really
needs the flexibility associated with the first situation, then there
is no need to explicitly manage the NumIndicesPerRow values or set
StaticProfile to true. In this case, it is best to set
NumIndicesPerRow to zero.

Users who are concerned about performance should carefully manage
NumIndicesPerRow and set StaticProfile to true. This will give the
best performance and use the least amount of memory.

A compromise approach would be to not set StaticProfile to true,
giving the user flexibility, but then calling OptimizeStorage() once
FillComplete() has been called. This approach requires additional
temporary memory because the graph will be copied into an efficient
data structure and the old memory deleted. However, once the copy has
been made, the resulting data structure is as efficient as when
StaticProfile is used.

Epetra_Map attributes

Epetra_CrsGraph objects have four Epetra_Map attributes.

The Epetra_Map attributes can be obtained via these accessor methods:
RowMap() Describes the numbering and distribution of the rows of the
graph. The row-map exists and is valid for the entire life of the
graph, having been passed in as a constructor argument. The set of
graph 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 graph. 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 the matrix operator. The range-map is
usually the same as the row-map. The range-map is set equal to the
row-map at graph 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.

Global versus Local indices

After creation and before FillComplete() has been called, the column-
indices of the graph are in the global space as received from the
user. One of the tasks performed by FillComplete() is to transform the
indices to a local index space. The query methods IndicesAreGlobal()
and IndicesAreLocal() return true or false depending on whether this
transformation has been performed or not.

Note the behavior of several graph methods:  InsertGlobalIndices()
returns an error if IndicesAreLocal()==true or
StorageOptimized()==true

InsertMyIndices() returns an error if IndicesAreGlobal()==true or
StorageOptimized()==true

RemoveGlobalIndices() returns an error if IndicesAreLocal()==true or
if graph was constructed in View mode

RemoveMyIndices() returns an error if IndicesAreGlobal()==true or if
graph was constructed in View mode

ExtractGlobalRowCopy() works regardless of state of indices

ExtractMyRowCopy() returns an error if IndicesAreGlobal()==true

ExtractGlobalRowView() returns an error if IndicesAreLocal()==true

ExtractMyRowView() returns an error if IndicesAreGlobal()==true

Note that even after a graph is constructed, it is possible to add or
remove entries. However, FillComplete must then be called again to
restore the graph to a consistent state.

C++ includes: Epetra_CrsGraph.h 

Member Function Documentation

def PyTrilinos::Epetra::CrsGraph::__getitem__ (   self,
  args 
)

__getitem__(self, int i) -> int

def PyTrilinos::Epetra::CrsGraph::__getitem__ (   self,
  args 
)

__getitem__(self, int i) -> int

def PyTrilinos::Epetra::CrsGraph::__init__ (   self,
  args 
)

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, int numIndicesPerRow,
    bool staticProfile=False) -> CrsGraph

  Constructor with implicit column map and constant indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    numIndicesPerRow  - Integer number of indices per row
    staticProfile     - Static profile flag

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, BlockMap colMap,
    int numIndicesPerRow, bool staticProfile=False) -> CrsGraph

  Constructor with specified column map and constant indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    colMap            - Map describing distribution of columns across processors
    numIndicesPerRow  - Integer number of indices per row
    staticProfile     - Static profile flag

__init__(self, CrsGraph graph) -> CrsGraph

  Copy constructor.  Arguments:

    graph - Source graph for copy constructor

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, PySequence
    numIndicesPerRow, bool staticProfile=False) -> CrsGraph

  Constructor with implicit column map and variable indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    numIndicesPerRow  - Sequence of integers representing the number of indices
                per row
    staticProfile     - Static profile flag

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, BlockMap colMap,
    PySequence numIndicesPerRow, bool staticProfile=False) -> CrsGraph

  Constructor with specified column map and variable indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    colMap            - Map describing distribution of columns across processors
    numIndicesPerRow  - Sequence of integers representing the number of indices
                per row
    staticProfile     - Static profile flag

Epetra_CrsGraph::Epetra_CrsGraph(const Epetra_CrsGraph &Graph)

Copy constructor.

This will create a Level 1 deep copy. This Graph will share ownership
of the CrsGraphData object with the right hand side Graph. 

Reimplemented from PyTrilinos::Epetra::Object.

def PyTrilinos::Epetra::CrsGraph::__init__ (   self,
  args 
)

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, int numIndicesPerRow,
    bool staticProfile=False) -> CrsGraph

  Constructor with implicit column map and constant indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    numIndicesPerRow  - Integer number of indices per row
    staticProfile     - Static profile flag

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, BlockMap colMap,
    int numIndicesPerRow, bool staticProfile=False) -> CrsGraph

  Constructor with specified column map and constant indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    colMap            - Map describing distribution of columns across processors
    numIndicesPerRow  - Integer number of indices per row
    staticProfile     - Static profile flag

__init__(self, CrsGraph graph) -> CrsGraph

  Copy constructor.  Arguments:

    graph - Source graph for copy constructor

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, PySequence
    numIndicesPerRow, bool staticProfile=False) -> CrsGraph

  Constructor with implicit column map and variable indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    numIndicesPerRow  - Sequence of integers representing the number of indices
                per row
    staticProfile     - Static profile flag

__init__(self, Epetra_DataAccess CV, BlockMap rowMap, BlockMap colMap,
    PySequence numIndicesPerRow, bool staticProfile=False) -> CrsGraph

  Constructor with specified column map and variable indices per row.
  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - Map describing distribution of rows across processors
    colMap            - Map describing distribution of columns across processors
    numIndicesPerRow  - Sequence of integers representing the number of indices
                per row
    staticProfile     - Static profile flag

Epetra_CrsGraph::Epetra_CrsGraph(const Epetra_CrsGraph &Graph)

Copy constructor.

This will create a Level 1 deep copy. This Graph will share ownership
of the CrsGraphData object with the right hand side Graph. 

Reimplemented from PyTrilinos::Epetra::Object.

def PyTrilinos::Epetra::CrsGraph::ColMap (   self,
  args 
)

ColMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::ColMap() const

Returns the Column Map associated with this graph.

HaveColMap()==true 

def PyTrilinos::Epetra::CrsGraph::ColMap (   self,
  args 
)

ColMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::ColMap() const

Returns the Column Map associated with this graph.

HaveColMap()==true 

def PyTrilinos::Epetra::CrsGraph::Comm (   self,
  args 
)

Comm(self) -> Comm

const Epetra_Comm&
Epetra_CrsGraph::Comm() const

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

Reimplemented from PyTrilinos::Epetra::DistObject.

def PyTrilinos::Epetra::CrsGraph::Comm (   self,
  args 
)

Comm(self) -> Comm

const Epetra_Comm&
Epetra_CrsGraph::Comm() const

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

Reimplemented from PyTrilinos::Epetra::DistObject.

def PyTrilinos::Epetra::CrsGraph::DataPtr (   self,
  args 
)

DataPtr(self) -> Epetra_CrsGraphData

const
Epetra_CrsGraphData* Epetra_CrsGraph::DataPtr() const

Returns a pointer to the CrsGraphData instance this CrsGraph uses.

(Intended for developer use only for testing purposes.) 

def PyTrilinos::Epetra::CrsGraph::DataPtr (   self,
  args 
)

DataPtr(self) -> Epetra_CrsGraphData

const
Epetra_CrsGraphData* Epetra_CrsGraph::DataPtr() const

Returns a pointer to the CrsGraphData instance this CrsGraph uses.

(Intended for developer use only for testing purposes.) 

def PyTrilinos::Epetra::CrsGraph::DomainMap (   self,
  args 
)

DomainMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::DomainMap() const

Returns the DomainMap associated with this graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::DomainMap (   self,
  args 
)

DomainMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::DomainMap() const

Returns the DomainMap associated with this graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::Exporter (   self,
  args 
)

Exporter(self) -> Export

const
Epetra_Export* Epetra_CrsGraph::Exporter() const

Returns the Exporter associated with this graph. 

def PyTrilinos::Epetra::CrsGraph::Exporter (   self,
  args 
)

Exporter(self) -> Export

const
Epetra_Export* Epetra_CrsGraph::Exporter() const

Returns the Exporter associated with this graph. 

def PyTrilinos::Epetra::CrsGraph::ExtractGlobalRowCopy (   self,
  args 
)

ExtractGlobalRowCopy(self, int globalRow) -> PyObject

int
Epetra_CrsGraph::ExtractGlobalRowCopy(int GlobalRow, int LenOfIndices,
int &NumIndices, int *Indices) const

Extract a list of elements in a specified global row of the graph. Put
into storage allocated by calling routine.

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

Row:  - (In) Global row number to get indices.

LenOfIndices:  - (In) Length of Indices array.

NumIndices:  - (Out) Number of Indices.

Indices:  - (Out) Global column indices corresponding to values.

Integer error code, set to 0 if successful. 

def PyTrilinos::Epetra::CrsGraph::ExtractGlobalRowCopy (   self,
  args 
)

ExtractGlobalRowCopy(self, int globalRow) -> PyObject

int
Epetra_CrsGraph::ExtractGlobalRowCopy(int GlobalRow, int LenOfIndices,
int &NumIndices, int *Indices) const

Extract a list of elements in a specified global row of the graph. Put
into storage allocated by calling routine.

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

Row:  - (In) Global row number to get indices.

LenOfIndices:  - (In) Length of Indices array.

NumIndices:  - (Out) Number of Indices.

Indices:  - (Out) Global column indices corresponding to values.

Integer error code, set to 0 if successful. 

def PyTrilinos::Epetra::CrsGraph::ExtractMyRowCopy (   self,
  args 
)

ExtractMyRowCopy(self, int localRow) -> PyObject

int
Epetra_CrsGraph::ExtractMyRowCopy(int LocalRow, int LenOfIndices, int
&NumIndices, int *Indices) const

Extract a list of elements in a specified local row of the graph. Put
into storage allocated by calling routine.

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

Row:  - (In) Local row number to get indices.

LenOfIndices:  - (In) Length of Indices array.

NumIndices:  - (Out) Number of Indices.

Indices:  - (Out) Local column indices corresponding to values.

Integer error code, set to 0 if successful.

IndicesAreLocal()==true 

def PyTrilinos::Epetra::CrsGraph::ExtractMyRowCopy (   self,
  args 
)

ExtractMyRowCopy(self, int localRow) -> PyObject

int
Epetra_CrsGraph::ExtractMyRowCopy(int LocalRow, int LenOfIndices, int
&NumIndices, int *Indices) const

Extract a list of elements in a specified local row of the graph. Put
into storage allocated by calling routine.

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

Row:  - (In) Local row number to get indices.

LenOfIndices:  - (In) Length of Indices array.

NumIndices:  - (Out) Number of Indices.

Indices:  - (Out) Local column indices corresponding to values.

Integer error code, set to 0 if successful.

IndicesAreLocal()==true 

def PyTrilinos::Epetra::CrsGraph::FillComplete (   self,
  args 
)

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

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

Transform to local index space using specified Domain/Range maps.
Perform other operations to allow optimal matrix operations.

Performs this sequence of operations: Transform indices to local index
space

Sort column-indices within each row

Compress out any redundant indices within rows

Compute global data such as num-nonzeros, maximum row-lengths, etc.

Integer error code, set to 0 if successful. Returns 1 if data is
shared (i.e., if the underlying graph-data object has a reference-
count greater than 1).

IndicesAreLocal()==true, Filled()==true 

def PyTrilinos::Epetra::CrsGraph::FillComplete (   self,
  args 
)

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

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

Transform to local index space using specified Domain/Range maps.
Perform other operations to allow optimal matrix operations.

Performs this sequence of operations: Transform indices to local index
space

Sort column-indices within each row

Compress out any redundant indices within rows

Compute global data such as num-nonzeros, maximum row-lengths, etc.

Integer error code, set to 0 if successful. Returns 1 if data is
shared (i.e., if the underlying graph-data object has a reference-
count greater than 1).

IndicesAreLocal()==true, Filled()==true 

def PyTrilinos::Epetra::CrsGraph::Filled (   self,
  args 
)

Filled(self) -> bool

bool
Epetra_CrsGraph::Filled() const

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

def PyTrilinos::Epetra::CrsGraph::Filled (   self,
  args 
)

Filled(self) -> bool

bool
Epetra_CrsGraph::Filled() const

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

def PyTrilinos::Epetra::CrsGraph::GCID (   self,
  args 
)

GCID(self, int LCID_in) -> int

int
Epetra_CrsGraph::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.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::GCID (   self,
  args 
)

GCID(self, int LCID_in) -> int

int
Epetra_CrsGraph::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.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxColDim (   self,
  args 
)

GlobalMaxColDim(self) -> int

int
Epetra_CrsGraph::GlobalMaxColDim() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxColDim (   self,
  args 
)

GlobalMaxColDim(self) -> int

int
Epetra_CrsGraph::GlobalMaxColDim() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxNumIndices (   self,
  args 
)

GlobalMaxNumIndices(self) -> int

int
Epetra_CrsGraph::GlobalMaxNumIndices() const

Returns the maximun number of nonzero entries across all rows across
all processors.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxNumIndices (   self,
  args 
)

GlobalMaxNumIndices(self) -> int

int
Epetra_CrsGraph::GlobalMaxNumIndices() const

Returns the maximun number of nonzero entries across all rows across
all processors.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxNumNonzeros (   self,
  args 
)

GlobalMaxNumNonzeros(self) -> int

int
Epetra_CrsGraph::GlobalMaxNumNonzeros() const

Returns the maximun number of nonzero points across all rows across
all processors.

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxNumNonzeros (   self,
  args 
)

GlobalMaxNumNonzeros(self) -> int

int
Epetra_CrsGraph::GlobalMaxNumNonzeros() const

Returns the maximun number of nonzero points across all rows across
all processors.

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxRowDim (   self,
  args 
)

GlobalMaxRowDim(self) -> int

int
Epetra_CrsGraph::GlobalMaxRowDim() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GlobalMaxRowDim (   self,
  args 
)

GlobalMaxRowDim(self) -> int

int
Epetra_CrsGraph::GlobalMaxRowDim() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::GRID (   self,
  args 
)

GRID(self, int LRID_in) -> int

int
Epetra_CrsGraph::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::CrsGraph::GRID (   self,
  args 
)

GRID(self, int LRID_in) -> int

int
Epetra_CrsGraph::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::CrsGraph::HaveColMap (   self,
  args 
)

HaveColMap(self) -> bool

bool
Epetra_CrsGraph::HaveColMap() const

Returns true if we have a well-defined ColMap, and returns false
otherwise.

We have a well-defined ColMap if a) a ColMap was passed in at
construction, or b) the MakeColMap function has been called. (Calling
either of the FillComplete functions will result in MakeColMap being
called.) 

def PyTrilinos::Epetra::CrsGraph::HaveColMap (   self,
  args 
)

HaveColMap(self) -> bool

bool
Epetra_CrsGraph::HaveColMap() const

Returns true if we have a well-defined ColMap, and returns false
otherwise.

We have a well-defined ColMap if a) a ColMap was passed in at
construction, or b) the MakeColMap function has been called. (Calling
either of the FillComplete functions will result in MakeColMap being
called.) 

def PyTrilinos::Epetra::CrsGraph::Importer (   self,
  args 
)

Importer(self) -> Import

const
Epetra_Import* Epetra_CrsGraph::Importer() const

Returns the Importer associated with this graph. 

def PyTrilinos::Epetra::CrsGraph::Importer (   self,
  args 
)

Importer(self) -> Import

const
Epetra_Import* Epetra_CrsGraph::Importer() const

Returns the Importer associated with this graph. 

def PyTrilinos::Epetra::CrsGraph::ImportMap (   self,
  args 
)

ImportMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::ImportMap() const

Use ColMap() instead. 

def PyTrilinos::Epetra::CrsGraph::ImportMap (   self,
  args 
)

ImportMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::ImportMap() const

Use ColMap() instead. 

def PyTrilinos::Epetra::CrsGraph::IndexBase (   self,
  args 
)

IndexBase(self) -> int

int
Epetra_CrsGraph::IndexBase() const

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

def PyTrilinos::Epetra::CrsGraph::IndexBase (   self,
  args 
)

IndexBase(self) -> int

int
Epetra_CrsGraph::IndexBase() const

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

def PyTrilinos::Epetra::CrsGraph::IndicesAreGlobal (   self,
  args 
)

IndicesAreGlobal(self) -> bool

bool
Epetra_CrsGraph::IndicesAreGlobal() const

If column indices are in global range, this query returns true,
otherwise it returns false. 

def PyTrilinos::Epetra::CrsGraph::IndicesAreGlobal (   self,
  args 
)

IndicesAreGlobal(self) -> bool

bool
Epetra_CrsGraph::IndicesAreGlobal() const

If column indices are in global range, this query returns true,
otherwise it returns false. 

def PyTrilinos::Epetra::CrsGraph::IndicesAreLocal (   self,
  args 
)

IndicesAreLocal(self) -> bool

bool
Epetra_CrsGraph::IndicesAreLocal() const

If column indices are in local range, this query returns true,
otherwise it returns false. 

def PyTrilinos::Epetra::CrsGraph::IndicesAreLocal (   self,
  args 
)

IndicesAreLocal(self) -> bool

bool
Epetra_CrsGraph::IndicesAreLocal() const

If column indices are in local range, this query returns true,
otherwise it returns false. 

def PyTrilinos::Epetra::CrsGraph::InsertGlobalIndices (   self,
  args 
)

InsertGlobalIndices(self, int globalRow, PySequence indices) -> int

Insert a sequence of global indices into the set of nonzero columns
for the specified global row.  Argument indices can be a numpy array
of integers or any python sequence that can be converted to a numpy
array of integers.  The integers represent global IDs that are to be
inserted into the graph.  An integer error/warning code is returned.


int
Epetra_CrsGraph::InsertGlobalIndices(int GlobalRow, int NumIndices,
int *Indices)

Enter a list of elements in a specified global row of the graph.

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

Row:  - (In) Global row number of indices.

NumIndices:  - (In) Number of Indices.

Indices:  - (In) Global column indices to insert.

Integer error code, set to 0 if successful. If the insertion requires
that additional memory be allocated for the row, a positive error code
of 1 is returned. If the graph is a 'View' mode graph, then a positive
warning code of 2 will be returned if the specified row already
exists. Returns 1 if underlying graph data is shared by multiple graph
instances.

IndicesAreGlobal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::InsertGlobalIndices (   self,
  args 
)

InsertGlobalIndices(self, int globalRow, PySequence indices) -> int

Insert a sequence of global indices into the set of nonzero columns
for the specified global row.  Argument indices can be a numpy array
of integers or any python sequence that can be converted to a numpy
array of integers.  The integers represent global IDs that are to be
inserted into the graph.  An integer error/warning code is returned.


int
Epetra_CrsGraph::InsertGlobalIndices(int GlobalRow, int NumIndices,
int *Indices)

Enter a list of elements in a specified global row of the graph.

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

Row:  - (In) Global row number of indices.

NumIndices:  - (In) Number of Indices.

Indices:  - (In) Global column indices to insert.

Integer error code, set to 0 if successful. If the insertion requires
that additional memory be allocated for the row, a positive error code
of 1 is returned. If the graph is a 'View' mode graph, then a positive
warning code of 2 will be returned if the specified row already
exists. Returns 1 if underlying graph data is shared by multiple graph
instances.

IndicesAreGlobal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::InsertMyIndices (   self,
  args 
)

InsertMyIndices(self, int localRow, PySequence indices) -> int

Insert a sequence of local indices into the set of nonzero columns for
the specified local row.  Argument indices can be a numpy array of
integers or any python sequence that can be converted to a numpy array
of integers.  The integers represent local IDs that are to be inserted
into the graph.  An integer error/warning code is returned.


int
Epetra_CrsGraph::InsertMyIndices(int LocalRow, int NumIndices, int
*Indices)

Enter a list of elements in a specified local row of the graph.

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

Row:  - (In) Local row number of indices.

NumIndices:  - (In) Number of Indices.

Indices:  - (In) Local column indices to insert.

Integer error code, set to 0 if successful. If the insertion requires
that additional memory be allocated for the row, a positive error code
of 1 is returned. If one or more of the indices is ignored (due to not
being contained in the column-map), then a positive warning code of 2
is returned. If the graph is a 'View' mode graph, then a positive
warning code of 3 will be returned if the specified row already
exists. Returns 1 if underlying graph data is shared by multiple graph
instances.

IndicesAreLocal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::InsertMyIndices (   self,
  args 
)

InsertMyIndices(self, int localRow, PySequence indices) -> int

Insert a sequence of local indices into the set of nonzero columns for
the specified local row.  Argument indices can be a numpy array of
integers or any python sequence that can be converted to a numpy array
of integers.  The integers represent local IDs that are to be inserted
into the graph.  An integer error/warning code is returned.


int
Epetra_CrsGraph::InsertMyIndices(int LocalRow, int NumIndices, int
*Indices)

Enter a list of elements in a specified local row of the graph.

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

Row:  - (In) Local row number of indices.

NumIndices:  - (In) Number of Indices.

Indices:  - (In) Local column indices to insert.

Integer error code, set to 0 if successful. If the insertion requires
that additional memory be allocated for the row, a positive error code
of 1 is returned. If one or more of the indices is ignored (due to not
being contained in the column-map), then a positive warning code of 2
is returned. If the graph is a 'View' mode graph, then a positive
warning code of 3 will be returned if the specified row already
exists. Returns 1 if underlying graph data is shared by multiple graph
instances.

IndicesAreLocal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::LCID (   self,
  args 
)

LCID(self, int GCID_in) -> int

int
Epetra_CrsGraph::LCID(int GCID_in) const

Returns the local column index for given global column index, returns
-1 if no local column for this global column.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::LCID (   self,
  args 
)

LCID(self, int GCID_in) -> int

int
Epetra_CrsGraph::LCID(int GCID_in) const

Returns the local column index for given global column index, returns
-1 if no local column for this global column.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::LowerTriangular (   self,
  args 
)

LowerTriangular(self) -> bool

bool
Epetra_CrsGraph::LowerTriangular() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::LowerTriangular (   self,
  args 
)

LowerTriangular(self) -> bool

bool
Epetra_CrsGraph::LowerTriangular() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::LRID (   self,
  args 
)

LRID(self, int GRID_in) -> int

int
Epetra_CrsGraph::LRID(int GRID_in) const

Returns the local row index for given global row index, returns -1 if
no local row for this global row. 

def PyTrilinos::Epetra::CrsGraph::LRID (   self,
  args 
)

LRID(self, int GRID_in) -> int

int
Epetra_CrsGraph::LRID(int GRID_in) const

Returns the local row index for given global row index, returns -1 if
no local row for this global row. 

def PyTrilinos::Epetra::CrsGraph::MaxColDim (   self,
  args 
)

MaxColDim(self) -> int

int
Epetra_CrsGraph::MaxColDim() const

Returns the max column dimension of block entries on the processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxColDim (   self,
  args 
)

MaxColDim(self) -> int

int
Epetra_CrsGraph::MaxColDim() const

Returns the max column dimension of block entries on the processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxNumIndices (   self,
  args 
)

MaxNumIndices(self) -> int

int
Epetra_CrsGraph::MaxNumIndices() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxNumIndices (   self,
  args 
)

MaxNumIndices(self) -> int

int
Epetra_CrsGraph::MaxNumIndices() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxNumNonzeros (   self,
  args 
)

MaxNumNonzeros(self) -> int

int
Epetra_CrsGraph::MaxNumNonzeros() const

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

For each entry in the graph, let i = the GRID of the entry and j = the
CGID of the entry. Then the entry size is the product of the rowmap
elementsize of i and the colmap elementsize of i. Let ki = sum of all
entry sizes for the entries in the ith row. For example, if the ith
block row had 5 block entries and the element size of each entry was
4-by-4, ki would be 80. Then this function returns the max over all ki
for all row on this processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxNumNonzeros (   self,
  args 
)

MaxNumNonzeros(self) -> int

int
Epetra_CrsGraph::MaxNumNonzeros() const

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

For each entry in the graph, let i = the GRID of the entry and j = the
CGID of the entry. Then the entry size is the product of the rowmap
elementsize of i and the colmap elementsize of i. Let ki = sum of all
entry sizes for the entries in the ith row. For example, if the ith
block row had 5 block entries and the element size of each entry was
4-by-4, ki would be 80. Then this function returns the max over all ki
for all row on this processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxRowDim (   self,
  args 
)

MaxRowDim(self) -> int

int
Epetra_CrsGraph::MaxRowDim() const

Returns the max row dimension of block entries on the processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MaxRowDim (   self,
  args 
)

MaxRowDim(self) -> int

int
Epetra_CrsGraph::MaxRowDim() const

Returns the max row dimension of block entries on the processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::MyGCID (   self,
  args 
)

MyGCID(self, int GCID_in) -> bool

bool
Epetra_CrsGraph::MyGCID(int GCID_in) const

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

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::MyGCID (   self,
  args 
)

MyGCID(self, int GCID_in) -> bool

bool
Epetra_CrsGraph::MyGCID(int GCID_in) const

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

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::MyGlobalRow (   self,
  args 
)

MyGlobalRow(self, int GID) -> bool

bool
Epetra_CrsGraph::MyGlobalRow(int GID) const

Returns true of GID is owned by the calling processor, otherwise it
returns false. 

def PyTrilinos::Epetra::CrsGraph::MyGlobalRow (   self,
  args 
)

MyGlobalRow(self, int GID) -> bool

bool
Epetra_CrsGraph::MyGlobalRow(int GID) const

Returns true of GID is owned by the calling processor, otherwise it
returns false. 

def PyTrilinos::Epetra::CrsGraph::MyGRID (   self,
  args 
)

MyGRID(self, int GRID_in) -> bool

bool
Epetra_CrsGraph::MyGRID(int GRID_in) const

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

def PyTrilinos::Epetra::CrsGraph::MyGRID (   self,
  args 
)

MyGRID(self, int GRID_in) -> bool

bool
Epetra_CrsGraph::MyGRID(int GRID_in) const

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

def PyTrilinos::Epetra::CrsGraph::MyLCID (   self,
  args 
)

MyLCID(self, int LCID_in) -> bool

bool
Epetra_CrsGraph::MyLCID(int LCID_in) const

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

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::MyLCID (   self,
  args 
)

MyLCID(self, int LCID_in) -> bool

bool
Epetra_CrsGraph::MyLCID(int LCID_in) const

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

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsGraph::MyLRID (   self,
  args 
)

MyLRID(self, int LRID_in) -> bool

bool
Epetra_CrsGraph::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::CrsGraph::MyLRID (   self,
  args 
)

MyLRID(self, int LRID_in) -> bool

bool
Epetra_CrsGraph::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::CrsGraph::NoDiagonal (   self,
  args 
)

NoDiagonal(self) -> bool

bool
Epetra_CrsGraph::NoDiagonal() const

If graph has no diagonal entries in global index space, this query
returns true, otherwise it returns false.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NoDiagonal (   self,
  args 
)

NoDiagonal(self) -> bool

bool
Epetra_CrsGraph::NoDiagonal() const

If graph has no diagonal entries in global index space, this query
returns true, otherwise it returns false.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumAllocatedGlobalIndices (   self,
  args 
)

NumAllocatedGlobalIndices(self, int Row) -> int

int Epetra_CrsGraph::NumAllocatedGlobalIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumAllocatedGlobalIndices (   self,
  args 
)

NumAllocatedGlobalIndices(self, int Row) -> int

int Epetra_CrsGraph::NumAllocatedGlobalIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumAllocatedMyIndices (   self,
  args 
)

NumAllocatedMyIndices(self, int Row) -> int

int
Epetra_CrsGraph::NumAllocatedMyIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumAllocatedMyIndices (   self,
  args 
)

NumAllocatedMyIndices(self, int Row) -> int

int
Epetra_CrsGraph::NumAllocatedMyIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumGlobalBlockCols (   self,
  args 
)

NumGlobalBlockCols(self) -> int

int
Epetra_CrsGraph::NumGlobalBlockCols() const

Returns the number of Block matrix columns in global matrix.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalBlockCols (   self,
  args 
)

NumGlobalBlockCols(self) -> int

int
Epetra_CrsGraph::NumGlobalBlockCols() const

Returns the number of Block matrix columns in global matrix.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalBlockDiagonals (   self,
  args 
)

NumGlobalBlockDiagonals(self) -> int

int
Epetra_CrsGraph::NumGlobalBlockDiagonals() const

Returns the number of Block diagonal entries in the global graph,
based on global row/column index comparisons.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalBlockDiagonals (   self,
  args 
)

NumGlobalBlockDiagonals(self) -> int

int
Epetra_CrsGraph::NumGlobalBlockDiagonals() const

Returns the number of Block diagonal entries in the global graph,
based on global row/column index comparisons.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalBlockRows (   self,
  args 
)

NumGlobalBlockRows(self) -> int

int
Epetra_CrsGraph::NumGlobalBlockRows() const

Returns the number of Block matrix rows in global matrix. 

def PyTrilinos::Epetra::CrsGraph::NumGlobalBlockRows (   self,
  args 
)

NumGlobalBlockRows(self) -> int

int
Epetra_CrsGraph::NumGlobalBlockRows() const

Returns the number of Block matrix rows in global matrix. 

def PyTrilinos::Epetra::CrsGraph::NumGlobalCols (   self,
  args 
)

NumGlobalCols(self) -> int

int
Epetra_CrsGraph::NumGlobalCols() const

Returns the number of matrix columns in global matrix.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalCols (   self,
  args 
)

NumGlobalCols(self) -> int

int
Epetra_CrsGraph::NumGlobalCols() const

Returns the number of matrix columns in global matrix.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalDiagonals (   self,
  args 
)

NumGlobalDiagonals(self) -> int

int
Epetra_CrsGraph::NumGlobalDiagonals() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalDiagonals (   self,
  args 
)

NumGlobalDiagonals(self) -> int

int
Epetra_CrsGraph::NumGlobalDiagonals() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalEntries (   self,
  args 
)

NumGlobalEntries(self) -> int

int
Epetra_CrsGraph::NumGlobalEntries() const

Returns the number of entries in the global graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalEntries (   self,
  args 
)

NumGlobalEntries(self) -> int

int
Epetra_CrsGraph::NumGlobalEntries() const

Returns the number of entries in the global graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalIndices (   self,
  args 
)

NumGlobalIndices(self, int Row) -> int

int
Epetra_CrsGraph::NumGlobalIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumGlobalIndices (   self,
  args 
)

NumGlobalIndices(self, int Row) -> int

int
Epetra_CrsGraph::NumGlobalIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumGlobalNonzeros (   self,
  args 
)

NumGlobalNonzeros(self) -> int

int
Epetra_CrsGraph::NumGlobalNonzeros() const

Returns the number of indices in the global graph.

Note that if the graph's maps are defined such that some nonzeros
appear on more than one processor, then those nonzeros will be counted
more than once. If the user wishes to assemble a graph from
overlapping data, they can use Epetra_FECrsGraph.  Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalNonzeros (   self,
  args 
)

NumGlobalNonzeros(self) -> int

int
Epetra_CrsGraph::NumGlobalNonzeros() const

Returns the number of indices in the global graph.

Note that if the graph's maps are defined such that some nonzeros
appear on more than one processor, then those nonzeros will be counted
more than once. If the user wishes to assemble a graph from
overlapping data, they can use Epetra_FECrsGraph.  Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumGlobalRows (   self,
  args 
)

NumGlobalRows(self) -> int

int
Epetra_CrsGraph::NumGlobalRows() const

Returns the number of matrix rows in global matrix. 

def PyTrilinos::Epetra::CrsGraph::NumGlobalRows (   self,
  args 
)

NumGlobalRows(self) -> int

int
Epetra_CrsGraph::NumGlobalRows() const

Returns the number of matrix rows in global matrix. 

def PyTrilinos::Epetra::CrsGraph::NumMyBlockCols (   self,
  args 
)

NumMyBlockCols(self) -> int

int
Epetra_CrsGraph::NumMyBlockCols() const

Returns the number of Block matrix columns on this processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyBlockCols (   self,
  args 
)

NumMyBlockCols(self) -> int

int
Epetra_CrsGraph::NumMyBlockCols() const

Returns the number of Block matrix columns on this processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyBlockDiagonals (   self,
  args 
)

NumMyBlockDiagonals(self) -> int

int
Epetra_CrsGraph::NumMyBlockDiagonals() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyBlockDiagonals (   self,
  args 
)

NumMyBlockDiagonals(self) -> int

int
Epetra_CrsGraph::NumMyBlockDiagonals() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyBlockRows (   self,
  args 
)

NumMyBlockRows(self) -> int

int
Epetra_CrsGraph::NumMyBlockRows() const

Returns the number of block matrix rows on this processor. 

def PyTrilinos::Epetra::CrsGraph::NumMyBlockRows (   self,
  args 
)

NumMyBlockRows(self) -> int

int
Epetra_CrsGraph::NumMyBlockRows() const

Returns the number of block matrix rows on this processor. 

def PyTrilinos::Epetra::CrsGraph::NumMyCols (   self,
  args 
)

NumMyCols(self) -> int

int
Epetra_CrsGraph::NumMyCols() const

Returns the number of entries in the set of column-indices that appear
on this processor.

The set of column-indices that appear on this processor is the union
of column-indices that appear in all local rows. The size of this set
isn't available until FillComplete() has been called.  Filled()==true

def PyTrilinos::Epetra::CrsGraph::NumMyCols (   self,
  args 
)

NumMyCols(self) -> int

int
Epetra_CrsGraph::NumMyCols() const

Returns the number of entries in the set of column-indices that appear
on this processor.

The set of column-indices that appear on this processor is the union
of column-indices that appear in all local rows. The size of this set
isn't available until FillComplete() has been called.  Filled()==true

def PyTrilinos::Epetra::CrsGraph::NumMyDiagonals (   self,
  args 
)

NumMyDiagonals(self) -> int

int
Epetra_CrsGraph::NumMyDiagonals() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyDiagonals (   self,
  args 
)

NumMyDiagonals(self) -> int

int
Epetra_CrsGraph::NumMyDiagonals() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyEntries (   self,
  args 
)

NumMyEntries(self) -> int

int
Epetra_CrsGraph::NumMyEntries() const

Returns the number of entries on this processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyEntries (   self,
  args 
)

NumMyEntries(self) -> int

int
Epetra_CrsGraph::NumMyEntries() const

Returns the number of entries on this processor.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyIndices (   self,
  args 
)

NumMyIndices(self, int Row) -> int

int
Epetra_CrsGraph::NumMyIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumMyIndices (   self,
  args 
)

NumMyIndices(self, int Row) -> int

int
Epetra_CrsGraph::NumMyIndices(int Row) const

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

def PyTrilinos::Epetra::CrsGraph::NumMyNonzeros (   self,
  args 
)

NumMyNonzeros(self) -> int

int
Epetra_CrsGraph::NumMyNonzeros() const

Returns the number of indices in the local graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyNonzeros (   self,
  args 
)

NumMyNonzeros(self) -> int

int
Epetra_CrsGraph::NumMyNonzeros() const

Returns the number of indices in the local graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::NumMyRows (   self,
  args 
)

NumMyRows(self) -> int

int
Epetra_CrsGraph::NumMyRows() const

Returns the number of matrix rows on this processor. 

def PyTrilinos::Epetra::CrsGraph::NumMyRows (   self,
  args 
)

NumMyRows(self) -> int

int
Epetra_CrsGraph::NumMyRows() const

Returns the number of matrix rows on this processor. 

def PyTrilinos::Epetra::CrsGraph::OptimizeStorage (   self,
  args 
)

OptimizeStorage(self) -> int

int
Epetra_CrsGraph::OptimizeStorage()

Make consecutive row index sections contiguous, minimize internal
storage used for constructing graph.

After construction and during initialization (when indices are being
added via InsertGlobalIndices() etc.), the column- indices for each
row are held in a separate piece of allocated memory. This method
moves the column-indices for all rows into one large contiguous array
and eliminates internal storage that is not needed after graph
construction. Calling this method can have a significant impact on
memory costs and machine performance.

If this object was constructed in View mode then this method can't
make non-contiguous indices contiguous and will return a warning code
of 1 if the viewed data isn't already contiguous. Integer error code,
set to 0 if successful.

Filled()==true.

If CV=View when the graph was constructed, then this method will be
effective  if the indices of the graph were already contiguous. In
this case, the indices are left untouched and internal storage for the
graph is minimized.

StorageOptimized()==true, if successful 

def PyTrilinos::Epetra::CrsGraph::OptimizeStorage (   self,
  args 
)

OptimizeStorage(self) -> int

int
Epetra_CrsGraph::OptimizeStorage()

Make consecutive row index sections contiguous, minimize internal
storage used for constructing graph.

After construction and during initialization (when indices are being
added via InsertGlobalIndices() etc.), the column- indices for each
row are held in a separate piece of allocated memory. This method
moves the column-indices for all rows into one large contiguous array
and eliminates internal storage that is not needed after graph
construction. Calling this method can have a significant impact on
memory costs and machine performance.

If this object was constructed in View mode then this method can't
make non-contiguous indices contiguous and will return a warning code
of 1 if the viewed data isn't already contiguous. Integer error code,
set to 0 if successful.

Filled()==true.

If CV=View when the graph was constructed, then this method will be
effective  if the indices of the graph were already contiguous. In
this case, the indices are left untouched and internal storage for the
graph is minimized.

StorageOptimized()==true, if successful 

def PyTrilinos::Epetra::CrsGraph::PrintGraphData (   self,
  args 
)

PrintGraphData(self, ostream os)
PrintGraphData(self, ostream os, int level)

void
Epetra_CrsGraph::PrintGraphData(ostream &os, int level) const 

def PyTrilinos::Epetra::CrsGraph::PrintGraphData (   self,
  args 
)

PrintGraphData(self, ostream os)
PrintGraphData(self, ostream os, int level)

void
Epetra_CrsGraph::PrintGraphData(ostream &os, int level) const 

def PyTrilinos::Epetra::CrsGraph::RangeMap (   self,
  args 
)

RangeMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::RangeMap() const

Returns the RangeMap associated with this graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::RangeMap (   self,
  args 
)

RangeMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::RangeMap() const

Returns the RangeMap associated with this graph.

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::ReferenceCount (   self,
  args 
)

ReferenceCount(self) -> int

int
Epetra_CrsGraph::ReferenceCount() const

Returns the reference count of CrsGraphData.

(Intended for testing purposes.) 

def PyTrilinos::Epetra::CrsGraph::ReferenceCount (   self,
  args 
)

ReferenceCount(self) -> int

int
Epetra_CrsGraph::ReferenceCount() const

Returns the reference count of CrsGraphData.

(Intended for testing purposes.) 

def PyTrilinos::Epetra::CrsGraph::RemoveGlobalIndices (   self,
  args 
)

RemoveGlobalIndices(self, int globalRow, PySequence indices) -> int

Remove a sequence of global indices from the set of nonzero columns
for the specified global row.  Argument indices can be a numpy array
of integers or any python sequence that can be converted to a numpy
array of integers.  The integers represent global IDs that are to be
removed from the graph.  An integer error/warning code is returned.

RemoveGlobalIndices(self, int Row) -> int

int
Epetra_CrsGraph::RemoveGlobalIndices(int Row)

Remove all indices from a specified global row of the graph.

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

Row:  - (In) Global row number of indices.

Integer error code, set to 0 if successful. Returns 1 if data is
shared.

IndicesAreGlobal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::RemoveGlobalIndices (   self,
  args 
)

RemoveGlobalIndices(self, int globalRow, PySequence indices) -> int

Remove a sequence of global indices from the set of nonzero columns
for the specified global row.  Argument indices can be a numpy array
of integers or any python sequence that can be converted to a numpy
array of integers.  The integers represent global IDs that are to be
removed from the graph.  An integer error/warning code is returned.

RemoveGlobalIndices(self, int Row) -> int

int
Epetra_CrsGraph::RemoveGlobalIndices(int Row)

Remove all indices from a specified global row of the graph.

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

Row:  - (In) Global row number of indices.

Integer error code, set to 0 if successful. Returns 1 if data is
shared.

IndicesAreGlobal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::RemoveMyIndices (   self,
  args 
)

RemoveMyIndices(self, int localRow, PySequence indices) -> int

Remove a sequence of local indices from the set of nonzero columns for
the specified local row.  Argument indices can be a numpy array of
integers or any python sequence that can be converted to a numpy array
of integers.  The integers represent local IDs that are to be removed
from the graph.  An integer error/warning code is returned.

RemoveMyIndices(self, int Row) -> int

int
Epetra_CrsGraph::RemoveMyIndices(int Row)

Remove all indices from a specified local row of the graph.

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

Row:  - (In) Local row number of indices.

Integer error code, set to 0 if successful. Returns 1 if data is
shared.

IndicesAreLocal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::RemoveMyIndices (   self,
  args 
)

RemoveMyIndices(self, int localRow, PySequence indices) -> int

Remove a sequence of local indices from the set of nonzero columns for
the specified local row.  Argument indices can be a numpy array of
integers or any python sequence that can be converted to a numpy array
of integers.  The integers represent local IDs that are to be removed
from the graph.  An integer error/warning code is returned.

RemoveMyIndices(self, int Row) -> int

int
Epetra_CrsGraph::RemoveMyIndices(int Row)

Remove all indices from a specified local row of the graph.

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

Row:  - (In) Local row number of indices.

Integer error code, set to 0 if successful. Returns 1 if data is
shared.

IndicesAreLocal()==true, StorageOptimized()==false 

def PyTrilinos::Epetra::CrsGraph::ReplaceColMap (   self,
  args 
)

ReplaceColMap(self, BlockMap newmap) -> int

int
Epetra_CrsGraph::ReplaceColMap(const Epetra_BlockMap &newmap)

Replaces the current ColMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

ColMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsGraph::ReplaceColMap (   self,
  args 
)

ReplaceColMap(self, BlockMap newmap) -> int

int
Epetra_CrsGraph::ReplaceColMap(const Epetra_BlockMap &newmap)

Replaces the current ColMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

ColMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsGraph::ReplaceRowMap (   self,
  args 
)

ReplaceRowMap(self, BlockMap newmap) -> int

int
Epetra_CrsGraph::ReplaceRowMap(const Epetra_BlockMap &newmap)

Replaces the current RowMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

RowMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsGraph::ReplaceRowMap (   self,
  args 
)

ReplaceRowMap(self, BlockMap newmap) -> int

int
Epetra_CrsGraph::ReplaceRowMap(const Epetra_BlockMap &newmap)

Replaces the current RowMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

RowMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsGraph::RowMap (   self,
  args 
)

RowMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::RowMap() const

Returns the RowMap associated with this graph. 

def PyTrilinos::Epetra::CrsGraph::RowMap (   self,
  args 
)

RowMap(self) -> BlockMap

const
Epetra_BlockMap& Epetra_CrsGraph::RowMap() const

Returns the RowMap associated with this graph. 

def PyTrilinos::Epetra::CrsGraph::SortGhostsAssociatedWithEachProcessor (   self,
  args 
)

SortGhostsAssociatedWithEachProcessor(self, bool Flag)

def PyTrilinos::Epetra::CrsGraph::SortGhostsAssociatedWithEachProcessor (   self,
  args 
)

SortGhostsAssociatedWithEachProcessor(self, bool Flag)

def PyTrilinos::Epetra::CrsGraph::StorageOptimized (   self,
  args 
)

StorageOptimized(self) -> bool

bool
Epetra_CrsGraph::StorageOptimized() const

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

def PyTrilinos::Epetra::CrsGraph::StorageOptimized (   self,
  args 
)

StorageOptimized(self) -> bool

bool
Epetra_CrsGraph::StorageOptimized() const

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

def PyTrilinos::Epetra::CrsGraph::TransformToLocal (   self,
  args 
)

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

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

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

def PyTrilinos::Epetra::CrsGraph::TransformToLocal (   self,
  args 
)

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

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

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

def PyTrilinos::Epetra::CrsGraph::UpperTriangular (   self,
  args 
)

UpperTriangular(self) -> bool

bool
Epetra_CrsGraph::UpperTriangular() const

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

Filled()==true 

def PyTrilinos::Epetra::CrsGraph::UpperTriangular (   self,
  args 
)

UpperTriangular(self) -> bool

bool
Epetra_CrsGraph::UpperTriangular() const

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

Filled()==true 


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

Generated on Thu Dec 17 11:00:21 2009 for PyTrilinos by  doxygen 1.5.9