int
LOCA::Epetra::AugmentedOp::blockMap2PointMap(const Epetra_BlockMap& BlockMap,
Epetra_Map*& PointMap) const
{
// Generate an Epetra_Map that has the same number and distribution of points
// as the input Epetra_BlockMap object. The global IDs for the output PointMap
// are computed by using the MaxElementSize of the BlockMap. For variable block
// sizes this will create gaps in the GID space, but that is OK for Epetra_Maps.
int MaxElementSize = BlockMap.MaxElementSize();
int PtNumMyElements = BlockMap.NumMyPoints();
int * PtMyGlobalElements = 0;
if (PtNumMyElements>0) PtMyGlobalElements = new int[PtNumMyElements];
int NumMyElements = BlockMap.NumMyElements();
int curID = 0;
for (int i=0; i<NumMyElements; i++) {
int StartID = BlockMap.GID(i)*MaxElementSize;
int ElementSize = BlockMap.ElementSize(i);
for (int j=0; j<ElementSize; j++) PtMyGlobalElements[curID++] = StartID+j;
}
assert(curID==PtNumMyElements); // Sanity test
PointMap = new Epetra_Map(-1, PtNumMyElements, PtMyGlobalElements, BlockMap.IndexBase(), BlockMap.Comm());
if (PtNumMyElements>0) delete [] PtMyGlobalElements;
if (!BlockMap.PointSameAs(*PointMap)) {EPETRA_CHK_ERR(-1);} // Maps not compatible
return(0);
}
//=========================================================================
int Ifpack_CrsRiluk::BlockMap2PointMap(const Epetra_BlockMap & BlockMap, Teuchos::RefCountPtr<Epetra_Map>* PointMap) {
// Generate an Epetra_Map that has the same number and distribution of points
// as the input Epetra_BlockMap object. The global IDs for the output PointMap
// are computed by using the MaxElementSize of the BlockMap. For variable block
// sizes this will create gaps in the GID space, but that is OK for Epetra_Maps.
int MaxElementSize = BlockMap.MaxElementSize();
int PtNumMyElements = BlockMap.NumMyPoints();
vector<int> PtMyGlobalElements;
if (PtNumMyElements>0) PtMyGlobalElements.resize(PtNumMyElements);
int NumMyElements = BlockMap.NumMyElements();
int curID = 0;
for (int i=0; i<NumMyElements; i++) {
int StartID = BlockMap.GID(i)*MaxElementSize;
int ElementSize = BlockMap.ElementSize(i);
for (int j=0; j<ElementSize; j++) PtMyGlobalElements[curID++] = StartID+j;
}
assert(curID==PtNumMyElements); // Sanity test
(*PointMap) = Teuchos::rcp( new Epetra_Map(-1, PtNumMyElements, &PtMyGlobalElements[0], BlockMap.IndexBase(), BlockMap.Comm()) );
if (!BlockMap.PointSameAs(*(*PointMap))) {EPETRA_CHK_ERR(-1);} // Maps not compatible
return(0);
}
Teuchos::Array<int>
Albany::NodeSetSolutionCullingStrategy::
selectedGIDs(const Epetra_BlockMap &sourceMap) const
{
Teuchos::Array<int> result;
{
Teuchos::Array<int> mySelectedGIDs;
{
const NodeSetList &nodeSets = disc_->getNodeSets();
const NodeSetList::const_iterator it = nodeSets.find(nodeSetLabel_);
if (it != nodeSets.end()) {
typedef NodeSetList::mapped_type NodeSetEntryList;
const NodeSetEntryList &sampleNodeEntries = it->second;
for (NodeSetEntryList::const_iterator jt = sampleNodeEntries.begin(); jt != sampleNodeEntries.end(); ++jt) {
typedef NodeSetEntryList::value_type NodeEntryList;
const NodeEntryList &sampleEntries = *jt;
for (NodeEntryList::const_iterator kt = sampleEntries.begin(); kt != sampleEntries.end(); ++kt) {
mySelectedGIDs.push_back(sourceMap.GID(*kt));
}
}
}
}
const Epetra_Comm &comm = sourceMap.Comm();
{
int selectedGIDCount;
{
int mySelectedGIDCount = mySelectedGIDs.size();
comm.SumAll(&mySelectedGIDCount, &selectedGIDCount, 1);
}
result.resize(selectedGIDCount);
}
const int ierr = Epetra::GatherAllV(
comm,
mySelectedGIDs.getRawPtr(), mySelectedGIDs.size(),
result.getRawPtr(), result.size());
TEUCHOS_ASSERT(ierr == 0);
}
std::sort(result.begin(), result.end());
return result;
}
int BlockMapToHandle(FILE * handle, const Epetra_BlockMap & map) {
const Epetra_Comm & comm = map.Comm();
int numProc = comm.NumProc();
bool doSizes = !map.ConstantElementSize();
if (numProc==1) {
int * myElements = map.MyGlobalElements();
int * elementSizeList = 0;
if (doSizes) elementSizeList = map.ElementSizeList();
return(writeBlockMap(handle, map.NumGlobalElements(), myElements, elementSizeList, doSizes));
}
int numRows = map.NumMyElements();
Epetra_Map allGidsMap(-1, numRows, 0,comm);
Epetra_IntVector allGids(allGidsMap);
for (int i=0; i<numRows; i++) allGids[i] = map.GID(i);
Epetra_IntVector allSizes(allGidsMap);
for (int i=0; i<numRows; i++) allSizes[i] = map.ElementSize(i);
// Now construct a Map on PE 0 by strip-mining the rows of the input matrix map.
int numChunks = numProc;
int stripSize = allGids.GlobalLength()/numChunks;
int remainder = allGids.GlobalLength()%numChunks;
int curStart = 0;
int curStripSize = 0;
Epetra_IntSerialDenseVector importGidList;
Epetra_IntSerialDenseVector importSizeList;
if (comm.MyPID()==0) {
importGidList.Size(stripSize+1); // Set size of vector to max needed
if (doSizes) importSizeList.Size(stripSize+1); // Set size of vector to max needed
}
for (int i=0; i<numChunks; i++) {
if (comm.MyPID()==0) { // Only PE 0 does this part
curStripSize = stripSize;
if (i<remainder) curStripSize++; // handle leftovers
for (int j=0; j<curStripSize; j++) importGidList[j] = j + curStart;
curStart += curStripSize;
}
// The following import map will be non-trivial only on PE 0.
Epetra_Map importGidMap(-1, curStripSize, importGidList.Values(), 0, comm);
Epetra_Import gidImporter(importGidMap, allGidsMap);
Epetra_IntVector importGids(importGidMap);
if (importGids.Import(allGids, gidImporter, Insert)) return(-1);
Epetra_IntVector importSizes(importGidMap);
if (doSizes) if (importSizes.Import(allSizes, gidImporter, Insert)) return(-1);
// importGids (and importSizes, if non-trivial block map)
// now have a list of GIDs (and sizes, respectively) for the current strip of map.
int * myElements = importGids.Values();
int * elementSizeList = 0;
if (doSizes) elementSizeList = importSizes.Values();
// Finally we are ready to write this strip of the map to file
writeBlockMap(handle, importGids.MyLength(), myElements, elementSizeList, doSizes);
}
return(0);
}
static int compute_hypergraph_metrics(const Epetra_BlockMap &rowmap,
const Epetra_BlockMap &colmap,
int numGlobalColumns,
Isorropia::Epetra::CostDescriber &costs,
double &myGoalWeight,
double &balance, double &cutn, double &cutl) // output
{
const Epetra_Comm &comm = rowmap.Comm();
#ifdef HAVE_MPI
const Epetra_MpiComm* mpiComm =
dynamic_cast<const Epetra_MpiComm*>(&comm);
MPI_Comm mcomm = mpiComm->Comm();
#endif
int nProcs = comm.NumProc();
int myProc = comm.MyPID();
double min, avg;
std::map<int, float> vertexWeights;
std::map<int, std::map<int, float > > graphEdgeWeights;
std::map<int, float> hyperEdgeWeights;
costs.getCosts(vertexWeights, // vertex global ID -> weight
graphEdgeWeights, // vertex global ID -> map from neighbor global ID to edge weight
hyperEdgeWeights); // hyperedge global ID -> weight
Epetra_Vector vwgt(rowmap);
int numVWgts = vertexWeights.size();
if (numVWgts > 0){
double *wvals = new double [numVWgts];
int *gids = new int [numVWgts];
std::map<int, float>::iterator vnext = vertexWeights.begin();
int i=0;
while (vnext != vertexWeights.end()){
wvals[i] = vnext->second;
gids[i] = vnext->first;
vnext++;
i++;
}
vwgt.ReplaceGlobalValues(i, wvals, gids);
delete [] wvals;
delete [] gids;
}
else{
vwgt.PutScalar(1.0); // default to unit weights
}
compute_balance(vwgt, myGoalWeight, min, balance, avg);
if (balance < 0){
return 1;
}
/* Compute cutl and cutn.
*/
int totalHEWeights = 0;
int numHEWeights = hyperEdgeWeights.size();
comm.SumAll(&numHEWeights, &totalHEWeights, 1);
if ((totalHEWeights > 0) && (totalHEWeights < numGlobalColumns)){
if (myProc == 0)
std::cerr << "Must supply either no h.e. weights or else supply at least one for each column" << std::endl;
return -1;
}
std::map<int, float>::iterator heWgtIter;
// Create a set containing all the columns in my rows. We assume all
// the rows are in the same partition.
int numMyCols = colmap.NumMyElements();
std::set<int> colGIDS;
std::set<int>::iterator gidIter;
for (int j=0; j<numMyCols; j++){
colGIDS.insert(colmap.GID(j));
}
/* Divide columns among processes, then each process computes its
* assigned columns' cutl and cutn.
* TODO - numGlobalColumns can be less than nprocs
* Fix this when a process is assigned no columns. TODO
*/
int ncols = numGlobalColumns / nProcs;
int leftover = numGlobalColumns - (nProcs * ncols);
std::vector<int> colCount(nProcs, 0);
for (int i=0; i<nProcs; i++){
colCount[i] = ncols;
if (i < leftover) colCount[i]++;
}
int *colTotals = NULL;
double *colWeights = NULL;
if (colCount[myProc] > 0){
colTotals = new int [colCount[myProc]];
if (totalHEWeights > 0){
colWeights = new double [colCount[myProc]];
}
}
int *colLocal= new int [ncols + 1];
double *localWeights = NULL;
if (totalHEWeights > 0){
localWeights = new double [ncols + 1];
}
int base = colmap.IndexBase();
int colStart = base;
for (int i=0; i<nProcs; i++){
// All processes send info to the process reponsible
// for the next group of columns
int ncols = colCount[i];
int colEnd = colStart + ncols;
for (int j=colStart,k=0; j < colEnd; j++,k++){
gidIter = colGIDS.find(j);
if (gidIter != colGIDS.end()){
colLocal[k] = 1; // column j has rows in my partition
}
else{
colLocal[k] = 0;
}
if (totalHEWeights > 0){
std::map<int, float>::iterator heWgtIter = hyperEdgeWeights.find(j);
if (heWgtIter != hyperEdgeWeights.end()){
// I have the edge weight for column j
localWeights[k] = heWgtIter->second;
}
else{
localWeights[k] = 0.0;
}
}
}
#ifdef HAVE_MPI
int rc = MPI_Reduce(colLocal, colTotals, ncols, MPI_INT, MPI_SUM, i, mcomm);
if (totalHEWeights > 0){
rc = MPI_Reduce(localWeights, colWeights, ncols, MPI_DOUBLE, MPI_SUM, i, mcomm);
}
// TODO handle possible MPI error
#else
memcpy(colTotals, colLocal, ncols * sizeof(int));
if (totalHEWeights > 0){
memcpy(colWeights, localWeights, ncols * sizeof(double));
}
#endif
colStart = colEnd;
}
delete [] colLocal;
if (localWeights) delete [] localWeights;
double localCutN=0;
double localCutL=0;
double ewgt = 1.0;
for (int j=0; j<colCount[myProc]; j++){
if (totalHEWeights > 0){
ewgt = colWeights[j];
}
if (colTotals[j] > 1){
localCutL += (colTotals[j] - 1) * ewgt; // # of cuts in columns/edges
localCutN += ewgt; // # of cut columns/edges
}
}
if (colTotals) delete [] colTotals;
if (colWeights) delete [] colWeights;
comm.SumAll(&localCutN, &cutn, 1);
comm.SumAll(&localCutL, &cutl, 1);
return 0;
}
static int compute_graph_metrics(const Epetra_BlockMap &rowmap, const Epetra_BlockMap &colmap,
std::vector<std::vector<int> > &rows,
Isorropia::Epetra::CostDescriber &costs, double &myGoalWeight,
double &balance, int &numCuts, double &cutWgt, double &cutn, double &cutl)
{
const Epetra_Comm &comm = rowmap.Comm();
int myProc = comm.MyPID();
int myCols = colmap.NumMyElements();
double min, avg;
std::map<int, float> vertexWeights;
std::map<int, std::map<int, float > > graphEdgeWeights;
std::map<int, float> hyperEdgeWeights;
costs.getCosts(vertexWeights, // vertex global ID -> weight
graphEdgeWeights, // vertex global ID -> map from neighbor global ID to edge weight
hyperEdgeWeights); // hyperedge global ID -> weight
// Compute the balance
Epetra_Vector vwgt(rowmap);
int numVWgts = vertexWeights.size();
if (numVWgts > 0){
double *wvals = new double [numVWgts];
int *gids = new int [numVWgts];
std::map<int, float>::iterator vnext = vertexWeights.begin();
int i=0;
while (vnext != vertexWeights.end()){
wvals[i] = vnext->second;
gids[i] = vnext->first;
vnext++;
i++;
}
vwgt.ReplaceGlobalValues(i, wvals, gids);
delete [] wvals;
delete [] gids;
}
else{
vwgt.PutScalar(1.0); // default to unit weights
}
compute_balance(vwgt, myGoalWeight, min, balance, avg);
if (balance < 0){
return 1;
}
// Compute the measures based on cut edges
int *procID = new int [myCols];
int *GID = new int [myCols];
int *tmp = new int [myCols];
for (int i=0; i < myCols; i++){
GID[i] = colmap.GID(i);
}
rowmap.RemoteIDList(myCols, GID, procID, tmp); // matrix is square
delete [] tmp;
int haveEdgeWeights = graphEdgeWeights.size();
int localNumCuts = 0;
double localCutWgt = 0.0;
double localCutn = 0.0;
double localCutl = 0.0;
for (int i=0; i < rowmap.NumMyElements(); i++){
int vtxGID = rowmap.GID(i);
int numEdges = rows[i].size();
if (numEdges > 0){
std::map<int, std::map<int, float> >::iterator wnext;
if (haveEdgeWeights){
wnext = graphEdgeWeights.find(vtxGID);
if (wnext == graphEdgeWeights.end()){
std::cerr << "Graph edge weights are missing for vertex " << vtxGID;
std::cerr << std::endl;
return -1;
}
}
double heWeight = 0.0;
std::set<int> nbors;
for (int j=0; j < numEdges; j++){
int colGID = GID[rows[i][j]];
int nborProc = procID[rows[i][j]];
if (colGID == vtxGID) continue; // skip self edges
float wgt = 1.0;
if (haveEdgeWeights){
std::map<int, float>::iterator curr = (wnext->second).find(colGID);
if (curr == (wnext->second).end()){
std::cerr << "Graph edge weights do not match matrix";
std::cerr << std::endl;
return -1;
}
wgt = curr->second;
}
if (nborProc != myProc){
localNumCuts++; // number of graph edges that are cut
nbors.insert(nborProc); // count number of neighboring processes
localCutWgt += wgt; // sum of weights of cut edges
}
heWeight += wgt; // implied hyperedge weight, sum all edges
}
int numNbors = nbors.size();
if (numNbors > 0){
// implied hyperedge is vertex and neighbors, if cut, add in its he weight
localCutn += heWeight;
// sum of (number of partitions - 1) weighted by the
// implied hyperedge weight
localCutl += (numNbors * heWeight);
}
}
} // next vertex in my partition
delete [] GID;
delete [] procID;
double lval[4], gval[4];
lval[0] = (double)localNumCuts;
lval[1] = localCutWgt;
lval[2] = localCutn;
lval[3] = localCutl;
comm.SumAll(lval, gval, 4);
numCuts = (int)gval[0];
cutWgt = gval[1];
cutn = gval[2];
cutl = gval[3];
return 0;
}
int checkmap(Epetra_BlockMap & Map, int NumGlobalElements, int NumMyElements,
int *MyGlobalElements, int ElementSize, int * ElementSizeList,
int NumGlobalPoints, int NumMyPoints,
int IndexBase, Epetra_Comm& Comm,
bool DistributedGlobal,
bool IsOneToOne)
{
int i, ierr=0, forierr=0;// forierr is used in for loops, then is tested
// after for loop completes to see if it is non zero - potentially prevents
// thousands of error messages
if (ElementSizeList==0)
{
EPETRA_TEST_ERR(!Map.ConstantElementSize(),ierr);
}
else
EPETRA_TEST_ERR(Map.ConstantElementSize(),ierr);
EPETRA_TEST_ERR(DistributedGlobal!=Map.DistributedGlobal(),ierr);
EPETRA_TEST_ERR(IsOneToOne!=Map.IsOneToOne(),ierr);
int *MyElementSizeList;
if (ElementSizeList==0)
{
EPETRA_TEST_ERR(Map.ElementSize()!=ElementSize,ierr);
MyElementSizeList = new int[NumMyElements];
EPETRA_TEST_ERR(Map.ElementSizeList(MyElementSizeList)!=0,ierr);
forierr = 0;
for (i=0; i<NumMyElements; i++)
forierr += MyElementSizeList[i]!=ElementSize;
EPETRA_TEST_ERR(forierr,ierr);
EPETRA_TEST_ERR(Map.MaxMyElementSize() != ElementSize,ierr);
EPETRA_TEST_ERR(Map.MinMyElementSize() != ElementSize,ierr);
}
else
{
MyElementSizeList = new int[NumMyElements];
EPETRA_TEST_ERR(Map.ElementSizeList(MyElementSizeList)!=0,ierr);
int MaxSize = MyElementSizeList[0];
int MinSize = MyElementSizeList[0];
forierr=0;
for (i=0; i<NumMyElements; i++) {
forierr += MyElementSizeList[i]!=ElementSizeList[i];
if (MyElementSizeList[i] > MaxSize)
MaxSize = MyElementSizeList[i];
if (MyElementSizeList[i] < MinSize)
MinSize = MyElementSizeList[i];
// Test ElementSize(int LID) method
forierr += Map.ElementSize(Map.LID(MyGlobalElements[i])) != ElementSizeList[i];
}
EPETRA_TEST_ERR(forierr,ierr);
EPETRA_TEST_ERR(MaxSize !=Map.MaxMyElementSize(),ierr);
EPETRA_TEST_ERR(MinSize !=Map.MinMyElementSize(),ierr);
}
const Epetra_Comm & Comm1 = Map.Comm();
EPETRA_TEST_ERR(Comm1.NumProc()!=Comm.NumProc(),ierr);
EPETRA_TEST_ERR(Comm1.MyPID()!=Comm.MyPID(),ierr);
EPETRA_TEST_ERR(Map.IndexBase()!=IndexBase,ierr);
EPETRA_TEST_ERR(!Map.LinearMap() && MyGlobalElements==0,ierr);
EPETRA_TEST_ERR(Map.LinearMap() && MyGlobalElements!=0,ierr);
EPETRA_TEST_ERR(Map.MaxAllGID()!=NumGlobalElements-1+IndexBase,ierr);
EPETRA_TEST_ERR(Map.MaxElementSize()!=ElementSize,ierr);
int MaxLID = Map.MaxLID();
EPETRA_TEST_ERR(MaxLID!=NumMyElements-1,ierr);
int MaxMyGID = (Comm.MyPID()+1)*NumMyElements-1+IndexBase;
if (Comm.MyPID()>2) MaxMyGID+=3;
if (!DistributedGlobal) MaxMyGID = NumMyElements-1+IndexBase;
EPETRA_TEST_ERR(Map.MaxMyGID()!=MaxMyGID,ierr);
EPETRA_TEST_ERR(Map.MinAllGID()!=IndexBase,ierr);
if (ElementSizeList==0)
{
EPETRA_TEST_ERR(Map.MinElementSize()!=ElementSize,ierr);
}
else EPETRA_TEST_ERR(Map.MinElementSize()!=2,ierr);
int MinLID = Map.MinLID();
EPETRA_TEST_ERR(MinLID!=0,ierr);
int MinMyGID = Comm.MyPID()*NumMyElements+IndexBase;
if (Comm.MyPID()>2) MinMyGID+=3;
if (!DistributedGlobal) MinMyGID = IndexBase; // Not really needed
EPETRA_TEST_ERR(Map.MinMyGID()!=MinMyGID,ierr);
int * MyGlobalElements1 = new int[NumMyElements];
EPETRA_TEST_ERR(Map.MyGlobalElements(MyGlobalElements1)!=0,ierr);
forierr = 0;
if (MyGlobalElements==0) {
for (i=0; i<NumMyElements; i++)
forierr += MyGlobalElements1[i]!=MinMyGID+i;
EPETRA_TEST_ERR(forierr,ierr);
}
else {
for (i=0; i<NumMyElements; i++)
forierr += MyGlobalElements[i]!=MyGlobalElements1[i];
EPETRA_TEST_ERR(forierr,ierr);
}
EPETRA_TEST_ERR(Map.NumGlobalElements()!=NumGlobalElements,ierr);
EPETRA_TEST_ERR(Map.NumGlobalPoints()!=NumGlobalPoints,ierr);
EPETRA_TEST_ERR(Map.NumMyElements()!=NumMyElements,ierr);
EPETRA_TEST_ERR(Map.NumMyPoints()!=NumMyPoints,ierr);
int MaxMyGID2 = Map.GID(Map.LID(MaxMyGID));
EPETRA_TEST_ERR(MaxMyGID2 != MaxMyGID,ierr);
int MaxLID2 = Map.LID(Map.GID(MaxLID));
EPETRA_TEST_ERR(MaxLID2 != MaxLID,ierr);
EPETRA_TEST_ERR(Map.GID(MaxLID+1) != IndexBase-1,ierr);// MaxLID+1 doesn't exist
EPETRA_TEST_ERR(Map.LID(MaxMyGID+1) != -1,ierr);// MaxMyGID+1 doesn't exist or is on a different processor
EPETRA_TEST_ERR(!Map.MyGID(MaxMyGID),ierr);
EPETRA_TEST_ERR(Map.MyGID(MaxMyGID+1),ierr);
EPETRA_TEST_ERR(!Map.MyLID(MaxLID),ierr);
EPETRA_TEST_ERR(Map.MyLID(MaxLID+1),ierr);
EPETRA_TEST_ERR(!Map.MyGID(Map.GID(MaxLID)),ierr);
EPETRA_TEST_ERR(Map.MyGID(Map.GID(MaxLID+1)),ierr);
EPETRA_TEST_ERR(!Map.MyLID(Map.LID(MaxMyGID)),ierr);
EPETRA_TEST_ERR(Map.MyLID(Map.LID(MaxMyGID+1)),ierr);
// Test the FirstPointInElementList methods, begin by testing that they produce identical results
int * FirstPointInElementList = new int[NumMyElements+1];
Map.FirstPointInElementList(FirstPointInElementList);
int * FirstPointInElementList1 = Map.FirstPointInElementList();
forierr = 0;
for (i=0; i<=NumMyElements; i++)
forierr += FirstPointInElementList[i]!=FirstPointInElementList1[i];
EPETRA_TEST_ERR(forierr,ierr);
// Now make sure values are correct
forierr = 0;
if (Map.ConstantElementSize()) {
for (i=0; i<=NumMyElements; i++)
forierr += FirstPointInElementList1[i]!=(i*ElementSize);// NOTE:FirstPointInElement[NumMyElements] is not the first point of an element
EPETRA_TEST_ERR(forierr,ierr);
}
else {
int FirstPoint = 0;
for (i=0; i<NumMyElements; i++) {
forierr += FirstPointInElementList1[i]!=FirstPoint;
FirstPoint += ElementSizeList[i];
}
EPETRA_TEST_ERR(forierr,ierr);
EPETRA_TEST_ERR(FirstPointInElementList[NumMyElements] != NumMyPoints,ierr);// The last entry in the array = the total number of Points on the proc
}
delete [] FirstPointInElementList;
// Declare some variables for the FindLocalElementID test
int ElementID, Offset;
// Test the PointToElementList methods, begin by testing that they produce identical results
int * PointToElementList = new int[NumMyPoints];
Map.PointToElementList(PointToElementList);
int * PointToElementList1 = Map.PointToElementList();
forierr = 0;
for (i=0; i<NumMyPoints; i++)
forierr += PointToElementList1[i] != PointToElementList[i];
EPETRA_TEST_ERR(forierr,ierr);
//Now make sure values are correct
forierr=0;
if (Map.ConstantElementSize()) {
for (i=0; i<NumMyElements; i++)
for (int j=0; j<ElementSize; j++) {
forierr += PointToElementList[i*ElementSize+j] != i;
// Test FindLocalElementID method
Map.FindLocalElementID(i*ElementSize+j,ElementID,Offset);
forierr += ElementID != i || Offset != j;
}
EPETRA_TEST_ERR(forierr,ierr);
}
else {
int MyPointTot = 0; // Keep track of total number of points in all previously completely checked elements
for (i=0; i<NumMyElements; i++) {
for (int j=0; j<ElementSizeList[i]; j++) {
forierr += PointToElementList[MyPointTot+j] != i;
// Test FindLocalElementID method
Map.FindLocalElementID(MyPointTot+j,ElementID,Offset);
forierr += ElementID != i || Offset != j;
}
MyPointTot += ElementSizeList[i];
}
EPETRA_TEST_ERR(forierr,ierr);
}
delete [] PointToElementList;
// Check RemoteIDList function that includes a parameter for size
// Get some GIDs off of each processor to test
int TotalNumEle, NumElePerProc, NumProc = Comm.NumProc();
int MinNumEleOnProc;
int NumMyEle = Map.NumMyElements();
Comm.MinAll(&NumMyEle,&MinNumEleOnProc,1);
if (MinNumEleOnProc > 5) NumElePerProc = 6;
else NumElePerProc = MinNumEleOnProc;
if (NumElePerProc > 0) {
TotalNumEle = NumElePerProc*NumProc;
int * MyGIDlist = new int[NumElePerProc];
int * GIDlist = new int[TotalNumEle];
int * PIDlist = new int[TotalNumEle];
int * LIDlist = new int[TotalNumEle];
int * SizeList = new int[TotalNumEle];
for (i=0; i<NumElePerProc; i++)
MyGIDlist[i] = MyGlobalElements1[i];
Comm.GatherAll(MyGIDlist,GIDlist,NumElePerProc);// Get a few values from each proc
Map.RemoteIDList(TotalNumEle, GIDlist, PIDlist, LIDlist, SizeList);
int MyPID= Comm.MyPID();
forierr = 0;
for (i=0; i<TotalNumEle; i++) {
if (Map.MyGID(GIDlist[i])) {
forierr += PIDlist[i] != MyPID;
forierr += !Map.MyLID(Map.LID(GIDlist[i])) || Map.LID(GIDlist[i]) != LIDlist[i] || Map.GID(LIDlist[i]) != GIDlist[i];
forierr += SizeList[i] != Map.ElementSize(LIDlist[i]);
}
else {
forierr += PIDlist[i] == MyPID; // If MyGID comes back false, the PID listed should be that of another proc
}
}
EPETRA_TEST_ERR(forierr,ierr);
delete [] MyGIDlist;
delete [] GIDlist;
delete [] PIDlist;
delete [] LIDlist;
delete [] SizeList;
}
delete [] MyGlobalElements1;
delete [] MyElementSizeList;
// Check RemoteIDList function (assumes all maps are linear, even if not stored that way)
if (Map.LinearMap()) {
int * GIDList = new int[3];
int * PIDList = new int[3];
int * LIDList = new int[3];
int MyPID = Map.Comm().MyPID();
int NumIDs = 0;
//GIDList[NumIDs++] = Map.MaxAllGID()+1; // Should return -1 for both PID and LID
if (Map.MinMyGID()-1>=Map.MinAllGID()) GIDList[NumIDs++] = Map.MinMyGID()-1;
if (Map.MaxMyGID()+1<=Map.MaxAllGID()) GIDList[NumIDs++] = Map.MaxMyGID()+1;
Map.RemoteIDList(NumIDs, GIDList, PIDList, LIDList);
NumIDs = 0;
//EPETRA_TEST_ERR(!(PIDList[NumIDs]==-1),ierr);
//EPETRA_TEST_ERR(!(LIDList[NumIDs++]==-1),ierr);
if (Map.MinMyGID()-1>=Map.MinAllGID()) EPETRA_TEST_ERR(!(PIDList[NumIDs++]==MyPID-1),ierr);
if (Map.MaxMyGID()+1<=Map.MaxAllGID()) EPETRA_TEST_ERR(!(PIDList[NumIDs]==MyPID+1),ierr);
if (Map.MaxMyGID()+1<=Map.MaxAllGID()) EPETRA_TEST_ERR(!(LIDList[NumIDs++]==0),ierr);
delete [] GIDList;
delete [] PIDList;
delete [] LIDList;
}
return (ierr);
}
