meshconstructor.h

Go to the documentation of this file.

#ifndef MESHCONSTRUCTOR_H
#define MESHCONSTRUCTOR_H

#include "util.h"
#include "cell.h"

/* Predeclaration of Classes */
class Simulation;
class BezierMesh;
class BoundaryMesh;
class ConformalMesher;

class MeshConstructor {
    private:
        BezierMesh *bezier;
        BoundaryMesh *bdry;
        ConformalMesher *mesher;

        /* This fucntion calculates deboor points and knot values
         * given a set of points on the geometry and an initial deboor
         */
        BoundaryEdge* create_edge(BoundaryVertex *v0,
                                  BoundaryVertex *v1,
                                  const std::vector<Point2D> &geometry_pts,
                                  const Point2D &initial);


        double spiral_derivative(Radians phi, double r0, Radians delta, Radians start);
    public:
        MeshConstructor(BezierMesh* _bezier_mesh, BoundaryMesh* _bdry_mesh);
        ~MeshConstructor();

        void add_remove_point(const Point2D &p);
        int mesh(bool refine); /* angle set on boundary facets */
        void remove_small_angles();

        BoundaryVertex* add_vertex();
        BoundaryVertex* add_vertex(const Point2D &p);

        BoundaryFace*
        add_face(const std::vector<BoundaryEdge*> &edges, const Point2D &point);

        /* uses v0->cp and v1->cp as endpoints */
        BoundaryEdge*
        add_line(BoundaryVertex* v0,
                 BoundaryVertex* v1,
                 int segments);

        /* uses v0->cp as first endpoint and p1 as second, moves v1 to p1 */
        BoundaryEdge*
        add_line(BoundaryVertex* v0,
                 BoundaryVertex* v1,
                 const Point2D &p1,
                 int segments);

        /* uses p0 and p1 as endpoints moves v0 to p0 and v1 to p1 */
        BoundaryEdge*
        add_line(BoundaryVertex* v0,
                 BoundaryVertex* v1,
                 const Point2D &p0,
                 const Point2D &p1,
                 int segments);

        /* Repositions v0 to be start radians around circle*/
        BoundaryEdge*
        add_circle(BoundaryVertex *v0,
                   const Point2D &center,
                   double radius,
                   Radians start,
                   int segments);

        /* Repositions both v0 and v1 to be start and stop radians
           around circle respectivly */
        BoundaryEdge*
        add_arc(BoundaryVertex *v0,
                BoundaryVertex *v1,
                const Point2D &center,
                double radius,
                Radians start,
                Radians stop,
                int segments);

        /* Repositions both v0 and v1 */
        BoundaryEdge*
        add_spiral( BoundaryVertex *v0,
                    BoundaryVertex *v1,
                    const Point2D &center,
                    double divergence,
                    double start_radius,
                    Radians start,
                    Radians stop,
                    int segments);

        /* Repositions both v0 and v1 */
        BoundaryEdge*
        add_bezier(BoundaryVertex *v0,
                   BoundaryVertex *v1,
                   const Point2D &p0,
                   const Point2D &p1,
                   const Point2D &p2 );

        /*
        BoundaryEdge*
        add_elipse(BoundaryVertex *v0,
                   const Point2D &center,
                   const Point2D &axis1,
                   const Point2D &axis2,
                   int segments);
        */

    void
        add_box_void(const Point2D &p0,
                const Point2D &p1,
                const Point2D &p2,
                const Point2D &p3,
                int segments);
 protected:

        std::vector<BoundaryEdge*>
        add_box(const Point2D &p0,
                const Point2D &p1,
                const Point2D &p2,
                const Point2D &p3,
                int segments);


        void
        add_red_blood_cells_box(int num,
                                const Point2D &box_top,
                                const Point2D &box_bot,
                                int cell_type,
                                double cell_size,
                                std::vector<BoundaryVertex*> &verts,
                                std::vector<BoundaryEdge*> &cells,
                                std::vector<Point2D> &centers);
        void
        add_red_blood_cells_triangle(int num,
                                     const Point2D &p1,
                                     const Point2D &p2,
                                     const Point2D &p3,
                                     int cell_type,
                                     double cell_size,
                                     std::vector<BoundaryVertex*> &verts,
                                     std::vector<BoundaryEdge*> &cells,
                                     std::vector<Point2D> &centers);
        void
        insert_cells(int num,
                     std::vector<Point2D> initial_cells,
                     int cell_type,
                     double cell_size,
                     std::vector<BoundaryVertex*> &verts,
                     std::vector<BoundaryEdge*> &cells,
                     std::vector<Point2D> &centers);

};

#endif /* MESHCONSTRUCTOR_H */

---