Fix bug where int function had no return statement. Some tabs got converted to spaces...
authorIsaac Dooley <idooley2@illinois.edu>
Fri, 30 Mar 2007 21:26:38 +0000 (21:26 +0000)
committerIsaac Dooley <idooley2@illinois.edu>
Fri, 30 Mar 2007 21:26:38 +0000 (21:26 +0000)
checking function for Isaac to use.

src/libs/ck-libs/ParFUM/ParFUM_internals.h
src/libs/ck-libs/ParFUM/main.C
src/libs/ck-libs/ParFUM/mesh.C

index 4509b4fe22deed1ab29ca2bcd722643e0d9aa74e..724167a9a97ff9cd678aa11a8ede686e5a6f7258 100644 (file)
@@ -5,10 +5,10 @@
 /*@{*/
 
 
-/*** 
+/***
    ParFUM_internals.h
 
-   This file should contain ALL required header code that is 
+   This file should contain ALL required header code that is
    internal to ParFUM, but should not be visible to users. This
    includes all the old fem_mesh.h type files.
 
@@ -66,7 +66,7 @@ CtvExtern(FEM_Adapt_Algs *, _adaptAlgs);
   Charm++ Finite Element Framework:
   C++ implementation file: Mesh representation and manipulation
 
-  This file lists the classes used to represent and manipulate 
+  This file lists the classes used to represent and manipulate
   Finite Element Meshes inside the FEM framework.
 
   Orion Sky Lawlor, olawlor@acm.org, 1/3/2003
@@ -77,7 +77,7 @@ typedef IDXL_Side FEM_Comm;
 typedef IDXL_List FEM_Comm_List;
 typedef IDXL_Rec FEM_Comm_Rec;
 
-/// We want the FEM_Comm/IDXL_Side's to be accessible to *both* 
+/// We want the FEM_Comm/IDXL_Side's to be accessible to *both*
 ///  FEM routines (via these data structures) and IDXL routines
 ///  (via an idxl->addStatic registration).  Hence this class, which
 ///  manages IDXL's view of FEM's data structures.
@@ -90,7 +90,7 @@ class FEM_Comm_Holder {
   FEM_Comm_Holder(FEM_Comm *sendComm, FEM_Comm *recvComm);
   void pup(PUP::er &p);
   ~FEM_Comm_Holder(void);
-       
+
   /// Return our IDXL_Comm_t, registering with chunk if needed
   inline IDXL_Comm_t getIndex(IDXL_Chunk *c) {
     if (idx==-1) registerIdx(c);
@@ -113,10 +113,10 @@ class FEM_Sym_Desc : public PUP::able {
 
   /// Apply this symmetry to this location vector
   virtual CkVector3d applyLoc(const CkVector3d &loc) const =0;
-       
+
   /// Apply this symmetry to this relative (vel or acc) vector
   virtual CkVector3d applyVec(const CkVector3d &vec) const =0;
-       
+
   /// Allows Desc's to be pup'd via | operator:
   friend inline void operator|(PUP::er &p,FEM_Sym_Desc &a) {a.pup(p);}
   friend inline void operator|(PUP::er &p,FEM_Sym_Desc* &a) {
@@ -130,13 +130,13 @@ class FEM_Sym_Linear : public FEM_Sym_Desc {
  public:
   FEM_Sym_Linear(const CkVector3d &shift_) :shift(shift_) {}
   FEM_Sym_Linear(CkMigrateMessage *m) {}
-       
+
   /// Apply this symmetry to this location vector
   CkVector3d applyLoc(const CkVector3d &loc) const {return loc+shift;}
-       
+
   /// Apply this symmetry to this relative (vel or acc) vector
   virtual CkVector3d applyVec(const CkVector3d &vec) const {return vec;}
-       
+
   virtual void pup(PUP::er &p);
   PUPable_decl(FEM_Sym_Linear);
 };
@@ -147,24 +147,24 @@ class FEM_Sym_Linear : public FEM_Sym_Desc {
  */
 class FEM_Sym_List {
   //This lists the different kinds of symmetry
-  CkPupAblePtrVec<FEM_Sym_Desc> sym; 
-       
+  CkPupAblePtrVec<FEM_Sym_Desc> sym;
+
   FEM_Sym_List(const FEM_Sym_List &src); //NOT DEFINED: copy constructor
  public:
   FEM_Sym_List();
   void operator=(const FEM_Sym_List &src); //Assignment operator
   ~FEM_Sym_List();
-       
+
   /// Add a new kind of symmetry to this list, returning
   ///  the way objects with that symmetry should be marked.
   FEM_Symmetries_t add(FEM_Sym_Desc *desc);
-       
+
   /// Apply all the listed symmetries to this location
   void applyLoc(CkVector3d *loc,FEM_Symmetries_t sym) const;
-       
+
   /// Apply all the listed symmetries to this relative vector
   void applyVec(CkVector3d *vec,FEM_Symmetries_t sym) const;
-       
+
   void pup(PUP::er &p);
 };
 
@@ -176,21 +176,21 @@ class BasicTable2d : public CkNoncopyable {
   int cols; //Size of each entry in table
   T *table; //Data in table [rows * cols]
  public:
-  BasicTable2d(T *src,int cols_,int rows_) 
+  BasicTable2d(T *src,int cols_,int rows_)
     :rows(rows_), cols(cols_), table(src) {}
-       
+
   /// "size" of the table is the number of rows:
   inline int size(void) const {return rows;}
   /// Width of the table is the number of columns:
   inline int width(void) const {return cols;}
-       
+
   T *getData(void) {return table;}
   const T *getData(void) const {return table;}
-       
+
   // Element-by-element operations:
   T operator() (int r,int c) const {return table[c+r*cols];}
   T &operator() (int r,int c) {return table[c+r*cols];}
-       
+
   // Row-by-row operations
   ///Get a pointer to a row of the table:
   inline T *getRow(int r) {return &table[r*cols];}
@@ -213,22 +213,22 @@ class BasicTable2d : public CkNoncopyable {
 
   // These affect the entire table:
   void set(const T *src,T idxBase=0) {
-    for (int r=0;r<rows;r++) 
+    for (int r=0;r<rows;r++)
       for (int c=0;c<cols;c++)
        table[c+r*cols]=src[c+r*cols]-idxBase;
   }
   void setTranspose(const T *srcT,int idxBase=0) {
-    for (int r=0;r<rows;r++) 
+    for (int r=0;r<rows;r++)
       for (int c=0;c<cols;c++)
        table[c+r*cols]=srcT[r+c*rows]-idxBase;
   }
   void get(T *dest,T idxBase=0) const {
-    for (int r=0;r<rows;r++) 
+    for (int r=0;r<rows;r++)
       for (int c=0;c<cols;c++)
        dest[c+r*cols]=table[c+r*cols]+idxBase;
   }
   void getTranspose(T *destT,int idxBase=0) const {
-    for (int r=0;r<rows;r++) 
+    for (int r=0;r<rows;r++)
       for (int c=0;c<cols;c++)
        destT[r+c*rows]=table[c+r*cols]+idxBase;
   }
@@ -249,13 +249,13 @@ class AllocTable2d : public BasicTable2d<T> {
   ///Maximum number of rows that can be used without reallocation
   int max;
   ///Value to fill uninitialized regions with
-  T fill; 
+  T fill;
   /// the table that I allocated
   T *allocTable;
  public:
   ///default constructor
-  AllocTable2d(int cols_=0,int rows_=0,T fill_=0) 
-    :BasicTable2d<T>(NULL,cols_,rows_), max(0), fill(fill_)            
+  AllocTable2d(int cols_=0,int rows_=0,T fill_=0)
+    :BasicTable2d<T>(NULL,cols_,rows_), max(0), fill(fill_)
     {
                        allocTable = NULL;
       if (this->rows>0) allocate(this->rows);
@@ -263,11 +263,11 @@ class AllocTable2d : public BasicTable2d<T> {
   ///default destructor
   ~AllocTable2d() {if(allocTable != NULL){delete[] allocTable;}}
   /// Make room for this many rows
-  void allocate(int rows_) { 
+  void allocate(int rows_) {
     allocate(this->width(),rows_);
   }
   /// Make room for this many cols & rows
-  void allocate(int cols_,int rows_,int max_=0) { 
+  void allocate(int cols_,int rows_,int max_=0) {
     if (cols_==this->cols && rows_<max) {
       //We have room--just update the size:
       this->rows=rows_;
@@ -276,7 +276,7 @@ class AllocTable2d : public BasicTable2d<T> {
     if (max_==0) { //They gave no suggested size-- pick one:
       if (rows_==this->rows+1) //Growing slowly: grab a little extra
        max_=10+rows_+(rows_>>2); //  125% plus 10
-      else // for a big change, just go with the minimum needed: 
+      else // for a big change, just go with the minimum needed:
        max_=rows_;
     }
 
@@ -287,7 +287,7 @@ class AllocTable2d : public BasicTable2d<T> {
     this->table=new T[max*this->cols];
     //Preserve old table entries (FIXME: assumes old cols is unchanged)
     int copyRows=0;
-    if (allocTable!=NULL) { 
+    if (allocTable!=NULL) {
       copyRows=oldRows;
       if (copyRows>max) copyRows=max;
       memcpy(this->table,allocTable,sizeof(T)*this->cols*copyRows);
@@ -298,7 +298,7 @@ class AllocTable2d : public BasicTable2d<T> {
     }
     allocTable = this->table;
   }
-       
+
   /// Pup routine and operator|:
   void pup(PUP::er &p) {
     p|this->rows; p|this->cols;
@@ -317,7 +317,7 @@ class AllocTable2d : public BasicTable2d<T> {
 
   /// Add a row to the table (by analogy with std::vector):
   T *push_back(void) {
-    if (this->rows>=max) 
+    if (this->rows>=max)
       { //Not already enough room for the new row:
        int newMax=max+(max/4)+16; //Grow 25% longer
        allocate(this->cols,this->rows,newMax);
@@ -333,7 +333,7 @@ class AllocTable2d : public BasicTable2d<T> {
     if(allocTable != NULL){
       delete [] allocTable;
       allocTable = NULL;
-    }  
+    }
     this->table = user;
     this->rows = len;
     this->max = max;
@@ -369,16 +369,16 @@ class FEM_Attribute {
   int datatype;
   ///True if subclass allocate has been called.
   bool allocated;
-  
-  ///Abort with a nice error message saying: 
+
+  ///Abort with a nice error message saying:
   /** Our <field> was previously set to <cur>; it cannot now be <next>*/
   void bad(const char *field,bool forRead,int cur,int next,const char *caller) const;
-  
+
  protected:
   /**
    * Allocate storage for at least length width-item records of type datatype.
    * This routine is called after all three parameters are set,
-   * as a convenience for subclasses. 
+   * as a convenience for subclasses.
    */
   virtual void allocate(int length,int width,int datatype) =0;
  public:
@@ -386,68 +386,68 @@ class FEM_Attribute {
   virtual void pup(PUP::er &p);
   virtual void pupSingle(PUP::er &p, int pupindx);
   virtual ~FEM_Attribute();
-       
+
   /// Install this attribute as our ghost:
   inline void setGhost(FEM_Attribute *ghost_) { ghost=ghost_;}
-       
+
   /// Return true if we're a ghost
   inline bool isGhost(void) const { return ghost!=NULL; }
-       
+
   /// Return our attribute code
   inline int getAttr(void) const {return attr;}
 
   inline FEM_Entity *getEntity(void) {return e;}
-       
+
   /// Return the number of rows in our table of data (0 if unknown).
   /// This value is obtained directly from our owning Entity.
   int getLength(void) const;
   int getRealLength(void) const;
 
   int getMax();
-       
+
   /// Return the number of columns in our table of data (0 if unknown)
   inline int getWidth(void) const { return width<0?0:width; }
   inline int getRealWidth(void) const { return width; }
-       
+
   /// Return our FEM_* datatype (-1 if unknown)
   inline int getDatatype(void) const { return datatype; }
-       
+
   /**
    * Set our length (number of rows, or records) to this value.
    * Default implementation calls setLength on our owning entity
    * and tries to call allocate().
    */
   void setLength(int l,const char *caller="");
-       
+
   /**
    * Set our width (number of values per row) to this value.
    * The default implementation sets width and tries to call allocate().
    */
   void setWidth(int w,const char *caller="");
-       
+
   /**
    * Set our datatype (e.g., FEM_INT, FEM_DOUBLE) to this value.
    * The default implementation sets width and tries to call allocate().
    */
   void setDatatype(int dt,const char *caller="");
-       
+
   /**
    * Copy our width and datatype from this attribute.
    * The default implementation calls setWidth and setDatatype.
    * which should be enough for virtually any attribute.
    */
   virtual void copyShape(const FEM_Attribute &src);
-       
+
   /// Check if all three of length, width, and datatype are set,
   ///  but we're not yet allocated.  If so, call allocate; else ignore.
   void tryAllocate(void);
-       
+
   /// Our parent's length has changed: reallocate our storage
   inline void reallocate(void) { allocated=false; tryAllocate(); }
-       
+
   /// Return true if we've already had storage allocated.
   inline bool isAllocated(void) const {return allocated;}
-       
+
   /**
    * Set our data to these (typically user-supplied, unchecked) values.
    * Subclasses normally override this method as:
@@ -456,9 +456,9 @@ class FEM_Attribute {
    *       copy data from src.
    *    }
    */
-  virtual void set(const void *src, int firstItem,int length, 
+  virtual void set(const void *src, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller);
-       
+
   /**
    * Extract this quantity of user data.  Length and layout are
    * parameter checked by the default implementation.
@@ -470,16 +470,16 @@ class FEM_Attribute {
    */
   virtual void get(void *dest, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller) const;
-       
+
   /// Copy everything associated with src[srcEntity] into our dstEntity.
   virtual void copyEntity(int dstEntity,const FEM_Attribute &src,int srcEntity) =0;
 
-  /** Register this user data for this attributre 
+  /** Register this user data for this attributre
       Length, layout etc are checked by the default implementaion
   */
   virtual void register_data(void *dest, int length,int max,
                             const IDXL_Layout &layout, const char *caller);
-       
+
 };
 PUPmarshall(FEM_Attribute);
 
@@ -505,33 +505,33 @@ class FEM_DataAttribute : public FEM_Attribute {
   virtual void pup(PUP::er &p);
   virtual void pupSingle(PUP::er &p, int pupindx);
   ~FEM_DataAttribute();
-  
+
   AllocTable2d<unsigned char> &getChar(void) {return *char_data;}
   const AllocTable2d<unsigned char> &getChar(void) const {return *char_data;}
-  
+
   AllocTable2d<int> &getInt(void) {return *int_data;}
   const AllocTable2d<int> &getInt(void) const {return *int_data;}
-    
+
   AllocTable2d<double> &getDouble(void) {return *double_data;}
   const AllocTable2d<double> &getDouble(void) const {return *double_data;}
 
   AllocTable2d<float> &getFloat(void) {return *float_data;}
   const AllocTable2d<float> &getFloat(void) const {return *float_data;}
 
-  
-  virtual void set(const void *src, int firstItem,int length, 
+
+  virtual void set(const void *src, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller);
-  
-  virtual void get(void *dest, int firstItem,int length, 
+
+  virtual void get(void *dest, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller) const;
-  
+
   virtual void register_data(void *dest, int length,int max,
                             const IDXL_Layout &layout, const char *caller);
-  
-       
+
+
   /// Copy src[srcEntity] into our dstEntity.
   virtual void copyEntity(int dstEntity,const FEM_Attribute &src,int srcEntity);
-  
+
   /// extrapolate the values of a node from 2 others
   /** Extrapolate the value of D from A and B (using the fraction 'frac')
    */
@@ -554,7 +554,7 @@ class FEM_IndexAttribute : public FEM_Attribute {
   class Checker {
   public:
     virtual ~Checker();
-    
+
     /**
      * Check this (newly set) row of our table for validity.
      * You're expected to abort or throw or exit if something is wrong.
@@ -574,19 +574,19 @@ class FEM_IndexAttribute : public FEM_Attribute {
   virtual void pup(PUP::er &p);
   virtual void pupSingle(PUP::er &p, int pupindx);
   ~FEM_IndexAttribute();
-  
+
   AllocTable2d<int> &get(void) {return idx;}
   const AllocTable2d<int> &get(void) const {return idx;}
-       
-  virtual void set(const void *src, int firstItem,int length, 
+
+  virtual void set(const void *src, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller);
-       
+
   virtual void get(void *dest, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller) const;
 
   virtual void register_data(void *dest, int length, int max,
                             const IDXL_Layout &layout, const char *caller);
-       
+
   /// Copy src[srcEntity] into our dstEntity.
   virtual void copyEntity(int dstEntity,const FEM_Attribute &src,int srcEntity);
 };
@@ -594,7 +594,7 @@ PUPmarshall(FEM_IndexAttribute);
 
 ///The FEM_Attribute is a variable set of integer indices
 /**
-  This table maps an entity to a list of integer indices 
+  This table maps an entity to a list of integer indices
   of unknown length.
   The node to element adjacency array is an example, where a node
   is mapped to a list of element indices of unknown length.
@@ -655,7 +655,7 @@ class FEM_VarIndexAttribute : public FEM_Attribute{
  protected:
   virtual void allocate(int _length,int _width,int _datatype){
     if(_length > oldlength){
-      setWidth(1,"allocate"); //there is 1 vector per entity 
+      setWidth(1,"allocate"); //there is 1 vector per entity
       oldlength = _length*2;
       idx.reserve(oldlength);
       for(int i=idx.size();i<oldlength;i++){
@@ -671,25 +671,25 @@ class FEM_VarIndexAttribute : public FEM_Attribute{
   virtual void pupSingle(PUP::er &p, int pupindx);
   CkVec<CkVec<ID> > &get(){return idx;};
   const CkVec<CkVec<ID> > &get() const {return idx;};
-       
+
   virtual void set(const void *src,int firstItem,int length,
                   const IDXL_Layout &layout,const char *caller);
 
   virtual void get(void *dest, int firstItem,int length,
                   const IDXL_Layout &layout, const char *caller) const;
-       
+
   virtual void copyEntity(int dstEntity,const FEM_Attribute &src,int srcEntity);
 
   int findInRow(int row,const ID &data);
-       
+
   void print();
 };
 
 ///FEM_Entity describes an entire entity (nodes/elements/sparse) which contains attributes
 /**
- * Describes an entire class of "entities"--nodes, elements, or sparse 
+ * Describes an entire class of "entities"--nodes, elements, or sparse
  *  data records. Basically consists of a length and a set of
- *  FEM_Attributes. 
+ *  FEM_Attributes.
  */
 class FEM_Entity {
   ///symmetries
@@ -702,51 +702,51 @@ class FEM_Entity {
   FEM_Mesh_alloc_fn resize;
   /// arguments to the resize function
   void *args;
-       
+
   /**
-   * This is our main list of attributes-- everything about each of 
+   * This is our main list of attributes-- everything about each of
    * our entities is in this list of attributes.  This list is searched
-   * by our "lookup" method and maintained by our subclasses "create" 
+   * by our "lookup" method and maintained by our subclasses "create"
    * method and calls to our "add" method.
-   * 
+   *
    * It's a little funky having the superclass keep pointers to subclass
    * objects (like element connectivity), but very nice to be able to
    * easily loop over everything associated with an entity.
    */
   CkVec<FEM_Attribute *> attributes;
-       
+
   /**
    * Coordinates of each entity, from FEM_COORD.
    * Datatype is always FEM_DOUBLE, width is always 2 or 3.
    *  If NULL, coordinates are unknown.
    */
-  FEM_DataAttribute *coord; 
+  FEM_DataAttribute *coord;
   void allocateCoord(void);
-       
+
   /**
    * Symmetries of each entity, from FEM_SYMMETRIES.  This bitvector per
    * entity indicates which symmetry conditions the entity belongs to.
-   * Datatype is always FEM_BYTE (same as FEM_Symmetries_t), width 
+   * Datatype is always FEM_BYTE (same as FEM_Symmetries_t), width
    * is always 1.  If NULL, all the symmetries are 0.
    */
-  FEM_DataAttribute *sym; 
+  FEM_DataAttribute *sym;
   void allocateSym(void);
-       
+
   /**
    * Global numbers of each entity, from FEM_GLOBALNO.
    * If NULL, the global numbers are unknown.
    */
   FEM_IndexAttribute *globalno;
   void allocateGlobalno(void);
-       
+
   /**
     used to allocate the integer array for storing the boundary
-    values associated with an entity. 
+    values associated with an entity.
   */
   void allocateBoundary();
 
   /// Mesh sizing attribute for elements
-  /** Specifies a double edge length target for the mesh at each 
+  /** Specifies a double edge length target for the mesh at each
       element; used in adaptivity algorithms */
   FEM_DataAttribute *meshSizing;
   void allocateMeshSizing(void);
@@ -765,11 +765,11 @@ class FEM_Entity {
    * allocate only when we need to
    */
   int* invalidList;
-  ///length of invalid list 
+  ///length of invalid list
   int invalidListLen;
   ///length of allocated invalid list
   int invalidListAllLen;
-  
+
  protected:
   /**
    * lookup of this attribute code has failed: check if it needs
@@ -785,62 +785,62 @@ class FEM_Entity {
    * known beforehand should just call add() from their constructor.
    */
   virtual void create(int attr,const char *caller);
-       
+
   /// Add this attribute to this kind of Entity.
   /// This superclass is responsible for eventually deleting the attribute.
-  /// This class also attaches the ghost attribute, so be sure to 
+  /// This class also attaches the ghost attribute, so be sure to
   ///   call add before manipulating the attribute.
   void add(FEM_Attribute *attribute);
  public:
 
   FEM_Entity *ghost; // Our ghost entity type, or NULL if we're the ghost
-               
+
   FEM_Comm ghostSend; //Non-ghosts we send out (only set for real entities)
   FEM_Comm ghostRecv; //Ghosts we recv into (only set for ghost entities)
-  
+
        FEM_Comm_Holder ghostIDXL; //IDXL interface
 
   FEM_Entity(FEM_Entity *ghost_); //Default constructor
   void pup(PUP::er &p);
   virtual ~FEM_Entity();
-       
+
   /// Return true if we're a ghost
   bool isGhost(void) const {return ghost==NULL;}
-       
+
   /// Switch from this, a real entity, to the ghosts:
   FEM_Entity *getGhost(void) {return ghost;}
   const FEM_Entity *getGhost(void) const {return ghost;}
-       
+
        //should only be called on non-ghost elements that have ghosts.
        //empty its corresponding ghost entity and clear the idxls
        void clearGhost();
-       
+
   /// Return the number of entities of this type
   inline int size(void) const {return length==-1?0:length;}
   inline int realsize(void) const {return length;}
 
-  // return the maximum size 
+  // return the maximum size
   inline int getMax() { if(max > 0) return max; else return length;}
-       
+
   /// Return the human-readable name of this entity type, like "node"
   virtual const char *getName(void) const =0;
-       
+
   /// Copy all our attributes' widths and data types from this entity.
   void copyShape(const FEM_Entity &src);
-       
-  /** 
+
+  /**
    *  The user is setting this many entities.  This reallocates
    * all existing attributes to make room for the new entities.
    */
   void setLength(int newlen, bool f=false);
 
-  /** Support for registration API 
-   *  Set the current length and maximum length for this entity. 
+  /** Support for registration API
+   *  Set the current length and maximum length for this entity.
    *  If the current length exceeds the maximum length a resize
    *  method is called .
    */
   void setMaxLength(int newLen,int newMaxLen,void *args,FEM_Mesh_alloc_fn fn);
-       
+
   /// Copy everything associated with src[srcEntity] into our dstEntity.
   /// dstEntity must have already been allocated, e.g., with setLength.
   void copyEntity(int dstEntity,const FEM_Entity &src,int srcEntity);
@@ -848,25 +848,25 @@ class FEM_Entity {
   /// Add room for one more entity, with initial values from src[srcEntity],
   /// and return the new entity's index.
   int push_back(const FEM_Entity &src,int srcEntity);
-       
+
   /**
-   * Find this attribute (from an FEM_ATTR code) of this entity, or 
+   * Find this attribute (from an FEM_ATTR code) of this entity, or
    * create the entity (using the create method below) or abort if it's
    * not found.
    */
   FEM_Attribute *lookup(int attr,const char *caller);
 
-       
+
   /**
    * Get a list of the attribute numbers for this entity.
    */
   int getAttrs(int *attrs) const {
     int len=attributes.size();
-    for (int i=0;i<len;i++) 
+    for (int i=0;i<len;i++)
       attrs[i]=attributes[i]->getAttr();
     return len;
   }
-       
+
   /**
    * Allocate or Modify the FEM_IS_VALID attribute data
    */
@@ -875,9 +875,11 @@ class FEM_Entity {
   void set_invalid(int idx, bool isNode);
   int is_valid(int idx);         // will fail assertions for out of range indices
   int is_valid_any_idx(int idx); // will not fail assertions for out of range indices
+  int is_valid_nonghost_idx(int idx); // same as is_valid_any_idx except returns false for ghosts
+
   int count_valid();
   int get_next_invalid(FEM_Mesh *m=NULL, bool isNode=false, bool isGhost=false);// the arguments are not really needed but Nilesh added them when he wrote a messy version and did not remove them when he fixed the implementation. Since changing the uses was too painful the default arguments were added.
-  int set_all_invalid();
+  void set_all_invalid();
 
 
   virtual bool hasConn(int idx)=0;
@@ -892,22 +894,22 @@ class FEM_Entity {
   CkVec<FEM_Attribute *>* getAttrVec(){
     return &attributes;
   }
-       
+
   // Stupidest possible coordinate access
   inline FEM_DataAttribute *getCoord(void) {return coord;}
   inline const FEM_DataAttribute *getCoord(void) const {return coord;}
-       
+
   //Symmetry array access:
   const FEM_Symmetries_t *getSymmetries(void) const {
     if (sym==NULL) return NULL;
     else return (const FEM_Symmetries_t *)sym->getChar()[0];
   }
-  FEM_Symmetries_t getSymmetries(int r) const { 
+  FEM_Symmetries_t getSymmetries(int r) const {
     if (sym==NULL) return FEM_Symmetries_t(0);
     else return sym->getChar()(r,0);
   }
   void setSymmetries(int r,FEM_Symmetries_t s);
-       
+
   //Global numbering array access
   bool hasGlobalno(void) const {return globalno!=0;}
   int getGlobalno(int r) const {
@@ -921,24 +923,24 @@ class FEM_Entity {
 
   // Mesh sizing array access
   bool hasMeshSizing(void) const {return meshSizing!=0;}
-  double getMeshSizing(int r); 
+  double getMeshSizing(int r);
   void setMeshSizing(int r,double s);
   void setMeshSizing(double *sf);
-       
+
   //Ghost comm. list access
   FEM_Comm &setGhostSend(void) { return ghostSend; }
   const FEM_Comm &getGhostSend(void) const { return ghostSend; }
-  FEM_Comm &setGhostRecv(void) { 
+  FEM_Comm &setGhostRecv(void) {
     if (ghost==NULL) return ghostRecv;
-    else return ghost->ghostRecv; 
+    else return ghost->ghostRecv;
   }
   const FEM_Comm &getGhostRecv(void) const { return ghost->ghostRecv; }
-       
+
   void addVarIndexAttribute(int code){
     FEM_VarIndexAttribute *varAttribute = new FEM_VarIndexAttribute(this,code);
     add(varAttribute);
   }
-       
+
   void print(const char *type,const IDXL_Print_Map &map);
 };
 PUPmarshall(FEM_Entity);
@@ -951,7 +953,7 @@ inline int FEM_Attribute::getMax(){ return e->getMax();}
 
 ///FEM_Node is a type of FEM_Entity, which refers to nodes
 /**
- * Describes a set of FEM Nodes--the FEM_NODE entity type. 
+ * Describes a set of FEM Nodes--the FEM_NODE entity type.
  * Unlike elements, nodes have no connectivity; but they do have
  * special shared-nodes communications and a "primary" flag.
  */
@@ -963,27 +965,27 @@ class FEM_Node : public FEM_Entity {
    * Datatype is always FEM_BYTE (we need an FEM_BIT!), width is always 1,
    * since there's only one such flag per node.
    */
-  FEM_DataAttribute *primary; 
+  FEM_DataAttribute *primary;
   void allocatePrimary(void);
-       
+
   void allocateElemAdjacency();
   void allocateNodeAdjacency();
 
-  FEM_VarIndexAttribute *elemAdjacency; ///< stores the node to element adjacency vector 
-  FEM_VarIndexAttribute *nodeAdjacency; ///< stores the node to node adjacency vector 
+  FEM_VarIndexAttribute *elemAdjacency; ///< stores the node to element adjacency vector
+  FEM_VarIndexAttribute *nodeAdjacency; ///< stores the node to node adjacency vector
   typedef FEM_VarIndexAttribute::ID var_id;
  protected:
   virtual void create(int attr,const char *caller);
  public:
   FEM_Comm shared; ///<Shared nodes
   FEM_Comm_Holder sharedIDXL; ///<IDXL interface to shared nodes
-       
+
   FEM_Node(FEM_Node *ghost_);
   void pup(PUP::er &p);
   ~FEM_Node();
-       
+
   virtual const char *getName(void) const;
-       
+
   inline bool getPrimary(int nodeNo) const {
     if (primary==NULL) return true; //Everything must be primary
     else return primary->getChar()(nodeNo,0);
@@ -1017,30 +1019,30 @@ class FEM_Elem:public FEM_Entity {
   int tuplesPerElem;
 
   // The following are attributes that will commonly be used:
-  FEM_IndexAttribute *conn;                ///< FEM_CONN attribute: element-to-node mapping 
+  FEM_IndexAttribute *conn;                ///< FEM_CONN attribute: element-to-node mapping
   FEM_IndexAttribute *elemAdjacency;       ///< FEM_ELEM_ELEM_ADJACENCY attribute
   FEM_IndexAttribute *elemAdjacencyTypes;  ///< FEM_ELEM_ELEM_ADJ_TYPES attribute
-  
+
  public:
-  
+
   FEM_Elem(const FEM_Mesh &mesh_, FEM_Elem *ghost_);
   void pup(PUP::er &p);
   ~FEM_Elem();
-  
+
   virtual const char *getName(void) const;
-  
+
   // Directly access our connectivity table:
   inline conn_t &setConn(void) {return conn->get();}
   inline const conn_t &getConn(void) const {return conn->get();}
-  
+
   void print(const char *type,const IDXL_Print_Map &map);
-  
+
   void create(int attr,const char *caller);
-  
+
   void allocateElemAdjacency();
-  
+
   FEM_IndexAttribute *getElemAdjacency(){return elemAdjacency;}
-  
+
   // Backward compatability routines:
   int getConn(int elem,int nodeNo) const {return conn->get()(elem,nodeNo);}
   int getNodesPer(void) const {return conn->get().width();}
@@ -1064,9 +1066,9 @@ PUPmarshall(FEM_Elem);
 class FEM_Sparse : public FEM_Elem {
   typedef FEM_Elem super;
   typedef AllocTable2d<int> elem_t;
-       
+
   /**
-   * elem, from FEM_SPARSE_ELEM, is an optional (that is, possibly NULL) 
+   * elem, from FEM_SPARSE_ELEM, is an optional (that is, possibly NULL)
    * array which changes the partitioning of sparse entities: if non-NULL,
    * sparse entity t lives on the same chunk as FEM_ELEM+elem[2*t]
    * local number elem[2*t+1].
@@ -1082,19 +1084,19 @@ class FEM_Sparse : public FEM_Elem {
   FEM_Sparse(const FEM_Mesh &mesh_, FEM_Sparse *ghost_);
   void pup(PUP::er &p);
   virtual ~FEM_Sparse();
-       
+
   virtual const char *getName(void) const;
-       
+
   /// Return true if we have an element partitioning table
   bool hasElements(void) const {return elem!=NULL;}
-       
+
   /// Directly access our element partitioning table (e.g., for re-numbering)
   inline elem_t &setElem(void) {return elem->get();}
   inline const elem_t &getElem(void) const {return elem->get();}
 };
 PUPmarshall(FEM_Sparse);
 
-/** Describes a user function to pup a piece of mesh data 
+/** Describes a user function to pup a piece of mesh data
  */
 class FEM_Userdata_pupfn {
   FEM_Userdata_fn fn;
@@ -1114,10 +1116,10 @@ class FEM_Userdata_item {
  public:
   int tag; //User-assigned identifier
   FEM_Userdata_item(int tag_=-1) {tag=tag_;}
-       
+
   /// Return true if we have stored data.
   bool hasStored(void) const {return data.size()!=0;}
-       
+
   /// Store this userdata inside us:
   void store(FEM_Userdata_pupfn &f) {
     data.resize(PUP::size(f));
@@ -1127,7 +1129,7 @@ class FEM_Userdata_item {
   void restore(FEM_Userdata_pupfn &f) {
     PUP::fromMemBuf(f,&data[0],data.size());
   }
-       
+
   /// Save our stored data to this PUP::er
   void pup(PUP::er &p) {
     p|tag;
@@ -1135,7 +1137,7 @@ class FEM_Userdata_item {
   }
 };
 
-/// Describes all the unassociated data in a mesh. 
+/// Describes all the unassociated data in a mesh.
 class FEM_Userdata_list {
   CkVec<FEM_Userdata_item> list;
  public:
@@ -1158,7 +1160,7 @@ void FEM_Index_Check(const char *caller,const char *entityType,int type,int maxT
 void FEM_Is_NULL(const char *caller,const char *entityType,int type);
 
 /**
- * This class describes several different types of a certain kind 
+ * This class describes several different types of a certain kind
  * of entity.  For example, there might be a FEM_Entity_Types<FEM_Elem>
  * that lists the different kinds of element.
  *
@@ -1176,9 +1178,9 @@ class FEM_Entity_Types {
   const char *name; //FEM_SPARSE or FEM_ELEM, or some such.
 
  public:
-  FEM_Entity_Types(const FEM_Mesh &mesh_,const char *name_) 
+  FEM_Entity_Types(const FEM_Mesh &mesh_,const char *name_)
     :mesh(mesh_), name(name_) {}
-  void pup(PUP::er &p) { 
+  void pup(PUP::er &p) {
     // Can't just use p|types, because T has a funky constructor:
     int n=types.size();
     p|n;
@@ -1193,10 +1195,10 @@ class FEM_Entity_Types {
     for (int i=0;i<types.size();i++)
       if (types[i]) delete types[i];
   }
-       
+
   /// Return the number of different entity types
   inline int size(void) const {return types.size();}
-       
+
   /// Return a read-only copy of this type, or else abort if type isn't set.
   const T &get(int type,const char *caller="") const {
     FEM_Index_Check(caller,name,type,types.size());
@@ -1204,13 +1206,13 @@ class FEM_Entity_Types {
     if (ret==NULL) FEM_Is_NULL(caller,name,type);
     return *ret;
   }
-       
+
   /// Return true if we have a type t, and false otherwise
-  bool has(int type) const { 
+  bool has(int type) const {
     if (type>=types.size()) return false;
-    return types[type]!=NULL; 
+    return types[type]!=NULL;
   }
-       
+
   /// Return a writable copy of this type, calling new T(mesh) if it's not there
   T &set(int type,const char *caller="") {
     if (type<0) FEM_Index_Check(caller,name,type,types.size());
@@ -1221,7 +1223,7 @@ class FEM_Entity_Types {
     }
     return *types[type];
   }
-       
+
   /// Read-only and write-only operator[]'s:
   inline T &operator[] (int type) { return set(type); }
   inline const T &operator[] (int type) const { return get(type); }
@@ -1246,9 +1248,9 @@ class FEM_Mesh : public CkNoncopyable {
   /// The symmetries in the mesh
   FEM_Sym_List symList;
   bool m_isSetting;
-  
+
   void checkElemType(int elType,const char *caller) const;
-  void checkSparseType(int uniqueID,const char *caller) const; 
+  void checkSparseType(int uniqueID,const char *caller) const;
 
  public:
   femMeshModify *fmMM;
@@ -1257,32 +1259,32 @@ class FEM_Mesh : public CkNoncopyable {
   FEM_ElemAdj_Layer* lastElemAdjLayer;
   void setFemMeshModify(femMeshModify *m);
   void setParfumSA(ParFUMShadowArray *m);
-  
+
   FEM_Mesh();
   void pup(PUP::er &p); //For migration
   ~FEM_Mesh();
 
   /// The nodes in this mesh:
-  FEM_Node node; 
-  
+  FEM_Node node;
+
   /// The different element types in this mesh:
   FEM_Entity_Types<FEM_Elem> elem;
-  
+
   /// The different sparse types in this mesh:
   FEM_Entity_Types<FEM_Sparse> sparse;
-  
+
   /// The unassociated user data for this mesh:
   FEM_Userdata_list udata;
-  
+
   /// The symmetries that apply to this mesh:
   void setSymList(const FEM_Sym_List &src) {symList=src;}
   const FEM_Sym_List &getSymList(void) const {return symList;}
-  
+
   /// Set up the "shape" of our fields-- the number of element types,
   /// the datatypes for user data, etc--based on this mesh.
   void copyShape(const FEM_Mesh &src);
 
-  // Get the fem mesh modification object associated with this mesh or partition  
+  // Get the fem mesh modification object associated with this mesh or partition
   femMeshModify *getfmMM();
 
   //Return this type of element, given an element type
@@ -1297,16 +1299,16 @@ class FEM_Mesh : public CkNoncopyable {
   FEM_Elem &setElem(int elType) {return elem[chkET(elType)];}
   const FEM_Elem &getElem(int elType) const {return elem[chkET(elType)];}
   int chkET(int elType) const; //Check this element type-- abort if it's bad
-  
+
   /// Look up this FEM_Entity type in this mesh, or abort if it's not valid.
   FEM_Entity *lookup(int entity,const char *caller);
   const FEM_Entity *lookup(int entity,const char *caller) const;
-  
+
   /// Set/get direction control:
   inline bool isSetting(void) const {return m_isSetting;}
   void becomeSetting(void) {m_isSetting=true;}
   void becomeGetting(void) {m_isSetting=false;}
-  
+
   int nElems() const //Return total number of elements (of all types)
     {return nElems(elem.size());}
   /// Return the total number of elements before type t
@@ -1317,33 +1319,33 @@ class FEM_Mesh : public CkNoncopyable {
   void setAscendingGlobalno(void);
   ///  The global numbers for elements runs across different types
   void setAbsoluteGlobalno();
-  
+
   void copyOldGlobalno(const FEM_Mesh &m);
   void print(int idxBase);//Write a human-readable description to CkPrintf
   /// Extract a list of our entities:
   int getEntities(int *entites);
-  
+
   /**
         * clearing the idxl and data for shared nodes and ghost nodes and shared elements
-        * 
+        *
         * */
 
        void clearSharedNodes();
        void clearGhostNodes();
        void clearGhostElems();
-  
+
   /********** New methods ***********/
   /*
-    This method creates the mapping from a node to all the elements that are 
+    This method creates the mapping from a node to all the elements that are
     incident on it . It assumes the presence of one layer of ghost nodes that
     share a node.
   */
   void createNodeElemAdj();
   void createNodeNodeAdj();
   void createElemElemAdj();
-  
+
   FEM_ElemAdj_Layer *getElemAdjLayer(void);
-  
+
   // Terry's adjacency accessors & modifiers
 
   //  ------- Element-to-element: preserve initial ordering relative to nodes
@@ -1355,7 +1357,7 @@ class FEM_Mesh : public CkNoncopyable {
   /// Given id of element e and id of another element nbr, return i such that
   /// nbr is the i-th element adjacent to e
   int e2e_getIndex(int e, int nbr, int etype=0);
-  /// Set the element adjacencies of element e to neighbors; assumes neighbors 
+  /// 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);
   /// Set the idx-th element adjacent to e to be newElem
@@ -1375,7 +1377,7 @@ class FEM_Mesh : public CkNoncopyable {
   /// Given id of element e and id of a node n, return i such that
   /// n is the i-th node adjacent to e
   short e2n_getIndex(int e, int n, int etype=0);
-  /// Set the node adjacencies of element e to adjnodes; assumes adjnodes 
+  /// Set the node adjacencies of element e to adjnodes; assumes adjnodes
   /// has the correct size
   void e2n_setAll(int e, int *adjnodes, int etype=0);
   /// Set the idx-th node adjacent to e to be newNode
@@ -1388,7 +1390,7 @@ class FEM_Mesh : public CkNoncopyable {
 
   //  ------- Node-to-node
   int n2n_getLength(int n);
-  /// Place all of node n's adjacent nodes in adjnodes and the resulting 
+  /// Place all of node n's adjacent nodes in adjnodes and the resulting
   /// length of adjnodes in sz; assumes adjnodes is not allocated, but sz is
   void n2n_getAll(int n, int *&adjnodes, int &sz);
   /// Adds newNode to node n's node adjacency list
@@ -1404,8 +1406,8 @@ class FEM_Mesh : public CkNoncopyable {
 
   //  ------- Node-to-element
   int n2e_getLength(int n);
-  /// Place all of node n's adjacent elements in adjelements and the resulting 
-  /// length of adjelements in sz; assumes adjelements is not allocated, 
+  /// Place all of node n's adjacent elements in adjelements and the resulting
+  /// length of adjelements in sz; assumes adjelements is not allocated,
   /// but sz is
   void n2e_getAll(int n, int *&adjelements, int &sz);
   /// Adds newElem to node n's element adjacency list
@@ -1418,20 +1420,20 @@ class FEM_Mesh : public CkNoncopyable {
   void n2e_removeAll(int n);
 
   /// Get an element on edge (n1, n2) where n1, n2 are chunk-local
-  /// node numberings and result is chunk-local element; return -1 in case 
+  /// node numberings and result is chunk-local element; return -1 in case
   /// of failure
   int getElementOnEdge(int n1, int n2);
 
   /// Get two elements adjacent to both n1 and n2
   void get2ElementsOnEdge(int n1, int n2, int *result_e1, int *result_e2) ;
-}; 
+};
 PUPmarshall(FEM_Mesh);
 
 FEM_Mesh *FEM_Mesh_lookup(int fem_mesh,const char *caller);
 FEM_Entity *FEM_Entity_lookup(int fem_mesh,int entity,const char *caller);
 FEM_Attribute *FEM_Attribute_lookup(int fem_mesh,int entity,int attr,const char *caller);
 
-void FEM_Mesh_data_layout(int fem_mesh,int entity,int attr,    
+void FEM_Mesh_data_layout(int fem_mesh,int entity,int attr,
                          void *data, int firstItem,int length, const IDXL_Layout &layout);
 
 //registration internal api
@@ -1455,7 +1457,7 @@ void FEM_writeMesh(FEM_Mesh *m,const char *prefix,int chunkNo,int nChunks);
   Orion Sky Lawlor, olawlor@acm.org, 9/28/00
 */
 
-/* A stupid, stupid number: the maximum value of user-defined "elType" fields. 
+/* A stupid, stupid number: the maximum value of user-defined "elType" fields.
    This should be dynamic, so any use of this should be considered a bug.
 */
 #define FEM_MAX_ELTYPE 20
@@ -1479,7 +1481,7 @@ class l2g_t {
 template <class T>
 class NumberedVec {
   CkPupPtrVec<T, CkPupAlwaysAllocatePtr<T> > vec;
-       
+
  public:
   //Extend the vector to have up to this element
   void makeLonger(int toHaveElement)
@@ -1495,16 +1497,16 @@ class NumberedVec {
     vec[doomedEl].destroy();
     vec[doomedEl]=new T;
   }
-       
+
   int size(void) const {return vec.size();}
-       
+
   //Same old bracket operators, but return the actual object, not a pointer:
   T &operator[](int i) {
     if (i>=vec.size()) makeLonger(i);
     return *( vec[i] );
   }
   const T &operator[](int i) const {return *( vec[i] );}
-       
+
   void pup(PUP::er &p) {
     vec.pup(p);
   }
@@ -1544,7 +1546,7 @@ class marshallNewHeapCopy {
   marshallNewHeapCopy(void) { //Used on recv side:
     cur=new T;
   }
-       
+
   void pup(PUP::er &p) {
     cur->pup(p);
   }
@@ -1561,13 +1563,13 @@ class FEM_T_List {
  protected:
   int FIRST_DT; // User index of first T
   int size(void) const {return list.size();}
-       
+
   /// If this isn't a valid, allocated index, abort.
   inline void check(int l,const char *caller) const {
-    if (l<FIRST_DT || l>=FIRST_DT+list.size() || list[l-FIRST_DT]==NULL) 
+    if (l<FIRST_DT || l>=FIRST_DT+list.size() || list[l-FIRST_DT]==NULL)
       badIndex(l,caller);
   }
-       
+
   void badIndex(int l,const char *caller) const {
     if (l<FIRST_DT || l>FIRST_DT+list.size()) bad(l,0,caller);
     else bad(l,1,caller);
@@ -1576,13 +1578,13 @@ class FEM_T_List {
   FEM_T_List(int FIRST_DT_) :FIRST_DT(FIRST_DT_) {}
   virtual ~FEM_T_List() {}
   void pup(PUP::er &p) { p|list; }
-       
+
   /// This routine is called when we're passed an invalid T index.
   virtual void bad(int l,int bad_code,const char *caller) const =0;
-       
+
   /// Insert a new T (allocated with "new"), returning the user index:
   int put(T *t) {
-    for (int i=0;i<list.size();i++) 
+    for (int i=0;i<list.size();i++)
       if (list[i]==NULL) {
        list[i]=t;
        return FIRST_DT+i;
@@ -1591,19 +1593,19 @@ class FEM_T_List {
     list.push_back(t);
     return FIRST_DT+ret;
   }
-       
+
   /// Get this T given its user index.
   inline T *lookup(int l,const char *caller) const {
     check(l,caller);
     return list[l-FIRST_DT];
   }
-       
+
   /// Free this T
   void destroy(int l,const char *caller) {
     check(l,caller);
     list[l-FIRST_DT].destroy();
   }
-       
+
   /// Clear all stored T's:
   void empty(void) {
     for (int i=0;i<list.size();i++) list[i].destroy();
@@ -1613,7 +1615,7 @@ class FEM_Mesh_list : public FEM_T_List<FEM_Mesh> {
   typedef FEM_T_List<FEM_Mesh> super;
  public:
   FEM_Mesh_list() :super(FEM_MESH_FIRST) { }
-       
+
   virtual void bad(int l,int bad_code,const char *caller) const;
 };
 
@@ -1624,20 +1626,20 @@ class FEM_Mesh_list : public FEM_T_List<FEM_Mesh> {
 /**
    FEM global data object.  Keeps track of the global
    list of meshes, and the default read and write meshes.
-  
-   This class was once an array element, back when the 
+
+   This class was once an array element, back when the
    FEM framework was built directly on Charm++.
-  
+
    There's only one of this object per thread, and it's
    kept in a thread-private variable.
 */
-class FEM_chunk 
+class FEM_chunk
 {
  public:
   FEM_Mesh_list meshes; ///< Global list of meshes.
   int default_read; ///< Index of default read mesh.
   int default_write; ///< Index of default write mesh.
-  
+
   /// Default communicator to use
   FEM_Comm_t defaultComm;
 
@@ -1652,7 +1654,7 @@ class FEM_chunk
 
  private:
   CkVec<int> listTmp;//List of local entities, for ghost list exchange
+
   void initFields(void);
 
  public:
@@ -1660,17 +1662,17 @@ class FEM_chunk
   FEM_chunk(CkMigrateMessage *msg);
   void pup(PUP::er &p);
   ~FEM_chunk();
-  
+
   /// Return this thread's single static FEM_chunk instance:
   static FEM_chunk *get(const char *caller);
-  
+
   inline FEM_Mesh *lookup(int fem_mesh,const char *caller) {
     return meshes.lookup(fem_mesh,caller);
   }
 
-  inline FEM_Mesh *getMesh(const char *caller) 
+  inline FEM_Mesh *getMesh(const char *caller)
     {return meshes.lookup(default_read,caller);}
-  inline FEM_Mesh *setMesh(const char *caller) 
+  inline FEM_Mesh *setMesh(const char *caller)
     {return meshes.lookup(default_write,caller);}
 
   void print(int fem_mesh,int idxBase);
@@ -1682,10 +1684,10 @@ class FEM_chunk
   void recvList(int elemType,int fmChk,int nIdx,const int *idx);
   const CkVec<int> &getList(void) {return listTmp;}
   void emptyList(void) {listTmp.length()=0;}
-  
+
   void reduce_field(int idxl_datatype, const void *nodes, void *outbuf, int op);
   void reduce(int idxl_datatype, const void *inbuf, void *outbuf, int op);
-  void readField(int idxl_datatype, void *nodes, const char *fname);  
+  void readField(int idxl_datatype, void *nodes, const char *fname);
 };
 
 /// Describes a single layer of ghost elements.
@@ -1736,15 +1738,15 @@ class FEM_Ghost_Stencil {
   int n;
   /// If true, add ghost nodes as well as elements
   bool addNodes;
-       
+
   /// Last adjacency entry (plus one), indexed by element.
   ///  That is, element i's data is at [ends[i-1],ends[i])
   intArrayPtr ends;
-       
+
   /** Adjacency entries for each element.
       Stored as a series of pairs: elType, elNum.
       The first pair for element i starts at
-      2*(ends[i-1]) 
+      2*(ends[i-1])
       the last pair for element i starts at
       2*(ends[i]-1)
       This array then has, in total, 2*ends[n-1] elements.
@@ -1752,20 +1754,20 @@ class FEM_Ghost_Stencil {
   intArrayPtr adj;
  public:
   /**
-     Create a stencil with this number of elements, 
+     Create a stencil with this number of elements,
      and these adjecent elements.
   */
   FEM_Ghost_Stencil(int elType_, int n_,bool addNodes_,
                    const int *ends_,
                    const int *adj_,
                    int idxBase);
-       
+
   /// Make sure this stencil makes sense for this mesh.
   void check(const FEM_Mesh &mesh) const;
-       
+
   /// Return the type of element we describe
   inline int getType(void) const {return elType;}
-       
+
   /**
      Return a pair consisting of the i'th element's
      j'th neighbor: the return value's first int is an element type,
@@ -1778,16 +1780,16 @@ class FEM_Ghost_Stencil {
     if (j>=ends[i]-start) return 0;
     return &adj[2*(start+j)];
   }
-       
+
   inline bool wantNodes(void) const {return addNodes;}
 };
 
 /// Describes a way to grow a set of ghosts.
 class FEM_Ghost_Region {
- public:       
+ public:
   FEM_Ghost_Layer *layer;
   FEM_Ghost_Stencil *stencil;
-       
+
   FEM_Ghost_Region() {layer=0; stencil=0;}
   FEM_Ghost_Region(FEM_Ghost_Layer *l) {layer=l; stencil=0;}
   FEM_Ghost_Region(FEM_Ghost_Stencil *s) {layer=0; stencil=s;}
@@ -1801,21 +1803,21 @@ class FEM_Initial_Symmetries; /*Defined in symmetries.C*/
 class FEM_Partition : public CkNoncopyable {
   /// Maps element number to (0-based) chunk number, allocated with new[]
   int *elem2chunk;
-       
+
   /// Describes the different regions of ghost elements:
   CkVec<FEM_Ghost_Region> regions;
   FEM_Ghost_Layer *lastLayer;
-       
+
   /// Describes the problem domain's spatial symmetries.
   FEM_Initial_Symmetries *sym;
  public:
   FEM_Partition();
   ~FEM_Partition();
-       
+
   // Manipulate partitioning information
   void setPartition(const int *elem2chunk, int nElem, int idxBase);
   const int *getPartition(FEM_Mesh *src,int nChunks) const;
-       
+
   // Manipulate ghost layers
   FEM_Ghost_Layer *addLayer(void) {
     lastLayer=new FEM_Ghost_Layer();
@@ -1826,7 +1828,7 @@ class FEM_Partition : public CkNoncopyable {
     if (lastLayer==0) CkAbort("Must call FEM_Add_ghost_layer before FEM_Add_ghost_elem\n");
     return lastLayer;
   }
-       
+
   // Manipulate ghost stencils
   void addGhostStencil(FEM_Ghost_Stencil *s) {
     regions.push_back(s);
@@ -1835,11 +1837,11 @@ class FEM_Partition : public CkNoncopyable {
   void markGhostStencilLayer(void) {
     regions.push_back(FEM_Ghost_Region());
   }
-       
+
   // Read back ghost regions
   int getRegions(void) const {return regions.size();}
   const FEM_Ghost_Region &getRegion(int regNo) const {return regions[regNo];}
-       
+
   // Manipulate spatial symmetries:
   void setSymmetries(int nNodes_,int *new_can,const int *sym_src);
   void addLinearPeriodic(int nFaces_,int nPer,
@@ -1893,7 +1895,7 @@ class FEM_ElemAdj_Layer : public CkNoncopyable {
  public:
   int initialized;
   int nodesPerTuple; //Number of shared nodes for a pair of elements
-  
+
   class elemAdjInfo {
   public:
     //  int recentElType; // should not be here, but if it is it should be pup'ed
@@ -1904,11 +1906,11 @@ class FEM_ElemAdj_Layer : public CkNoncopyable {
     void pup(PUP::er &p) {//CkAbort("FEM> Shouldn't call elemGhostInfo::pup!\n");
     }
   };
-  
+
   elemAdjInfo elem[FEM_MAX_ELTYPE];
-  
+
   FEM_ElemAdj_Layer() {initialized=0;}
-  
+
   virtual void pup(PUP::er &p){
     p | nodesPerTuple;
     p | initialized;
@@ -1939,7 +1941,7 @@ class FEM_ElemAdj_Layer : public CkNoncopyable {
 
 
 /*
-  File containing the data structures, function declaration 
+  File containing the data structures, function declaration
   and msa array declarations used during parallel partitioning
   of the mesh.
   Author Sayantan Chakravorty
@@ -2023,8 +2025,8 @@ public:
     if(lvec->length() != 0){
       int count=0;
       for(int i=1;i<lvec->length();i++){
-       if((*lvec)[count] == (*lvec)[i]){       
-       }else{                                  
+       if((*lvec)[count] == (*lvec)[i]){
+       }else{
          count++;
          if(i != count){
            (*lvec)[count] = (*lvec)[i];
@@ -2032,7 +2034,7 @@ public:
        }
       }
       lvec->resize(count+1);
-    }  
+    }
   }
 };
 
@@ -2129,9 +2131,9 @@ class NodeElem {
   a chunk.
 */
 class MeshElem{
- public: 
+ public:
   FEM_Mesh *m;
-  CkVec<int> gedgechunk; // Chunk number of 
+  CkVec<int> gedgechunk; // Chunk number of
   MeshElem(){
     m = new FEM_Mesh;
   }
@@ -2148,11 +2150,11 @@ class MeshElem{
   inline MeshElem& operator=(const MeshElem &rhs){
     if(m != NULL){
       delete m;
-    }  
+    }
     m = new FEM_Mesh;
     m->copyShape(*(rhs.m));
     (*this) += rhs;
-                
+
     return *this;
   }
   inline MeshElem& operator+=(const MeshElem &rhs){
@@ -2160,14 +2162,14 @@ class MeshElem{
     m->copyShape(*(rhs.m));
     for(int i=0;i<rhs.m->node.size();i++){
       m->node.push_back((rhs.m)->node,i);
-    }  
+    }
     if((rhs.m)->elem.size()>0){
       for(int t=0;t<(rhs.m)->elem.size();t++){
        if((rhs.m)->elem.has(t)){
          for(int e=0;e<(rhs.m)->elem.get(t).size();e++){
            m->elem[t].push_back((rhs.m)->elem.get(t),e);
-         }     
-       }       
+         }
+       }
       }
     }
 
@@ -2219,7 +2221,7 @@ public:
        int numnodes; //number of nodes in this tuple
        //TODO: replace *nodes with the above tupledata class
        tupledata nodes;        //the nodes in the tuple
-       int chunk;              //the chunk number to which this element belongs 
+       int chunk;              //the chunk number to which this element belongs
        int elementNo;          //local number of that element
        Hashnode(){
                numnodes=0;
@@ -2288,7 +2290,7 @@ public:
     }
     return true;
   }
-       
+
   inline bool operator<=(const Hashnode &rhs){
     if(numnodes < rhs.numnodes){
       return true;
@@ -2296,7 +2298,7 @@ public:
     if(numnodes > rhs.numnodes){
       return false;
     }
-               
+
     for(int i=0;i<numnodes;i++){
       if(nodes[i] < rhs.nodes[i]){
        return true;
@@ -2319,7 +2321,7 @@ public:
     }
     return true;
   }
-       
+
   inline bool equals(tupledata &tuple){
     for(int i=0;i<numnodes;i++){
       if(tuple.nodes[i] != nodes[i]){
@@ -2376,7 +2378,7 @@ struct conndata{
 };
 
 /**
-  Structure to store connectivity data after the 
+  Structure to store connectivity data after the
   global element partition has been returned by parmetis
 */
 struct partconndata{
@@ -2452,7 +2454,7 @@ class MsaHashtable{
     }
     int index = (int )(sum %(long )numSlots);
     Hashnode entry(nodesPerTuple,chunk,elementNo,tuple);
-       
+
     Hashtuple &list=table.accumulate(index);
     list.vec->push_back(entry);
     char str[100];
@@ -2476,7 +2478,7 @@ class MsaHashtable{
   const Hashtuple &get(int i){
     return table.get(i);
   }
-       
+
 };
 
 
@@ -2520,19 +2522,19 @@ extern "C" int ck_fem_map_compare_int(const void *a, const void *b);
 class elemList {
  public:
   int chunk;
-  int tupleNo;//tuple number on this element for the tuple that this list sorrounds 
+  int tupleNo;//tuple number on this element for the tuple that this list sorrounds
   int localNo;//Local number of this element on this chunk (negative for a ghost)
   int type; //Kind of element
   FEM_Symmetries_t sym; //Symmetries this element was reached via
   elemList *next;
 
   elemList(int chunk_,int localNo_,int type_,FEM_Symmetries_t sym_)
-    :chunk(chunk_),localNo(localNo_),type(type_), sym(sym_) 
+    :chunk(chunk_),localNo(localNo_),type(type_), sym(sym_)
     { next=NULL; }
   elemList(int chunk_,int localNo_,int type_,FEM_Symmetries_t sym_,int tupleNo_)
     :chunk(chunk_),localNo(localNo_),type(type_), sym(sym_) , tupleNo(tupleNo_)
     { next=NULL; }
-       
+
   ~elemList() {if (next) delete next;}
   void setNext(elemList *n) {next=n;}
 };
@@ -2551,7 +2553,7 @@ class tupleTable : public CkHashtable {
     int os=sizeof(elemList *);
     return CkHashtableLayout(ks,ks,oo,os,oo+os);
   }
-  
+
   //Make a canonical version of this tuple, so different
   // orderings of the same nodes don't end up in different lists.
   //I canonicalize by sorting:
@@ -2595,8 +2597,8 @@ class tupleTable : public CkHashtable {
     int can[MAX_TUPLE];
     canonicalize(tuple,can);
     return (elemList **)get(can);
-  }    
-       
+  }
+
   //Register this (new'd) element with this tuple
   void addTuple(const int *tuple,elemList *nu)
     {
@@ -2604,7 +2606,7 @@ class tupleTable : public CkHashtable {
       canonicalize(tuple,can);
       //First try for an existing list:
       elemList **dest=(elemList **)get(can);
-      if (dest!=NULL) 
+      if (dest!=NULL)
        { //A list already exists here-- link it into the new list
          nu->setNext(*dest);
        } else {//No pre-existing list-- initialize a new one.
@@ -2619,7 +2621,7 @@ class tupleTable : public CkHashtable {
   elemList *lookupNext(void) {
     void *ret=it->next();
     if (ret==NULL) {
-      delete it; 
+      delete it;
       return NULL;
     }
     return *(elemList **)ret;
@@ -2673,7 +2675,7 @@ class chunkList : public CkNoncopyable {
     else if (next==NULL) return NULL;
     else return next->onChunk(c,s);
   }
-  int isEmpty(void) const //Return 1 if this is an empty list 
+  int isEmpty(void) const //Return 1 if this is an empty list
     {return (chunk==-1);}
   int isShared(void) const //Return 1 if this is a shared entity
     {return next!=NULL;}
@@ -2697,7 +2699,7 @@ class chunkList : public CkNoncopyable {
 
 /* File: util.h
  * Authors: Nilesh Choudhury
- * 
+ *
  */
 /// A utility class with helper functions for adaptivity
 class FEM_MUtil {
@@ -2812,9 +2814,9 @@ class FEM_MUtil {
   void idxllock(FEM_Mesh *m, int chk, int type);
   ///Unlock the idxl list with 'chk' (might be remote if chk is smaller)
   void idxlunlock(FEM_Mesh *m, int chk, int type);
-  ///Lock the idxl list with chk on this chunk 
+  ///Lock the idxl list with chk on this chunk
   void idxllockLocal(FEM_Mesh *m, int toChk, int type);
-  ///Unlock the idxl list with chk on this chunk 
+  ///Unlock the idxl list with chk on this chunk
   void idxlunlockLocal(FEM_Mesh *m, int toChk, int type);
 
   ///Print the node-to-node adjacency for this node
@@ -2866,7 +2868,7 @@ class FEM_MUtil {
 
   This file provides various utility routines for easily
   manipulating 2-D vectors-- included are arithmetic,
-  dot product, magnitude and normalization terms. 
+  dot product, magnitude and normalization terms.
   All routines are provided right in the header file (for inlining).
 
   Converted from vector3d.h.
@@ -2893,16 +2895,16 @@ class vector2d {
   vector2d(const Real Nx,const Real Ny) {x=Nx;y=Ny;}
   //Copy constructor
   vector2d(const vector2d &copy) {x=copy.x;y=copy.y;}
-       
+
   //Cast-to-Real * operators (treat vector as array)
   operator Real *() {return &x;}
   operator const Real *() const {return &x;}
-       
+
   /*Arithmetic operations: these are carefully restricted to just those
     that make unambiguous sense (to me... now...  ;-)
     Counterexamples: vector*vector makes no sense (use .dot()) because
-    Real/vector is meaningless (and we'd want a*b/b==a for b!=0), 
-    ditto for vector&vector (dot?), vector|vector (projection?), 
+    Real/vector is meaningless (and we'd want a*b/b==a for b!=0),
+    ditto for vector&vector (dot?), vector|vector (projection?),
     vector^vector (cross?),Real+vector, vector+=real, etc.
   */
   vector2d &operator=(const vector2d &b) {x=b.x;y=b.y;return *this;}
@@ -2910,7 +2912,7 @@ class vector2d {
   int operator!=(const vector2d &b) const {return (x!=b.x)||(y!=b.y);}
   vector2d operator+(const vector2d &b) const {return vector2d(x+b.x,y+b.y);}
   vector2d operator-(const vector2d &b) const {return vector2d(x-b.x,y-b.y);}
-  vector2d operator*(const Real scale) const 
+  vector2d operator*(const Real scale) const
     {return vector2d(x*scale,y*scale);}
   friend vector2d operator*(const Real scale,const vector2d &v)
     {return vector2d(v.x*scale,v.y*scale);}
@@ -2927,18 +2929,18 @@ class vector2d {
   Real magSqr(void) const {return x*x+y*y;}
   //Return the magnitude (length) of this vector
   Real mag(void) const {return sqrt(magSqr());}
-       
+
   //Return the square of the distance to the vector b
-  Real distSqr(const vector2d &b) const 
+  Real distSqr(const vector2d &b) const
     {return (x-b.x)*(x-b.x)+(y-b.y)*(y-b.y);}
   //Return the distance to the vector b
   Real dist(const vector2d &b) const {return sqrt(distSqr(b));}
-       
+
   //Return the dot product of this vector and b
   Real dot(const vector2d &b) const {return x*b.x+y*b.y;}
   //Return the cosine of the angle between this vector and b
   Real cosAng(const vector2d &b) const {return dot(b)/(mag()*b.mag());}
-       
+
   //Return the "direction" (unit vector) of this vector
   vector2d dir(void) const {return (*this)/mag();}
 
@@ -2947,7 +2949,7 @@ class vector2d {
 
   //Return this vector scaled by that
   vector2d &scale(const vector2d &b) {x*=b.x;y*=b.y;return *this;}
-       
+
   //Return the largest coordinate in this vector
   Real max(void) {return (x>y)?x:y;}
   //Make each of this vector's coordinates at least as big
@@ -2961,13 +2963,13 @@ class vector2d {
 /*
  * The former cktimer.h
  *
- */ 
+ */
 
 #ifndef CMK_THRESHOLD_TIMER
 #define CMK_THRESHOLD_TIMER
 
 /** Time a sequence of operations, printing out the
-    names and times of any operations that exceed a threshold. 
+    names and times of any operations that exceed a threshold.
 
     Use it with only the constructor and destructor like:
     void foo(void) {
@@ -2986,7 +2988,7 @@ class vector2d {
     t.start("third");
     ...
     }
-  
+
     This class *only* prints out the time if it exceeds
     a threshold-- by default, one millisecond.
 */
@@ -2994,7 +2996,7 @@ class CkThresholdTimer {
   double threshold; // Print any times that exceed this (s).
   double lastStart; // Last activity started at this time (s).
   const char *lastWhat; // Last activity has this name.
-       
+
   void start_(const char *what) {
     lastStart=CmiWallTimer();
     lastWhat=what;
@@ -3006,7 +3008,7 @@ class CkThresholdTimer {
     }
   }
  public:
-  CkThresholdTimer(const char *what,double thresh=0.001) 
+  CkThresholdTimer(const char *what,double thresh=0.001)
     :threshold(thresh) { start_(what); }
   void start(const char *what) { done_(); start_(what); }
   ~CkThresholdTimer() {done_();}
index 1cf5cc3990faf635018e940e03a6671c5b6fb76e..006926f0fee0f6b978ed08090b92292471d3d143 100644 (file)
@@ -5,17 +5,17 @@
 
 /*
 This is a compatability main routine for FEM framework programs.
-It is an MPI main program that calls the old-style "init" routine 
+It is an MPI main program that calls the old-style "init" routine
 on processor 0, then runs driver on all processors.
 
 This routine need not get called-- an MPI program may choose
-to implement a main routine and call FEM_Init itself, in which 
+to implement a main routine and call FEM_Init itself, in which
 case there's no "init" or "driver" routines.
 
 This routine is only linked in if you link with
-       -language fem
+       -language ParFUM
 if you use
-       -language ampi -module fem
+       -language ampi -module ParFUM
 this routine is not linked.
 
 Orion Sky Lawlor, olawlor@acm.org, 2003/7/13
@@ -39,10 +39,10 @@ int main(int argc,char **argv) {
        if (CmiGetArgFlagDesc(argv,"-read","Skip init()--read mesh from files"))
        { /* "-read" was passed: skip init & read parallel mesh from files */
                parallelMesh=FEM_Mesh_read("fem_mesh",myPart,nPart);
-       } 
+       }
        else
        { /* Call init normally: */
-               if (myPart==0) 
+               if (myPart==0)
                { // Make a little mesh, and call user's "init" routine to fill it out:
                        serialMesh=FEM_Mesh_allocate();
                        FEM_Mesh_set_default_write(serialMesh);
@@ -59,13 +59,13 @@ int main(int argc,char **argv) {
                parallelMesh=FEM_Mesh_broadcast(serialMesh,0,(FEM_Comm_t)comm);
                if (myPart==0) FEM_Mesh_deallocate(serialMesh);
        }
-       
+
        if (CmiGetArgFlagDesc(argv,"-write","Skip driver()--write mesh to files"))
        {/* "-write" was passed: skip driver & write files */
                FEM_Mesh_write(parallelMesh,"fem_mesh",myPart,nPart);
                FEM_Mesh_deallocate(parallelMesh);
        }
-       else 
+       else
        { /* Call user's driver routine for the main computation */
                FEM_Mesh_set_default_read(parallelMesh);
                FEM_Mesh_set_default_write(FEM_Mesh_allocate());
index c97886f74efdbf10f4aa7dc182b66e30ef29119e..9bd46748cca080047234fcca7837afab460e7bab 100644 (file)
@@ -16,7 +16,7 @@ FEM_Comm_Holder::FEM_Comm_Holder(FEM_Comm *sendComm, FEM_Comm *recvComm)
        :comm(sendComm,recvComm)
 {
        registered=false;
-       idx=-1; 
+       idx=-1;
 }
 void FEM_Comm_Holder::registerIdx(IDXL_Chunk *c) {
        assert(!registered);
@@ -28,7 +28,7 @@ void FEM_Comm_Holder::registerIdx(IDXL_Chunk *c) {
 }
 void FEM_Comm_Holder::pup(PUP::er &p) {
        p|idx;
-       if (p.isUnpacking() && idx!=-1) 
+       if (p.isUnpacking() && idx!=-1)
        { // Try to grab the same index we had on our old processor:
                registerIdx(IDXL_Chunk::get("FEM_Comm_Holder::pup"));
        }
@@ -36,11 +36,11 @@ void FEM_Comm_Holder::pup(PUP::er &p) {
 
 FEM_Comm_Holder::~FEM_Comm_Holder(void)
 {
-       if (registered) 
+       if (registered)
        { // Try to unregister from IDXL:
                const char *caller="FEM_Comm_Holder::~FEM_Comm_Holder";
                IDXL_Chunk *owner=IDXL_Chunk::getNULL();
-               if (owner) owner->destroy(idx,caller); 
+               if (owner) owner->destroy(idx,caller);
        }
 }
 
@@ -55,13 +55,13 @@ static void checkIsSet(int fem_mesh,bool wantSet,const char *caller) {
 }
 
 /* Connectivity: Map calls to appropriate version of FEM_Mesh_data */
-CDECL void 
+CDECL void
 FEM_Mesh_conn(int fem_mesh,int entity,
-       int *conn, int firstItem, int length, int width) 
+       int *conn, int firstItem, int length, int width)
 {
        FEM_Mesh_data(fem_mesh,entity,FEM_CONN, conn, firstItem,length, FEM_INDEX_0, width);
 }
-FDECL void 
+FDECL void
 FTN_NAME(FEM_MESH_CONN,fem_mesh_conn)(int *fem_mesh,int *entity,
        int *conn, int *firstItem,int *length, int *width)
 {
@@ -102,7 +102,7 @@ FTN_NAME(FEM_MESH_GET_CONN,fem_mesh_get_conn)(int *fem_mesh,int *entity,
 
 /* Data: map to FEM_Mesh_offset */
 CDECL void
-FEM_Mesh_data(int fem_mesh,int entity,int attr,        
+FEM_Mesh_data(int fem_mesh,int entity,int attr,
        void *data, int firstItem,int length, int datatype,int width)
 {
        IDXL_Layout lo(datatype,width);
@@ -116,7 +116,7 @@ FORTRAN_AS_C(FEM_MESH_DATA,FEM_Mesh_data,fem_mesh_data,
 
 
 CDECL void
-FEM_Mesh_set_data(int fem_mesh,int entity,int attr,    
+FEM_Mesh_set_data(int fem_mesh,int entity,int attr,
        const void *data, int firstItem,int length, int datatype,int width)
 {
        checkIsSet(fem_mesh,true,"FEM_Mesh_set_data");
@@ -128,7 +128,7 @@ FORTRAN_AS_C(FEM_MESH_SET_DATA,FEM_Mesh_set_data,fem_mesh_set_data,
 )
 
 CDECL void
-FEM_Mesh_get_data(int fem_mesh,int entity,int attr,    
+FEM_Mesh_get_data(int fem_mesh,int entity,int attr,
        void *data, int firstItem,int length, int datatype,int width)
 {
        checkIsSet(fem_mesh,false,"FEM_Mesh_get_data");
@@ -140,7 +140,7 @@ FORTRAN_AS_C(FEM_MESH_GET_DATA,FEM_Mesh_get_data,fem_mesh_get_data,
 )
 
 CDECL void
-FEM_Mesh_data_layout(int fem_mesh,int entity,int attr,         
+FEM_Mesh_data_layout(int fem_mesh,int entity,int attr,
        void *data, int firstItem,int length, IDXL_Layout_t layout)
 {
        const char *caller="FEM_Mesh_data_layout";
@@ -154,7 +154,7 @@ FORTRAN_AS_C(FEM_MESH_DATA_LAYOUT,FEM_Mesh_data_layout,fem_mesh_data_layout,
 )
 
 CDECL void
-FEM_Mesh_data_offset(int fem_mesh,int entity,int attr,         
+FEM_Mesh_data_offset(int fem_mesh,int entity,int attr,
        void *data, int firstItem,int length,
        int type,int width, int offsetBytes,int distanceBytes,int skewBytes)
 {
@@ -187,30 +187,30 @@ void FEM_Register_array(int fem_mesh,int entity,int attr,
        FEM_Register_array_layout(fem_mesh,entity,attr,data,firstItem,lo);
 }
 
-void FEM_Register_array_layout(int fem_mesh,int entity,int attr,       
+void FEM_Register_array_layout(int fem_mesh,int entity,int attr,
        void *data, IDXL_Layout_t layout,int firstItem){
        const char *caller="FEM_Register_array_layout";
-       FEM_Register_array_layout(fem_mesh,entity,attr,data,firstItem, 
+       FEM_Register_array_layout(fem_mesh,entity,attr,data,firstItem,
                IDXL_Layout_List::get().get(layout,caller));
 
 }
 
 /*registration api */
-CDECL void 
+CDECL void
 FEM_Register_array(int fem_mesh,int entity,int attr,
        void *data, int datatype,int width)
-{      
+{
        FEM_Register_array(fem_mesh,entity,attr,data,datatype,width,0);
 }
 
 CDECL void
-FEM_Register_array_layout(int fem_mesh,int entity,int attr,    
+FEM_Register_array_layout(int fem_mesh,int entity,int attr,
        void *data, IDXL_Layout_t layout){
        FEM_Register_array_layout(fem_mesh,entity,attr,data,layout,0);
 }
 
 
-CDECL void 
+CDECL void
 FEM_Register_entity(int fem_mesh,int entity,void *data,
                int len,int max,FEM_Mesh_alloc_fn fn) {
                FEM_Register_entity_impl(fem_mesh,entity,data,len,max,fn);
@@ -230,7 +230,7 @@ FORTRAN_AS_C(FEM_REGISTER_ENTITY,FEM_Register_entity,fem_register_entity,
 
 
 // User data API:
-CDECL void 
+CDECL void
 FEM_Mesh_pup(int fem_mesh,int dataTag,FEM_Userdata_fn fn,void *data) {
        const char *caller="FEM_Mesh_pup"; FEMAPI(caller);
        FEM_Mesh *m=FEM_Mesh_lookup(fem_mesh,caller);
@@ -247,7 +247,7 @@ FORTRAN_AS_C(FEM_MESH_PUP,FEM_Mesh_pup,fem_mesh_pup,
        (int *m,int *t,FEM_Userdata_fn fn,void *data), (*m,*t,fn,data))
 
 // Accessor API:
-CDECL void 
+CDECL void
 FEM_Mesh_set_length(int fem_mesh,int entity,int newLength) {
        const char *caller="FEM_Mesh_set_length"; FEMAPI(caller);
        checkIsSet(fem_mesh,true,caller);
@@ -259,7 +259,7 @@ FORTRAN_AS_C(FEM_MESH_SET_LENGTH,FEM_Mesh_set_length,fem_mesh_set_length,
 )
 
 
-CDECL int 
+CDECL int
 FEM_Mesh_get_length(int fem_mesh,int entity) {
        const char *caller="FEM_Mesh_get_length"; FEMAPI(caller);
        int len=FEM_Entity_lookup(fem_mesh,entity,caller)->size();
@@ -271,7 +271,7 @@ FORTRAN_AS_C_RETURN(int,
 )
 
 
-CDECL void 
+CDECL void
 FEM_Mesh_set_width(int fem_mesh,int entity,int attr,int newWidth) {
        const char *caller="FEM_Mesh_set_width";
        FEMAPI(caller);
@@ -283,7 +283,7 @@ FORTRAN_AS_C(FEM_MESH_SET_WIDTH,FEM_Mesh_set_width,fem_mesh_set_width,
        (*fem_mesh,*entity,*attr,*newWidth)
 )
 
-CDECL int 
+CDECL int
 FEM_Mesh_get_width(int fem_mesh,int entity,int attr) {
        const char *caller="FEM_Mesh_get_width";
        FEMAPI(caller);
@@ -294,7 +294,7 @@ FORTRAN_AS_C_RETURN(int,
        (int *fem_mesh,int *entity,int *attr),(*fem_mesh,*entity,*attr)
 )
 
-CDECL int 
+CDECL int
 FEM_Mesh_get_datatype(int fem_mesh,int entity,int attr) {
        const char *caller="FEM_Mesh_get_datatype";
        FEMAPI(caller);
@@ -305,7 +305,7 @@ FORTRAN_AS_C_RETURN(int,
        (int *fem_mesh,int *entity,int *attr),(*fem_mesh,*entity,*attr)
 )
 
-CDECL int 
+CDECL int
 FEM_Mesh_is_set(int fem_mesh) /* return 1 if this is a writing mesh */
 {
        return (FEM_Mesh_lookup(fem_mesh,"FEM_Mesh_is_get")->isSetting())?1:0;
@@ -315,7 +315,7 @@ FORTRAN_AS_C_RETURN(int,
        (int *fem_mesh),(*fem_mesh)
 )
 
-CDECL int 
+CDECL int
 FEM_Mesh_is_get(int fem_mesh) /* return 1 if this is a readable mesh */
 {
        return (!FEM_Mesh_lookup(fem_mesh,"FEM_Mesh_is_get")->isSetting())?1:0;
@@ -325,21 +325,21 @@ FORTRAN_AS_C_RETURN(int,
        (int *fem_mesh),(*fem_mesh)
 )
 
-CDECL void 
+CDECL void
 FEM_Mesh_become_get(int fem_mesh) /* Make this a readable mesh */
 { FEM_Mesh_lookup(fem_mesh,"FEM_Mesh_become_get")->becomeGetting(); }
 FORTRAN_AS_C(FEM_MESH_BECOME_GET,FEM_Mesh_become_get,fem_mesh_become_get, (int *m),(*m))
 
-CDECL void 
+CDECL void
 FEM_Mesh_become_set(int fem_mesh)
 { FEM_Mesh_lookup(fem_mesh,"FEM_Mesh_become_get")->becomeSetting(); }
 FORTRAN_AS_C(FEM_MESH_BECOME_SET,FEM_Mesh_become_set,fem_mesh_become_set, (int *m),(*m))
 
 
-CDECL IDXL_t 
+CDECL IDXL_t
 FEM_Comm_shared(int fem_mesh,int entity) {
        const char *caller="FEM_Comm_shared";
-       FEMAPI(caller); 
+       FEMAPI(caller);
        if (entity!=FEM_NODE) FEM_Abort(caller,"Only shared nodes supported");
        return FEM_Mesh_lookup(fem_mesh,caller)->node.
                sharedIDXL.getIndex(IDXL_Chunk::get(caller));
@@ -349,7 +349,7 @@ FORTRAN_AS_C_RETURN(int,
        (int *fem_mesh,int *entity),(*fem_mesh,*entity)
 )
 
-CDECL IDXL_t 
+CDECL IDXL_t
 FEM_Comm_ghost(int fem_mesh,int entity) {
        const char *caller="FEM_Comm_ghost";
        FEMAPI(caller);
@@ -364,16 +364,16 @@ FORTRAN_AS_C_RETURN(int,
 
 
 // Internal API:
-void FEM_Mesh_data_layout(int fem_mesh,int entity,int attr,    
-       void *data, int firstItem,int length, const IDXL_Layout &layout) 
+void FEM_Mesh_data_layout(int fem_mesh,int entity,int attr,
+       void *data, int firstItem,int length, const IDXL_Layout &layout)
 {
        if (femVersion == 0 && length==0) return;
        const char *caller="FEM_Mesh_data";
        FEMAPI(caller);
        FEM_Mesh *m=FEM_Mesh_lookup(fem_mesh,caller);
        FEM_Attribute *a=m->lookup(entity,caller)->lookup(attr,caller);
-       
-       if (m->isSetting()) 
+
+       if (m->isSetting())
                a->set(data,firstItem,length,layout,caller);
        else /* m->isGetting()*/
                a->get(data,firstItem,length,layout,caller);
@@ -396,8 +396,8 @@ void FEM_Register_array_layout(int fem_mesh,int entity,int attr,void *data,int f
        //      a->setDatatype(layout.type);
                a->setWidth(layout.width);
        }
-       
-       
+
+
        if(m->isSetting()){
          a->register_data(data,length,max,layout,caller);
        }else{
@@ -426,7 +426,7 @@ FEM_Attribute *FEM_Attribute_lookup(int fem_mesh,int entity,int attr,const char
 
 CDECL int FEM_Mesh_get_entities(int fem_mesh, int *entities) {
        const char *caller="FEM_Mesh_get_entities";
-       FEMAPI(caller); 
+       FEMAPI(caller);
        return FEM_Mesh_lookup(fem_mesh,caller)->getEntities(entities);
 }
 FORTRAN_AS_C_RETURN(int,
@@ -461,15 +461,15 @@ CDECL const char *FEM_Get_datatype_name(int datatype,char *storage) {
 
 /// Return the human-readable version of this FEM_ATTR code.
 ///  For example, FEM_attr2name(FEM_CONN)=="FEM_CONN".
-CDECL const char *FEM_Get_attr_name(int attr,char *storage) 
+CDECL const char *FEM_Get_attr_name(int attr,char *storage)
 {
-       if (attr<FEM_ATTRIB_TAG_MAX) 
+       if (attr<FEM_ATTRIB_TAG_MAX)
        { //It's a user tag:
                sprintf(storage,"FEM_DATA+%d",attr-FEM_DATA);
                return storage;
        }
        switch(attr) {
-       case FEM_CONN: return "FEM_CONN"; 
+       case FEM_CONN: return "FEM_CONN";
        case FEM_SPARSE_ELEM: return "FEM_SPARSE_ELEM";
        case FEM_COOR: return "FEM_COOR";
        case FEM_GLOBALNO: return "FEM_GLOBALNO";
@@ -489,7 +489,7 @@ CDECL const char *FEM_Get_attr_name(int attr,char *storage)
        return storage;
 }
 
-//Abort with a nice error message saying: 
+//Abort with a nice error message saying:
 // Our <field> was previously set to <cur>; it cannot now be <operation> <next>
 void FEM_Attribute::bad(const char *field,bool forRead,int cur,int next,const char *caller) const
 {
@@ -511,7 +511,7 @@ void FEM_Attribute::bad(const char *field,bool forRead,int cur,int next,const ch
        if (cannotBe!=NULL) /* Use standard ... <something> cannot be <something>'d... error message */
                sprintf(errBuf,"The %s %s %s was previously set to %d; it cannot now be %s %d",
                        e->getName(),name,field,cur,cannotBe,next);
-       
+
        FEM_Abort(caller,errBuf);
 }
 
@@ -536,15 +536,15 @@ FEM_Attribute::~FEM_Attribute() {}
 
 void FEM_Attribute::setLength(int next,const char *caller) {
        int cur=getLength();
-       if (next==cur) return; //Already set--nothing to do 
+       if (next==cur) return; //Already set--nothing to do
        if (cur>0) bad("length",false,cur,next, caller);
        e->setLength(next);
        tryAllocate();
 }
-       
+
 void FEM_Attribute::setWidth(int next,const char *caller) {
        int cur=getWidth();
-       if (next==cur) return; //Already set--nothing to do 
+       if (next==cur) return; //Already set--nothing to do
        if (cur>0) bad("width",false,cur,next, caller);
        width=next;
        tryAllocate();
@@ -553,7 +553,7 @@ void FEM_Attribute::setWidth(int next,const char *caller) {
 
 void FEM_Attribute::setDatatype(int next,const char *caller) {
        int cur=getDatatype();
-       if (next==cur) return; //Already set--nothing to do 
+       if (next==cur) return; //Already set--nothing to do
        if (cur!=-1) bad("datatype",false,cur,next, caller);
        datatype=next;
        tryAllocate();
@@ -565,8 +565,8 @@ void FEM_Attribute::copyShape(const FEM_Attribute &src) {
        if (src.getDatatype()!=-1)
          setDatatype(src.getDatatype()); //Automatically calls tryAllocate
 }
-void FEM_Attribute::set(const void *src, int firstItem,int length, 
-               const IDXL_Layout &layout, const char *caller) 
+void FEM_Attribute::set(const void *src, int firstItem,int length,
+               const IDXL_Layout &layout, const char *caller)
 {
        if (firstItem!=0) { /* If this isn't the start... */
                if (length!=1) /* And we're not setting one at a time */
@@ -575,39 +575,39 @@ void FEM_Attribute::set(const void *src, int firstItem,int length,
 
        if (femVersion == 0 && getRealLength() == -1) setLength(length);
        else if (getLength()==0) setLength(length);
-       else if (length!=1 && length!=getLength()) 
+       else if (length!=1 && length!=getLength())
                bad("length",false,getLength(),length, caller);
-       
+
        int width=layout.width;
        if (femVersion==0 && getRealWidth()==-1) setWidth(width);
        else if (getWidth()==0) setWidth(width);
-       else if (width!=getWidth()) 
+       else if (width!=getWidth())
                bad("width",false,getWidth(),width, caller);
-       
+
        int datatype=layout.type;
        if (getDatatype()==-1) setDatatype(datatype);
-       else if (datatype!=getDatatype()) 
+       else if (datatype!=getDatatype())
                bad("datatype",false,getDatatype(),datatype, caller);
-       
+
        /* Assert: our storage should be allocated now.
           Our subclass will actually copy user data */
 }
 
-void FEM_Attribute::get(void *dest, int firstItem,int length, 
+void FEM_Attribute::get(void *dest, int firstItem,int length,
                const IDXL_Layout &layout, const char *caller)  const
 {
        if (length==0) return; //Nothing to get
-       if (length!=1 && length!=getLength()) 
+       if (length!=1 && length!=getLength())
                bad("length",true,getLength(),length, caller);
-       
+
        int width=layout.width;
-       if (width!=getWidth()) 
+       if (width!=getWidth())
                bad("width",true,getWidth(),width, caller);
-       
+
        int datatype=layout.type;
-       if (datatype!=getDatatype()) 
+       if (datatype!=getDatatype())
                bad("datatype",true,getDatatype(),datatype, caller);
-       
+
        /* our subclass will actually copy into user data */
 }
 
@@ -615,7 +615,7 @@ void FEM_Attribute::get(void *dest, int firstItem,int length,
 
 void FEM_Attribute::register_data(void *user, int length,int max,
        const IDXL_Layout &layout, const char *caller){
-       
+
                int width=layout.width;
                if (femVersion == 0 && getRealWidth()==-1) setWidth(width);
                else if (getWidth()==0){
@@ -624,17 +624,17 @@ void FEM_Attribute::register_data(void *user, int length,int max,
                        if (width!=getWidth()){
                                bad("width",false,getWidth(),width, caller);
                        }
-               }       
-       
+               }
+
                int datatype=layout.type;
                if (getDatatype()==-1){
                        setDatatype(datatype);
                }else{
-                       if (datatype!=getDatatype()){ 
+                       if (datatype!=getDatatype()){
                                bad("datatype",false,getDatatype(),datatype, caller);
                        }
-               }       
-               
+               }
+
 }
 
 //Check if all three of length, width, and datatype are set.
@@ -658,7 +658,7 @@ void FEM_Attribute::tryAllocate(void) {
 
 /*********************** DataAttribute *******************/
 FEM_DataAttribute::FEM_DataAttribute(FEM_Entity *e,int myAttr)
-       :FEM_Attribute(e,myAttr), 
+       :FEM_Attribute(e,myAttr),
         char_data(0),int_data(0),float_data(0),double_data(0)
 {
 }
@@ -666,15 +666,15 @@ void FEM_DataAttribute::pup(PUP::er &p) {
        super::pup(p);
        switch(getDatatype()) {
        case -1: /* not allocated yet */ break;
-       case FEM_BYTE:   
+       case FEM_BYTE:
          if (char_data) {
            /*if(p.isSizing()) {
              char_data->setRowLen(getEntity()->size());
              }*/
            char_data->pup(p);
-         } 
+         }
          break;
-       case FEM_INT:    
+       case FEM_INT:
          if (int_data) {
            /*if(p.isSizing()) {
              int_data->setRowLen(getEntity()->size());
@@ -682,7 +682,7 @@ void FEM_DataAttribute::pup(PUP::er &p) {
            int_data->pup(p);
          }
          break;
-       case FEM_FLOAT:  
+       case FEM_FLOAT:
          if (float_data) {
            /*if(p.isSizing()) {
              float_data->setRowLen(getEntity()->size());
@@ -690,7 +690,7 @@ void FEM_DataAttribute::pup(PUP::er &p) {
            float_data->pup(p);
          }
          break;
-       case FEM_DOUBLE: 
+       case FEM_DOUBLE:
          if (double_data) {
            /*if(p.isSizing()) {
              double_data->setRowLen(getEntity()->size());
@@ -717,13 +717,13 @@ FEM_DataAttribute::~FEM_DataAttribute() {
        if (int_data) delete int_data;
        if (float_data) delete float_data;
        if (double_data) delete double_data;
-       
+
 }
 
 /// Copy this data out of the user's (layout-formatted) array:
 template <class T>
-inline void setTableData(const void *user, int firstItem, int length, 
-       IDXL_LAYOUT_PARAM, AllocTable2d<T> *table) 
+inline void setTableData(const void *user, int firstItem, int length,
+       IDXL_LAYOUT_PARAM, AllocTable2d<T> *table)
 {
        for (int r=0;r<length;r++) {
                register T *tableRow=table->getRow(firstItem+r);
@@ -734,8 +734,8 @@ inline void setTableData(const void *user, int firstItem, int length,
 
 /// Copy this data into the user's (layout-formatted) array:
 template <class T>
-inline void getTableData(void *user, int firstItem, int length, 
-       IDXL_LAYOUT_PARAM, const AllocTable2d<T> *table) 
+inline void getTableData(void *user, int firstItem, int length,
+       IDXL_LAYOUT_PARAM, const AllocTable2d<T> *table)
 {
        for (int r=0;r<length;r++) {
                register const T *tableRow=table->getRow(firstItem+r);
@@ -745,7 +745,7 @@ inline void getTableData(void *user, int firstItem, int length,
 
 }
 
-void FEM_DataAttribute::set(const void *u, int f,int l, 
+void FEM_DataAttribute::set(const void *u, int f,int l,
                const IDXL_Layout &layout, const char *caller)
 {
        super::set(u,f,l,layout,caller);
@@ -756,7 +756,7 @@ void FEM_DataAttribute::set(const void *u, int f,int l,
        case FEM_DOUBLE: setTableData(u,f,l,IDXL_LAYOUT_CALL(layout),double_data); break;
        }
 }
-       
+
 void FEM_DataAttribute::get(void *u, int f,int l,
                const IDXL_Layout &layout, const char *caller) const
 {
@@ -802,7 +802,7 @@ void FEM_DataAttribute::copyEntity(int dstEntity,const FEM_Attribute &src,int sr
        const FEM_DataAttribute *dsrc=(const FEM_DataAttribute *)&src;
        switch(getDatatype()) {
        case FEM_BYTE:  char_data->setRow(dstEntity,dsrc->char_data->getRow(srcEntity)); break;
-       case FEM_INT: 
+       case FEM_INT:
                        int_data->setRow(dstEntity,dsrc->int_data->getRow(srcEntity)); break;
        case FEM_FLOAT: float_data->setRow(dstEntity,dsrc->float_data->getRow(srcEntity)); break;
        case FEM_DOUBLE: double_data->setRow(dstEntity,dsrc->double_data->getRow(srcEntity)); break;
@@ -861,7 +861,7 @@ inline void minAttrs(AllocTable2d<T> *data,int *iNodes,int rNode,int k,int width
   }
   T *rowR = data->getRow(rNode);
   for(int i=0;i<width;i++){
-    rowR[i] = row[0][i]; 
+    rowR[i] = row[0][i];
     for (int j=1; j<k; j++) {
       if (row[j][i] < rowR[i]) {
        rowR[i] = row[j][i];
@@ -873,16 +873,16 @@ inline void minAttrs(AllocTable2d<T> *data,int *iNodes,int rNode,int k,int width
 void FEM_DataAttribute::interpolate(int A,int B,int D,double frac){
   switch(getDatatype()){
   case FEM_BYTE:
-    minAttrs(char_data,A,B,D,frac,getWidth());         
+    minAttrs(char_data,A,B,D,frac,getWidth());
     break;
   case FEM_INT:
-    minAttrs(int_data,A,B,D,frac,getWidth());          
+    minAttrs(int_data,A,B,D,frac,getWidth());
     break;
   case FEM_FLOAT:
-    interpolateAttrs(float_data,A,B,D,frac,getWidth());                
+    interpolateAttrs(float_data,A,B,D,frac,getWidth());
     break;
   case FEM_DOUBLE:
-    interpolateAttrs(double_data,A,B,D,frac,getWidth());               
+    interpolateAttrs(double_data,A,B,D,frac,getWidth());
     break;
   }
 }
@@ -890,16 +890,16 @@ void FEM_DataAttribute::interpolate(int A,int B,int D,double frac){
 void FEM_DataAttribute::interpolate(int *iNodes,int rNode,int k){
   switch(getDatatype()){
   case FEM_BYTE:
-    minAttrs(char_data,iNodes,rNode,k,getWidth());             
+    minAttrs(char_data,iNodes,rNode,k,getWidth());
     break;
   case FEM_INT:
-    minAttrs(int_data,iNodes,rNode,k,getWidth());              
+    minAttrs(int_data,iNodes,rNode,k,getWidth());
     break;
   case FEM_FLOAT:
-    interpolateAttrs(float_data,iNodes,rNode,k,getWidth());            
+    interpolateAttrs(float_data,iNodes,rNode,k,getWidth());
     break;
   case FEM_DOUBLE:
-    interpolateAttrs(double_data,iNodes,rNode,k,getWidth());           
+    interpolateAttrs(double_data,iNodes,rNode,k,getWidth());
     break;
   }
 }
@@ -933,8 +933,8 @@ void FEM_IndexAttribute::allocate(int length,int width,int datatype)
 }
 
 /**
- * Convert a datatype, which must be FEM_INDEX_0 or FEM_INDEX_1, to 
- * the first valid index (base index) of that type.  Otherwise 
+ * Convert a datatype, which must be FEM_INDEX_0 or FEM_INDEX_1, to
+ * the first valid index (base index) of that type.  Otherwise
  * call FEM_Abort, because the datatype is wrong.
  */
 static int type2base(int base_type,const char *caller) {
@@ -946,8 +946,8 @@ static int type2base(int base_type,const char *caller) {
 }
 
 /// Copy this data out of the user's (layout-formatted, indexBase) array:
-void setIndexTableData(const void *user, int firstItem, int length, 
-       IDXL_LAYOUT_PARAM, AllocTable2d<int> *table,int indexBase) 
+void setIndexTableData(const void *user, int firstItem, int length,
+       IDXL_LAYOUT_PARAM, AllocTable2d<int> *table,int indexBase)
 {
        for (int r=0;r<length;r++) {
                register int *tableRow=table->getRow(firstItem+r);
@@ -957,8 +957,8 @@ void setIndexTableData(const void *user, int firstItem, int length,
 }
 
 /// Copy this data into the user's (layout-formatted, indexBase) array:
-void getIndexTableData(void *user, int firstItem, int length, 
-       IDXL_LAYOUT_PARAM, const AllocTable2d<int> *table,int indexBase) 
+void getIndexTableData(void *user, int firstItem, int length,
+       IDXL_LAYOUT_PARAM, const AllocTable2d<int> *table,int indexBase)
 {
        for (int r=0;r<length;r++) {
                register const int *tableRow=table->getRow(firstItem+r);
@@ -972,21 +972,21 @@ void FEM_IndexAttribute::set(const void *src, int firstItem,int length,
 {
        IDXL_Layout lo=layout; lo.type=FEM_INT; //Pretend it's always int data, not INDEX
        super::set(src,firstItem,length,lo,caller);
-       
+
        int indexBase=type2base(layout.type,caller);
        setIndexTableData(src,firstItem,length,IDXL_LAYOUT_CALL(layout),&idx,indexBase);
-       
-       if (checker) 
+
+       if (checker)
                for (int r=0;r<length;r++)
                        checker->check(firstItem+r,idx,caller);
 }
 
-void FEM_IndexAttribute::get(void *dest, int firstItem,int length, 
+void FEM_IndexAttribute::get(void *dest, int firstItem,int length,
                const IDXL_Layout &layout,const char *caller) const
 {
        IDXL_Layout lo=layout; lo.type=FEM_INT; //Pretend it's always int data, not INDEX
        super::get(dest,firstItem,length,lo,caller);
-       
+
        int indexBase=type2base(layout.type,caller);
        getIndexTableData(dest,firstItem,length,IDXL_LAYOUT_CALL(layout),&idx,indexBase);
 }
@@ -1034,7 +1034,7 @@ void FEM_VarIndexAttribute::set(const void *src,int firstItem,int length,
 void FEM_VarIndexAttribute::get(void *dest, int firstItem,int length,
                const IDXL_Layout &layout, const char *caller) const{
         printf("get not yet implemented for FEM_VarIndexAttribute \n");
-                       
+
 }
 
 void FEM_VarIndexAttribute::copyEntity(int dstEntity,const FEM_Attribute &_src,int srcEntity){
@@ -1070,7 +1070,7 @@ int FEM_VarIndexAttribute::findInRow(int row,const ID &data){
 /********************** Entity **************************/
 
 /// Return the human-readable version of this entity code.
-CDECL const char *FEM_Get_entity_name(int entity,char *storage) 
+CDECL const char *FEM_Get_entity_name(int entity,char *storage)
 {
        char *dest=storage;
        if (entity<FEM_ENTITY_FIRST || entity>=FEM_ENTITY_LAST) {
@@ -1102,7 +1102,7 @@ FEM_Entity::FEM_Entity(FEM_Entity *ghost_) //Default constructor
                length=-1;
                max=-1;
        }
-} 
+}
 void FEM_Entity::pup(PUP::er &p) {
        p|length;
        p|max;
@@ -1113,16 +1113,16 @@ void FEM_Entity::pup(PUP::er &p) {
        ghostRecv.pup(p);
        p.comment(" Ghost IDXL tag: ");
        ghostIDXL.pup(p);
-       
+
        int nAttributes=attributes.size();
        p|nAttributes;
-       for (int a=0;a<nAttributes;a++) 
+       for (int a=0;a<nAttributes;a++)
        {
        /* Beautiful hack: the FEM_Attribute objects are normally hideously cross-linked
           with their owning classes.  Thus instead of trying to rebuild the FEM_Attributes
           from scratch here, we just use the existing "lookup" method to demand-create those
           that need it, or just *find* those that are already there.
-          
+
           This is a much better fit for this situation than using the general PUP::able.
         */
          int attr=0; // The attribute type we're pupping
@@ -1135,7 +1135,7 @@ void FEM_Entity::pup(PUP::er &p) {
          if (p.isUnpacking()) { //Recv side: create (or recycle) the destination
            r=lookup(attr,"FEM_Entity::pup");
          }
-         
+
          { //Put the human-readable attribute name in the output file:
            char attrNameStorage[256];
            p.comment(FEM_Get_attr_name(attr,attrNameStorage));
@@ -1156,14 +1156,14 @@ void FEM_Entity::pup(PUP::er &p) {
        if(p.isDeleting()) {
          if(invalidList!=NULL) delete[] invalidList;
        }
-       
+
        if (ghost!=NULL) {
                p.comment(" ---- Ghost attributes ---- ");
                ghost->pup(p);
        }
 }
 
-FEM_Entity::~FEM_Entity() 
+FEM_Entity::~FEM_Entity()
 {
        delete ghost;
        for (int a=0;a<attributes.size();a++)
@@ -1172,7 +1172,7 @@ FEM_Entity::~FEM_Entity()
 
 /// Copy our attributes' widths and data types from this entity.
 void FEM_Entity::copyShape(const FEM_Entity &src) {
-       for (int a=0;a<src.attributes.size();a++) 
+       for (int a=0;a<src.attributes.size();a++)
        { // We need each of his attributes:
                const FEM_Attribute *Asrc=src.attributes[a];
                FEM_Attribute *Adst=lookup(Asrc->getAttr(),"FEM_Entity::copyShape");
@@ -1181,7 +1181,7 @@ void FEM_Entity::copyShape(const FEM_Entity &src) {
        if (ghost) ghost->copyShape(*src.ghost);
 }
 
-void FEM_Entity::setLength(int newlen, bool f) 
+void FEM_Entity::setLength(int newlen, bool f)
 {
     if (!resize) {
         if (size() != newlen) {
@@ -1206,12 +1206,12 @@ void FEM_Entity::setLength(int newlen, bool f)
             }
             for (int a=0;a<attributes.size();a++){
                 int code = attributes[a]->getAttr();
-                if (!(code <= FEM_ATTRIB_TAG_MAX || 
+                if (!(code <= FEM_ATTRIB_TAG_MAX ||
                             code == FEM_CONN || code == FEM_COORD ||
                      code == FEM_BOUNDARY)) { //user can store bpundary & connectivity also
                     attributes[a]->reallocate();
                 }
-            }  
+            }
             // call resize with args max n;
             //CkPrintf("Resize called \n");
             resize(args,&otherlen,&max); //resets length to otherlen
@@ -1229,15 +1229,15 @@ void FEM_Entity::allocateValid(void) {
     valid->setLength(size());
     valid->setDatatype(FEM_BYTE);
     valid->reallocate();
-    
+
     // Set all to valid initially
     for(int i=0;i<size();i++) {
       valid->getChar()(i,0)=1;
     }
     if(true) { //maintains a list of invalid elements. FASTER
       invalidListLen=0; invalidListAllLen=16;
-      invalidList = new int[invalidListAllLen]; 
-      //its ok to waste a few bytes for an entity, especially when it can 
+      invalidList = new int[invalidListAllLen];
+      //its ok to waste a few bytes for an entity, especially when it can
       //bring up the performance of the average case
       for(int i=0; i<invalidListAllLen; i++) {
        invalidList[i] = -1; //means this position is empty
@@ -1268,13 +1268,13 @@ void FEM_Entity::set_valid(int idx, bool isNode){
       CkAssert(idx < size1 && idx >=0 && first_invalid<=last_invalid);
       valid->getChar()(idx,0)=1;
       if(idx == first_invalid) {
-       // Move first_invalid to the next invalid entry 
+       // Move first_invalid to the next invalid entry
        while((first_invalid<last_invalid) && is_valid(first_invalid)){
          first_invalid++;
        }
       }
       else if(idx == last_invalid) {
-       // Move last_invalid to the previous invalid entry      
+       // Move last_invalid to the previous invalid entry
        while((first_invalid<last_invalid) && is_valid(last_invalid)) {
          last_invalid--;
        }
@@ -1303,7 +1303,7 @@ void FEM_Entity::set_invalid(int idx, bool isNode){
   else {
     CkAssert(idx < size() && idx >=0 && first_invalid<=last_invalid);
     valid->getChar()(idx,0)=0;
-    
+
     // If there are currently no invalid entities
     if(first_invalid==0 && last_invalid==0 && is_valid(0)){
       first_invalid = last_invalid = idx;
@@ -1316,30 +1316,42 @@ void FEM_Entity::set_invalid(int idx, bool isNode){
       last_invalid = idx;
     }
     // TODO:
-    // We should probably have an algorithm for shrinking the entire attribute 
+    // We should probably have an algorithm for shrinking the entire attribute
     // array if we invalidate the final element. In this case we should scan backwards
     // to find the largest indexed valid entity and resize down to it.
-    // 
+    //
     // It may be necessary to modify the idxl lists if we do this type of shrinking.
-    // Someone needs to confirm whether that is necessary. If not, then it should be 
+    // Someone needs to confirm whether that is necessary. If not, then it should be
     // simple to allow shrinking of the number of nodes or elements.
   }
 }
 
+
+/** Determine if an index refers to a valid non-ghost entity. Index must be between 0 and size(). Changing this assumption will break things. If required use the other functions is_valid_any_idx() or is_valid_nonghost_idx() */
 int FEM_Entity::is_valid(int idx){
     CkAssert(idx < size() && idx >=0);
     return valid->getChar()(idx,0);
 }
 
+/** Determine if an index refers to a valid entity, with negatives corresponding to a valid ghost */
 int FEM_Entity::is_valid_any_idx(int idx){
   if(idx == -1 || idx >= size())
        return false;
   else if(idx < 0)
        return ghost->is_valid_any_idx(FEM_To_ghost_index(idx));
-  else 
+  else
+    return valid->getChar()(idx,0);
+}
+
+/** Determine if an index refers to a valid non-ghost entity */
+int FEM_Entity::is_valid_nonghost_idx(int idx){
+  if(idx < 0 || idx >= size())
+    return false;
+  else
     return valid->getChar()(idx,0);
 }
 
+/** Linear scan to count valid entities */
 int FEM_Entity::count_valid(){
   int count=0;
   for(int i=0;i<size();i++)
@@ -1347,7 +1359,7 @@ int FEM_Entity::count_valid(){
   return count;
 }
 
-int FEM_Entity::set_all_invalid(){
+void FEM_Entity::set_all_invalid(){
     // Set all to invalid
     for(int i=0;i<size();i++) {
       valid->getChar()(i,0)=0;
@@ -1367,7 +1379,7 @@ int FEM_Entity::get_next_invalid(FEM_Mesh *m, bool isNode, bool isGhost){
     }
     else {
       retval = size();
-      setLength(retval+1,true);  
+      setLength(retval+1,true);
     }
 //  }
 /*  else {
@@ -1412,7 +1424,7 @@ int FEM_Entity::get_next_invalid(FEM_Mesh *m, bool isNode, bool isGhost){
            }
            else retval++;
          }
-       }  
+       }
        else{
          // resize array and return new entity
          flag1 = true;
@@ -1441,7 +1453,7 @@ void FEM_Entity::setMaxLength(int newLen,int newMaxLen,void *pargs,FEM_Mesh_allo
 void FEM_Entity::copyEntity(int dstEntity,const FEM_Entity &src,int srcEntity) {
        FEM_Entity *dp=this; //Destination entity
        const FEM_Entity *sp=&src;
-       for (int a=0;a<sp->attributes.size();a++) 
+       for (int a=0;a<sp->attributes.size();a++)
        { //We copy each of his attributes:
                const FEM_Attribute *Asrc=sp->attributes[a];
                FEM_Attribute *Adst=dp->lookup(Asrc->getAttr(),"FEM_Entity::copyEntity");
@@ -1461,7 +1473,7 @@ int FEM_Entity::push_back(const FEM_Entity &src,int srcEntity) {
 /// Add this attribute to this kind of Entity.
 /// This method is normally called by the default lookup method.
 void FEM_Entity::add(FEM_Attribute *attribute) {
-       if (ghost!=NULL) 
+       if (ghost!=NULL)
        { //Look up (or create) the ghost attribute, too:
                attribute->setGhost(ghost->lookup(attribute->getAttr(),"FEM_Entity::add"));
        }
@@ -1479,10 +1491,10 @@ FEM_Attribute *FEM_Entity::lookup(int attr,const char *caller) {
                if (attributes[a]->getAttr()==attr)
                        return attributes[a];
        }
-       
+
        //If we get here, no existing attribute fits the bill: create one
        create(attr,caller);
-       
+
        // If create did its job, the next lookup should succeed:
        return lookup(attr,caller);
 }
@@ -1490,21 +1502,21 @@ FEM_Attribute *FEM_Entity::lookup(int attr,const char *caller) {
 /**
  * Create a new attribute from an FEM_ATTR code.
  * The default implementation handles FEM_DATA tags; entity-specific
- * attributes (like FEM_CONN) need to be overridden and created 
+ * attributes (like FEM_CONN) need to be overridden and created
  * by subclasses.
  */
 void FEM_Entity::create(int attr,const char *caller) {
   if (attr<=FEM_ATTRIB_TAG_MAX) //It's a valid user data tag
        add(new FEM_DataAttribute(this,attr));
-  else if (attr==FEM_COORD) 
+  else if (attr==FEM_COORD)
        allocateCoord();
-  else if (attr==FEM_SYMMETRIES) 
+  else if (attr==FEM_SYMMETRIES)
        allocateSym();
-  else if (attr==FEM_GLOBALNO) 
+  else if (attr==FEM_GLOBALNO)
        allocateGlobalno();
   else if (attr==FEM_IS_VALID_ATTR)
        allocateValid();
-  else if (attr==FEM_MESH_SIZING) 
+  else if (attr==FEM_MESH_SIZING)
        allocateMeshSizing();
   else if(attr == FEM_CHUNK){
        FEM_IndexAttribute *chunkNo= new FEM_IndexAttribute(this,FEM_CHUNK,NULL);
@@ -1560,7 +1572,7 @@ void FEM_Entity::setSymmetries(int r,FEM_Symmetries_t s)
 /*
  * Set the coordinates for a node or other entity.
  * Use the appropriate 2d or 3d version.
- * 
+ *
  * Note that first the function attempts to find coordinates in
  * the FEM_COORD attribute's array "*coord". If this fails, then
  * it will use the user's FEM_DATA field. Little error checking is
@@ -1601,7 +1613,7 @@ void FEM_Entity::allocateGlobalno(void) {
 }
 
 void FEM_Entity::allocateMeshSizing(void) {
-  if (meshSizing) 
+  if (meshSizing)
     CkAbort("FEM_Entity::allocateMeshSizing called, but already allocated");
   meshSizing=new FEM_DataAttribute(this,FEM_MESH_SIZING);
   add(meshSizing); // meshSizing will be deleted via attributes list now
@@ -1661,7 +1673,7 @@ void FEM_Entity::setAscendingGlobalno(int base) {
 }
 void FEM_Entity::copyOldGlobalno(const FEM_Entity &e) {
        if ((!hasGlobalno()) && e.hasGlobalno() && size()>=e.size()) {
-               for (int i=0;i<size();i++) 
+               for (int i=0;i<size();i++)
                        setGlobalno(i,e.getGlobalno(i));
        }
 }
@@ -1678,7 +1690,7 @@ void FEM_Entity::clearGhost(){
 };
 
 /********************** Node *****************/
-FEM_Node::FEM_Node(FEM_Node *ghost_) 
+FEM_Node::FEM_Node(FEM_Node *ghost_)
   :FEM_Entity(ghost_), primary(0), sharedIDXL(&shared,&shared),
    elemAdjacency(0),nodeAdjacency(0)
 {}
@@ -1698,9 +1710,9 @@ bool FEM_Node::hasConn(int idx) {
 }
 
 void FEM_Node::pup(PUP::er &p) {
-       p.comment(" ---------------- Nodes ------------------ ");       
+       p.comment(" ---------------- Nodes ------------------ ");
        super::pup(p);
-       p.comment(" ---- Shared nodes ----- "); 
+       p.comment(" ---- Shared nodes ----- ");
        shared.pup(p);
        p.comment(" shared nodes IDXL ");
        sharedIDXL.pup(p);
@@ -1729,15 +1741,15 @@ class FEM_Elem_Conn_Checker : public FEM_IndexAttribute::Checker {
        const FEM_Entity &sizeSrc;
        const FEM_Entity *sizeSrc2;
 public:
-       FEM_Elem_Conn_Checker(const FEM_Entity &sizeSrc_,const FEM_Entity *sizeSrc2_) 
+       FEM_Elem_Conn_Checker(const FEM_Entity &sizeSrc_,const FEM_Entity *sizeSrc2_)
                :sizeSrc(sizeSrc_), sizeSrc2(sizeSrc2_) {}
-       
+
        void check(int row,const BasicTable2d<int> &table,const char *caller) const {
                const int *idx=table.getRow(row);
                int n=table.width();
                int max=sizeSrc.size();
                if (sizeSrc2) max+=sizeSrc2->size();
-               for (int i=0;i<n;i++) 
+               for (int i=0;i<n;i++)
                        if ((idx[i]<0) || (idx[i]>=max))
                        { /* This index is out of bounds: */
                                if (idx[i]<0)
@@ -1750,7 +1762,7 @@ public:
        }
 };
 
-FEM_Elem::FEM_Elem(const FEM_Mesh &mesh, FEM_Elem *ghost_) 
+FEM_Elem::FEM_Elem(const FEM_Mesh &mesh, FEM_Elem *ghost_)
   :FEM_Entity(ghost_), elemAdjacency(0), elemAdjacencyTypes(0)
 {
        FEM_IndexAttribute::Checker *c;
@@ -1770,8 +1782,8 @@ FEM_Elem::~FEM_Elem() {
 
 
 void FEM_Elem::create(int attr,const char *caller) {
-  // We need to catch both FEM_ELEM_ELEM_ADJACENCY and FEM_ELEM_ELEM_ADJ_TYPES, 
-  // since if either one falls through to 
+  // We need to catch both FEM_ELEM_ELEM_ADJACENCY and FEM_ELEM_ELEM_ADJ_TYPES,
+  // since if either one falls through to
   // the super::create(), it will not know what to do, and will fail
   //
   // Note: allocateElemAdjacency() will create both attribute fields since they
@@ -1805,7 +1817,7 @@ class FEM_Sparse_Elem_Checker : public FEM_IndexAttribute::Checker {
        const FEM_Mesh &mesh;
 public:
        FEM_Sparse_Elem_Checker(const FEM_Mesh &mesh_) :mesh(mesh_) {}
-       
+
        void check(int row,const BasicTable2d<int> &table,const char *caller) const {
                //assert: table.getWidth==2
                const int *elem=table.getRow(row);
@@ -1823,7 +1835,7 @@ public:
        }
 };
 
-FEM_Sparse::FEM_Sparse(const FEM_Mesh &mesh_,FEM_Sparse *ghost_) 
+FEM_Sparse::FEM_Sparse(const FEM_Mesh &mesh_,FEM_Sparse *ghost_)
        :FEM_Elem(mesh_,ghost_), elem(0), mesh(mesh_)
 {
 }
@@ -1851,7 +1863,7 @@ void FEM_Sparse::create(int attr,const char *caller) {
 
 
 /******************* Mesh *********************/
-FEM_Mesh::FEM_Mesh() 
+FEM_Mesh::FEM_Mesh()
        :node(new FEM_Node(NULL)),
         elem(*this,"FEM_ELEM"),
         sparse(*this,"FEM_SPARSE"),
@@ -1867,7 +1879,7 @@ FEM_Mesh::~FEM_Mesh() {
 
 FEM_Entity *FEM_Mesh::lookup(int entity,const char *caller) {
        FEM_Entity *e=NULL;
-       if (entity>=FEM_ENTITY_FIRST && entity<FEM_ENTITY_LAST) 
+       if (entity>=FEM_ENTITY_FIRST && entity<FEM_ENTITY_LAST)
        { //It's in the right range for an entity code:
                bool isGhost=false;
                if (entity-FEM_ENTITY_FIRST>=FEM_GHOST) {
@@ -1876,27 +1888,27 @@ FEM_Entity *FEM_Mesh::lookup(int entity,const char *caller) {
                }
                if (entity==FEM_NODE)
                        e=&node;
-               else if (entity>=FEM_ELEM && entity<FEM_ELEM+100) 
+               else if (entity>=FEM_ELEM && entity<FEM_ELEM+100)
                { //It's a kind of element:
                        int elType=entity-FEM_ELEM;
                        e=&elem.set(elType);
                }
-               else if (entity>=FEM_SPARSE && entity<FEM_SPARSE+100) 
+               else if (entity>=FEM_SPARSE && entity<FEM_SPARSE+100)
                { //It's a kind of sparse:
                        int sID=entity-FEM_SPARSE;
                        e=&sparse.set(sID);
                }
-               
+
                if (isGhost) //Move from the real to the ghost entity
                        e=e->getGhost();
        }
-       
+
        if (e==NULL) //We didn't find an entity!
                FEM_Abort(caller,"Expected an entity type (FEM_NODE, FEM_ELEM, etc.) but got %d",entity);
        return e;
 }
 const FEM_Entity *FEM_Mesh::lookup(int entity,const char *caller) const {
-       /// FIXME: the const version is quite similar to the above, 
+       /// FIXME: the const version is quite similar to the above,
        /// but it should *not* create new Entity types...
        return ((FEM_Mesh *)this)->lookup(entity,caller);
 }
@@ -1921,13 +1933,13 @@ void FEM_Mesh::pup(PUP::er &p)  //For migration
 
        p.comment(" ------------- Element Types ---------- ");
        elem.pup(p);
-       
+
        p.comment("-------------- Sparse Types ------------");
        sparse.pup(p);
-       
+
        p.comment("-------------- Symmetries ------------");
        symList.pup(p);
-       
+
        p|m_isSetting;
        p|lastLayerSet;
        if(lastLayerSet) {
@@ -1962,11 +1974,11 @@ int FEM_Mesh::nElems(int t_max) const //Return total number of elements before t
        }
 #endif
        int ret=0;
-       for (int t=0;t<t_max;t++){ 
+       for (int t=0;t<t_max;t++){
                if (elem.has(t)){
                        ret+=elem.get(t).size();
                }
-       }       
+       }
        return ret;
 }
 
@@ -1995,16 +2007,16 @@ void FEM_Mesh::setAbsoluteGlobalno(){
        node.setAscendingGlobalno();
        for (int e=0;e<elem.size();e++){
                if (elem.has(e)) elem[e].setAscendingGlobalno(nElems(e));
-       }       
+       }
 }
 
 void FEM_Mesh::copyOldGlobalno(const FEM_Mesh &m) {
        node.copyOldGlobalno(m.node);
        for (int e=0;e<m.elem.size();e++)
-               if (m.elem.has(e) && e<elem.size() && elem.has(e)) 
+               if (m.elem.has(e) && e<elem.size() && elem.has(e))
                        elem[e].copyOldGlobalno(m.elem[e]);
        for (int s=0;s<m.sparse.size();s++)
-               if (m.sparse.has(s) && s<sparse.size() && sparse.has(s)) 
+               if (m.sparse.has(s) && s<sparse.size() && sparse.has(s))
                        sparse[s].copyOldGlobalno(m.sparse[s]);
 }
 
@@ -2041,12 +2053,12 @@ void FEM_Is_NULL(const char *caller,const char *entityType,int type) {
 void FEM_Mesh::copyShape(const FEM_Mesh &src)
 {
        node.copyShape(src.node);
-       for (int t=0;t<src.elem.size();t++) 
+       for (int t=0;t<src.elem.size();t++)
                if (src.elem.has(t)) elem.set(t).copyShape(src.elem.get(t));
-       
+
        for (int s=0;s<src.sparse.size();s++)
                if (src.sparse.has(s)) sparse.set(s).copyShape(src.sparse.get(s));
-       
+
        setSymList(src.getSymList());
 }
 
@@ -2054,7 +2066,7 @@ void FEM_Mesh::copyShape(const FEM_Mesh &src)
 int FEM_Mesh::getEntities(int *entities) {
        int len=0;
        entities[len++]=FEM_NODE;
-       for (int t=0;t<elem.size();t++) 
+       for (int t=0;t<elem.size();t++)
                if (elem.has(t)) entities[len++]=FEM_ELEM+t;
        for (int s=0;s<sparse.size();s++)
                if (sparse.has(s)) entities[len++]=FEM_SPARSE+s;
@@ -2068,7 +2080,7 @@ FILE *FEM_openMeshFile(const char *prefix,int chunkNo,int nchunks,bool forRead)
     static const char *meshFileNames="%s_vp%d_%d.dat";
     sprintf(fname, meshFileNames, prefix, nchunks, chunkNo);
     FILE *fp = fopen(fname, forRead?"r":"w");
-    CkPrintf("FEM> %s %s...\n",forRead?"Reading":"Writing",fname);  
+    CkPrintf("FEM> %s %s...\n",forRead?"Reading":"Writing",fname);
     if(fp==0) {
       FEM_Abort(forRead?"FEM: unable to open input file"
        :"FEM: unable to create output file.\n");
@@ -2126,14 +2138,14 @@ void FEM_writeMesh(FEM_Mesh *m,const char *prefix,int chunkNo,int nChunks)
 
 
 // Setup the entity FEM_IS_VALID tables
-CDECL void FEM_Mesh_allocate_valid_attr(int fem_mesh, int entity_type){  
+CDECL void FEM_Mesh_allocate_valid_attr(int fem_mesh, int entity_type){
   FEM_Mesh *m=FEM_Mesh_lookup(fem_mesh,"FEM_Mesh_create_valid_elem");
   FEM_Entity *entity = m->lookup(entity_type,"FEM_Mesh_allocate_valid_attr");
   entity->allocateValid();
 }
 FORTRAN_AS_C(FEM_MESH_ALLOCATE_VALID_ATTR,
              FEM_Mesh_allocate_valid_attr,
-             fem_mesh_allocate_valid_attr, 
+             fem_mesh_allocate_valid_attr,
              (int *fem_mesh, int *entity_type),  (*fem_mesh, *entity_type) )
 
 
@@ -2143,10 +2155,10 @@ CDECL void FEM_set_entity_valid(int mesh, int entityType, int entityIdx){
   FEM_Entity *entity = m->lookup(entityType,"FEM_");
   entity->set_valid(entityIdx,true);
 }
-FORTRAN_AS_C(FEM_SET_ENTITY_VALID, 
-             FEM_set_entity_valid, 
-             fem_set_entity_valid,  
-             (int *fem_mesh, int *entity_type, int *entityIdx),  (*fem_mesh, *entity_type, *entityIdx) ) 
+FORTRAN_AS_C(FEM_SET_ENTITY_VALID,
+             FEM_set_entity_valid,
+             fem_set_entity_valid,
+             (int *fem_mesh, int *entity_type, int *entityIdx),  (*fem_mesh, *entity_type, *entityIdx) )
 
 
 // mark an entity as invalid
@@ -2155,10 +2167,10 @@ CDECL void FEM_set_entity_invalid(int mesh, int entityType, int entityIdx){
   FEM_Entity *entity = m->lookup(entityType,"FEM_Mesh_allocate_valid_attr");
   return entity->set_invalid(entityIdx,true);
 }
-FORTRAN_AS_C(FEM_SET_ENTITY_INVALID,  
-             FEM_set_entity_invalid,  
-             fem_set_entity_invalid,   
-             (int *fem_mesh, int *entity_type, int *entityIdx),  (*fem_mesh, *entity_type, *entityIdx) )  
+FORTRAN_AS_C(FEM_SET_ENTITY_INVALID,
+             FEM_set_entity_invalid,
+             fem_set_entity_invalid,
+             (int *fem_mesh, int *entity_type, int *entityIdx),  (*fem_mesh, *entity_type, *entityIdx) )
 
 
 // Determine if an entity is valid
@@ -2167,10 +2179,10 @@ CDECL int FEM_is_valid(int mesh, int entityType, int entityIdx){
   FEM_Entity *entity = m->lookup(entityType,"FEM_Mesh_allocate_valid_attr");
   return (entity->is_valid(entityIdx) != 0);
 }
-FORTRAN_AS_C(FEM_IS_VALID,   
-             FEM_is_valid,   
-             fem_is_valid,    
-             (int *fem_mesh, int *entity_type, int *entityIdx),  (*fem_mesh, *entity_type, *entityIdx) )   
+FORTRAN_AS_C(FEM_IS_VALID,
+             FEM_is_valid,
+             fem_is_valid,
+             (int *fem_mesh, int *entity_type, int *entityIdx),  (*fem_mesh, *entity_type, *entityIdx) )
 
 
 // Count number of valid items for this entity type
@@ -2179,13 +2191,13 @@ CDECL int FEM_count_valid(int mesh, int entityType){
   FEM_Entity *entity = m->lookup(entityType,"FEM_Mesh_allocate_valid_attr");
   return entity->count_valid();
 }
-FORTRAN_AS_C(FEM_COUNT_VALID,    
-             FEM_count_valid,    
-             fem_count_valid,     
-             (int *fem_mesh, int *entity_type),  (*fem_mesh, *entity_type) )    
+FORTRAN_AS_C(FEM_COUNT_VALID,
+             FEM_count_valid,
+             fem_count_valid,
+             (int *fem_mesh, int *entity_type),  (*fem_mesh, *entity_type) )
+
 
-// Set coordinates for some entity's item number idx 
+// Set coordinates for some entity's item number idx
 void FEM_set_entity_coord2(int mesh, int entityType, int idx, double x, double y){
   FEM_Mesh *m=FEM_Mesh_lookup(mesh,"FEM_Mesh_create_valid_elem");
   FEM_Entity *entity = m->lookup(entityType,"FEM_Mesh_allocate_valid_attr");