PyTrilinos.Isorropia.Operator Class Reference

Inheritance diagram for PyTrilinos.Isorropia.Operator:

Collaboration diagram for PyTrilinos.Isorropia.Operator:

List of all members.

Public Member Functions
def	__init__
def	setParameters
def	compute
def	alreadyComputed
def	numProperties
def	numLocalProperties
def	numElemsWithProperty
def	elemsWithProperty
def	extractPropertiesView
def	extractPropertiesCopy

---

Detailed Description

Interface (abstract base class) for computing a new
partitioning/coloring/ ordering and exploiting their results.

If the accessor methods are called before the computation of the
result (by a method like compute()) 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_Operator.hpp 

---

Member Function Documentation

def PyTrilinos.Isorropia.Operator.alreadyComputed	(		self,
			args
	)

alreadyComputed(Operator self) -> bool

virtual
bool Isorropia::Operator::alreadyComputed() const =0

Query whether the computation has already been called.

True if the computation has already been done, False otherwise. 

def PyTrilinos.Isorropia.Operator.compute	(		self,
			args
	)

compute(Operator self, bool forceRecomputing=False)

virtual void
Isorropia::Operator::compute(bool forceRecomputing=false)=0

Method which does the work of computing a new
partitioning/coloring/ordering, depending on the child class used.

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

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

def PyTrilinos.Isorropia.Operator.elemsWithProperty	(		self,
			args
	)

elemsWithProperty(Operator self, int property, int * elementList, int len)

virtual void Isorropia::Operator::elemsWithProperty(int property, int
*elementList, int len) const =0

Fill user-allocated list (of length len) with the local element ids of
the LOCAL elements with the given property.

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

property:  Value of the property to consider.

elementList:  User allocated array (of size at least len) of local ID
that have the asked property.

len:  Maximum lenght for the array. If len is greater than the result
of numElemsWithProperty() for property, only the first and relevant
elements are filled.

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

def PyTrilinos.Isorropia.Operator.extractPropertiesCopy	(		self,
			args
	)

extractPropertiesCopy(Operator self, int len, int & size, int * array) -> int

virtual int Isorropia::Operator::extractPropertiesCopy(int len, int
&size, int *array) const =0

Copy a part of the property array.

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

len:  of the array given by the user.

size:  Number of elements in the array.

array:  Array of properties. 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::extractPropertiesView() 

def PyTrilinos.Isorropia.Operator.extractPropertiesView	(		self,
			args
	)

extractPropertiesView(Operator self, int & size, int const *& array) -> int

virtual int Isorropia::Operator::extractPropertiesView(int &size,
const int *&array) const =0

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

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

size:  Number of elements in the array.

array:  Pointer to the the properties array inside the object.

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

See:   Isorropia::Operator::extractPropertiesCopy().

Isorropia::Operator::extractPropertiesCopy() 

def PyTrilinos.Isorropia.Operator.numElemsWithProperty	(		self,
			args
	)

numElemsWithProperty(Operator self, int property) -> int

virtual int Isorropia::Operator::numElemsWithProperty(int property)
const =0

Return the number of LOCAL elements with the given property.

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

property:  Value of the property to consider.

Number of local elems which have this property. 

def PyTrilinos.Isorropia.Operator.numLocalProperties	(		self,
			args
	)

numLocalProperties(Operator self) -> int

virtual int Isorropia::Operator::numLocalProperties() const =0

Return the number of different values used for "properties" for this
process only.

Local number of values for properties 

def PyTrilinos.Isorropia.Operator.numProperties	(		self,
			args
	)

numProperties(Operator self) -> int

virtual
int Isorropia::Operator::numProperties() const =0

Return the number of different values used for "properties".

For example, the number of colors or the number of parts used for the
overall graph/matrix.

Global number of values for properties

Infact, it returns the upper bound of the interval of taken values.
For example, for the colors "1,2,4" , it will return "4" 

def PyTrilinos.Isorropia.Operator.setParameters	(		self,
			args
	)

setParameters(Operator self, ParameterList paramlist)

virtual
void Isorropia::Operator::setParameters(const Teuchos::ParameterList
&paramlist)=0

Set parameters for the Operator instance. The contents of the input
paramlist object are copied into an internal ParameterList attribute.
Instances of this interface should not retain a reference to the input
ParameterList after this method returns.

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

paramlist:  List of parameters that the user wants to use. 

---

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

• Isorropia/__init__.py