//=============================================================================
int Epetra_DistObject::DoTransfer(const Epetra_SrcDistObject& A,
Epetra_CombineMode CombineMode,
int NumSameIDs,
int NumPermuteIDs,
int NumRemoteIDs,
int NumExportIDs,
int* PermuteToLIDs,
int* PermuteFromLIDs,
int* RemoteLIDs,
int* ExportLIDs,
int& LenExports,
char*& Exports,
int& LenImports,
char*& Imports,
Epetra_Distributor& Distor,
bool DoReverse,
const Epetra_OffsetIndex * Indexor)
{
EPETRA_CHK_ERR(CheckSizes(A));
if (NumSameIDs + NumPermuteIDs > 0) {
EPETRA_CHK_ERR(CopyAndPermute(A, NumSameIDs, NumPermuteIDs, PermuteToLIDs, PermuteFromLIDs,Indexor, CombineMode));
}
// Once CopyAndPermute is done, switch to Add so rest works as before.
if(CombineMode == Epetra_AddLocalAlso) {
CombineMode = Add;
}
if (CombineMode==Zero)
return(0); // All done if CombineMode only involves copying and permuting
int SizeOfPacket;
bool VarSizes = false;
if( NumExportIDs > 0) {
delete [] Sizes_;
Sizes_ = new int[NumExportIDs];
}
EPETRA_CHK_ERR(PackAndPrepare(A, NumExportIDs, ExportLIDs,
LenExports, Exports, SizeOfPacket, Sizes_, VarSizes, Distor));
if ((DistributedGlobal_ && DoReverse) || (A.Map().DistributedGlobal() && !DoReverse)) {
if (DoReverse) {
// Do the exchange of remote data
if( VarSizes ) {
EPETRA_CHK_ERR(Distor.DoReverse(Exports, SizeOfPacket, Sizes_, LenImports, Imports));
}
else {
EPETRA_CHK_ERR(Distor.DoReverse(Exports, SizeOfPacket, LenImports, Imports));
}
}
else {
// Do the exchange of remote data
if( VarSizes ) {
EPETRA_CHK_ERR(Distor.Do(Exports, SizeOfPacket, Sizes_, LenImports, Imports));
}
else {
EPETRA_CHK_ERR(Distor.Do(Exports, SizeOfPacket, LenImports, Imports));
}
}
EPETRA_CHK_ERR(UnpackAndCombine(A, NumRemoteIDs, RemoteLIDs, LenImports, Imports, SizeOfPacket, Distor, CombineMode, Indexor));
}
return(0);
}
void Epetra_OffsetIndex::GenerateRemoteOffsets_( const Epetra_CrsGraph & SourceGraph,
const Epetra_CrsGraph & TargetGraph,
const int * ExportLIDs,
const int * RemoteLIDs,
Epetra_Distributor & Distor )
{
int numProcs = SourceGraph.RowMap().Comm().NumProc();
if (numProcs < 2) {
return;
}
const int GlobalMaxNumIndices = SourceGraph.GlobalMaxNumIndices();
int NumIndices;
/* "Indices" appears to be unused -- [email protected]
int * Indices = 0;
if( GlobalMaxNumIndices>0 ) Indices = new int[GlobalMaxNumIndices];
*/
//Pack Source Rows
int * Sizes = 0;
if( NumExport_ > 0 ) Sizes = new int[NumExport_];
int TotalSize = 0;
for( int i = 0; i < NumExport_; ++i ) {
Sizes[i] = SourceGraph.NumMyIndices(ExportLIDs[i]) + 1;
TotalSize += Sizes[i];
}
int_type * SourceArray = new int_type[TotalSize+1];
int Loc = 0;
for( int i = 0; i < NumExport_; ++i ) {
int_type GID = (int_type) SourceGraph.GRID64(ExportLIDs[i]);
SourceArray[Loc] = Sizes[i]-1;
SourceGraph.ExtractGlobalRowCopy( GID,
GlobalMaxNumIndices,
NumIndices,
&(SourceArray[Loc+1]) );
Loc += Sizes[i];
}
//Push to Target
char * cRecvArray = 0;
int_type * RecvArray = 0;
int RecvArraySize = 0;
Distor.Do( reinterpret_cast<char *>(SourceArray),
(int)sizeof(int_type),
Sizes,
RecvArraySize,
cRecvArray );
RecvArray = reinterpret_cast<int_type*>(cRecvArray);
//Construct RemoteOffsets
if( NumRemote_ > 0 ) RemoteOffsets_ = new int*[NumRemote_];
for( int i = 0; i < NumRemote_; ++i ) RemoteOffsets_[i] = 0;
Loc = 0;
for( int i = 0; i < NumRemote_; ++i ) {
NumIndices = (int) RecvArray[Loc];
RemoteOffsets_[i] = new int[NumIndices];
++Loc;
int FLoc = 0;
int Start = 0;
for( int j = 0; j < NumIndices; ++j ) {
Start = FLoc;
if( TargetGraph.FindGlobalIndexLoc(RemoteLIDs[i],RecvArray[Loc],Start,FLoc) )
RemoteOffsets_[i][j] = FLoc;
else
RemoteOffsets_[i][j] = -1;
++Loc;
}
}
/* "Indices" appears to be unused -- [email protected]
if( GlobalMaxNumIndices>0 ) delete [] Indices;
*/
if( Sizes ) delete [] Sizes;
if( SourceArray ) delete [] SourceArray;
if( RecvArraySize ) delete [] cRecvArray;
}
