---

ReferenceCell.h

Go to the documentation of this file.

#ifndef REFERENCECELL_H
#define REFERENCECELL_H

#include "SundanceDefs.h"

#include "Pool.h"
#include "TSFSmartPtr.h"
#include "ReferenceCellBase.h"


namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  class Cell;

  class FacetSetBase;


  /**  \ingroup LowLevelGeometry
   *
   * A ReferenceCell contains the data and
   * methods that are common to all cells of a given geometry
   * type. The ReferenceCell class itself is a handle to a
   * ReferenceCellBase, from which geometry-specific subtypes are
   * derived.  ReferenceCell provides several types of service:
   * mapping between physical and reference coordinates, and
   * identification of facets
   */

  class ReferenceCell
    {
    public:
      /** empty ctor, for use in containers */
      ReferenceCell() : ptr_(0) {;}
      /** construct with a pointer to a derived type */
      ReferenceCell(ReferenceCellBase* ptr) : ptr_(ptr) {;}


      /** \name introspection */
      //@{
      /** get a name for this tpye of cell */
      const string& typeName() const {return ptr_->typeName();}
      /** get a topology identifier */
      CellTopologyCode topologyCode() const {return ptr_->topologyCode();}

      /** identify affine cells. Affine cells have constant Jacobians so
       * we can do simpler calculations in that case. */
      bool isAffine() const {return ptr_->isAffine();}

      /** get cell dimension */
      int dim() const {return ptr_->dim();}
      /** number of nodes */
      int numNodes() const {return ptr_->numNodes();}
      /** number of vertices (vertices are nodes which correspond to zero-cells) */
      int numVertices() const {return ptr_->numVertices();}
      /** number of facets of dimension d */
      int numFacets(int d) const {return ptr_->numFacets(d);}

      //@}

      /** \name faceting methods */
      //@{

      /** facetNodePtrs() returns a list of pointers to nodes for the facets
       * of dimension facetDim. They are organized as
       * facetNodes[facetNumber][nodeNumber]. The pointers are indices into
       * a cell's local array of nodes. */
      const TSFArray<TSFArray<int> >& facetNodePtrs(int facetDim) const
        {return ptr_->facetNodePtrs(facetDim);}

      /** facetFacetPtrs() returns a list of pointers to the facets of
       * the facet-num-th facet of dimension d. */
      const TSFArray<TSFArray<int> >& facetFacetPtrs(int d, int facetNum) const
        {return ptr_->facetFacetPtrs(d, facetNum);}

      /** return the reference cell for the given facet. */
      const ReferenceCell& facetReferenceCell(int facetDim,
                                              int facetNumber) const
        {return ptr_->facetReferenceCell(facetDim, facetNumber);}

      /** create a facet set */
      FacetSetBase* newFacetSet() const
        {return ptr_->newFacetSet();}
      //@}

      /**\name mappings and jacobians */
      //@{
      /** Jacobian computation, general maximal-dimension non-affine case. */
      void jacobian(const Cell& cell,
                    const TSFArray<Point>& refpts,
                    TSFArray<CellJacobian>& J) const ;

      /** Jacobian computation on embedded cells */
      void detJacobian(const Cell& cell,
                       const TSFArray<Point>& refpts,
                       TSFArray<double>& detJ) const ;

      /** constant-Jacobian, maximal-dimension computation,
       * for efficiency on affine cells. */
      void constantJacobian(const Cell& cell,
                            CellJacobian& J) const ;

      /** constant-Jacobian, embedded cell computation,
       * for efficiency on affine cells. */
      void constantDetJacobian(const Cell& cell,
                               double& detJ) const ;

      /** push forward (ref --> phys) */
      void pushFwd(const Cell& cell,
                   const TSFArray<Point>& ref,
                   TSFArray<Point>& phys) const ;
      //@}

      /** \name compute diameter of cell */
      double diameter(const Cell& cell) const ;

      /** \name compute outward normal of cell */
      Point normal(const Cell& cell) const ;

      /** \name memory management */
      //@{
      /** pooled new */
      static void* operator new(size_t s);
      /** pooled delete */
      static void operator delete(void* p);
      //@}
    private:
      TSFSmartPtr<ReferenceCellBase> ptr_;
      // memory pool
      static Pool memPool_;
    };

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

  inline void ReferenceCell::operator delete(void* p)
    {
      memPool_.free(p);
    }
}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by