---

Mesh.h

Go to the documentation of this file.

#ifndef MESH_H
#define MESH_H

#include "SundanceDefs.h"

#include "TSFSmartPtr.h"
#include "TSFArray.h"
#include "Cell.h"
#include "MeshData.h"



namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  class Point;
  class MeshTransformation;
  class CellFactory;
  class MeshWriter;
  class LogicalExpr;

  typedef bool (*CellConditional)(const Cell& cell);

  /** \ingroup UserLevelGeometry
   * Mesh represents an unstructured mesh.
   */

  class Mesh
    {
    public:
      /** \name Constructors */
      //@{
      /** Null constructor */
      Mesh();
      /** Start an empty mesh of a specified spatial dimension */
      Mesh(int spatialDim, const MPIComm& comm = MPIComm::world());
      /** Start an empty mesh of a specified spatial dimension, pretending
       * that it is the rank-th processor of an nproc-processor parallel
       * computer. */
      Mesh(int spatialDim, int rank, int nProc);
      //@}

      /** \name Informational methods */
      //@{
      /** Get dimension of the mesh */
      int spatialDim() const {return data_->spatialDim_;}
      /** Get number of cells of dimension dim */
      int numCells(int dim) const {return data_->cells_[dim].length();}
      /** Get number of point in the mesh */
      int numPoints() const {return data_->points_.length();}
      //@}

      /** \name getting individual cells and points */
      //@{
      /** look up a cell by its local index */
      const Cell& getCell(int dim, int index) const ;
      /** look up a cell by its global index */
      const Cell& getCellByGlobalIndex(int dim, int globalIndex) const ;
      /** */
      const Point& getPointByLocalIndex(int localIndex) const ;
      /** */
      const Point& getPointByGlobalIndex(int globalIndex) const ;
      //@}

      /** \name Cell labeling */
      //@{
      /** Label all cells of dimension=dim that satisfy a condition given
          by a user-defined function */
      void labelCells(int dim, const string& label, CellConditional conditional);

      /** Label all maximal cells on which the given logical expression is true */
      void labelMaximalCells(const string& label, const LogicalExpr& filter);


      /** Label all zero cells on which the given logical expression is true */
      void labelPoints(const string& label, const LogicalExpr& filter);

      /** Return a list of all labels in the mesh */
      const TSFArray<string>& labels() const {return data_->labels_;}
      //@}

      /** find the zero-cell closest to a specified point */
      Cell cellNearestToPoint(const Point& x) const ;



      /** \name Methods for creating a mesh */
      //@{
      /** add a point to the mesh. Give the coordinates of the point,
       * the ID of the processor that owns the point, a list of
       * other processors that include this point, and the global
       * index of the point */
      int addPoint(const Point& x,
                   int ownerProcID=0,
                   int globalIndex=-1);
      /**
       * Create a zero cell and add it to the mesh. Specify the
       * global index of the node associated with the zero cell,
       * the label, and the ID of the processor that owns the point
       */
      Cell createZeroCell(int globalNodeIndex, const string& label,
                          int ownerProcID=0);
      /**
       * Create a maximal cell
       */
      Cell createMaximalCell(const CellFactory& factory,
                             const string& label,
                             int ownerProcID=0,
                             int globalIndex=-1);
      /**
       * Create an intermediate cell and add it to the mesh.
       */
      Cell createIntermediateCell(int parentIndex, int cellDim,
                                  int myFacetID, int pid=0);
      //@}


      /** \name information about parallel environment */
      //@{
      /** return the local processor ID */
      int procID() const {return data_->procID_;}
      /** return the number of processors used to model the mesh */
      int numProcs() const {return data_->numProcs_;}
      /** get the communicator used y the */
      const MPIComm& comm() const {return data_->comm_;}
      //@}

      /** \name Mesh partioning */
      //@{
      /** Scatter a mesh into nProcs pieces, storing the n-th piece in a file
       * called filename.n.
       */
      void scatterMesh(int nProcs,
                       const string& filename,
                       const MeshWriter& writer) const ;
      Mesh getSubmesh(const MPIComm& comm = MPIComm::world()) const ;
      void getSubmesh(Mesh& subMesh, int myPid, int nProc,
                      const TSFArray<short>& assignments) const ;

      void findProcAssignments(int nProc, TSFArray<short>& procAssignments) const ;
      //@}
      /** \name Mesh transformations */

      //@{
      /** replace the mesh points with a new set of points */
      void replacePoints(const TSFArray<Point>& points);

      /** carry out an arbitrary transformation on the mesh */
      void transform(const MeshTransformation& trans);

      /** undo a mesh transformation */
      void undo(const MeshTransformation& trans);

      /** get the entire array of mesh points */
      const TSFArray<Point>& getPoints() const ;
      //@}

      /** \name Developer-only methods */
      //@{
      /** */
      int meshID() const {return data_->meshID_;}

      bool containsPoint(int globalIndex) const ;
      bool containsCell(int dim, int globalIndex) const ;



      void getBoundary(TSFArray<Cell>& bdryCells) const ;
      bool isBoundaryCell(int i) const {return data_->isBoundary_[i];}

      void getLabeledCells(const string& label, TSFArray<Cell>& cells) const ;


      int labelIndex(const string& label) const ;
      const string& label(int i) const ;
      int numLabels() const {return data_->labels_.length();}

      /** */
      int numFacets(int cellIndex, int dim) const ;
      /** */
      int numCofacets(int cellIndex, int dim) const ;
      /** */
      int facetIndex(int cellIndex, int dim, int facetNumber) const ;
      /** */
      int cofacetIndex(int cellIndex, int dim, int cofacetNumber) const ;
      /** */
      const Cell& getZeroCellByNodeIndex(int globalNodeIndex) const ;
      //    {return data_->cells_[0][data_->pointToZeroCellMap_[data_->pointIndexMap_.get(globalNodeIndex)]];}
      /** */
      int pointGlobalIndex(int pointLocalIndex) const
        {return data_->pointGlobalIndex_[pointLocalIndex];}
      /** */
      int pointOwnerProc(int pointLocalIndex) const
        {return data_->pointOwnerProcID_[pointLocalIndex];}
      /** */
      const TSFArray<int>& pointSharerProcIDs(int pointLocalIndex) const
        {return data_->pointSharerProcID_[pointLocalIndex];}
      /** */
      int lookupCellByNodes(int dim, const TSFArray<int>& nodes) const ;

      void printCells() const ;

      string toString() const {return "Mesh";}

      void diagnostics() const ;
      void assignGlobalIndices();

      static void traceCommunications() {traceComm_ = true;}
      static void traceCommunicationsOff() {traceComm_ = false;}

      friend class BoundaryCellSet;
      //@}
    private:
      //@{
      void computeGlobalOffsets(TSFArray<int>& offsets) const ;
      void shareIndexRequests(int d,
                              const TSFArray<TSFArray<int> >& indexRequestList,
                              const TSFArray<TSFArray<int> >& localIndexList,
                              TSFArray<TSFArray<int> >& globalIndices) const ;
      //@}
      TSFSmartPtr<MeshData> data_;

      static bool traceComm_;
    };


}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by