PyTrilinos.Isorropia.Partitioner Class Reference

Inheritance diagram for PyTrilinos.Isorropia.Partitioner:

Collaboration diagram for PyTrilinos.Isorropia.Partitioner:

List of all members.

Public Member Functions
def	__init__
def	partition
def	numElemsInPart
def	elemsInPart
def	extractPartsView
def	extractPartsCopy

---

Detailed Description

Interface (abstract base class) for computing a new partitioning and
describing the layout of elements in the new partition (the parts).

If the methods which describe the new partitioning (e.g., operator [],
elemsInPart()) are called before compute_partitioning() has been
called, behavior is not well defined. Implementations will either
return empty/erroneous data, or throw an exception. In most cases,
implementations will probably call compute_partitioning() internally
in a constructor or factory method, so this won't usually be an issue.

C++ includes: Isorropia_Partitioner.hpp 

---

Member Function Documentation

def PyTrilinos.Isorropia.Partitioner.elemsInPart	(		self,
			args
	)

elemsInPart(Partitioner self, int part, int * elementList, int len)

virtual
void Isorropia::Partitioner::elemsInPart(int part, int *elementList,
int len) const =0

Fill user-allocated list (of length len) with the local element ids to
be located in the given part

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

part:  the part ID we consider

elementList:  array of elements that belongs to this part ID, must be
allocated by user with size at least len

len:  maximum number of elements we can put in the array. Usually, may
be the result of Isorropia::Partitioner::numElemsInPart(). .

See:   Isorropia::Operator::elemsWithProperty() 

def PyTrilinos.Isorropia.Partitioner.extractPartsCopy	(		self,
			args
	)

extractPartsCopy(Partitioner self, int len, int & size, int * array) -> int

virtual int Isorropia::Partitioner::extractPartsCopy(int len, int
&size, int *array) const

Copy a part of the part assignment array.

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

len:  of the array given by the user.

size:  Number of elements in the array.

array:  Array of part assignments. Allocated by the user with a size
of at least len elements.

Memory space which is not useful in the array is not initialized or
used in this method.

See:   Isorropia::Operator::extractPropertiesCopy() 

def PyTrilinos.Isorropia.Partitioner.extractPartsView	(		self,
			args
	)

extractPartsView(Partitioner self, int & size, int const *& array) -> int

virtual int Isorropia::Partitioner::extractPartsView(int &size, const
int *&array) const

Give access of the part assignments array that is owned by the current
processor.

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

size:  Number of elements in the array.

array:  Pointer to the the part assignements array inside the object.

This pointer is only significant if the object still exists.
Otherwise, you must use

See:  Isorropia::Operator::extractPartsCopy()

Isorropia::Operator::extractPropertiesView() 

def PyTrilinos.Isorropia.Partitioner.numElemsInPart	(		self,
			args
	)

numElemsInPart(Partitioner self, int part) -> int

virtual int Isorropia::Partitioner::numElemsInPart(int part) const =0

Return the number of LOCAL elements in a given part.

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

part:  the part ID we want to know the number of local elements.

number of local elements that belongs to the given part.

See:   Isorropia::Operator::numElemsWithProperty() 

def PyTrilinos.Isorropia.Partitioner.partition	(		self,
			args
	)

partition(Partitioner self, bool forceRepartitioning=False)

virtual
void Isorropia::Partitioner::partition(bool
forceRepartitioning=false)=0

Method which does the work of computing a new partitioning.
Implementations of this interface will typically be constructed with
an object or information describing the existing ('old') partitioning.
This method computes a 'new' rebalanced partitioning for that input
data.

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

forceRepartitioning:  Optional argument defaults to false. Depending
on the implementation, partitioning() should only perform a
repartitioning the first time it is called, and subsequent repeated
calls are no-ops. If the user's intent is to re-compute the
partitioning (e.g., if parameters or other inputs have been changed),
then setting this flag to true will force a new partitioning to be
computed.

See:   Isorropia::Operator::compute() 

---

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

• Isorropia/__init__.py