---

Cell.h

Go to the documentation of this file.

#ifndef CELL_H
#define CELL_H

#include "SundanceDefs.h"

#include "TSFArray.h"
#include "TSFSmartPtr.h"
#include "CellBase.h"
#include "FacetSetBase.h"


namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  class CellBase;

  class Mesh;
  class CellMap;
  class MeshData;

  /** \ingroup UserLevelGeometry
      Class Cell represents a cell in an unstructured mesh.



  */


  class Cell
    {
    public:
      /** empty ctor */
      Cell() : ptr_(0) {;}
      /** construct, assuming control of a ptr to a CellBase subtype */
      Cell(CellBase* ptr) : ptr_(ptr) {;}

      /** identify self as a zero-cell */
      bool isZeroCell() const {return ptr_->isZeroCell();}
      /** identify self as a maximal cell */
      bool isMaximalCell() const {return ptr_->isMaximalCell();}
      /** identify self as an affine cell */
      bool isAffine() const {return ptr_->isAffine();}

      /** return the rank of the processor that owns this cell */
      int ownerProcID() const {return ptr_->ownerProcID();}
      /** return the local index that the current processor uses to identify
       * this cell */
      int localIndex() const {return ptr_->localIndex();}
      /** return the global index of this cell */
      int globalIndex() const {return ptr_->globalIndex();}
      /** set the global index of this cell */
      void setGlobalIndex(int globalIndex) {ptr_->setGlobalIndex(globalIndex);}
      /** Inform a cell that it has a parent */
      void addParent(int parentIndex, int myFacetIndex)
        {ptr_->addParent(parentIndex, myFacetIndex);}

      /** return the spatial dimension of this cell */
      int dim() const {return ptr_->dim();}
      /** return the spatial dimension of the mesh in which this cell lives */
      int meshDim() const ;
      /** return an ID code for the mesh in which this cell lives */
      int meshID() const ;


      // topological methods
      /** return the number of nodes defining this cell */
      int numNodes() const {return ptr_->numNodes();}
      /** return the number of vertices */
      int numVertices() const {return ptr_->numVertices();}
      /** return the number of facets of a given dimension */
      int numFacets(int dim) const {return ptr_->numFacets(dim);}
      /** return the number of cofacets of a given dimension */
      int numCofacets(int dim) const {return ptr_->numCofacets(dim);}
      /** get a list of the cell's node numbers */
      void getNodes(TSFArray<int>& nodes) const {ptr_->getNodes(nodes);}
      /** get a list of the cell's facet indices */
      void getFacetIndices(TSFArray<TSFArray<int> >& facetIndices) const
        {ptr_->getFacetIndices(facetIndices);}
      /** determine if this cell is topologically equivalent to the
       * given list of nodes */
      bool topologicallyEquals(const TSFArray<int>& nodes) const
        {return ptr_->topologicallyEquals(nodes);}
      /** return the (facetNumber)-th facet cell of dimension (facetDim). */
      const Cell& facet(int facetDim, int facetNumber) const
        {return ptr_->facet(facetDim, facetNumber);}
      /** return the (cofacetNumber)-th cofacet cell of dimension (cofacetDim). */
      const Cell& cofacet(int cofacetDim, int cofacetNumber) const
        {return ptr_->cofacet(cofacetDim, cofacetNumber);}

      /** */
      int numParents() const {return ptr_->numParents();}
      /** return the index of the i-th maximal cell that owns this cell */
      int parentIndex(int i) const {return ptr_->parentIndex(i);}
      /** return the facet index by which the parent refers to this cell */
      int myFacetIndex(int i) const {return ptr_->myFacetIndex(i);}
      /** return the i-th maximal parent cell */
      const Cell& maximalParent(int i) const ;
      /** return the list of the cell's node numbers (MaximalCells only) */
      const TSFArray<int>& nodes() const {return ptr_->nodes();}
      /** return the node number of this cell (ZeroCells only) */
      int node() const {return ptr_->node();}
      //  const TSFArray<TSFArray<int> >& facets() const {return ptr_->facets();}
      const FacetSetBase* facets() const {return ptr_->facets();}
      /** return list of indices of cofacets */
      const TSFArray<TSFArray<int> >& cofacetIndices() const
        {return ptr_->cofacetIndices();}
      /** identify self as boundary cell or not */
      bool isBoundaryCell() const {return ptr_->isBoundaryCell();}

      /** return cell's label */
      const string& label() const {return ptr_->label();}
      /** return my label's index in the label list */
      int labelIndex() const {return ptr_->labelIndex();}
      /** set my label */
      void setLabel(const string& newLabel) {ptr_->setLabel(newLabel);}

      /** type id */
      const string& typeName() const {return ptr_->typeName();}
      /** topology code */
      CellTopologyCode topologyCode() const {return ptr_->topologyCode();}

      /** return the reference cell used to compute geometric quantities
       * for this cell */
      const ReferenceCell& refCell() const {return ptr_->refCell();}


      /** return the point coordinates of the i-th node */
      const Point& point(int i) const {return ptr_->point(i);}

      /** */
      Point position() const ;

      /** compute the diameter of this cell */
      double diameter() const ;

      /** compute the outward normal of this cell */
      Point normal() const ;

      /** get jacobian at an array of points */
      void jacobian(const TSFArray<Point>& refpts,
                    TSFArray<CellJacobian>& J) const ;

      /** get determinant of the Jacobian at an array of points */
      void detJacobian(const TSFArray<Point>& refpts,
                       TSFArray<double>& detJ) const ;


      /** get jacobian (specialized to affine cells) */
      void constantJacobian(CellJacobian& J) const ;

      /** get determinant of jacobian (specialized to affine cells) */
      void constantDetJacobian(double& detJ) const ;

      /** do pullback map (physical  to reference coordinates)  */
      void pullBack(const TSFArray<Point>& phys,
                    TSFArray<Point>& ref) const ;
      /** do push-forward map (reference to physical coordinates) */
      void pushFwd(const TSFArray<Point>& ref,
                   TSFArray<Point>& phys) const ;

      /** do push-forward map (reference to physical coordinates) */
      void pushFwd(int numPts, const double* ref, double* phys) const ;

      /** do pullback map (physical to reference coordinates) */
      void pullBack(int numPts, const double* phys, double* ref) const ;

      /** register a new facet with this cell */
      void registerFacet(int dim, int facetNum, int facetCellIndex)
        {ptr_->registerFacet(dim, facetNum, facetCellIndex);}
      /** register a new cofacet with this cell */
      void registerCofacet(int dim, int cofacetCellIndex)
        {ptr_->registerCofacet(dim, cofacetCellIndex);}

      /** print to stream */
      ostream& print(ostream& os) const {return ptr_->print(os);}
      /** write in a standard text form */
      void textWrite(ostream& os) const {ptr_->textWrite(os);}
      /** write to a string */
      string toString() const {return ptr_->toString();}

      /** return number of bytes required by this cell */
      int byteCount() const {return ptr_->byteCount();}
      TSFArray<int> wastage() const {return ptr_->wastage();}

    private:
      TSFSmartPtr<CellBase> ptr_;
    };

  inline ostream& operator<<(ostream& os, const Cell& cell)
    {
      return cell.print(os);
    }



}

namespace TSF
{
  using namespace std;

  inline string toString(const Sundance::Cell& cell) {return cell.toString();}
}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by