apfMesh.h

Go to the documentation of this file.

/*
 * Copyright 2011 Scientific Computation Research Center
 *
 * This work is open source software, licensed under the terms of the
 * BSD license as described in the LICENSE file in the top-level directory.
 */
 
#ifndef APF_MESH_H
#define APF_MESH_H
 
#include <vector>
#include <map>
#include <set>
#include <PCU.h>
#include "apfVector.h"
#include "apfDynamicArray.h"
 
struct gmi_model;
 
namespace apf {
 
class FieldShape;
class Field;
template <class T>
class NumberingOf;
typedef NumberingOf<int> Numbering;
typedef NumberingOf<long> GlobalNumbering;
 
class MeshEntity;
class MeshIterator;
class MeshTag;
 
class ModelEntity;
 
typedef std::map<int,MeshEntity*> Copies;
typedef std::set<int> Parts;
typedef DynamicArray<MeshEntity*> Adjacent;
typedef MeshEntity* Downward[12];
 
class Migration;
 
struct Up
{
  int n;
  MeshEntity* e[400];
};
 
struct Copy
{
  Copy():peer(0),entity(0) {}
  Copy(int p, MeshEntity* e):peer(p),entity(e) {}
  int peer;
  MeshEntity* entity;
};
typedef Copy Match;
 
typedef DynamicArray<Copy> CopyArray;
typedef CopyArray Matches;
typedef CopyArray DgCopies;
 
class Mesh
{
  public:
    void init(FieldShape* s, pcu::PCU *PCUObj);
    virtual ~Mesh();
    virtual int getDimension() = 0;
    virtual std::size_t count(int dimension) = 0;
    virtual MeshIterator* begin(int dimension) = 0;
    virtual MeshEntity* iterate(MeshIterator* it) = 0;
    virtual void end(MeshIterator* it) = 0;
// seol
    // return true if adjacency *from_dim <--> to_dim*  is stored
    virtual bool hasAdjacency(int from_dim, int to_dim) = 0;
    // store adjacency *from_dim <--> to_dim* if not stored
    virtual void createAdjacency(int from_dim, int to_dim) = 0;
    // remove adjacency *from_dim <--> to_dim* except for one-level apart adjacency
    virtual void deleteAdjacency(int from_dim, int to_dim) = 0;
 
    virtual bool isShared(MeshEntity* e) = 0;
//seol
    virtual bool isGhosted(MeshEntity* e) = 0;
    virtual bool isGhost(MeshEntity* e) = 0;
    virtual bool isOwned(MeshEntity* e) = 0;
    virtual int getOwner(MeshEntity* e) = 0;
    enum Type {
      VERTEX,   //0
      EDGE,     //1
      TRIANGLE, //2
      QUAD,     //3
      TET,      //4
      HEX,      //5
      PRISM,    //6
      PYRAMID,  //7
      TYPES };  //8
    static int const adjacentCount[TYPES][4];
    static int const typeDimension[TYPES];
    static char const* const typeName[TYPES];
    static Type const simplexTypes[4];
    virtual void getAdjacent(MeshEntity* e, int dimension,
        Adjacent& adjacent) = 0;
    virtual int getDownward(MeshEntity* e, int dimension,
        MeshEntity** adjacent) = 0;
    virtual int countUpward(MeshEntity* e) = 0;
    virtual MeshEntity* getUpward(MeshEntity* e, int i) = 0;
    virtual void getUp(MeshEntity* e, Up& up) = 0;
    virtual bool hasUp(MeshEntity* e) = 0;
    void getPoint(MeshEntity* e, int node, Vector3& point);
    virtual void getPoint_(MeshEntity* e, int node, Vector3& point) = 0;
    virtual void getParam(MeshEntity* e, Vector3& p) = 0;
    virtual Type getType(MeshEntity* e) = 0;
    virtual void getRemotes(MeshEntity* e, Copies& remotes) = 0;
// seol
    virtual int getGhosts(MeshEntity* e, Copies& ghosts) = 0;
    virtual void getResidence(MeshEntity* e, Parts& residence) = 0;
    virtual MeshTag* createDoubleTag(const char* name, int size) = 0;
    virtual MeshTag* createIntTag(const char* name, int size) = 0;
    virtual MeshTag* createLongTag(const char* name, int size) = 0;
    virtual MeshTag* findTag(const char* name) = 0;
    virtual void destroyTag(MeshTag* tag) = 0;
    virtual void getTags(DynamicArray<MeshTag*>& tags) = 0;
    virtual void getDoubleTag(MeshEntity* e, MeshTag* tag, double* data) = 0;
    virtual void setDoubleTag(MeshEntity* e, MeshTag* tag, double const* data) = 0;
    virtual void getIntTag(MeshEntity* e, MeshTag* tag, int* data) = 0;
    virtual void setIntTag(MeshEntity* e, MeshTag* tag, int const* data) = 0;
    virtual void getLongTag(MeshEntity* e, MeshTag* tag, long* data) = 0;
    virtual void setLongTag(MeshEntity* e, MeshTag* tag, long const* data) = 0;
    virtual void removeTag(MeshEntity* e, MeshTag* tag) = 0;
    virtual bool hasTag(MeshEntity* e, MeshTag* tag) = 0;
    virtual void renameTag(MeshTag* tag, const char* newName) = 0;
    virtual unsigned getTagChecksum(MeshTag* tag, int type) = 0;
    enum TagType {
      DOUBLE,
      INT,
      LONG };
    virtual int getTagType(MeshTag* t) = 0;
    virtual int getTagSize(MeshTag* t) = 0;
    virtual const char* getTagName(MeshTag* t) = 0;
    virtual ModelEntity* toModel(MeshEntity* e) = 0;
    virtual gmi_model* getModel() = 0;
    virtual void setModel(gmi_model* newModel) = 0;
    int getModelType(ModelEntity* e);
    int getModelTag(ModelEntity* e);
    ModelEntity* findModelEntity(int type, int tag);
    bool canSnap();
    bool canGetClosestPoint();
    bool canGetModelNormal();
    void snapToModel(ModelEntity* m, Vector3 const& p, Vector3& x);
    void getParamOn(ModelEntity* g, MeshEntity* e, Vector3& p);
    bool getPeriodicRange(ModelEntity* g, int axis,
        double range[2]);
    void getClosestPoint(ModelEntity* g, Vector3 const& from,
        Vector3& to, Vector3& p);
    void getNormal(ModelEntity* g, Vector3 const& p, Vector3& n);
      void getFirstDerivative(ModelEntity* g, Vector3 const& p,
          Vector3& t0, Vector3& t1);
    bool isParamPointInsideModel(ModelEntity* g,
      Vector3 const& param, Vector3& x);
    bool isInClosureOf(ModelEntity* g, ModelEntity* target);
    void boundingBox(ModelEntity* g, Vector3& bmin, Vector3& bmax);
    bool isOnModel(ModelEntity* g, Vector3 p, double scale);
    FieldShape* getShape() const;
    Field* getCoordinateField() {return coordinateField;}
    void setCoordinateField(Field* field);
    void changeShape(FieldShape* newShape, bool project = true);
    virtual void migrate(Migration* plan) = 0;
    virtual int getId() = 0;
    virtual void writeNative(const char* fileName) = 0;
    virtual void destroyNative() = 0;
    virtual void verify() = 0;
    virtual bool hasMatching() = 0;
    virtual void getMatches(MeshEntity* e, Matches& m) = 0;
    virtual void getDgCopies(MeshEntity* e, DgCopies& dgCopies, ModelEntity* me = 0) = 0;
    virtual double getElementBytes(int) {return 1.0;}
    void addField(Field* f);
    void removeField(Field* f);
    Field* findField(const char* name);
    int countFields();
    Field* getField(int i);
    void addNumbering(Numbering* f);
    void removeNumbering(Numbering* f);
    Numbering* findNumbering(const char* name);
    int countNumberings();
    Numbering* getNumbering(int i);
    void addGlobalNumbering(GlobalNumbering* f);
    void removeGlobalNumbering(GlobalNumbering* f);    
    int countGlobalNumberings();
    GlobalNumbering* findGlobalNumbering(const char* name);
 
    GlobalNumbering* getGlobalNumbering(int i);
    pcu::PCU* getPCU() const {return pcu_;}
    void switchPCU(pcu::PCU *newPCU);
    bool hasFrozenFields;
  protected:
    Field* coordinateField;
    std::vector<Field*> fields;
    std::vector<Numbering*> numberings;
    std::vector<GlobalNumbering*> globalNumberings;
    pcu::PCU* pcu_;
};
 
void verify(Mesh* m, bool abort_on_error=true);
 
long verifyVolumes(Mesh* m, bool printVolumes = true);
 
int getDimension(Mesh* m, MeshEntity* e);
 
void unite(Parts& into, Parts const& from);
 
void removeTagFromDimension(Mesh* m, MeshTag* tag, int d);
 
MeshEntity* findUpward(Mesh* m, int type, MeshEntity** down);
 
MeshEntity* findElement(
    Mesh* m,
    int type,
    MeshEntity** verts);
 
MeshEntity* getEdgeVertOppositeVert(Mesh* m, MeshEntity* edge, MeshEntity* v);
 
void getBridgeAdjacent(Mesh* m, MeshEntity* origin,
    int bridgeDimension, int targetDimension, Adjacent& result);
 
int countEntitiesOfType(Mesh* m, int type);
 
bool isSimplex(int type);
 
Vector3 getLinearCentroid(Mesh* m, MeshEntity* e);
 
class Migration
{
  public:
    Migration(Mesh* m);
    Migration(Mesh* m, MeshTag* existingTag);
    ~Migration();
    int count();
    MeshEntity* get(int i);
    bool has(MeshEntity* e);
    void send(MeshEntity* e, int to);
    int sending(MeshEntity* e);
    Mesh* getMesh() {return mesh;}
  private:
    Mesh* mesh;
    MeshTag* tag;
    std::vector<MeshEntity*> elements;
};
 
struct Sharing
{
  virtual ~Sharing() {}
  virtual bool isOwned(MeshEntity* e) = 0;
  virtual int getOwner(MeshEntity* e) = 0;
  virtual void getCopies(MeshEntity* e,
      CopyArray& copies) = 0;
  virtual bool isShared(MeshEntity* e) = 0;
};
 
struct NormalSharing : public Sharing
{
  NormalSharing(Mesh* m);
  virtual int getOwner(MeshEntity* e);
  virtual bool isOwned(MeshEntity* e);
  virtual void getCopies(MeshEntity* e,
      CopyArray& copies);
  virtual bool isShared(MeshEntity* e);
private:
  Mesh* mesh;
};
 
struct MatchedSharing : public Sharing
{
  MatchedSharing(Mesh* m);
  Copy getOwnerCopy(MeshEntity* e);
  virtual int getOwner(MeshEntity* e);
  virtual bool isOwned(MeshEntity* e);
  virtual void getCopies(MeshEntity* e,
      CopyArray& copies);
  virtual bool isShared(MeshEntity* e);
  Mesh* mesh;
private:
  size_t getNeighborCount(int peer);
  bool isLess(Copy const& a, Copy const& b);
  void getNeighbors(Parts& neighbors);
  void formCountMap();
  NormalSharing helper;
  std::map<int, size_t> countMap;
};
 
Sharing* getSharing(Mesh* m);
 
extern int const tri_edge_verts[3][2];
extern int const quad_edge_verts[4][2];
extern int const tet_edge_verts[6][2];
extern int const prism_edge_verts[9][2];
extern int const pyramid_edge_verts[8][2];
extern int const tet_tri_verts[4][3];
extern int const hex_quad_verts[6][4];
extern int const prism_tri_verts[2][3];
extern int const prism_quad_verts[3][4];
extern int const pyramid_tri_verts[4][3];
 
void getPeers(Mesh* m, int d, Parts& peers);
 
int findIn(MeshEntity** a, int n, MeshEntity* e);
 
void findTriDown(
    Mesh* m,
    MeshEntity** verts,
    MeshEntity** down);
 
void changeMeshShape(Mesh* m, FieldShape* newShape, bool project = true);
 
void unfreezeFields(Mesh* m);
 
void freezeFields(Mesh* m);
 
int countEntitiesOn(Mesh* m, ModelEntity* me, int dim);
 
int countOwned(Mesh* m, int dim, Sharing * shr = NULL);
 
void printStats(Mesh* m);
 
void warnAboutEmptyParts(Mesh* m);
 
Copy getOtherCopy(Mesh* m, MeshEntity* s);
 
class ElementVertOp
{
  public:
    virtual MeshEntity* apply(int type, MeshEntity** down) = 0;
    MeshEntity* run(int type, MeshEntity** verts);
    void runDown(int type, MeshEntity** verts, MeshEntity** down);
};
 
int getFirstType(Mesh* m, int dim);
 
void getAlignment(Mesh* m, MeshEntity* elem, MeshEntity* boundary,
    int& which, bool& flip, int& rotate);
 
void packString(std::string s, int to, pcu::PCU *PCUObj);
std::string unpackString(pcu::PCU *PCUObj);
void packTagInfo(Mesh* m, MeshTag* t, int to);
void unpackTagInfo(std::string& name, int& type, int& size, pcu::PCU *PCUObj);
 
extern char const* const dimName[4];
 
MeshTag* tagOpposites(GlobalNumbering* gn, const char* name);
 
} //namespace apf
 
#endif