|
PyTrilinos
Development
|
Public Member Functions | |
| def | __call__ |
| def | NumColors |
| def | MaxNumColors |
| def | DefaultColor |
| def | NumElementsWithColor |
| def | GenerateMap |
| def | GenerateBlockMap |
| def | __init__ |
| def | __getitem__ |
| def | __setitem__ |
| def | ListOfColors |
| def | ColorLIDList |
| def | ElementColors |
Public Attributes | |
| this | |
Epetra_MapColoring: A class for coloring Epetra_Map and Epetra_BlockMap objects. This class allows the user to associate an integer value, i.e., a color, to each element of an existing Epetra_Map or Epetra_BlockMap object. Colors may be assigned at construction, or via set methods. Any elements that are not explicitly assigned a color are assigned the color 0 (integer zero). This class has the following features: A color (arbitrary integer label) can be associated locally with each element of a map. Color assignment can be done all-at-once via the constructor, or via operator[] (using LIDs) one-at-a-time operator() (using GIDs) one-at-a-time or some combination of the above. Any element that is not explicitly colored takes on the default color. The default color is implicitly zero, unless specified differently at the time of construction. Color information may be accessed in the following ways: By local element ID (LID) - Returns the color of a specified LID, where the LID is associated with the Epetra_Map or BlockMap that was passed in to the Epetra_MapColoring constructor. By global element ID (GID) - Returns the color of the specified GID. There two methods for accessing GIDs, one assumes the request is for GIDs owned by the calling processor, the second allows arbitrary requested for GIDs, as long as the GID is defined on some processor for the Epetra_Map or Epetra_BlockMap. By color groups - Elements are grouped by color so that all elements of a given color can be accessed. Epetra_Map/Epetra_BlockMap pointers for a specified color - This facilitates use of coloring with Epetra distributed objects that are distributed via the map that was colored. For example, if users want to work with all rows of a matrix that have a certain color, they can create a map for that color and use it to access only those rows. The Epetra_MapColoring class implements the Epetra_DistObject interface. Therefore, a map coloring can be computed for a map with a given distribution and then redistributed across the parallel machine. For example, it would be possible to compute a map coloring on a single processor (perhaps because the algorithm for computing the color assignment is too difficult to implement in parallel or because it is cheap to run and not worth parallelizing), and then re- distribute the coloring using an Epetra_Export or Epetra_Import object. C++ includes: Epetra_MapColoring.h
| def PyTrilinos.Epetra.MapColoring.__init__ | ( | self, | |
| args | |||
| ) |
__init__(Epetra_MapColoring self, BlockMap Map, int const DefaultColor=0) -> MapColoring __init__(Epetra_MapColoring self, MapColoring Source) -> MapColoring __init__(Epetra_MapColoring self, BlockMap map, int numColors, int const defaultColor=0) -> MapColoring Epetra_MapColoring::Epetra_MapColoring(const Epetra_MapColoring &Source) Epetra_MapColoring copy constructor.
Reimplemented from PyTrilinos.Epetra.Object.
| def PyTrilinos.Epetra.MapColoring.__call__ | ( | self, | |
| args | |||
| ) |
__call__(MapColoring self, int GID) -> int &
| def PyTrilinos.Epetra.MapColoring.__getitem__ | ( | self, | |
| args | |||
| ) |
__getitem__(MapColoring self, int i) -> int
| def PyTrilinos.Epetra.MapColoring.__setitem__ | ( | self, | |
| args | |||
| ) |
__setitem__(MapColoring self, int i, int color)
| def PyTrilinos.Epetra.MapColoring.ColorLIDList | ( | self, | |
| args | |||
| ) |
ColorLIDList(MapColoring self, int color) -> PyObject * int * Epetra_MapColoring::ColorLIDList(int Color) const Returns pointer to array of Map LIDs associated with the specified color. Returns a pointer to a list of Map LIDs associated with the specified color. This is a purely local list with no information about other processors. If there are no LIDs associated with the specified color, the pointer is set to zero.
| def PyTrilinos.Epetra.MapColoring.DefaultColor | ( | self, | |
| args | |||
| ) |
DefaultColor(MapColoring self) -> int int Epetra_MapColoring::DefaultColor() const Returns default color.
| def PyTrilinos.Epetra.MapColoring.ElementColors | ( | self, | |
| args | |||
| ) |
ElementColors(MapColoring self) -> PyObject * int* Epetra_MapColoring::ElementColors() const Returns pointer to array of the colors associated with the LIDs on the calling processor. Returns a pointer to the list of colors associated with the elements on this processor such that ElementColor[LID] is the color assigned to that LID.
| def PyTrilinos.Epetra.MapColoring.GenerateBlockMap | ( | self, | |
| args | |||
| ) |
GenerateBlockMap(MapColoring self, int Color) -> BlockMap Epetra_BlockMap * Epetra_MapColoring::GenerateBlockMap(int Color) const Generates an Epetra_BlockMap of the GIDs associated with the specified color. This method will create an Epetra_BlockMap such that on each processor the GIDs associated with the specified color will be part of the map on that processor. Note that this method will generate an Epetra_BlockMap such that each element as the same element size as the corresponding element of map associated with the map coloring. Once the map is generated, the user is responsible for deleting it.
| def PyTrilinos.Epetra.MapColoring.GenerateMap | ( | self, | |
| args | |||
| ) |
GenerateMap(MapColoring self, int Color) -> Map Epetra_Map * Epetra_MapColoring::GenerateMap(int Color) const Generates an Epetra_Map of the GIDs associated with the specified color. This method will create an Epetra_Map such that on each processor the GIDs associated with the specified color will be part of the map on that processor. Note that this method always generates an Epetra_Map, not an Epetra_BlockMap, even if the map associated with this map coloring is a block map. Once the map is generated, the user is responsible for deleting it.
| def PyTrilinos.Epetra.MapColoring.ListOfColors | ( | self, | |
| args | |||
| ) |
ListOfColors(MapColoring self) -> PyObject * int* Epetra_MapColoring::ListOfColors() const Array of length NumColors() containing List of color values used in this coloring. Color values can be arbitrary integer values. As a result, a user of a previously constructed MapColoring object may need to know exactly which color values are present. This array contains that information as a sorted list of integer values.
| def PyTrilinos.Epetra.MapColoring.MaxNumColors | ( | self, | |
| args | |||
| ) |
MaxNumColors(MapColoring self) -> int int Epetra_MapColoring::MaxNumColors() const Returns maximum over all processors of the number of colors.
| def PyTrilinos.Epetra.MapColoring.NumColors | ( | self, | |
| args | |||
| ) |
NumColors(MapColoring self) -> int int Epetra_MapColoring::NumColors() const Returns number of colors on the calling processor.
| def PyTrilinos.Epetra.MapColoring.NumElementsWithColor | ( | self, | |
| args | |||
| ) |
NumElementsWithColor(MapColoring self, int Color) -> int int Epetra_MapColoring::NumElementsWithColor(int Color) const Returns number of map elements on calling processor having specified Color.
1.7.6.1
