maMesh.h

Go to the documentation of this file.

/****************************************************************************** 

  Copyright 2013 Scientific Computation Research Center, 
      Rensselaer Polytechnic Institute. All rights reserved.
  
  The LICENSE file included with this distribution describes the terms
  of the SCOREC Non-Commercial License this program is distributed under.
 
*******************************************************************************/
#ifndef MA_MESH_H
#define MA_MESH_H

#include <apfMesh2.h>
#include <apfMatrix.h>
#include <set>

namespace ma {

typedef apf::Vector3 Vector;
typedef apf::Matrix3x3 Matrix;
typedef apf::Mesh2 Mesh;
typedef apf::MeshEntity Entity;
typedef apf::MeshIterator Iterator;
typedef apf::MeshTag Tag;
typedef apf::DynamicArray<Entity*> EntityArray;
typedef std::set<Entity*> EntitySet;
typedef EntityArray Upward;
typedef apf::Downward Downward;
typedef apf::ModelEntity Model;

Vector getPosition(Mesh* m, Entity* vertex);

typedef apf::Copies Remotes;
typedef apf::Parts Parts;

void rotateTri(Entity** iv, int n, Entity** ov);
void rotateQuad(Entity** iv, int n, Entity** ov);
void rotateTet(Entity** iv, int n, Entity** ov);
void rotatePrism(Entity** iv, int n, Entity** ov);
void rotatePyramid(Entity** iv, int n, Entity** ov);
void rotateEntity(int type, Entity** iv, int n, Entity** ov);
void rotateEntity(apf::Mesh* m, Entity* e, int n, Entity** v);

int findTetRotation(Mesh* m, Entity* tet, Entity** v);
void unrotateTetXi(Vector& xi, int rotation);

void rotateOct(Entity** iv, int n, Entity** ov);

int getDownIndex(Mesh* m, Entity* e, Entity* de);
Entity* getTriEdgeOppositeVert(Mesh* m, Entity* tri, Entity* v);
Entity* getTriVertOppositeEdge(Mesh* m, Entity* tri, Entity* v);
Entity* getTetVertOppositeTri(Mesh* m, Entity* tet, Entity* tri);
Entity* getQuadEdgeOppositeEdge(Mesh* m, Entity* q, Entity* e);

Entity* findTetByTwoTris(Mesh* m, Entity** tris);

void getVertPoints(apf::Mesh* m, Entity* e, Vector* p);

struct RebuildCallback {
  virtual void rebuilt(Entity* e, Entity* original) = 0;
};

Entity* rebuildElement(
    Mesh* m,
    Entity* original,
    Entity* oldVert,
    Entity* newVert,
    apf::BuildCallback* cb,
    RebuildCallback* rcb = 0);

bool isInClosure(Mesh* m, Entity* parent, Entity* e);

void getBoundingBox(Mesh* m, Vector& lower, Vector& upper);
Vector getCentroid(Mesh* m);

void ensureParallelConsistency(Mesh* m);

Entity* findTriFromVerts(Mesh* m, Entity** v);

bool isOnModelEdge(Mesh* m, Entity* e);
bool isOnModelFace(Mesh* m, Entity* e);

Vector getTriNormal(Mesh* m, Entity** v);
Vector getTriNormal(Mesh* m, Entity* e);
bool isTwoTriAngleAcute(Mesh* m, Entity** va, Entity** vb);
bool isTwoTriAngleAcute(Mesh* m, Entity* a, Entity* b);

double getInsphere(Mesh* m, Entity* e);

double getAverageElementSize(Mesh* m);
double getMinimumElementSize(Mesh* m);

void getFaceEdgesAndDirections(
    Mesh* m,
    Entity* face,
    Entity** edges,
    int* directions);

Entity* findEdge(Mesh* m, Entity* v0, Entity* v1);
bool edgeExists(Mesh* m, Entity* v0, Entity* v1);

/* returns true iff the direction of the edge is along
   the direction of the triangle's vertex (and edge) ordering */
bool isTriEdgeAligned(Mesh* m, Entity* tri, Entity* edge);

}

#endif