Inheritance diagram for PyTrilinos.NOX.Epetra.CrsMatrix:

Collaboration diagram for PyTrilinos.NOX.Epetra.CrsMatrix:

Public Member Functions
def	PutScalar
def	Scale
def	ReplaceDiagonalValues
def	FillComplete
def	OptimizeStorage
def	MakeDataContiguous
def	ExtractDiagonalCopy
def	Multiply
def	Multiply1
def	Solve
def	InvRowSums
def	InvRowMaxs
def	LeftScale
def	InvColSums
def	InvColMaxs
def	RightScale
def	Filled
def	StorageOptimized
def	IndicesAreGlobal
def	IndicesAreLocal
def	IndicesAreContiguous
def	LowerTriangular
def	UpperTriangular
def	NoDiagonal
def	NormInf
def	NormOne
def	NormFrobenius
def	NumGlobalNonzeros
def	NumGlobalNonzeros64
def	NumGlobalRows
def	NumGlobalRows64
def	NumGlobalCols
def	NumGlobalCols64
def	NumGlobalDiagonals
def	NumGlobalDiagonals64
def	NumMyNonzeros
def	NumMyRows
def	NumMyCols
def	NumMyDiagonals
def	NumGlobalEntries
def	NumAllocatedGlobalEntries
def	MaxNumEntries
def	GlobalMaxNumEntries
def	NumMyEntries
def	NumAllocatedMyEntries
def	IndexBase
def	StaticGraph
def	Graph
def	RowMap
def	ReplaceRowMap
def	HaveColMap
def	ReplaceColMap
def	ColMap
def	DomainMap
def	RangeMap
def	Importer
def	Exporter
def	Comm
def	LRID
def	GRID
def	GRID64
def	LCID
def	GCID
def	GCID64
def	MyGRID
def	MyLRID
def	MyGCID
def	MyLCID
def	MyGlobalRow
def	Label
def	SetUseTranspose
def	Apply
def	ApplyInverse
def	HasNormInf
def	UseTranspose
def	OperatorDomainMap
def	OperatorRangeMap
def	NumMyRowEntries
def	Map
def	RowMatrixRowMap
def	RowMatrixColMap
def	RowMatrixImporter
def	SortGhostsAssociatedWithEachProcessor
def	ImportMap
def	TransformToLocal
def	InsertGlobalValues
def	ReplaceGlobalValues
def	SumIntoGlobalValues
def	InsertMyValues
def	ReplaceMyValues
def	SumIntoMyValues
def	__init__
def	ExtractGlobalRowCopy
def	ExtractMyRowCopy
def	__setitem__
def	__getitem__
Public Attributes
	this

Detailed Description

Proxy of C++ Epetra_CrsMatrix class

Constructor & Destructor Documentation

def PyTrilinos.NOX.Epetra.CrsMatrix.__init__	(	self,
		args
	)

__init__(self, Epetra_DataAccess CV, Map rowMap, int numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with implicit column map and constant number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    numEntriesPerRow  - constant number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, Map rowMap, Map colMap, int numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with specified column map and constant number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    colMap            - describes distribution of columns across processors
    numEntriesPerRow  - constant number of entries per row
    staticProfile     - static profile flag

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

  CrsMatrix constructor with CrsGraph.  Arguments:

    CV     - Epetra.Copy or Epetra.View
    graph  - CrsGraph describing structure of matrix

__init__(self, CrsMatrix matrix) -> CrsMatrix

  CrsMatrix copy constructor.  Argument:

    matrix  - source CrsMatrix

__init__(self, Epetra_DataAccess CV, Map rowMap, PySequence numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with implicit column map and variable number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    numEntriesPerRow  - variable number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, Map rowMap, Map colMap, PySequence
    numEntriesPerRow, bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with specified column map and variable number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    colMap            - describes distribution of columns across processors
    numEntriesPerRow  - variable number of entries per row
    staticProfile     - static profile flag

Reimplemented from PyTrilinos.NOX.Epetra.CompObject.

Reimplemented in PyTrilinos.NOX.Epetra.FECrsMatrix.

Member Function Documentation

def PyTrilinos.NOX.Epetra.CrsMatrix.__getitem__	(	self,
		args
	)

__getitem__(self, PyTuple index) -> double
__getitem__(self, int row) -> numpy.ndarray

The __getitem__() method is called when square-bracket indexing is
used to get a value from the matrix.  For example, the last two lines
of::

    comm = Epetra.SerialComm()
    m = Epetra.CrsMatrix(9,0,comm)
    m.InsertGlobalValues(0, [0.0, 1.0, 2.0], [0,1,2])
    diag = m[0,0]
    row  = m[0]

call::

    m.__getitem__((0,0))
    m.__getitem__(0)

The __getitem__() method behaves according to the following table:

            FillComplete()    #    
    Index               called      procs  Return value
    --------------  --------------  -----  ---------------------------
    single integer       true        any   numpy array of doubles
    single integer       false        1    numpy array of doubles
    single integer       false       >1    raise IndexError
    two integers         either      any   double

You should provide global IDs as the integer indices if FillComplete()
has been called.  If not, you should provide local IDs.  If you
reference a matrix element that is off-processor, __getitem__() will
raise an IndexError.

Under the covers, __getitem__() will call ExtractGlobalRowView() if
FillComplete() has been called, or ExtractMyRowView() if it has not.
If either of these return a non-zero return code, this is converted to
a python RuntimeError.  The resulting data is copied to the output
array.

Reimplemented in PyTrilinos.NOX.Epetra.FECrsMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.__setitem__	(	self,
		args
	)

__setitem__(self, PyTuple index, double val)

The __setitem__() method is called when square-bracket indexing is
used to set a value of the matrix.  For example, the last line of::

    comm = Epetra.SerialComm()
    m = Epetra.CrsMatrix(9,0,comm)
    m[0,0] = 3.14

calls::

    m.__setitem__((0,0), 3.14)

Thus, argument 'index' is a tuple filled with whatever indices you
give the square-bracket operator when setting.  For __setitem__(),
this raises an IndexError unless 'index' is a two-tuple of integers.
Argument 'val' must be convertible to a double.  Under the covers,
__setitem__() calls ReplaceGlobalValues() or InsertGlobalValues() as
necessary, so the indices are expected to be global IDs.  Note that if
you use __setitem__() to insert a new matrix element, you will need to
call FillComplete() again, whether or not you have called it before.

Reimplemented in PyTrilinos.NOX.Epetra.FECrsMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.Apply	(	self,
		args
	)

Apply(self, MultiVector x, MultiVector y) -> int

In C++, the Apply() method is pure virtual, thus intended to be
overridden by derived classes.  In python, cross-language polymorphism
is supported, and you are expected to derive classes from this base
class and redefine the Apply() method.  C++ code (e.g., AztecOO
solvers) can call back to your Apply() method as needed.  You must
support two arguments, labeled here MultiVector x and MultiVector y.
These will be converted from Epetra_MultiVector C++ objects to
numpy-hybrid Epetra.MultiVector objects before they are passed to you.
Thus, it is legal to use slice indexing and other numpy features to
compute y from x.

If application of your operator is successful, return 0; else return
some non-zero error code.

It is strongly suggested that you prevent Apply() from raising any
exceptions.  Accidental errors can be prevented by wrapping your code
in a try block:

    try:
# Your code goes here...
    except Exception, e:
print 'A python exception was raised by method Apply:'
print e
return -1

By returning a -1, you inform the calling routine that Apply() was
unsuccessful.

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

def PyTrilinos.NOX.Epetra.CrsMatrix.ApplyInverse	(	self,
		args
	)

ApplyInverse(self, MultiVector x, MultiVector y) -> int

In C++, the ApplyInverse() method is pure virtual, thus intended to be
overridden by derived classes.  In python, cross-language polymorphism
is supported, and you are expected to derive classes from this base
class and redefine the ApplyInverse() method.  C++ code (e.g., AztecOO
solvers) can call back to your ApplyInverse() method as needed.  You
must support two arguments, labeled here MultiVector x and MultiVector
y.  These will be converted from Epetra_MultiVector C++ objects to
numpy-hybrid Epetra.MultiVector objects before they are passed to you.
Thus, it is legal to use slice indexing and other numpy features to
compute y from x.

If application of your operator is successful, return 0; else return
some non-zero error code.

It is strongly suggested that you prevent ApplyInverse() from raising
any exceptions.  Accidental errors can be prevented by wrapping your
code in a try block:

    try:
# Your code goes here...
    except Exception, e:
print 'A python exception was raised by method ApplyInverse:'
print e
return -1

By returning a -1, you inform the calling routine that ApplyInverse()
was unsuccessful.

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

def PyTrilinos.NOX.Epetra.CrsMatrix.ColMap	(	self,
		args
	)

ColMap(CrsMatrix self) -> Map

def PyTrilinos.NOX.Epetra.CrsMatrix.Comm	(	self,
		args
	)

Comm(CrsMatrix self) -> Comm

Reimplemented from PyTrilinos.NOX.Epetra.DistObject.

def PyTrilinos.NOX.Epetra.CrsMatrix.DomainMap	(	self,
		args
	)

DomainMap(CrsMatrix self) -> Map

def PyTrilinos.NOX.Epetra.CrsMatrix.Exporter	(	self,
		args
	)

Exporter(CrsMatrix self) -> Export

def PyTrilinos.NOX.Epetra.CrsMatrix.ExtractDiagonalCopy	(	self,
		args
	)

ExtractDiagonalCopy(Vector diagonal) -> int

Argument diagonal is provided to you as a numpy-hybrid Epetra.Vector,
giving you access to the numpy interface in addition to the
Epetra_Vector C++ interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.ExtractGlobalRowCopy	(	self,
		args
	)

ExtractGlobalRowCopy(self, int globalRow) -> (numpy.ndarray,numpy.ndarray)

  Returns a two-tuple of numpy arrays of the same size; the first is
  an array of integers that represent the nonzero columns on the
  matrix; the second is an array of doubles that represent the values
  of the matrix entries.  The input argument is a global row index.

def PyTrilinos.NOX.Epetra.CrsMatrix.ExtractMyRowCopy	(	self,
		args
	)

ExtractMyRowCopy(self, int myRow) -> (numpy.ndarray,numpy.ndarray)

  Returns a two-tuple of numpy arrays of the same size; the first is
  an array of integers that represent the nonzero columns on the
  matrix; the second is an array of doubles that represent the values
  of the matrix entries.  The input argument is a local row index.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.FillComplete	(	self,
		args
	)

FillComplete(CrsMatrix self, bool OptimizeDataStorage=True) -> int
FillComplete(CrsMatrix self, Map DomainMap, Map RangeMap, bool OptimizeDataStorage=True) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.Filled	(	self,
		args
	)

Filled(CrsMatrix self) -> bool

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.GCID	(	self,
		args
	)

GCID(CrsMatrix self, int LCID_in) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.GCID64	(	self,
		args
	)

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

def PyTrilinos.NOX.Epetra.CrsMatrix.GlobalMaxNumEntries	(	self,
		args
	)

GlobalMaxNumEntries(CrsMatrix self) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.Graph	(	self,
		args
	)

Graph(CrsMatrix self) -> CrsGraph

def PyTrilinos.NOX.Epetra.CrsMatrix.GRID	(	self,
		args
	)

GRID(CrsMatrix self, int LRID_in) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.GRID64	(	self,
		args
	)

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

def PyTrilinos.NOX.Epetra.CrsMatrix.HasNormInf	(	self,
		args
	)

HasNormInf(CrsMatrix self) -> bool

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

def PyTrilinos.NOX.Epetra.CrsMatrix.HaveColMap	(	self,
		args
	)

HaveColMap(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.Importer	(	self,
		args
	)

Importer(CrsMatrix self) -> Import

def PyTrilinos.NOX.Epetra.CrsMatrix.ImportMap	(	self,
		args
	)

ImportMap(CrsMatrix self) -> Map

def PyTrilinos.NOX.Epetra.CrsMatrix.IndexBase	(	self,
		args
	)

IndexBase(CrsMatrix self) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.IndicesAreContiguous	(	self,
		args
	)

IndicesAreContiguous(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.IndicesAreGlobal	(	self,
		args
	)

IndicesAreGlobal(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.IndicesAreLocal	(	self,
		args
	)

IndicesAreLocal(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.InsertGlobalValues	(	self,
		args
	)

InsertGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to insert
    indices   - a sequence of integers that represent the indices to insert

InsertGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to insert
    cols    - a sequence of integers that represent the column indices to
      insert
    values  - a sequence of doubles that represent the values to insert

Reimplemented in PyTrilinos.NOX.Epetra.FECrsMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.InsertMyValues	(	self,
		args
	)

InsertMyValues(CrsMatrix self, int MyRow, int NumEntries, double const * Values, int const * Indices) -> int
InsertMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to insert
    indices   - a sequence of integers that represent the indices to insert

InsertMyValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to insert
    cols    - a sequence of integers that represent the column indices to
      insert
    values  - a sequence of doubles that represent the values to insert

def PyTrilinos.NOX.Epetra.CrsMatrix.InvColMaxs	(	self,
		args
	)

InvColMaxs(CrsMatrix self, Epetra_Vector x) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.InvColSums	(	self,
		args
	)

InvColSums(Vector x) -> int

Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving
you access to the numpy interface in addition to the Epetra_Vector C++
interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.InvRowMaxs	(	self,
		args
	)

InvRowMaxs(CrsMatrix self, Epetra_Vector x) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.InvRowSums	(	self,
		args
	)

InvRowSums(Vector x) -> int

Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving
you access to the numpy interface in addition to the Epetra_Vector C++
interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.Label	(	self,
		args
	)

Label(CrsMatrix self) -> char const *

Reimplemented from PyTrilinos.NOX.Epetra.Object.

def PyTrilinos.NOX.Epetra.CrsMatrix.LCID	(	self,
		args
	)

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

def PyTrilinos.NOX.Epetra.CrsMatrix.LeftScale	(	self,
		args
	)

LeftScale(Vector x) -> int

Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving
you access to the numpy interface in addition to the Epetra_Vector C++
interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.LowerTriangular	(	self,
		args
	)

LowerTriangular(CrsMatrix self) -> bool

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.LRID	(	self,
		args
	)

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

def PyTrilinos.NOX.Epetra.CrsMatrix.MakeDataContiguous	(	self,
		args
	)

MakeDataContiguous(CrsMatrix self) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.Map	(	self,
		args
	)

Map(CrsMatrix self) -> BlockMap

Reimplemented from PyTrilinos.NOX.Epetra.DistObject.

def PyTrilinos.NOX.Epetra.CrsMatrix.MaxNumEntries	(	self,
		args
	)

MaxNumEntries(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.Multiply	(	self,
		args
	)

Multiply(bool useTranspose, MultiVector x, MultiVector y) -> int

In C++, arguments x and y are Epetra_MultiVectors.  In python, they
are provided to you as numpy-hybrid Epetra.MultiVectors, giving you
access to the numpy interface in addition to the Epetra_MultiVector
C++ interface.
Multiply(bool useTranspose, MultiVector x, MultiVector y) -> int

In C++, arguments x and y are Epetra_MultiVectors.  In python, they
are provided to you as numpy-hybrid Epetra.MultiVectors, giving you
access to the numpy interface in addition to the Epetra_MultiVector
C++ interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.Multiply1	(	self,
		args
	)

Multiply1(CrsMatrix self, bool TransA, Epetra_Vector x, Epetra_Vector y) -> int
Multiply1(CrsMatrix self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.MyGCID	(	self,
		args
	)

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

def PyTrilinos.NOX.Epetra.CrsMatrix.MyGlobalRow	(	self,
		args
	)

MyGlobalRow(CrsMatrix self, int GID) -> bool
MyGlobalRow(CrsMatrix self, long long GID) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.MyGRID	(	self,
		args
	)

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

def PyTrilinos.NOX.Epetra.CrsMatrix.MyLCID	(	self,
		args
	)

MyLCID(CrsMatrix self, int LCID_in) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.MyLRID	(	self,
		args
	)

MyLRID(CrsMatrix self, int LRID_in) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.NoDiagonal	(	self,
		args
	)

NoDiagonal(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.NormFrobenius	(	self,
		args
	)

NormFrobenius(CrsMatrix self) -> double

def PyTrilinos.NOX.Epetra.CrsMatrix.NormInf	(	self,
		args
	)

NormInf(CrsMatrix self) -> double

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NormOne	(	self,
		args
	)

NormOne(CrsMatrix self) -> double

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumAllocatedGlobalEntries	(	self,
		args
	)

NumAllocatedGlobalEntries(CrsMatrix self, int Row) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.NumAllocatedMyEntries	(	self,
		args
	)

NumAllocatedMyEntries(CrsMatrix self, int Row) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalCols	(	self,
		args
	)

NumGlobalCols(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalCols64	(	self,
		args
	)

NumGlobalCols64(CrsMatrix self) -> long long

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalDiagonals	(	self,
		args
	)

NumGlobalDiagonals(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalDiagonals64	(	self,
		args
	)

NumGlobalDiagonals64(CrsMatrix self) -> long long

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalEntries	(	self,
		args
	)

NumGlobalEntries(CrsMatrix self, long long Row) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalNonzeros	(	self,
		args
	)

NumGlobalNonzeros(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalNonzeros64	(	self,
		args
	)

NumGlobalNonzeros64(CrsMatrix self) -> long long

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalRows	(	self,
		args
	)

NumGlobalRows(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumGlobalRows64	(	self,
		args
	)

NumGlobalRows64(CrsMatrix self) -> long long

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumMyCols	(	self,
		args
	)

NumMyCols(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumMyDiagonals	(	self,
		args
	)

NumMyDiagonals(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumMyEntries	(	self,
		args
	)

NumMyEntries(CrsMatrix self, int Row) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.NumMyNonzeros	(	self,
		args
	)

NumMyNonzeros(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumMyRowEntries	(	self,
		args
	)

NumMyRowEntries(int myRow, numpy.ndarray numEntries) -> int

In C++, numEntries in an int&.  In python, it is provided to you as a
numpy array of length one so that you can set its value in-place using
numEntries[0] = ....

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.NumMyRows	(	self,
		args
	)

NumMyRows(CrsMatrix self) -> int

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.OperatorDomainMap	(	self,
		args
	)

OperatorDomainMap(CrsMatrix self) -> Map

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

def PyTrilinos.NOX.Epetra.CrsMatrix.OperatorRangeMap	(	self,
		args
	)

OperatorRangeMap(CrsMatrix self) -> Map

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

def PyTrilinos.NOX.Epetra.CrsMatrix.OptimizeStorage	(	self,
		args
	)

OptimizeStorage(CrsMatrix self) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.PutScalar	(	self,
		args
	)

PutScalar(CrsMatrix self, double ScalarConstant) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.RangeMap	(	self,
		args
	)

RangeMap(CrsMatrix self) -> Map

def PyTrilinos.NOX.Epetra.CrsMatrix.ReplaceColMap	(	self,
		args
	)

ReplaceColMap(CrsMatrix self, BlockMap newmap) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.ReplaceDiagonalValues	(	self,
		args
	)

ReplaceDiagonalValues(CrsMatrix self, Epetra_Vector Diagonal) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.ReplaceGlobalValues	(	self,
		args
	)

ReplaceGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to replace
    indices   - a sequence of integers that represent the indices to replace

ReplaceGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to replace
    cols    - a sequence of integers that represent the column indices to
      replace
    values  - a sequence of doubles that represent the values to replace

def PyTrilinos.NOX.Epetra.CrsMatrix.ReplaceMyValues	(	self,
		args
	)

ReplaceMyValues(CrsMatrix self, int MyRow, int NumEntries, double const * Values, int const * Indices) -> int
ReplaceMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to replace
    indices   - a sequence of integers that represent the indices to replace

ReplaceMyValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to replace
    cols    - a sequence of integers that represent the column indices to
      replace
    values  - a sequence of doubles that represent the values to replace

def PyTrilinos.NOX.Epetra.CrsMatrix.ReplaceRowMap	(	self,
		args
	)

ReplaceRowMap(CrsMatrix self, BlockMap newmap) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.RightScale	(	self,
		args
	)

RightScale(Vector x) -> int

Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving
you access to the numpy interface in addition to the Epetra_Vector C++
interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.RowMap	(	self,
		args
	)

RowMap(CrsMatrix self) -> Map

def PyTrilinos.NOX.Epetra.CrsMatrix.RowMatrixColMap	(	self,
		args
	)

RowMatrixColMap(CrsMatrix self) -> Map

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.RowMatrixImporter	(	self,
		args
	)

RowMatrixImporter(CrsMatrix self) -> Import

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.RowMatrixRowMap	(	self,
		args
	)

RowMatrixRowMap(CrsMatrix self) -> Map

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.Scale	(	self,
		args
	)

Scale(CrsMatrix self, double ScalarConstant) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.SetUseTranspose	(	self,
		args
	)

SetUseTranspose(CrsMatrix self, bool UseTranspose_in) -> int

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

def PyTrilinos.NOX.Epetra.CrsMatrix.Solve	(	self,
		args
	)

Solve((bool upper, bool trans, bool unitDiagonal, MultiVector x,
    MultiVector y) -> int

In C++, arguments x and y are Epetra_MultiVectors.  In python, they
are provided to you as numpy-hybrid Epetra.MultiVectors, giving you
access to the numpy interface in addition to the Epetra_MultiVector
C++ interface.
Solve((bool upper, bool trans, bool unitDiagonal, MultiVector x,
    MultiVector y) -> int

In C++, arguments x and y are Epetra_MultiVectors.  In python, they
are provided to you as numpy-hybrid Epetra.MultiVectors, giving you
access to the numpy interface in addition to the Epetra_MultiVector
C++ interface.

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.SortGhostsAssociatedWithEachProcessor	(	self,
		args
	)

SortGhostsAssociatedWithEachProcessor(CrsMatrix self, bool Flag) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.StaticGraph	(	self,
		args
	)

StaticGraph(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.StorageOptimized	(	self,
		args
	)

StorageOptimized(CrsMatrix self) -> bool

def PyTrilinos.NOX.Epetra.CrsMatrix.SumIntoGlobalValues	(	self,
		args
	)

SumIntoGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to sum into
    indices   - a sequence of integers that represent the indices to sum into

SumIntoGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to sum into
    cols    - a sequence of integers that represent the column indices to
      sum into
    values  - a sequence of doubles that represent the values to sum into

def PyTrilinos.NOX.Epetra.CrsMatrix.SumIntoMyValues	(	self,
		args
	)

SumIntoMyValues(CrsMatrix self, int MyRow, int NumEntries, double const * Values, int const * Indices) -> int
SumIntoMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to sum into
    indices   - a sequence of integers that represent the indices to sum into

SumIntoMyValues(CrsMatrix self, PyObject * Rows, PyObject * Cols, PyObject * Values) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.TransformToLocal	(	self,
		args
	)

TransformToLocal(CrsMatrix self) -> int
TransformToLocal(CrsMatrix self, Map DomainMap, Map RangeMap) -> int

def PyTrilinos.NOX.Epetra.CrsMatrix.UpperTriangular	(	self,
		args
	)

UpperTriangular(CrsMatrix self) -> bool

Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.

def PyTrilinos.NOX.Epetra.CrsMatrix.UseTranspose	(	self,
		args
	)

UseTranspose(CrsMatrix self) -> bool

Reimplemented from PyTrilinos.NOX.Epetra.Operator.

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

NOX/Epetra/__init__.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation