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); }