Epetra Package Browser (Single Doxygen Collection) Development
|Epetra_Export (const Epetra_BlockMap &SourceMap, const Epetra_BlockMap &TargetMap)|
|Constructs a Epetra_Export object from the source and target maps. |
|Epetra_Export (const Epetra_Export &Exporter)|
|Epetra_Export copy constructor. |
|Epetra_Export destructor. |
|int||NumSameIDs () const|
|Returns the number of elements that are identical between the source and target maps, up to the first different ID. |
|int||NumPermuteIDs () const|
|Returns the number of elements that are local to the calling processor, but not part of the first NumSameIDs() elements. |
|int *||PermuteFromLIDs () const|
|List of elements in the source map that are permuted. |
|int *||PermuteToLIDs () const|
|List of elements in the target map that are permuted. |
|int||NumRemoteIDs () const|
|Returns the number of elements that are not on the calling processor. |
|int *||RemoteLIDs () const|
|List of elements in the target map that are coming from other processors. |
|int||NumExportIDs () const|
|Returns the number of elements that must be sent by the calling processor to other processors. |
|int *||ExportLIDs () const|
|List of elements that will be sent to other processors. |
|int *||ExportPIDs () const|
|List of processors to which elements will be sent, ExportLIDs() [i] will be sent to processor ExportPIDs() [i]. |
|int||NumSend () const|
|Total number of elements to be sent. |
|int||NumRecv () const|
|Total number of elements to be received. |
|const Epetra_BlockMap &||SourceMap () const|
|Returns the SourceMap used to construct this exporter. |
|const Epetra_BlockMap &||TargetMap () const|
|Returns the TargetMap used to construct this exporter. |
|Epetra_Distributor &||Distributor () const|
|Epetra_Export &||operator= (const Epetra_Export &src)|
|virtual void||Print (ostream &os) const|
|Print object to an output stream Print method. |
Epetra_Export: This class builds an export object for efficient exporting of off-processor elements.
Epetra_Export 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 send data to a target processor.
This class currently has one constructor, taking two Epetra_Map or Epetra_BlockMap objects. The first map specifies the global IDs that are owned by the calling processor. The second map specifies the global IDs of elements that we want to export to later.
|Epetra_Export::Epetra_Export||(||const Epetra_BlockMap &||SourceMap,|
|const Epetra_BlockMap &||TargetMap|
Constructs a Epetra_Export object from the source and target maps.
This constructor builds an Epetra_Export object by comparing the GID lists of the source and target maps.
|SourceMap||(In) Map containing the GIDs from which data should be exported from each processor to the target map whenever an export operation is performed using this exporter.|
|TargetMap||(In) Map containing the GIDs that should be used for exporting data.|
Builds an export object that will transfer objects built with SourceMap to objects built with TargetMap.
Given the above information, the Epetra_Export constructor builds a list of elements that must be communicated to other processors as a result of export requests. The number of exported elements (where multiple sends of the same element to different processors is counted) is returned by NumExportIDs(). The local IDs to be sent are returned by the list ExportLIDs(). The processors to which each of the elements will be sent in returned in a list of the same length by ExportPIDs().
The following example illustrates the basic concepts.
Assume we have 3 processors and 9 global elements with each processor owning 3 elements as follows
PE 0 Elements | PE 1 Elements | PE 2 Elements 0 1 2 3 4 5 6 7 8
The above layout essentially defines the target map argument of the export object.
This could correspond to a 9-entry forcing vector with the first three entries on PE 0, and so on. Suppose that the entries of this forcing vector are computed by integrating over linear "hat" functions:
^ ^ ^ ^ ^ ^ ^ ^ ^ \/ \/ \/ \/ \/ \/ \/ \/ /\ /\ /\ /\ /\ /\ /\ /\ +--+--+--+--+--+--+--+--+ 0 1 2 3 4 5 6 7 8
In this case, PE 0 will make contributions to entries 0 through 3, PE 1 will make contributions to entries 2 through 6 and PE 2 will make contributions to entries 5 through 8. A convenient way to compute these contributions is to create a forcing vector with replicated entries for the shared contributions. Specifically the following SourceMap works for this scenario:
PE 0 Elements | PE 1 Elements | PE 2 Elements 0 1 2 3 2 3 4 5 6 5 6 7 8
A vector constructed using this SourceMap can be used to collect each processor's contributions to the forcing vector. Note that the ordering of the elements on each processor is not unique, but has been chosen for illustration.
With these two maps passed into the Epetra_Export constructor, we get the following attribute definitions:
On PE 0:
NumSameIDs = 3 NumPermuteIDs = 0 PermuteToLIDs = 0 PermuteFromLIDs = 0 NumRemoteIDs = 1 RemoteLIDs =  NumExportIDs = 1 ExportLIDs =  ExportPIDs =  NumSend = 1 NumRecv = 1
On PE 1:
NumSameIDs = 0 NumPermuteIDs = 3 PermuteToLIDs = [0, 1, 2] PermuteFromLIDs = [1, 2, 3] NumRemoteIDs = 2 RemoteLIDs = [0, 2] NumExportIDs = 2 ExportLIDs = [0, 4] ExportPIDs = [0, 2] NumSend = 2 NumRecv = 2
On PE 2:
NumSameIDs = 0 NumPermuteIDs = 3 PermuteToLIDs = [0, 1, 2] PermuteFromLIDs = [1, 2, 3] NumRemoteIDs = 1 RemoteLIDs =  NumExportIDs = 1 ExportLIDs =  ExportPIDs =  NumSend = 1 NumRecv = 1
Using Epetra_Export Objects
Once a Epetra_Export object has been constructed, it can be used by any of the Epetra classes that support distributed global objects, namely Epetra_Vector, Epetra_MultiVector, Epetra_CrsGraph, Epetra_CrsMatrix and Epetra_VbrMatrix. All of these classes have Export and Export methods that will fill new objects whose distribution is described by the target map, taking elements from the source object whose distribution is described by the source map. Details of usage for each class is given in the appropriate class documentation.
In the above example, if x_integrate is constructed using the SourceMap and then filled with local contributions, and x_force is constructed using the target map, the following operation will fill x_force with the combined results of x_integrate:
x_force.Export(x_integrate, exporter, Add);
The third argument above tells the export operation to add results that come from multiple processors for the same GID.
Epetra_Export objects can also be used by Import operations to perform the reverse operation. For example, if x_force in the above example had boundary conditions that should be sent to processors that share a boundary element, the following operation would send replicated values to x_integrate:
x_integrate.Import(x_force, exporter, Insert);
At the end of this operation, x_integrate would have replicated values from x_force of entries 2 and 3 on PEs 0 and 1, and entries 5 and 6 on PEs 1 and 2.
|Epetra_Export::Epetra_Export||(||const Epetra_Export &||Exporter||)|
|int Epetra_Export::NumSameIDs||(||)|| const
|int Epetra_Export::NumPermuteIDs||(||)|| const
|int* Epetra_Export::PermuteFromLIDs||(||)|| const
|int* Epetra_Export::PermuteToLIDs||(||)|| const
|int Epetra_Export::NumRemoteIDs||(||)|| const
|int* Epetra_Export::RemoteLIDs||(||)|| const
|int Epetra_Export::NumExportIDs||(||)|| const
|int* Epetra_Export::ExportLIDs||(||)|| const
|int* Epetra_Export::ExportPIDs||(||)|| const
|int Epetra_Export::NumSend||(||)|| const
|int Epetra_Export::NumRecv||(||)|| const
|const Epetra_BlockMap& Epetra_Export::SourceMap||(||)|| const
|const Epetra_BlockMap& Epetra_Export::TargetMap||(||)|| const
|Epetra_Distributor& Epetra_Export::Distributor||(||)|| const
|void Epetra_Export::Print||(||ostream &||os||)|| const