---

CellBase.h

Go to the documentation of this file.

#ifndef CELLBASE_H
#define CELLBASE_H

#include "SundanceDefs.h"

#include "TSFArray.h"
#include "Point.h"
#include "CellJacobian.h"
/* #include "InvCellJacobian.h" */
/* #include "InvCellHessian.h" */
#include "CellType.h"


namespace Sundance
{

  using namespace TSF;
  using std::ostream;

  class MeshData;
  class ReferenceCell;
  class Cell;
  class FacetSetBase;

  /** \ingroup LowLevelGeometry
      Base class for cell implementations.
  */

  class CellBase
    {
    public:
      /** Construct with a pointer to the low-level mesh data structure
       * and a local index. This will be used to create IntermediateCells,
       * for which the global index is not known until the processor
       * synchronization step */
      CellBase(MeshData* meshData,
               int localIndex,
               short int /*labelInd*/)
        : meshData_(meshData), localIndex_(localIndex),
        globalIndex_(-1)
        {;}
      /** Construct with a pointer to the low-level mesh data structure,
       *  a local index, and a global index. This will be used to create
       *  maximal and zero cells whose global index is known at creation */
      CellBase(MeshData* meshData,
               int localIndex,
               int globalIndex,
               short int /*labelInd*/)
        : meshData_(meshData), localIndex_(localIndex),
        globalIndex_(globalIndex)
        {;}
      /** dtor */
      virtual ~CellBase(){;}

      /** identify self as zero cell or not */
      virtual bool isZeroCell() const {return false;}
      /** identify self as maximal cell or not */
      virtual bool isMaximalCell() const {return false;}
      /** identify self as affine cell or not */
      bool isAffine() const ;
      /** return a code describing my topology type */
      CellTopologyCode topologyCode() const ;
      /** typeid */
      const string& typeName() const ;

      /** return the rank of the processor that owns me */
      short int ownerProcID() const ;
      /** return my local index on the current processor */
      int localIndex() const {return localIndex_;}
      /** return my global index */
      int globalIndex() const {return globalIndex_;}
      /** set my global index */
      void setGlobalIndex(int globalIndex);
      /** return my dimension */
      virtual int dim() const = 0 ;
      /** return the dimension of the mesh in which I live */
      int meshDim() const ;
      /** return the ID number of the mesh in which I live */
      int meshID() const ;

      /** return the number of nodes defining this cell */
      virtual int numNodes() const = 0 ;
      /** return the number of vertices */
      virtual int numVertices() const = 0 ;
      /** get a list of the cell's node numbers */
      virtual void getNodes(TSFArray<int>& nodes) const = 0 ;

      /** return my node number (ZeroCell only) */
      virtual int node() const ;
      /** return a list of my node numbers (MaximalCell only) */
      virtual const TSFArray<int>& nodes() const ;

      /** return the number of d-facets */
      virtual int numFacets(int d) const = 0 ;
      /** return the number of d-cofacets */
      virtual int numCofacets(int d) const = 0 ;

      /** determine if my node list is identical to the given node list */
      virtual bool topologicallyEquals(const TSFArray<int>& otherNodes) const = 0 ;

      /** return the facetNumber-th facet of dimension dim */
      virtual const Cell& facet(int dim, int facetNumber) const = 0;
      /** return the cofacetNumber-th cofacet of dimension d */
      virtual const Cell& cofacet(int d, int cofacetNumber) const = 0;
      virtual void getFacetIndices(TSFArray<TSFArray<int> >& facetIndices) const = 0 ;
      virtual void getCofacetIndices(TSFArray<TSFArray<int> >& cofacetIndices) const =0 ;

      virtual void addParent(int parentIndex, int myFacetIndex);
      virtual int numParents() const ;
      virtual int parentIndex(int i) const ;
      virtual int myFacetIndex(int i) const ;
      //  virtual const TSFArray<TSFArray<int> >& facets() const ;
      virtual const FacetSetBase* facets() const ;
      // implemented for zeroCell only
      virtual const TSFArray<TSFArray<int> >& cofacetIndices() const ;
      virtual bool isBoundaryCell() const ;

      // labeling methods
      void setLabel(const string& newLabel) ;
      short int labelIndex() const ;//{return labelIndex_;}
      //    {return meshData_->labelIndices_[dim()][localIndex_];}
      const string& label() const ;

      virtual const ReferenceCell& refCell() const = 0;

      virtual const Point& point(int i) const = 0 ;

      // mapping methods

      void jacobian(const TSFArray<Point>& refpts,
                    TSFArray<CellJacobian>& J) const ;
     /*  void invJacobian(const TSFArray<Point>& refpts, */
/*                        TSFArray<InvCellJacobian>& invJ) const ; */
/*       void invHessian(const TSFArray<Point>& refpts, */
/*                       TSFArray<InvCellHessian>& invH) const ; */
      void detJacobian(const TSFArray<Point>& refpts,
                       TSFArray<double>& detJ) const ;

      // constant-Jacobian methods, for efficiency on affine cells.
      // No Hessian is needed since affine cells have zero hessian.
      void constantJacobian(CellJacobian& J) const ;
/*       void constantInvJacobian(InvCellJacobian& invJ) const ; */
      void constantDetJacobian(double& detJ) const ;

      // mapping between physical and reference coordinates.
      // pullback means phys -> ref.
      // pushfwd means ref -> phys.
      void pullBack(const TSFArray<Point>& phys,
                    TSFArray<Point>& ref) const ;
      void pushFwd(const TSFArray<Point>& ref,
                   TSFArray<Point>& phys) const ;



      virtual void registerFacet(int dim, int facetNum, int facetCellIndex) = 0 ;
      virtual void registerCofacet(int d, int cofacetCellIndex) = 0 ;

      ostream& print(ostream& os) const ;
      void textWrite(ostream& os) const ;
      string toString() const ;

      virtual int byteCount() const = 0 ;
      virtual TSFArray<int> wastage() const {return 0;}

      const MeshData* meshData() const {return meshData_;}

#ifndef NO_POOLMEM
      static void operator delete(void* p, size_t s);
      static void* operator new(size_t s);
#endif

      virtual int anchorIndex() const ;
      virtual int cofacetIndex() const ;
      //virtual void setAnchorIndex(int anchorIndex);
      //  virtual void setCofacetIndex(int cofacetIndex);

    protected:
      bool permutedEqualityCheck(const TSFArray<int>& a1,
                                 const TSFArray<int>& a2) const ;

      // The mesh in which this cell lives.
      // This is an externally managed pointer, so don't delete it in
      // any methods of this class.
      MeshData* meshData_;

      // This cell's index in the mesh's local table of cells.
      // Cells are tabulated by (dimension, index).
      int localIndex_;   // index local to this processor
      int globalIndex_;  // index global across all processors

      // labeling: store an index into the mesh's table of labels.
      //  char labelIndex_;

      // ID number of the processor that owns this cell.
      // char ownerProcID_;

      // dummy -Wall return value for method nodes();
      static TSFArray<int> dummyRtn_;
      static TSFArray<TSFArray<int> > dummyRtn2_;
      static string dummystring_;
    };



}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by