Changes to get the shared node regeneration working, and to get the TOPS layer workin...
authorIsaac Dooley <idooley2@illinois.edu>
Thu, 12 Mar 2009 20:43:21 +0000 (20:43 +0000)
committerIsaac Dooley <idooley2@illinois.edu>
Thu, 12 Mar 2009 20:43:21 +0000 (20:43 +0000)
src/libs/ck-libs/ParFUM/Makefile
src/libs/ck-libs/ParFUM/ParFUM.h
src/libs/ck-libs/ParFUM/ParFUM_internals.h
src/libs/ck-libs/ParFUM/import.C
src/libs/ck-libs/ParFUM/import.h
src/libs/ck-libs/ParFUM/mesh.C
src/libs/ck-libs/ParFUM/mesh_adjacency.C
src/libs/ck-libs/ParFUM/mesh_modify.C

index dcccde4fee41820fca0a90be2b33513428f0e41c..c6196db3edcee0ce3ee8d6c88de959d4a4f9d6de 100644 (file)
@@ -7,7 +7,7 @@ MPICC=$(CDIR)/bin/mpiCC $(OPTS)
 INTERNALHEADERS= ParFUM_internals.h ParFUM_locking.h ParFUM_Mesh_Modify.h ParFUM_Adapt_Algs.h ParFUM_Adapt.h ParFUM_Interpolate.h ParFUM_SA.h import.h adapt_adj.h bulk_adapt_ops.h bulk_adapt.h
 
 #Headers to be copied to include directory so application users can see them
-HEADERS= ParFUM.h ParFUMf.h  $(INTERNALHEADERS)
+HEADERS= ParFUM.h ParFUMf.h ParFUM_Types.h $(INTERNALHEADERS)
 
 #Headers generated from .ci files
 GENHEADERS= ParFUM.def.h ParFUM.decl.h ParFUM_Adapt.decl.h ParFUM_Adapt.def.h ParFUM_SA.def.h ParFUM_SA.decl.h
index 50994a7c4783a1809395e0463c570cef22d2c502..76915bddb139b8e53227f72aa11d3785667e5ad8 100644 (file)
@@ -1,6 +1,12 @@
-/*Charm++ Finite Element Framework:
- * C interface file
- */
+/** Charm++ ParFUM Framework:
+    C++ interface file
+    
+    \addtogroup ParFUM
+    @{
+    
+*/
+
+
 #ifndef __PARFUM_H
 #define __PARFUM_H
 #include "charm++.h"
 #include "charm-api.h"
 #include "ckvector3d.h"
 #include "tcharm.h"
-
-/**
- * \addtogroup ParFUM
-*/
-/*@{*/
-
+#include "ParFUM_Types.h" // for ElemID
 
 
 
@@ -208,10 +209,6 @@ extern "C" {
   typedef void (*FEM_Userdata_fn)(pup_er p,void *data);
   void FEM_Mesh_pup(int fem_mesh,int dataTag,FEM_Userdata_fn fn,void *data);
 
-  // ghosts and spatial symmetries
-#define FEM_Is_ghost_index(idx) ((idx)<-1)
-#define FEM_To_ghost_index(idx) (-(idx)-2)
-#define FEM_From_ghost_index(idx) (-(idx)-2)
 
   void FEM_Add_ghost_layer(int nodesPerTuple,int doAddNodes);
   void FEM_Add_ghost_elem(int elType,int tuplesPerElem,const int *elem2tuple);
@@ -512,6 +509,12 @@ void ParFUM_SA_Init(int meshId);
 FDECL void FTN_NAME(PARFUM_SA_INIT,parfum_sa_init)(int *meshId);
 
 }
+
+
+
+
+
+
 #endif
 
 /*@}*/
index c85b9dd0ea8f36882ca823f6497e0f1ca669f984..eae895ded22f222b2f03eca86abbaa688a363b03 100644 (file)
@@ -43,6 +43,9 @@
 #include "cklists.h"
 #include "pup.h"
 
+#include "ParFUM.h"
+
+
 #if CMK_STL_USE_DOT_H /* Pre-standard C++ */
 #  include <iostream.h>
 #else /* ISO C++ */
@@ -245,7 +248,7 @@ class BasicTable2d : public CkNoncopyable {
 /** A heap-allocatable, resizable BasicTable2d.
  * To be stored here, T must not require a copy constructor.
  */
-template <class T>
+template <class BasicTable2dT>
 class AllocTable2d : public BasicTable2d<T> {
   ///Maximum number of rows that can be used without reallocation
   int max;
@@ -601,82 +604,57 @@ PUPmarshall(FEM_IndexAttribute);
   is mapped to a list of element indices of unknown length.
 */
 class FEM_VarIndexAttribute : public FEM_Attribute{
- public:
-        
-/** A reference to an element(contains both type and index). Ghost indices are handled correctly here */
-  class ID{
-  public:
-    ///type is negative for ghost elements
-    int type;
-    ///id refers to the index in the entity list
-    int id;
 
-    ///default constructor
-    ID(){
-      type=-1;
-      id = -1;
-    };
-    ///constructor - initializer
-    ID(int _type,int _id){
-      if(_id < 0) {
-         type = -(_type+1);
-         id = FEM_To_ghost_index(_id);
-      }
-      else {
-         type = _type;
-         id = _id;
-      }
-    };
-    bool operator ==(const ID &rhs)const {
-      return (type == rhs.type) && (id == rhs.id);
-    }
-    bool operator < (const ID &rhs)const {
-       return (type < rhs.type) || ( type == rhs.type && id < rhs.id);
-     }
-    const ID& operator =(const ID &rhs) {
-      type = rhs.type;
-      id = rhs.id;
-      return *this;
-    }
-    virtual void pup(PUP::er &p){
-      p | type;
-      p | id;
-    };
+/* /\**  */
+/*     A reference to an an entity. Internally this stores a signed  */
+/*     integer that can be interpreted a number of different ways. */
+/* *\/ */
+/*   class ID{ */
+/*   public: */
+/*     ///id refers to the index in the entity list */
+/*     int id; */
+    
+/*     ///default constructor */
+/*     ID(){ */
+/*       id = -1; */
+/*     }; */
+/*     ///constructor - initializer */
+/*     ID(int _id){ */
+/*       id = _id; */
+/*     }; */
+/*     bool operator ==(const ID &rhs)const { */
+/*       return (id == rhs.id); */
+/*     } */
+/*     bool operator < (const ID &rhs)const { */
+/*       return (id < rhs.id); */
+/*     } */
+
+/*     const ID& operator =(const ID &rhs) { */
+/*       id = rhs.id; */
+/*       return *this; */
+/*     } */
+    
+/*     static ID createNodeID(int node){ */
+/*       ID temp(node); */
+/*       return temp; */
+/*     } */
 
-    static ID createNodeID(int type,int node){
-      ID temp(type, node);
-      return temp;
-    }
-    int getSignedId() {
-      if(type<0){
-         return FEM_From_ghost_index(id);
-      }
-      else return id;
-    }
-    int getSignedType(){
-       return type;
-    }
-    /** Return the element's type. This is necessary because the type member itself is negative for ghosts(for some stupid reason) */
-    int getUnsignedType(){
-       if(type>=0)
-               return type;
-       else 
-               return -(type+1);
-    }
-        
-    void println(){
-       if(type<0){
-               CkPrintf("ghost element with type=%d, id=%d\n", getUnsignedType(), id);                 
-       } else    {
-               CkPrintf("element with type=%d, id=%d\n", getUnsignedType(), id);               
-       }
+/*     int getSignedId() { */
+/*       return id; */
+/*     } */
 
-    }
-    
-  };
+/*     void pup(PUP::er &p) { */
+/*       p|id; */
+/*     } */
+
+   
+/*   }; */
+  
+  
+  
  private:
   typedef FEM_Attribute super;
-  CkVec<CkVec<ID> > idx;
+  CkVec<CkVec<ElemID> > idx;
   int oldlength;
  protected:
   virtual void allocate(int _length,int _width,int _datatype){
@@ -685,7 +663,7 @@ class FEM_VarIndexAttribute : public FEM_Attribute{
       oldlength = _length*2;
       idx.reserve(oldlength);
       for(int i=idx.size();i<oldlength;i++){
-       CkVec<ID> tempVec;
+       CkVec<ElemID> tempVec;
        idx.insert(i,tempVec);
       }
     }
@@ -695,8 +673,8 @@ class FEM_VarIndexAttribute : public FEM_Attribute{
   ~FEM_VarIndexAttribute(){};
   virtual void pup(PUP::er &p);
   virtual void pupSingle(PUP::er &p, int pupindx);
-  CkVec<CkVec<ID> > &get(){return idx;};
-  const CkVec<CkVec<ID> > &get() const {return idx;};
+  CkVec<CkVec<ElemID> > &get(){return idx;};
+  const CkVec<CkVec<ElemID> > &get() const {return idx;};
 
   virtual void set(const void *src,int firstItem,int length,
                   const IDXL_Layout &layout,const char *caller);
@@ -706,7 +684,7 @@ class FEM_VarIndexAttribute : public FEM_Attribute{
 
   virtual void copyEntity(int dstEntity,const FEM_Attribute &src,int srcEntity);
 
-  int findInRow(int row,const ID &data);
+  int findInRow(int row,const ElemID &data);
 
   void print();
 };
@@ -1006,7 +984,7 @@ class FEM_Node : public FEM_Entity {
   
   FEM_VarIndexAttribute *nodeAdjacency; ///< stores the node to node adjacency vector
 
-  typedef FEM_VarIndexAttribute::ID var_id;
+  typedef ElemID var_id;
  protected:
   virtual void create(int attr,const char *caller);
  public:
@@ -1396,11 +1374,11 @@ class FEM_Mesh : public CkNoncopyable {
   /// nbr is the i-th element adjacent to e
   int e2e_getIndex(int e, int nbr, int etype=0);
   /// Same as previous but also returning the element type
-  FEM_VarIndexAttribute::ID e2e_getElem(int idx, int nbr, int etype=0);
+  ElemID e2e_getElem(int idx, int nbr, int etype=0);
   /// Get an element adjacent to elem across its nbr'th face
-  FEM_VarIndexAttribute::ID e2e_getElem(FEM_VarIndexAttribute::ID elem, int nbr);
+  ElemID e2e_getElem(ElemID elem, int nbr);
   /// Same as above
-  FEM_VarIndexAttribute::ID e2e_getElem(FEM_VarIndexAttribute::ID *elem, int nbr);
+  ElemID e2e_getElem(ElemID *elem, int nbr);
   /// Set the element adjacencies of element e to neighbors; assumes neighbors
   /// has the correct size
   void e2e_setAll(int e, int *neighbors, int etype=0);
@@ -1409,12 +1387,12 @@ class FEM_Mesh : public CkNoncopyable {
   /// Find element oldNbr in e's adjacent elements and replace with newNbr
   void e2e_replace(int e, int oldNbr, int newNbr, int etype=0);
   /// Find element oldNbr in e's adjacent elements and replace with newNbr
-  void e2e_replace(FEM_VarIndexAttribute::ID e, FEM_VarIndexAttribute::ID oldNbr, FEM_VarIndexAttribute::ID newNbr); 
+  void e2e_replace(ElemID e, ElemID oldNbr, ElemID newNbr); 
   
   /// Remove all neighboring elements in adjacency
   void e2e_removeAll(int e, int etype=0);
 
-  void e2e_printAll(FEM_VarIndexAttribute::ID e); 
+  void e2e_printAll(ElemID e); 
 
   
 
@@ -1463,10 +1441,10 @@ class FEM_Mesh : public CkNoncopyable {
   void n2e_getAll(int n, int *&adjelements, int &sz);
  
   /// Return a reference to the structure holding all the elements adjacent to a node
-  const CkVec<FEM_VarIndexAttribute::ID> & n2e_getAll(int n); 
+  const CkVec<ElemID> & n2e_getAll(int n); 
   
   /// Get one of node n's adjacent elements
-  FEM_VarIndexAttribute::ID  n2e_getElem(int n, int whichAdjElem);
+  ElemID  n2e_getElem(int n, int whichAdjElem);
   /// Adds newElem to node n's element adjacency list
   void n2e_add(int n, int newElem);
   /// Removes oldElem from n's element adjacency list
index 1ef1de0e1deec4edaf70a8739f9f052c4c90d567..7555c24da3072ead09b0910924359952c9ca987a 100644 (file)
@@ -14,9 +14,15 @@ void ParFUM_deghosting(int meshid){
        mesh->clearGhostElems();
 }
 
+
+
+/// Recreate the shared nodes. An alternate incorrect version can be enabled by undefining CORRECT_COORD_COMPARISON
 void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
+#define CORRECT_COORD_COMPARISON
   MPI_Comm comm = newComm;
   int rank, nParts;
+  int send_count=0; // sanity check
+  int recv_count=0; // sanity check
   MPI_Comm_rank(comm, &rank);
   MPI_Comm_size(comm, &nParts);
   // Shared data will be temporarily stored in the following structure
@@ -39,36 +45,39 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
   FEM_Mesh_become_get(meshid);
 
   FEM_Mesh_data(meshid,FEM_NODE,FEM_COORD, nodeCoords, 0, numNodes,FEM_DOUBLE, dim);
-  /*
-  printf("Node Coords for rank %d \n",rank);
-  for(int n=0;n<numNodes;n++){
-    printf("%d -> ", n);
-    for (int m-0; m<dim; m++) 
-      printf("%.5lf %.5lf \n", nodeCoords[dim*n+m]);
-  }
-  */
+  
   //MPI_Barrier(MPI_COMM_WORLD);
   if (rank==0) CkPrintf("Extracted node data...\n");
 
   // Begin exchange of node coordinates to determine shared nodes
   // FIX ME: compute bounding box, only exchange when bounding boxes collide
-  for (int i=rank+1; i<nParts; i++) { //send nodeCoords to rank i
-    //printf("[%d] Sending %d doubles to rank %d \n",rank,dim*numNodes,i);
-    MPI_Send(nodeCoords, dim*numNodes, MPI_DOUBLE, i, coord_msg_tag, comm);
+
+  /// The highest partition # to which I send my coordinates(wraps around)
+  int sendUpperBound;   if(nParts %2==0){
+    sendUpperBound = rank + (nParts/2)  - (rank%2);
+  } else {
+    sendUpperBound = rank + (nParts/2) ;
   }
-  // Handle node coordinate-matching requests from other ranks
 
-  //MPI_Barrier(MPI_COMM_WORLD);
-  if (rank==0) CkPrintf("Exchanged node coords...\n");
+  /// The lowest partition # to which I send my coordinates(wraps around)
+  int sendLowerBound;
+    if(nParts %2==0){
+    sendLowerBound = rank - (nParts/2) + ((rank+1)%2);
+  } else {
+    sendLowerBound = rank - (nParts/2);
+  }
 
-  int *sorted_local_idxs = (int *)malloc(numNodes*sizeof(int));
-  double *sorted_nodeCoords = (double *)malloc(dim*numNodes*sizeof(double));
-  sortNodes(nodeCoords, sorted_nodeCoords, sorted_local_idxs, numNodes, dim);
 
-  //MPI_Barrier(MPI_COMM_WORLD);
-  if (rank==0) CkPrintf("Sorted node coords...\n");
+  for (int i=rank+1; i<=sendUpperBound; i++) { //send nodeCoords to rank i
+    MPI_Send(nodeCoords, dim*numNodes, MPI_DOUBLE, i%nParts, coord_msg_tag, comm);
+    send_count ++;
+    //    printf("[%d] Sending %d doubles  to rank %d \n",rank,dim*numNodes,i%nParts);
+  }
+
 
-  for (int i=0; i<rank; i++) {
+  // Receive coordinates from the appropriate number of other partitions
+  // These can be received in any order
+  for (int i=sendLowerBound; i<rank; i++) {
     std::vector<int> remoteSharedNodes, localSharedNodes;
     double *recvNodeCoords;
     MPI_Status status;
@@ -77,7 +86,8 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
     MPI_Probe(MPI_ANY_SOURCE, coord_msg_tag, comm, &status);
     source = status.MPI_SOURCE;
     length = status.MPI_LENGTH/sizeof(double);
-    //printf("[%d] Receiving %d doubles from rank %d \n",rank,length,i);
+    // printf("[%d] Receiving %d doubles from rank %d \n",rank,length,source);
+    recv_count ++;
     // Receive whatever data was available according to probe
     recvNodeCoords = (double *)malloc(length*sizeof(double));
     MPI_Recv((void*)recvNodeCoords, length, MPI_DOUBLE, source, 
@@ -85,11 +95,7 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
     // Match coords between local nodes and received coords
     int recvNodeCount = length/dim;
 
-    int *sorted_remote_idxs = (int *)malloc(recvNodeCount*sizeof(int));
-    double *sorted_recvNodeCoords = (double *)malloc(length*sizeof(double));
-    sortNodes(recvNodeCoords, sorted_recvNodeCoords, sorted_remote_idxs, recvNodeCount, dim);
-
-    /* OLD SLOW WAY
+    //    CkPrintf("Comparing %d nodes with %d received nodes\n", numNodes, recvNodeCount);
     for (int j=0; j<numNodes; j++) {
       for (int k=0; k<recvNodeCount; k++) {
        if (coordEqual(&nodeCoords[j*dim], &recvNodeCoords[k*dim], dim)) {
@@ -100,31 +106,6 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
        }
       }
     }
-    */
-
-    int j = 0; 
-    int k = 0;
-    while ((j<numNodes) && (k < recvNodeCount)) {
-      if ((coordCompare(&sorted_nodeCoords[j*dim], &sorted_recvNodeCoords[k*dim], dim)) == 0) {
-       localSharedNodes.push_back(sorted_local_idxs[j]); 
-       remoteSharedNodes.push_back(sorted_remote_idxs[k]);
-       j++; k++;
-      }
-      else if (coord_leq(&sorted_nodeCoords[j*dim], &sorted_recvNodeCoords[k*dim], dim)) {
-       // local is less than remote
-       j++;
-      }
-      else if (!coord_leq(&sorted_nodeCoords[j*dim], &sorted_recvNodeCoords[k*dim], dim)) { 
-       // remote is less than local; remote is not present
-       k++;
-      }
-    }
-    
-    /*
-    if (localSharedNodes.size() > 0) {
-      printf("%d has %d nodes shared with %d.\n", rank, localSharedNodes.size(), source);
-    }
-    */
 
     // Copy local nodes that were shared with source into the data structure
     int *localSharedNodeList = (int *)malloc(localSharedNodes.size()*sizeof(int));
@@ -140,10 +121,8 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
     free(recvNodeCoords);
   }
 
-  //MPI_Barrier(MPI_COMM_WORLD);
-  if (rank==0) CkPrintf("Received node coords, send shared...\n");
 
-  for (int i=rank+1; i<nParts; i++) {  // recv shared node lists
+  for (int i=rank+1; i<=sendUpperBound; i++) {  // recv shared node lists (from the partitions in any order)
     int *sharedNodes;
     MPI_Status status;
     int source, length;
@@ -160,8 +139,7 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
     // don't delete sharedNodes! we kept a pointer to it!
   }
 
-  //MPI_Barrier(MPI_COMM_WORLD);
-  if (rank==0) CkPrintf("Received shared...\n");
+  if (rank==0) CkPrintf("Received new shared node lists...\n");
 
   // IMPLEMENT ME: use sharedNodeLists and sharedNodeCounts to move shared node data 
   // to IDXL
@@ -178,13 +156,17 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
       }
     }
   }
+  
+  
+  MPI_Barrier(MPI_COMM_WORLD);
 
-  //MPI_Barrier(MPI_COMM_WORLD);
   if (rank==0) CkPrintf("Recreation of shared nodes complete...\n");
 
   //printf("After recreating shared nodes %d \n",rank);
   //shared.print();
        
+  CkAssert(send_count + recv_count == nParts-1);
+
   // Clean up
   free(nodeCoords);
   free(sharedNodeCounts);
@@ -193,8 +175,6 @@ void ParFUM_recreateSharedNodes(int meshid, int dim, MPI_Comm newComm) {
       free(sharedNodeLists[i]);
   }
   free(sharedNodeLists);
-  //MPI_Barrier(MPI_COMM_WORLD);
-  if (rank==0) CkPrintf("All cleaned up.\n");
 }
 
 void ParFUM_createComm(int meshid, int dim, MPI_Comm comm)
index 81414588d432e682cf15e3684ad109bd4a2cb0c1..bad4d5a71a919cbf3537489290b8b94b9a084e50 100644 (file)
@@ -19,6 +19,8 @@ extern int getFloatFormat(void);
  * -1 if key1 < key2
  */
 inline int coordCompare(const double *key1, const double *key2, int dim) {
+#if TERRY_BIT_COMPARE
+  // This version contains some bit operations that confused Isaac, so he wrote the other implementation below.
   static const int endian = getFloatFormat();
   int maxUlps=100;
   for(int ii=0; ii<dim; ii++) {
@@ -38,6 +40,22 @@ inline int coordCompare(const double *key1, const double *key2, int dim) {
     }
   }
   return 0;
+#else
+  CkAssert(dim==3);
+  const double threshold = 0.001;
+  for(int i=0; i<dim; i++) {
+    const double a = key1[i];
+    const double b = key2[i];
+    const double diff = a-b;
+    if (diff < -1.0*threshold){
+      return 1;
+    }
+    else if (diff > threshold){
+      return -1;
+    }
+  }
+  return 0;
+#endif
 } 
 
 inline int coordEqual(const double *key1, const double *key2, int dim) {
index fdbdce9d91ae0ef5942d03b91b9f618880a93677..8c5e6f87d02e497290292c54a8f337f074ca218c 100644 (file)
@@ -6,7 +6,6 @@ Orion Sky Lawlor, olawlor@acm.org, 12/20/2002
 FEM Implementation file: mesh creation and user-data manipulation.
 */
 
-#include "ParFUM.h"
 #include "ParFUM_internals.h"
 
 extern int femVersion;
@@ -1039,8 +1038,8 @@ void FEM_VarIndexAttribute::get(void *dest, int firstItem,int length,
 
 void FEM_VarIndexAttribute::copyEntity(int dstEntity,const FEM_Attribute &_src,int srcEntity){
        FEM_VarIndexAttribute &src = (FEM_VarIndexAttribute &)_src;
-       const CkVec<CkVec<ID> > &srcTable = src.get();
-        CkVec<ID> temp = srcTable[srcEntity];
+       const CkVec<CkVec<ElemID> > &srcTable = src.get();
+        CkVec<ElemID> temp = srcTable[srcEntity];
        idx.insert(dstEntity, temp);
 }
 
@@ -1048,17 +1047,17 @@ void FEM_VarIndexAttribute::print(){
        for(int i=0;i<idx.size();i++){
                printf("%d -> ",i);
                for(int j=0;j<idx[i].size();j++){
-                       printf("(%d %d) ",((idx[i])[j]).type,((idx[i])[j]).id);
+                       printf("(%d) ",((idx[i])[j]).id);
                }
                printf("\n");
        }
 };
 
-int FEM_VarIndexAttribute::findInRow(int row,const ID &data){
+int FEM_VarIndexAttribute::findInRow(int row, const ElemID &data){
        if(row >= idx.length()){
                return -1;
        }
-       CkVec<ID> &rowVec = idx[row];
+       CkVec<ElemID> &rowVec = idx[row];
        for(int i=0;i<rowVec.length();i++){
                if(data == rowVec[i]){
                        return i;
index 5fb364fbdf4ec9e3d4ef544b572e7b5014004ee4..e5aabc32701be426ee44efda754c792ede36ec50 100644 (file)
@@ -113,9 +113,9 @@ void FEM_Node::allocateNodeAdjacency(){
 void FEM_Node::setElemAdjacency(int type, const FEM_Elem &elem){
        int nodesPerElem = elem.getNodesPer();
        FEM_VarIndexAttribute *adjacencyAttr = elemAdjacency;
-       CkVec<CkVec<var_id> > &adjacencyTable = elemAdjacency->get();
+       CkVec<CkVec<ElemID> > &adjacencyTable = elemAdjacency->get();
        FEM_VarIndexAttribute *ghostAdjacencyAttr = ((FEM_Node *)getGhost())->elemAdjacency;
-       CkVec<CkVec<var_id> > &ghostAdjacencyTable = ghostAdjacencyAttr->get();
+       CkVec<CkVec<ElemID> > &ghostAdjacencyTable = ghostAdjacencyAttr->get();
 
        // Scan through elements
        for(int i=0;i<elem.size();i++){
@@ -556,20 +556,20 @@ int FEM_Mesh::e2e_getNbr(int e, short idx, int etype)
 }
 
 
-FEM_VarIndexAttribute::ID FEM_Mesh::e2e_getElem(FEM_VarIndexAttribute::ID elem, int idx){
+ElemID FEM_Mesh::e2e_getElem(ElemID elem, int idx){
        return e2e_getElem(elem.id, idx, elem.type);
 }
 
-FEM_VarIndexAttribute::ID FEM_Mesh::e2e_getElem(FEM_VarIndexAttribute::ID *elem, int idx){
+ElemID FEM_Mesh::e2e_getElem(ElemID *elem, int idx){
        return e2e_getElem(elem->id, idx, elem->type);
 }
 
 
 
 /** Get the idx'th element adjacent to element (e,etype) */
-FEM_VarIndexAttribute::ID FEM_Mesh::e2e_getElem(int e, int idx, int etype){
+ElemID FEM_Mesh::e2e_getElem(int e, int idx, int etype){
   if (e == -1){
-    FEM_VarIndexAttribute::ID ele(-1,-1);    
+    ElemID ele(-1,-1);    
     return ele;
   }
   
@@ -585,7 +585,7 @@ FEM_VarIndexAttribute::ID FEM_Mesh::e2e_getElem(int e, int idx, int etype){
 
          int t =  eAdjTypes[FEM_To_ghost_index(e)][idx];
          int id =  eAdjs[FEM_To_ghost_index(e)][idx];
-         FEM_VarIndexAttribute::ID ele(t,id);
+         ElemID ele(t,id);
 
          return ele;
   }
@@ -603,7 +603,7 @@ FEM_VarIndexAttribute::ID FEM_Mesh::e2e_getElem(int e, int idx, int etype){
 
          int t =  eAdjTypes[e][idx];
          int id =  eAdjs[e][idx];
-         FEM_VarIndexAttribute::ID ele(t,id);
+         ElemID ele(t,id);
 
          return ele;
   }
@@ -716,7 +716,7 @@ void FEM_Mesh::e2e_replace(int e, int oldNbr, int newNbr, int etype)
 
 /** Find element oldNbr in e's adjacent elements and replace with newNbr
  */
-void FEM_Mesh::e2e_replace(FEM_VarIndexAttribute::ID e, FEM_VarIndexAttribute::ID oldNbr, FEM_VarIndexAttribute::ID newNbr) 
+void FEM_Mesh::e2e_replace(ElemID e, ElemID oldNbr, ElemID newNbr) 
 {
   if (e.id == -1) return;
 
@@ -788,7 +788,7 @@ void FEM_Mesh::e2e_removeAll(int e, int etype)
 
 /**  Print all the elements adjacent to the given element.
 */
-void FEM_Mesh::e2e_printAll(FEM_VarIndexAttribute::ID e) 
+void FEM_Mesh::e2e_printAll(ElemID e) 
 {
        if (e.id == -1) return; // non existent element
        
@@ -982,8 +982,8 @@ int FEM_Mesh::n2n_getLength(int n) {
   else {
     eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_getLength");
   }
-  CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-  CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+  CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+  CkVec<ElemID> &nsVec = eVec[n];
   return nsVec.length();
 }
 
@@ -998,8 +998,8 @@ void FEM_Mesh::n2n_getAll(int n, int *&adjnodes, int &sz)
   }
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_NODE_ADJACENCY,"n2n_getAll");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[FEM_To_ghost_index(n)];
        sz = nsVec.length();
        if(sz > 0) adjnodes = new int[sz];
        for (int i=0; i<sz; i++) {
@@ -1008,8 +1008,8 @@ void FEM_Mesh::n2n_getAll(int n, int *&adjnodes, int &sz)
   }
   else{
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_getAll");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[n];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[n];
        sz = nsVec.length();
        if(sz > 0) adjnodes = new int[sz];
        for (int i=0; i<sz; i++) {
@@ -1025,16 +1025,16 @@ void FEM_Mesh::n2n_add(int n, int newNode)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_NODE_ADJACENCY,"n2n_add");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       FEM_VarIndexAttribute::ID nn(0, newNode);
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       ElemID nn(0, newNode);
+       CkVec<ElemID> &nsVec = nVec[FEM_To_ghost_index(n)];
        nsVec.push_back(nn);
   }
   else{
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_add");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       FEM_VarIndexAttribute::ID nn(0, newNode);
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[n];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       ElemID nn(0, newNode);
+       CkVec<ElemID> &nsVec = nVec[n];
        nsVec.push_back(nn);
   }
 }
@@ -1049,8 +1049,8 @@ void FEM_Mesh::n2n_remove(int n, int oldNode)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_NODE_ADJACENCY,"n2n_remove");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[FEM_To_ghost_index(n)];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldNode) {
                nsVec.remove(i);
@@ -1060,8 +1060,8 @@ void FEM_Mesh::n2n_remove(int n, int oldNode)
   }
   else {
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_remove");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[n];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[n];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldNode) {
                nsVec.remove(i);
@@ -1079,16 +1079,16 @@ int FEM_Mesh::n2n_exists(int n, int queryNode)
   if(FEM_Is_ghost_index(n)){
        CkAssert(node.getGhost());
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_NODE_ADJACENCY,"n2n_exists");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[FEM_To_ghost_index(n)];
        for (int i=0; i<nsVec.length(); i++)
          if (nsVec[i].getSignedId() == queryNode) 
                return 1;
   }
   else {
     FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_exists");
-    CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-    CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[n];
+    CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+    CkVec<ElemID> &nsVec = nVec[n];
     for (int i=0; i<nsVec.length(); i++)
       if (nsVec[i].getSignedId() == queryNode) 
        return 1;
@@ -1103,22 +1103,22 @@ void FEM_Mesh::n2n_replace(int n, int oldNode, int newNode)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_NODE_ADJACENCY,"n2n_replace");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[FEM_To_ghost_index(n)];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldNode) {
-               nsVec[i] = FEM_VarIndexAttribute::ID(0,newNode);
+               nsVec[i] = ElemID(0,newNode);
                break;
          }
        }
   }
   else {
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_replace");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[n];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[n];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldNode) {
-               nsVec[i] = FEM_VarIndexAttribute::ID(0,newNode);
+               nsVec[i] = ElemID(0,newNode);
                break;
          }
        }
@@ -1133,14 +1133,14 @@ void FEM_Mesh::n2n_removeAll(int n)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_NODE_ADJACENCY,"n2n_removeAll");  
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[FEM_To_ghost_index(n)];
        nsVec.free();
   }
   else{
        FEM_VarIndexAttribute *nAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_NODE_ADJACENCY,"n2n_removeAll");  
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &nVec = nAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = nVec[n];
+       CkVec<CkVec<ElemID> > &nVec = nAdj->get();
+       CkVec<ElemID> &nsVec = nVec[n];
        nsVec.free();
   }
 }
@@ -1158,28 +1158,28 @@ int FEM_Mesh::n2e_getLength(int n) {
   else {
     eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getLength");
   }
-  CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-  CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+  CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+  CkVec<ElemID> &nsVec = eVec[n];
   return nsVec.length();
 }
 
 /** Return one of node n's adjacent elements 
 */
 
-FEM_VarIndexAttribute::ID FEM_Mesh::n2e_getElem(int n, int whichIdx){
+ElemID FEM_Mesh::n2e_getElem(int n, int whichIdx){
 
   if(FEM_Is_ghost_index(n)){
     FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getElem");
-    CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-    CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[FEM_To_ghost_index(n)];
+    CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+    CkVec<ElemID> &nsVec = eVec[FEM_To_ghost_index(n)];
     assert(whichIdx < nsVec.length());
     return  nsVec[whichIdx];
     
   }
   else {
     FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getAll");
-    CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-    CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+    CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+    CkVec<ElemID> &nsVec = eVec[n];
     assert(whichIdx < nsVec.length());
     return  nsVec[whichIdx];
   }
@@ -1200,8 +1200,8 @@ void FEM_Mesh::n2e_getAll(int n, int *&adjelements, int &sz)
   }
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getAll");  
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[FEM_To_ghost_index(n)];
        sz = nsVec.length();
        if(sz > 0) adjelements = new int[sz];
        for (int i=0; i<sz; i++) {
@@ -1210,8 +1210,8 @@ void FEM_Mesh::n2e_getAll(int n, int *&adjelements, int &sz)
   }
   else {
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getAll");  
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[n];
        int len = nsVec.length();
        sz = len;
        if(sz > 0) adjelements = new int[sz];
@@ -1228,18 +1228,18 @@ void FEM_Mesh::n2e_getAll(int n, int *&adjelements, int &sz)
     
     This function returns elements and their associated types.
 */
-const CkVec<FEM_VarIndexAttribute::ID> &  FEM_Mesh::n2e_getAll(int n) 
+const CkVec<ElemID> &  FEM_Mesh::n2e_getAll(int n) 
 {
        assert(n!=-1); 
 
        if(FEM_Is_ghost_index(n)){
                FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getAll");  
-               CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
+               CkVec<CkVec<ElemID> > &eVec = eAdj->get();
                return eVec[FEM_To_ghost_index(n)];
        }
        else {
                FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_getAll");  
-               CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
+               CkVec<CkVec<ElemID> > &eVec = eAdj->get();
                return eVec[n];
        }
 }
@@ -1253,9 +1253,9 @@ void FEM_Mesh::n2e_add(int n, int newElem)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_add");     
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[FEM_To_ghost_index(n)];
-       FEM_VarIndexAttribute::ID ne(0, newElem);
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[FEM_To_ghost_index(n)];
+       ElemID ne(0, newElem);
        nsVec.push_back(ne);
        int *testn2e, testn2ec;
        n2e_getAll(n,testn2e,testn2ec);
@@ -1269,9 +1269,9 @@ void FEM_Mesh::n2e_add(int n, int newElem)
   }
   else {
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_add");     
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
-       FEM_VarIndexAttribute::ID ne(0, newElem);
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[n];
+       ElemID ne(0, newElem);
        nsVec.push_back(ne);
   }
 }
@@ -1283,8 +1283,8 @@ void FEM_Mesh::n2e_remove(int n, int oldElem)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_remove");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[FEM_To_ghost_index(n)];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldElem) {
                nsVec.remove(i);
@@ -1294,8 +1294,8 @@ void FEM_Mesh::n2e_remove(int n, int oldElem)
   }
   else {
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_remove");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[n];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldElem) {
                nsVec.remove(i);
@@ -1312,11 +1312,11 @@ void FEM_Mesh::n2e_replace(int n, int oldElem, int newElem)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_replace");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[FEM_To_ghost_index(n)];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldElem) {
-               nsVec[i] = FEM_VarIndexAttribute::ID(0,newElem);
+               nsVec[i] = ElemID(0,newElem);
                break;
          }
        }
@@ -1332,11 +1332,11 @@ void FEM_Mesh::n2e_replace(int n, int oldElem, int newElem)
   }
   else{
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_replace");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[n];
        for (int i=0; i<nsVec.length(); i++) {
          if (nsVec[i].getSignedId() == oldElem) {
-               nsVec[i] = FEM_VarIndexAttribute::ID(0,newElem);
+               nsVec[i] = ElemID(0,newElem);
                break;
          }
        }
@@ -1350,14 +1350,14 @@ void FEM_Mesh::n2e_removeAll(int n)
   if (n == -1) return;
   if(FEM_Is_ghost_index(n)){
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.getGhost()->lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_removeAll");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[FEM_To_ghost_index(n)];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[FEM_To_ghost_index(n)];
        nsVec.free();
   }
   else{
        FEM_VarIndexAttribute *eAdj = (FEM_VarIndexAttribute *)node.lookup(FEM_NODE_ELEM_ADJACENCY,"n2e_removeAll");
-       CkVec<CkVec<FEM_VarIndexAttribute::ID> > &eVec = eAdj->get();
-       CkVec<FEM_VarIndexAttribute::ID> &nsVec = eVec[n];
+       CkVec<CkVec<ElemID> > &eVec = eAdj->get();
+       CkVec<ElemID> &nsVec = eVec[n];
        nsVec.free();
   }
 }
index f5f12e0c8125ae3d99dbad2e2d0bf40b21b4c2d2..b458914a6785bdd1d882e16cb0e18597d58d8ac8 100644 (file)
@@ -382,11 +382,11 @@ void update_new_element_e2e(FEM_Mesh *m, int newEl, int elemType) {
        int *adjnodes = new int[nodesPerElem];
 
        /// A list of all elements adjacent to one of the nodes
-       CkVec<FEM_VarIndexAttribute::ID> nodeAdjacentElements;
+       CkVec<ElemID> nodeAdjacentElements;
 
        m->e2n_getAll(newEl, adjnodes, elemType);
        for(int i=0;i<nodesPerElem;i++){
-               CkVec<FEM_VarIndexAttribute::ID> adjElements = m->n2e_getAll(adjnodes[i]);
+               CkVec<ElemID> adjElements = m->n2e_getAll(adjnodes[i]);
                for(int j=0;j<adjElements.size();j++){
                        int found=0;
                        // only insert if it is not already in the list