PyTrilinos.Epetra.Import Class Reference

Inheritance diagram for PyTrilinos.Epetra.Import:

Collaboration diagram for PyTrilinos.Epetra.Import:

List of all members.

Public Member Functions
def	__init__
def	NumSameIDs
def	NumPermuteIDs
def	NumRemoteIDs
def	NumExportIDs
def	NumSend
def	NumRecv
def	SourceMap
def	TargetMap
def	Distributor
def	PermuteFromLIDs
def	PermuteToLIDs
def	RemoteLIDs
def	ExportLIDs
def	ExportPIDs
Public Attributes
	this

---

Detailed Description

Epetra_Import: This class builds an import object for efficient
importing of off- processor elements.

Epetra_Import is used to construct a communication plan that can be
called repeatedly by computational classes such the Epetra matrix,
vector and multivector classes to efficiently obtain off-processor
elements.

This class currently has one constructor, taking two Epetra_Map or
Epetra_BlockMap objects. The first map specifies the global IDs of
elements that we want to import later. The second map specifies the
global IDs that are owned by the calling processor.

C++ includes: Epetra_Import.h 

---

Constructor & Destructor Documentation

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

__init__(Epetra_Import self, BlockMap TargetMap, BlockMap SourceMap) -> Import
__init__(Epetra_Import self, Import Importer) -> Import

Epetra_Import::Epetra_Import(const Epetra_Import &Importer)

Epetra_Import copy constructor. 

Reimplemented from PyTrilinos.Epetra.Object.

---

Member Function Documentation

def PyTrilinos.Epetra.Import.Distributor	(		self,
			args
	)

Distributor(Import self) -> Distributor

Epetra_Distributor& Epetra_Import::Distributor() const 

def PyTrilinos.Epetra.Import.ExportLIDs	(		self,
			args
	)

ExportLIDs(Import self) -> PyObject *

int*
Epetra_Import::ExportLIDs() const

List of elements that will be sent to other processors. 

def PyTrilinos.Epetra.Import.ExportPIDs	(		self,
			args
	)

ExportPIDs(Import self) -> PyObject *

int*
Epetra_Import::ExportPIDs() const

List of processors to which elements will be sent, ExportLIDs() [i]
will be sent to processor ExportPIDs() [i]. 

def PyTrilinos.Epetra.Import.NumExportIDs	(		self,
			args
	)

NumExportIDs(Import self) -> int

int
Epetra_Import::NumExportIDs() const

Returns the number of elements that must be sent by the calling
processor to other processors. 

def PyTrilinos.Epetra.Import.NumPermuteIDs	(		self,
			args
	)

NumPermuteIDs(Import self) -> int

int
Epetra_Import::NumPermuteIDs() const

Returns the number of elements that are local to the calling
processor, but not part of the first NumSameIDs() elements. 

def PyTrilinos.Epetra.Import.NumRecv	(		self,
			args
	)

NumRecv(Import self) -> int

int
Epetra_Import::NumRecv() const

Total number of elements to be received. 

def PyTrilinos.Epetra.Import.NumRemoteIDs	(		self,
			args
	)

NumRemoteIDs(Import self) -> int

int
Epetra_Import::NumRemoteIDs() const

Returns the number of elements that are not on the calling processor.

def PyTrilinos.Epetra.Import.NumSameIDs	(		self,
			args
	)

NumSameIDs(Import self) -> int

int
Epetra_Import::NumSameIDs() const

Returns the number of elements that are identical between the source
and target maps, up to the first different ID. 

def PyTrilinos.Epetra.Import.NumSend	(		self,
			args
	)

NumSend(Import self) -> int

int
Epetra_Import::NumSend() const

Total number of elements to be sent. 

def PyTrilinos.Epetra.Import.PermuteFromLIDs	(		self,
			args
	)

PermuteFromLIDs(Import self) -> PyObject *

int*
Epetra_Import::PermuteFromLIDs() const

List of elements in the source map that are permuted. 

def PyTrilinos.Epetra.Import.PermuteToLIDs	(		self,
			args
	)

PermuteToLIDs(Import self) -> PyObject *

int*
Epetra_Import::PermuteToLIDs() const

List of elements in the target map that are permuted. 

def PyTrilinos.Epetra.Import.RemoteLIDs	(		self,
			args
	)

RemoteLIDs(Import self) -> PyObject *

int*
Epetra_Import::RemoteLIDs() const

List of elements in the target map that are coming from other
processors. 

def PyTrilinos.Epetra.Import.SourceMap	(		self,
			args
	)

SourceMap(Import self) -> BlockMap

const
Epetra_BlockMap& Epetra_Import::SourceMap() const

Returns the SourceMap used to construct this importer. 

def PyTrilinos.Epetra.Import.TargetMap	(		self,
			args
	)

TargetMap(Import self) -> BlockMap

const
Epetra_BlockMap& Epetra_Import::TargetMap() const

Returns the TargetMap used to construct this importer. 

---

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

• Epetra.py