---

IntermediateCell.h

Go to the documentation of this file.

#ifndef INTERMEDIATECELL_H
#define INTERMEDIATECELL_H

#include "SundanceDefs.h"

#include "CellBase.h"
#include "Pool.h"
#include "MeshData.h"


namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  /** \ingroup LowLevelGeometry
   * Cell with dimension greater than zero and less than the spatial dimension.
   */


  class IntermediateCell : public CellBase
    {
    public:
      IntermediateCell(MeshData* meshData,
                       int myIndex,
                       int myDim,
                       int parentID,
                       int myFacetID)
        : CellBase(meshData, myIndex, -1),
        parentIndex_(1, parentID),
        myFacetIndex_(1, myFacetID),
        myDim_(myDim)
        {;}
      virtual ~IntermediateCell(){;}


      virtual int dim() const {return myDim_;}

      virtual int numNodes() const ;
      virtual int numVertices() const ;
      virtual int numFacets(int d) const ;
      virtual int numCofacets(int d) const ;
      virtual void getNodes(TSFArray<int>& nodes) const ;
      virtual bool topologicallyEquals(const TSFArray<int>& otherVertices) const ;
      virtual const Cell& facet(int dim, int facetNumber) const ;
      virtual const Cell& cofacet(int d, int cofacetNumber) const ;
      virtual void getFacetIndices(TSFArray<TSFArray<int> >& facetIndices) const ;
      virtual void getCofacetIndices(TSFArray<TSFArray<int> >& cofacetIndices) const ;
      virtual int numParents() const {return parentIndex_.length();}
      virtual int parentIndex(int i) const {return parentIndex_[i];}
      virtual int myFacetIndex(int i) const {return myFacetIndex_[i];}
      virtual void addParent(int parentIndex, int myFacetIndex)
        {parentIndex_.append(parentIndex); myFacetIndex_.append(myFacetIndex);}

      virtual bool isBoundaryCell() const ;

      virtual const ReferenceCell& refCell() const ;

      virtual const Point& point(int i) const ;

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

      virtual int byteCount() const ;

      virtual void setAnchorIndex(int anchorIndex) {anchorIndex_=anchorIndex;}
      virtual void setCofacetIndex(int cofacetIndex) {myCofacetIndex_=cofacetIndex;}
      virtual int anchorIndex() const {return anchorIndex_;}
      virtual int cofacetIndex() const {return myCofacetIndex_;}
#ifndef NO_POOLMEM
      static inline void* operator new(size_t s);
      static inline void operator delete(void* p, size_t s);
#endif

    protected:
      const Cell& parent(int i) const ;

      TSFArray<int> parentIndex_;
      int anchorIndex_;
      int myCofacetIndex_;
      TSFArray<char> myFacetIndex_;
      char myDim_;

      // memory pool
#ifndef NO_POOLMEM
      static Pool memPool_;
#endif

      // Usually we'll call several methods on a single cell. Therefore we cache
      // nodes, facets, and cofacets.
      inline void updateNodeCache() const ;
      inline void updateFacetCache() const ;
      inline void updateCofacetCache() const ;
      void fillNodeCache(TSFArray<int>& nodeCache) const ;
      void fillFacetCache(TSFArray<TSFArray<int> >& facetCache) const ;
      void fillCofacetCache(TSFArray<TSFArray<int> >& cofacetCache) const ;
      static short int nodeCacheCellDim_;
      static int nodeCacheCellIndex_;
      static short int facetCacheCellDim_;
      static int facetCacheCellIndex_;
      static short int cofacetCacheCellDim_;
      static int cofacetCacheCellIndex_;
      static TSFArray<int> nodeCache_;
      static TSFArray<TSFArray<int> > facetCache_;
      static TSFArray<TSFArray<int> > cofacetCache_;
    };

#ifndef NO_POOLMEM

  inline void* IntermediateCell::operator new(size_t s)
    {
      if (s != sizeof(IntermediateCell))
        {
          return ::operator new(s);
        }
      return memPool_.alloc();
      //return ::operator new(s);
    }

  inline void IntermediateCell::operator delete(void* p, size_t s)
    {
      if (s != sizeof(IntermediateCell)) ::operator delete(p);
      else memPool_.free(p);
      //else ::operator delete(p);
    }

#endif

  inline void IntermediateCell::updateNodeCache() const
    {
      if (nodeCacheCellDim_ != myDim_ || nodeCacheCellIndex_ != localIndex_)
        {
          nodeCacheCellDim_ = myDim_;
          nodeCacheCellIndex_ = localIndex_;
          fillNodeCache(nodeCache_);
        }
    }

  inline void IntermediateCell::updateFacetCache() const
    {
      if (facetCacheCellDim_ != myDim_ || facetCacheCellIndex_ != localIndex_)
        {
          facetCacheCellDim_ = myDim_;
          facetCacheCellIndex_ = localIndex_;
          fillFacetCache(facetCache_);
        }
    }

  inline void IntermediateCell::updateCofacetCache() const
    {
      if (cofacetCacheCellDim_ != myDim_ || cofacetCacheCellIndex_ != localIndex_)
        {
          cofacetCacheCellDim_ = myDim_;
          cofacetCacheCellIndex_ = localIndex_;
          fillCofacetCache(cofacetCache_);
        }
    }







}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by