fei_NodeDescriptor.hpp

#ifndef _NodeDescriptor_hpp_
#define _NodeDescriptor_hpp_

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/

#include <fei_macros.hpp>

#include <fei_ArrayUtils.hpp>
#include <iostream>
class NodeDescriptor {
 public:
   NodeDescriptor();

   NodeDescriptor(const NodeDescriptor& src)
    : nodeID_(src.nodeID_), nodeNumber_(src.nodeNumber_),
      numNodalDOF_(0), fieldIDList_(NULL),
      fieldEqnNumbers_(NULL), numFields_(0), blkEqnNumber_(0),
      ownerProc_(src.ownerProc_), blockList_()
   {}

   virtual ~NodeDescriptor();

   GlobalID getGlobalNodeID() const {return(nodeID_);}
   void setGlobalNodeID(GlobalID node) {nodeID_ = node;}

   int getNodeNumber() const {return(nodeNumber_);}
   void setNodeNumber(int nn) {nodeNumber_ = nn;};

   int getBlkEqnNumber() const {return(blkEqnNumber_);}
   void setBlkEqnNumber(int blkEqn) {blkEqnNumber_ = blkEqn;}

   int getNumNodalDOF() const {return(numNodalDOF_);}
   void setNumNodalDOF(int dof) {numNodalDOF_ = dof;}

   void addField(int fieldID);
   void setFieldEqnNumber(int fieldID, int eqn);

   int getNumFields() const {return(numFields_);}
   const int* getFieldIDList() const {return(fieldIDList_);}
   const int* getFieldEqnNumbers() const {return(fieldEqnNumbers_);}

   bool getFieldEqnNumber(int fieldID, int& eqnNumber) const;

   void getFieldID(int eqnNumber, int& fieldID, int& offset_into_field) const;

   bool operator==(const NodeDescriptor& nd) const
     { return( nodeID_ == nd.nodeID_ ); }

   bool operator!=(const NodeDescriptor& nd) const
     { return( nodeID_ != nd.nodeID_ ); }

   bool operator<(const NodeDescriptor& nd) const
     { return( nodeID_ < nd.nodeID_ ); }

   bool operator>(const NodeDescriptor& nd) const
     { return( nodeID_ > nd.nodeID_ ); }

   int getOwnerProc() const {return(ownerProc_);}
   void setOwnerProc(int proc) {ownerProc_ = proc;}

   void addBlockIndex(unsigned blk_idx)
     { fei::sortedListInsert(blk_idx, blockList_); }

   size_t getNumBlocks() const {return blockList_.size();}
   const std::vector<unsigned>& getBlockIndexList() const {return(blockList_);}
   bool hasBlockIndex(unsigned blk_idx) const;

 private:
   NodeDescriptor& operator=(const NodeDescriptor& src);

   void allocFieldLists();
   void allocBlockList();

   GlobalID nodeID_;

   int nodeNumber_;

   int numNodalDOF_;      //total number of nodal degrees-of-freedom

   int* fieldIDList_;     //list of field identifiers
   int* fieldEqnNumbers_; //list of starting (global) equation numbers.
                          //fields can consist of more than one scalar (and
                          //have more than one associated equation), this
                          //is the first equation number
   int numFields_;

   int blkEqnNumber_;

   int ownerProc_;        //processor that owns the equations for this node

   std::vector<unsigned> blockList_;  //indexes of blocks that contain this node
};

#endif