src/tetmesh/tet.h

Go to the documentation of this file.

#ifndef TET_H
#define TET_H

#include "matrix.h"
#include "linalg.h"
#include "vector3.h"
#include "vector4.h"
#include "entity.h"
#include "tetmesh.h"

namespace mesh {

class Point;
class Edge;
class Face;
class TetMesh;

class Tet : public Entity {
public:
  Tet(const TetMesh& mesh, id_t id, id_t corners[4], id_t material);
    ~Tet()
    {}
    id_t get_material_ID() const;
    double get_volume() const;
 
        Vector3 get_center_of_gravity() const;
    
    id_t get_face_id(int i) const
    { return _faces[i]; }
    void set_face_id(int i, id_t id);
    id_t get_edge_id(int i) const
    { return _edges[i]; }
    void set_edge_id(int i, id_t id);
    id_t get_corner_id(int i) const
    { return _corners[i]; }
    Face* get_face(int i) const;
    Edge* get_edge(int i) const;
    Point* get_corner(int i) const;
    bool get_edge_orientation(int edge_lid) const
    { return (_edge_orientation & (1 << edge_lid)) != 0; }
    void set_edge_orientation(int edge_lid, bool orientation);
    void cartesian_to_simplex(const Vector3& cartesian, Vector4& simplex) const;
    bool is_inside(const Vector3& point) const;
    bool is_inside_gracious(const Vector3& point) const;
    
    //
    // local numbering routines
    //
    static void get_face_point_lids(int face_lid, int& node1_lid, int& node2_lid, int& node3_lid) {
        node1_lid = face_lid % 4;
        node2_lid = (1+face_lid) % 4;
        node3_lid = (2+face_lid) % 4;
    }
    
    static void get_face_edge_lids(int face_lid, int& edge1_lid, int& edge2_lid, int& edge3_lid) {
                switch (face_lid) {
                        case 0:
                        edge1_lid = 0;
                        edge2_lid = 1;
                    edge3_lid = 3;
                    break;
                        case 1:
                        edge1_lid = 3;
                        edge2_lid = 4;
                    edge3_lid = 5;
                    break;
                        case 2:
                        edge1_lid = 1;
                        edge2_lid = 2;
                    edge3_lid = 5;
                    break;
                        case 3:
                        edge1_lid = 0;
                        edge2_lid = 2;
                    edge3_lid = 4;
                    break;
                }
    }

    class CoordinateMatrix : public colarray::Matrix<double> {
    public:
        CoordinateMatrix(const Tet& tet);
    };

    class GradientMatrix : public colarray::Matrix<double> {
    public:
        GradientMatrix(const CoordinateMatrix& X);
        GradientMatrix(const Tet& tet);
    };
    bool is_inside_bounding_box(const Vector3& point) const {
        Vector3 node_center, node_extent;
        get_bounding_box(node_center, node_extent);
        node_center -= point;
        node_center.x = fabs(node_center.x);
        node_center.y = fabs(node_center.y);
        node_center.z = fabs(node_center.z);
        return node_center <= node_extent;
    }
    bool is_inside_bounding_box_gracious(const Vector3& point) const {
        const double grace_tolerance = 1e-13;
        Vector3 node_center, node_extent;

        get_bounding_box(node_center, node_extent);
        node_center -= point;
        node_center.x = fabs(node_center.x);
        node_center.y = fabs(node_center.y);
        node_center.z = fabs(node_center.z);
        return node_center <= node_extent * (1.0 + grace_tolerance);
    }

public: // Implementation of the OctreeNode interface
    void get_bounding_box(Vector3& center, Vector3& extent) const;
public:
    TetMesh* get_mesh() const;
private: // private variables
    id_t _corners[4];
    id_t _edges[6];
    id_t _faces[4];
    id_t _material;
    unsigned char _edge_orientation;
};

}

#endif

---