fei_BlockDescriptor.hpp

#ifndef _fei_BlockDescriptor_hpp_
#define _fei_BlockDescriptor_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_defs.h"
#include <vector>

class BlockDescriptor {
 public:
   BlockDescriptor();
   virtual ~BlockDescriptor();

   GlobalID getGlobalBlockID() {return(blockID_);}
   void setGlobalBlockID(GlobalID blockID) {blockID_ = blockID;}

   int setNumNodesPerElement(int numNodes);
   int getNumNodesPerElement() const { return numNodesPerElement_; }

   int* fieldsPerNodePtr();  //length of this list = getNumNodesPerElement()

   int allocateFieldIDsTable();

   int** fieldIDsTablePtr() { return(nodalFieldIDs_); }

   bool containsField(int fieldID);

   int getNumDistinctFields() { return( numDistinctFields_ ); }
   void setNumDistinctFields(int nFields) { numDistinctFields_ = nFields; }

   int getInterleaveStrategy() const {return(interleaveStrategy_);}
   void setInterleaveStrategy(int strat) {interleaveStrategy_ = strat;}
   
   int getLumpingStrategy() const {return(lumpingStrategy_);}
   void setLumpingStrategy(int strat) {lumpingStrategy_ = strat;}

   int getNumElements() {return(numElements_);}
   void setNumElements(int numElems) {numElements_ = numElems;}
   
   size_t getNumElemDofFieldsPerElement() {return(elemDofFieldIDs_.size());}
   int setElemDofFieldIDs(int numFields, const int* fieldIDs);
   std::vector<int>& getElemDofFieldIDs() { return(elemDofFieldIDs_); }

   void setNumElemDOFPerElement(int ndof) { numElemDOFPerElement_ = ndof; }
   int getNumElemDOFPerElement() { return(numElemDOFPerElement_); }

   //elemDOFEqnNumbers is of length numElements.
   std::vector<int>& elemDOFEqnNumbers() {return(elemDOFEqnNumbers_);}

   int getNumEqnsPerElement() {return(numEqnsPerElement_);};
   void setNumEqnsPerElement(int numEqns) {numEqnsPerElement_ = numEqns;}

   int getNumBlkEqnsPerElement() {return(numBlkEqnsPerElement_);}
   void setNumBlkEqnsPerElement(int numBlkEqns) {numBlkEqnsPerElement_ = numBlkEqns;};

   int getNumActiveNodes() {return(numActiveNodes_);}
   void setNumActiveNodes(int num) {numActiveNodes_ = num;}

   int getTotalNumEqns() {return(totalNumEqns_);}
   void setTotalNumEqns(int numEqns) {totalNumEqns_ = numEqns;}

 private:
   BlockDescriptor(const BlockDescriptor& /*src*/)
     : blockID_(0), numNodesPerElement_(0), numFieldsPerNode_(NULL),
     nodalFieldIDs_(NULL), fieldIDsAllocated_(false),
     numDistinctFields_(0), elemDofFieldIDs_(), interleaveStrategy_(0),
     lumpingStrategy_(0), numElements_(0), numElemDOFPerElement_(0),
     elemDOFEqnNumbers_(), numEqnsPerElement_(0), numBlkEqnsPerElement_(0),
     numActiveNodes_(0), totalNumEqns_(0) {}

   BlockDescriptor& operator=(const BlockDescriptor& /*src*/)
     {
       return(*this);
     }

   void destroyFieldArrays();

   GlobalID blockID_;

   int numNodesPerElement_;

   int* numFieldsPerNode_; //list: length = numNodesPerElement_

   int** nodalFieldIDs_;   //table: number-of-rows = numNodesPerElement_
                           //       length-of-row[i] = numFieldsPerNode_[i]
   bool fieldIDsAllocated_;

   int numDistinctFields_;

   std::vector<int> elemDofFieldIDs_;

   int interleaveStrategy_;
   int lumpingStrategy_;

   int numElements_;
   int numElemDOFPerElement_; //number of elem-dof in each element (all
                              //elems in block have the same number)

   std::vector<int> elemDOFEqnNumbers_; //list -- length = numElements_
                            //holds eqn number of each element's first elemDOF

   int numEqnsPerElement_;
   int numBlkEqnsPerElement_;

   int numActiveNodes_;
   int totalNumEqns_;
};

#endif