PyTrilinos::Epetra::BlockMap Class Reference

Inheritance diagram for PyTrilinos::Epetra::BlockMap:

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

Collaboration graph
[legend]

List of all members.

Public Member Functions

def LID
def GID
def MyGID
def MyLID
def MinAllGID
def MaxAllGID
def MinMyGID
def MaxMyGID
def MinLID
def MaxLID
def NumGlobalElements
def NumMyElements
def ElementSize
def FirstPointInElement
def IndexBase
def NumGlobalPoints
def NumMyPoints
def MinMyElementSize
def MaxMyElementSize
def MinElementSize
def MaxElementSize
def UniqueGIDs
def ConstantElementSize
def SameAs
def PointSameAs
def LinearMap
def DistributedGlobal
def Comm
def IsOneToOne
def __init__
def RemoteIDList
def FindLocalElementID
def MyGlobalElements
def FirstPointInElementList
def ElementSizeList
def PointToElementList
def LID
def GID
def MyGID
def MyLID
def MinAllGID
def MaxAllGID
def MinMyGID
def MaxMyGID
def MinLID
def MaxLID
def NumGlobalElements
def NumMyElements
def ElementSize
def FirstPointInElement
def IndexBase
def NumGlobalPoints
def NumMyPoints
def MinMyElementSize
def MaxMyElementSize
def MinElementSize
def MaxElementSize
def UniqueGIDs
def ConstantElementSize
def SameAs
def PointSameAs
def LinearMap
def DistributedGlobal
def Comm
def IsOneToOne
def __init__
def RemoteIDList
def FindLocalElementID
def MyGlobalElements
def FirstPointInElementList
def ElementSizeList
def PointToElementList

Public Attributes

 this


Detailed Description

Epetra_BlockMap: A class for partitioning block element vectors and
matrices.

It is often the case that multiple matrix and vector objects have an
identical distribution of elements on a parallel machine. The
Epetra_BlockMap class keeps information that describes this
distribution for matrices and vectors that have block elements. The
definition of an element can vary depending on the situation. For
vectors (and multi-vectors), an element is a span of one or more
contiguous entries. For matrices, it is a span of one or more matrix
rows. More generally, an element in the BlockMap class is an ordered
list of points. (NOTE: Points do not have global ID's.) Two additional
definitions useful in understanding the BlockMap class follow:
BlockMap - A distributed ordered list of elements.

First Point - First ordered point in an element

This class has a variety of constructors that can be separated into
two categories: Fixed element size constructors: All map elements have
an identical size. This corresponds to a block partitioning of
matrices and vectors where the element size is the same for all
elements. A common example is multiple degrees of freedom per mesh
node in finite element computations where the number of degrees of
freedom is the same for all nodes.

Variable element size constructor: Map element sizes may vary and are
individually defined via a list of element sizes. This is the most
general case and corresponds to a variable block partitioning of the
matrices and vectors. A common example is multiple degrees of freedom
per mesh node in finite element computations where the number of
degrees of freedom varies. This happens, for example, if regions have
differing material types or there are chemical reactions in the
simulation.

Epetra_BlockMap allows the storage and retrieval of the following
information. Depending on the constructor that is used, some of the
information is defined by the user and some is determined by the
constructor. Once an Epetra_BlockMap is constructed any of the
following can be obtained by calling a query function that has the
same name as the attribute, e.g. to get the value of
NumGlobalElements, you can call a function NumGlobalElements(). For
attributes that are lists, the query functions return the list values
in a user allocated array.

NumGlobalElements - The total number of elements across all
processors. If this parameter and NumMyElements are both passed in to
the constructor, one of the three cases will apply: If
NumGlobalElements = NumMyElements (and not equal to zero) the map is
defined to be a local replicated map. In this case, objects
constructed using this map will be identically replicated across all
processors in the communicator.

If NumGlobalElements = -1 and NumMyElements is passed in then
NumGlobalElements will be computed as the sum of NumMyElements across
all processors.

If neither of the above is true, NumGlobalElements will be checked
against the sum of NumMyElements across all processors. An error is
issued if the comparison is not equal.

NumMyElements - The number of elements owned by the calling processor.

MyGlobalElements - A list of length NumMyElements that contains the
global element IDs of the elements owned by the calling processor.

ElementSize - The size of elements if the size of all elements is the
same. This will be the case if the query function
ConstantElementSize() returns true. Otherwise this value will be set
to zero.

ElementSizeList - A list of the element sizes for elements owned by
the calling processor. This list is always accessible, even if the
element sizes are all one or of constant value. However, in these
cases, the ElementSizeList will not be generated unless a query for
the list is called.

IndexBase - The base integer value for indexed array references.
Typically this is 0 for C/C++ and 1 for Fortran, but it can be set to
any integer value.

Comm - The Epetra_Comm communicator. This communicator can in turn be
queried for processor rank and size information.

In addition to the information above that is passed in to or created
by the Epetra_BlockMap constructor, the following attributes are
computed and available via query to the user using the same scheme as
above, e.g., use NumGlobalPoints() to get the value of
NumGlobalPoints.

NumGlobalPoints - The total number of points across all processors.

NumMyPoints - The number of points on the calling processor.

MinAllGID - The minimum global index value across all processors.

MaxAllGID - The maximum global index value across all processors.

MinMyGID - The minimum global index value on the calling processor.

MaxMyGID - The maximum global index value on the calling processor.

MinLID - The minimum local index value on the calling processor.

MaxLID - The maximum local index value on the calling processor.

MinElementSize - The minimum element size across all processors.

MaxElementSize - The maximum element size across all processors.

The following functions allow boolean tests for certain properties.

ConstantElementSize() - Returns true if the element size for this map
is the same for all elements.

LinearMap() - Returns true if the elements are distributed linear
across processors, i.e., processor 0 gets the first n/p elements,
processor 1 gets the next n/p elements, etc. where n is the number of
elements and p is the number of processors.

DistributedGlobal() - Returns true if the element space of the map
spans more than one processor. This will be true in most cases, but
will be false on in serial and for objects that are created via the
derived Epetra_LocalMap class.

WARNING:  A Epetra_Comm object is required for all Epetra_BlockMap
constructors.  {error handling}

Most methods in Epetra_BlockMap return an integer error code. If the
error code is 0, then no error occurred. If > 0 then a warning error
occurred. If < 0 then a fatal error occurred.

Epetra_BlockMap constructors will throw an exception of an error
occurrs. These exceptions will alway be negative integer values as
follows: -1 NumGlobalElements < -1. Should be >= -1 (Should be >= 0
for first BlockMap constructor).

-2 NumMyElements < 0. Should be >= 0.

-3 ElementSize <= 0. Should be > 0.

-4 Invalid NumGlobalElements. Should equal sum of MyGlobalElements, or
set to -1 to compute automatically.

-5 Minimum global element index is less than index base.

-99 Internal Epetra_BlockMap error. Contact developer.

For robust code, Epetra_BlockMap constructor calls should be caught
using the try {...} catch {...} mechanism. For example:

try {      Epetra_BlockMap * map = new
Epetra_BlockMap(NumGlobalElements, ElementSize, IndexBase, Comm);   }
catch (int Error) {     if (Error==-1) { // handle error }     if
(Error==-2) ...

{ In the current implementation, Epetra_BlockMap is the base class
for:  Epetra_Map.

Epetra_LocalBlockMap.  }

C++ includes: Epetra_BlockMap.h 

Member Function Documentation

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

__init__(self, int numGlobalElements, int elementSize, int indexBase,
     Comm comm) -> BlockMap

BlockMap constructor with implicit local elements and constant element
size.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     elementSize        - The number of degrees of freedom associated
                  with every element.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

__init__(self, int numGlobalElements, int numMyElements, int elementSize,
     int indexBase, Comm comm) -> BlockMap

BlockMap constructor with specified number of local elements and
constant element size.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     numMyElements      - Number of local elements on this processor.
     elementSize        - The number of degrees of freedom associated
                  with every element.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

__init__(self, int numGlobalElements, PySequence myGlobalElements,
     int elementSize, int indexBase, Comm comm) -> BlockMap

BlockMap constructor with specified list of local elements and
constant element size.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     myGlobalElements   - A sequence of integers specifying the global
                  element indexes on this processor.
     elementSize        - The number of degrees of freedom associated
                  with every element.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

__init__(self, BlockMap map) -> BlockMap

BlockMap copy constructor.

__init__(self, int numGlobalElements, PySequence myGlobalElements,
     PySequence elementsSizes, int indexBase, Comm comm) -> BlockMap

BlockMap constructor with specified list of local elements and
specified list of element sizes.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     myGlobalElements   - A sequence of integers specifying the global
                  element indexes on this processor.
     elementSizes       - A sequence of integers specifying the number of
                  degrees of freedom associated with each element
                  on this processor.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

Epetra_BlockMap::Epetra_BlockMap(const Epetra_BlockMap &map)

Epetra_BlockMap copy constructor. 

Reimplemented from PyTrilinos::Epetra::Object.

Reimplemented in PyTrilinos::Epetra::Map, PyTrilinos::Epetra::LocalMap, PyTrilinos::Epetra::Map, and PyTrilinos::Epetra::LocalMap.

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

__init__(self, int numGlobalElements, int elementSize, int indexBase,
     Comm comm) -> BlockMap

BlockMap constructor with implicit local elements and constant element
size.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     elementSize        - The number of degrees of freedom associated
                  with every element.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

__init__(self, int numGlobalElements, int numMyElements, int elementSize,
     int indexBase, Comm comm) -> BlockMap

BlockMap constructor with specified number of local elements and
constant element size.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     numMyElements      - Number of local elements on this processor.
     elementSize        - The number of degrees of freedom associated
                  with every element.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

__init__(self, int numGlobalElements, PySequence myGlobalElements,
     int elementSize, int indexBase, Comm comm) -> BlockMap

BlockMap constructor with specified list of local elements and
constant element size.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     myGlobalElements   - A sequence of integers specifying the global
                  element indexes on this processor.
     elementSize        - The number of degrees of freedom associated
                  with every element.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

__init__(self, BlockMap map) -> BlockMap

BlockMap copy constructor.

__init__(self, int numGlobalElements, PySequence myGlobalElements,
     PySequence elementsSizes, int indexBase, Comm comm) -> BlockMap

BlockMap constructor with specified list of local elements and
specified list of element sizes.  Arguments are:

     numGlobalElements  - Total number of elements over all processors.
                  Specify -1 to have the constructor compute
                  the number of global elements
     myGlobalElements   - A sequence of integers specifying the global
                  element indexes on this processor.
     elementSizes       - A sequence of integers specifying the number of
                  degrees of freedom associated with each element
                  on this processor.
     indexBase          - The base integer value for indexed array
                  references.  Typically this is 0 for C/C++ and 1
                  for Fortran, but it can be set to any integer
                  value.
     comm               - The Epetra.Comm communicator. This communicator
                  can in turn be queried for processor rank and
                  size information.

Epetra_BlockMap::Epetra_BlockMap(const Epetra_BlockMap &map)

Epetra_BlockMap copy constructor. 

Reimplemented from PyTrilinos::Epetra::Object.

Reimplemented in PyTrilinos::Epetra::Map, PyTrilinos::Epetra::LocalMap, PyTrilinos::Epetra::Map, and PyTrilinos::Epetra::LocalMap.

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

Comm(self) -> Comm

const Epetra_Comm&
Epetra_BlockMap::Comm() const

Access function for Epetra_Comm communicator. 

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

Comm(self) -> Comm

const Epetra_Comm&
Epetra_BlockMap::Comm() const

Access function for Epetra_Comm communicator. 

def PyTrilinos::Epetra::BlockMap::ConstantElementSize (   self,
  args 
)

ConstantElementSize(self) -> bool

bool
Epetra_BlockMap::ConstantElementSize() const

Returns true if map has constant element size. 

def PyTrilinos::Epetra::BlockMap::ConstantElementSize (   self,
  args 
)

ConstantElementSize(self) -> bool

bool
Epetra_BlockMap::ConstantElementSize() const

Returns true if map has constant element size. 

def PyTrilinos::Epetra::BlockMap::DistributedGlobal (   self,
  args 
)

DistributedGlobal(self) -> bool

bool
Epetra_BlockMap::DistributedGlobal() const

Returns true if map is defined across more than one processor. 

def PyTrilinos::Epetra::BlockMap::DistributedGlobal (   self,
  args 
)

DistributedGlobal(self) -> bool

bool
Epetra_BlockMap::DistributedGlobal() const

Returns true if map is defined across more than one processor. 

def PyTrilinos::Epetra::BlockMap::ElementSize (   self,
  args 
)

ElementSize(self) -> int
ElementSize(self, int LID) -> int

int
Epetra_BlockMap::ElementSize(int LID) const

Size of element for specified LID. 

def PyTrilinos::Epetra::BlockMap::ElementSize (   self,
  args 
)

ElementSize(self) -> int
ElementSize(self, int LID) -> int

int
Epetra_BlockMap::ElementSize(int LID) const

Size of element for specified LID. 

def PyTrilinos::Epetra::BlockMap::ElementSizeList (   self,
  args 
)

ElementSizeList(self) -> PyObject

Returns a numpy array of integer sizes for each local element.

def PyTrilinos::Epetra::BlockMap::ElementSizeList (   self,
  args 
)

ElementSizeList(self) -> PyObject

Returns a numpy array of integer sizes for each local element.

def PyTrilinos::Epetra::BlockMap::FindLocalElementID (   self,
  args 
)

FindLocalElementID(self, int pointID) -> PyObject

Returns a tuple containing the local ID of the element that contains
the given local pointID, and the offset of the point in that element.

def PyTrilinos::Epetra::BlockMap::FindLocalElementID (   self,
  args 
)

FindLocalElementID(self, int pointID) -> PyObject

Returns a tuple containing the local ID of the element that contains
the given local pointID, and the offset of the point in that element.

def PyTrilinos::Epetra::BlockMap::FirstPointInElement (   self,
  args 
)

FirstPointInElement(self, int LID) -> int

int
Epetra_BlockMap::FirstPointInElement(int LID) const

Returns the requested entry in the FirstPointInElementList; see
FirstPointInElementList() for details.

This function provides similar functionality to
FirstPointInElementList(), but for simple maps may avoid the explicit
construction of the FirstPointInElementList array. Returns -1 if LID
is out-of-range. 

def PyTrilinos::Epetra::BlockMap::FirstPointInElement (   self,
  args 
)

FirstPointInElement(self, int LID) -> int

int
Epetra_BlockMap::FirstPointInElement(int LID) const

Returns the requested entry in the FirstPointInElementList; see
FirstPointInElementList() for details.

This function provides similar functionality to
FirstPointInElementList(), but for simple maps may avoid the explicit
construction of the FirstPointInElementList array. Returns -1 if LID
is out-of-range. 

def PyTrilinos::Epetra::BlockMap::FirstPointInElementList (   self,
  args 
)

FirstPointInElementList(self) -> PyObject

Returns a numpy array of integer first local point numbers for all of
the local elements.

def PyTrilinos::Epetra::BlockMap::FirstPointInElementList (   self,
  args 
)

FirstPointInElementList(self) -> PyObject

Returns a numpy array of integer first local point numbers for all of
the local elements.

def PyTrilinos::Epetra::BlockMap::GID (   self,
  args 
)

GID(self, int LID) -> int

int
Epetra_BlockMap::GID(int LID) const

Returns global ID of local ID, return IndexBase-1 if not found on this
processor. 

def PyTrilinos::Epetra::BlockMap::GID (   self,
  args 
)

GID(self, int LID) -> int

int
Epetra_BlockMap::GID(int LID) const

Returns global ID of local ID, return IndexBase-1 if not found on this
processor. 

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

IndexBase(self) -> int

int
Epetra_BlockMap::IndexBase() const

Index base for this map. 

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

IndexBase(self) -> int

int
Epetra_BlockMap::IndexBase() const

Index base for this map. 

def PyTrilinos::Epetra::BlockMap::IsOneToOne (   self,
  args 
)

IsOneToOne(self) -> bool

bool
Epetra_BlockMap::IsOneToOne() const 

def PyTrilinos::Epetra::BlockMap::IsOneToOne (   self,
  args 
)

IsOneToOne(self) -> bool

bool
Epetra_BlockMap::IsOneToOne() const 

def PyTrilinos::Epetra::BlockMap::LID (   self,
  args 
)

LID(self, int GID) -> int

int
Epetra_BlockMap::LID(int GID) const

Returns local ID of global ID, return -1 if not found on this
processor. 

def PyTrilinos::Epetra::BlockMap::LID (   self,
  args 
)

LID(self, int GID) -> int

int
Epetra_BlockMap::LID(int GID) const

Returns local ID of global ID, return -1 if not found on this
processor. 

def PyTrilinos::Epetra::BlockMap::LinearMap (   self,
  args 
)

LinearMap(self) -> bool

bool
Epetra_BlockMap::LinearMap() const

Returns true if the global ID space is contiguously divided (but not
necessarily uniformly) across all processors. 

def PyTrilinos::Epetra::BlockMap::LinearMap (   self,
  args 
)

LinearMap(self) -> bool

bool
Epetra_BlockMap::LinearMap() const

Returns true if the global ID space is contiguously divided (but not
necessarily uniformly) across all processors. 

def PyTrilinos::Epetra::BlockMap::MaxAllGID (   self,
  args 
)

MaxAllGID(self) -> int

int
Epetra_BlockMap::MaxAllGID() const

Returns the maximum global ID across the entire map. 

def PyTrilinos::Epetra::BlockMap::MaxAllGID (   self,
  args 
)

MaxAllGID(self) -> int

int
Epetra_BlockMap::MaxAllGID() const

Returns the maximum global ID across the entire map. 

def PyTrilinos::Epetra::BlockMap::MaxElementSize (   self,
  args 
)

MaxElementSize(self) -> int

int
Epetra_BlockMap::MaxElementSize() const

Maximum element size across all processors. 

def PyTrilinos::Epetra::BlockMap::MaxElementSize (   self,
  args 
)

MaxElementSize(self) -> int

int
Epetra_BlockMap::MaxElementSize() const

Maximum element size across all processors. 

def PyTrilinos::Epetra::BlockMap::MaxLID (   self,
  args 
)

MaxLID(self) -> int

int
Epetra_BlockMap::MaxLID() const

The maximum local index value on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MaxLID (   self,
  args 
)

MaxLID(self) -> int

int
Epetra_BlockMap::MaxLID() const

The maximum local index value on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MaxMyElementSize (   self,
  args 
)

MaxMyElementSize(self) -> int

int
Epetra_BlockMap::MaxMyElementSize() const

Maximum element size on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MaxMyElementSize (   self,
  args 
)

MaxMyElementSize(self) -> int

int
Epetra_BlockMap::MaxMyElementSize() const

Maximum element size on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MaxMyGID (   self,
  args 
)

MaxMyGID(self) -> int

int
Epetra_BlockMap::MaxMyGID() const

Returns the maximum global ID owned by this processor. 

def PyTrilinos::Epetra::BlockMap::MaxMyGID (   self,
  args 
)

MaxMyGID(self) -> int

int
Epetra_BlockMap::MaxMyGID() const

Returns the maximum global ID owned by this processor. 

def PyTrilinos::Epetra::BlockMap::MinAllGID (   self,
  args 
)

MinAllGID(self) -> int

int
Epetra_BlockMap::MinAllGID() const

Returns the minimum global ID across the entire map. 

def PyTrilinos::Epetra::BlockMap::MinAllGID (   self,
  args 
)

MinAllGID(self) -> int

int
Epetra_BlockMap::MinAllGID() const

Returns the minimum global ID across the entire map. 

def PyTrilinos::Epetra::BlockMap::MinElementSize (   self,
  args 
)

MinElementSize(self) -> int

int
Epetra_BlockMap::MinElementSize() const

Minimum element size across all processors. 

def PyTrilinos::Epetra::BlockMap::MinElementSize (   self,
  args 
)

MinElementSize(self) -> int

int
Epetra_BlockMap::MinElementSize() const

Minimum element size across all processors. 

def PyTrilinos::Epetra::BlockMap::MinLID (   self,
  args 
)

MinLID(self) -> int

int
Epetra_BlockMap::MinLID() const

The minimum local index value on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MinLID (   self,
  args 
)

MinLID(self) -> int

int
Epetra_BlockMap::MinLID() const

The minimum local index value on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MinMyElementSize (   self,
  args 
)

MinMyElementSize(self) -> int

int
Epetra_BlockMap::MinMyElementSize() const

Minimum element size on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MinMyElementSize (   self,
  args 
)

MinMyElementSize(self) -> int

int
Epetra_BlockMap::MinMyElementSize() const

Minimum element size on the calling processor. 

def PyTrilinos::Epetra::BlockMap::MinMyGID (   self,
  args 
)

MinMyGID(self) -> int

int
Epetra_BlockMap::MinMyGID() const

Returns the maximum global ID owned by this processor. 

def PyTrilinos::Epetra::BlockMap::MinMyGID (   self,
  args 
)

MinMyGID(self) -> int

int
Epetra_BlockMap::MinMyGID() const

Returns the maximum global ID owned by this processor. 

def PyTrilinos::Epetra::BlockMap::MyGID (   self,
  args 
)

MyGID(self, int GID_in) -> bool

bool
Epetra_BlockMap::MyGID(int GID_in) const

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

def PyTrilinos::Epetra::BlockMap::MyGID (   self,
  args 
)

MyGID(self, int GID_in) -> bool

bool
Epetra_BlockMap::MyGID(int GID_in) const

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

def PyTrilinos::Epetra::BlockMap::MyGlobalElements (   self,
  args 
)

MyGlobalElements(self) -> PyObject

Returns a numpy array of integers specifying the list of global IDs on
the processor.

def PyTrilinos::Epetra::BlockMap::MyGlobalElements (   self,
  args 
)

MyGlobalElements(self) -> PyObject

Returns a numpy array of integers specifying the list of global IDs on
the processor.

def PyTrilinos::Epetra::BlockMap::MyLID (   self,
  args 
)

MyLID(self, int LID_in) -> bool

bool
Epetra_BlockMap::MyLID(int LID_in) const

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

def PyTrilinos::Epetra::BlockMap::MyLID (   self,
  args 
)

MyLID(self, int LID_in) -> bool

bool
Epetra_BlockMap::MyLID(int LID_in) const

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

def PyTrilinos::Epetra::BlockMap::NumGlobalElements (   self,
  args 
)

NumGlobalElements(self) -> int

int
Epetra_BlockMap::NumGlobalElements() const

Number of elements across all processors. 

def PyTrilinos::Epetra::BlockMap::NumGlobalElements (   self,
  args 
)

NumGlobalElements(self) -> int

int
Epetra_BlockMap::NumGlobalElements() const

Number of elements across all processors. 

def PyTrilinos::Epetra::BlockMap::NumGlobalPoints (   self,
  args 
)

NumGlobalPoints(self) -> int

int
Epetra_BlockMap::NumGlobalPoints() const

Number of global points for this map; equals the sum of all element
sizes across all processors. 

def PyTrilinos::Epetra::BlockMap::NumGlobalPoints (   self,
  args 
)

NumGlobalPoints(self) -> int

int
Epetra_BlockMap::NumGlobalPoints() const

Number of global points for this map; equals the sum of all element
sizes across all processors. 

def PyTrilinos::Epetra::BlockMap::NumMyElements (   self,
  args 
)

NumMyElements(self) -> int

int
Epetra_BlockMap::NumMyElements() const

Number of elements on the calling processor. 

def PyTrilinos::Epetra::BlockMap::NumMyElements (   self,
  args 
)

NumMyElements(self) -> int

int
Epetra_BlockMap::NumMyElements() const

Number of elements on the calling processor. 

def PyTrilinos::Epetra::BlockMap::NumMyPoints (   self,
  args 
)

NumMyPoints(self) -> int

int
Epetra_BlockMap::NumMyPoints() const

Number of local points for this map; equals the sum of all element
sizes on the calling processor. 

def PyTrilinos::Epetra::BlockMap::NumMyPoints (   self,
  args 
)

NumMyPoints(self) -> int

int
Epetra_BlockMap::NumMyPoints() const

Number of local points for this map; equals the sum of all element
sizes on the calling processor. 

def PyTrilinos::Epetra::BlockMap::PointSameAs (   self,
  args 
)

PointSameAs(self, BlockMap Map) -> bool

bool
Epetra_BlockMap::PointSameAs(const Epetra_BlockMap &Map) const

Returns true if this and Map have identical point-wise structure.

If both maps have the same number of global points and the same point
distribution across processors then this method returns true. 

def PyTrilinos::Epetra::BlockMap::PointSameAs (   self,
  args 
)

PointSameAs(self, BlockMap Map) -> bool

bool
Epetra_BlockMap::PointSameAs(const Epetra_BlockMap &Map) const

Returns true if this and Map have identical point-wise structure.

If both maps have the same number of global points and the same point
distribution across processors then this method returns true. 

def PyTrilinos::Epetra::BlockMap::PointToElementList (   self,
  args 
)

PointToElementList(self) -> PyObject

Returns a numpy array of integers such that for each local point, it
indicates the local element ID that the point belongs to.

def PyTrilinos::Epetra::BlockMap::PointToElementList (   self,
  args 
)

PointToElementList(self) -> PyObject

Returns a numpy array of integers such that for each local point, it
indicates the local element ID that the point belongs to.

def PyTrilinos::Epetra::BlockMap::RemoteIDList (   self,
  args 
)

RemoteIDList(self, PyObject GIDList) -> PyObject

``GIDList`` is a sequence of integer global IDs, and the return
argument is the three-tuple ``(PIDList, LIDList, sizeList)``, which
are ``numpy.ndarray`` objects of integers representing the processor
IDs, local IDs and element sizes, respectively.

def PyTrilinos::Epetra::BlockMap::RemoteIDList (   self,
  args 
)

RemoteIDList(self, PyObject GIDList) -> PyObject

``GIDList`` is a sequence of integer global IDs, and the return
argument is the three-tuple ``(PIDList, LIDList, sizeList)``, which
are ``numpy.ndarray`` objects of integers representing the processor
IDs, local IDs and element sizes, respectively.

def PyTrilinos::Epetra::BlockMap::SameAs (   self,
  args 
)

SameAs(self, BlockMap Map) -> bool

bool
Epetra_BlockMap::SameAs(const Epetra_BlockMap &Map) const

Returns true if this and Map are identical maps. 

def PyTrilinos::Epetra::BlockMap::SameAs (   self,
  args 
)

SameAs(self, BlockMap Map) -> bool

bool
Epetra_BlockMap::SameAs(const Epetra_BlockMap &Map) const

Returns true if this and Map are identical maps. 

def PyTrilinos::Epetra::BlockMap::UniqueGIDs (   self,
  args 
)

UniqueGIDs(self) -> bool

bool
Epetra_BlockMap::UniqueGIDs() const

Returns true if map GIDs are 1-to-1.

Certain operations involving Epetra_BlockMap and Epetra_Map objects
are well-defined only if the map GIDs are uniquely present in the map.
In other words, if a GID occurs in the map, it occurs only once on a
single processor and nowhere else. This boolean test returns true if
this property is true, otherwise it returns false. 

def PyTrilinos::Epetra::BlockMap::UniqueGIDs (   self,
  args 
)

UniqueGIDs(self) -> bool

bool
Epetra_BlockMap::UniqueGIDs() const

Returns true if map GIDs are 1-to-1.

Certain operations involving Epetra_BlockMap and Epetra_Map objects
are well-defined only if the map GIDs are uniquely present in the map.
In other words, if a GID occurs in the map, it occurs only once on a
single processor and nowhere else. This boolean test returns true if
this property is true, otherwise it returns false. 


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

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