meshio.h

Go to the documentation of this file.

#ifndef MESHIO_H
#define MESHIO_H

#include <vector>

#include "globals.h"
#include "hash_classes.h"
#include "hash_map.h"
#include "util.h"
#include "cell.h"

/* Foreward declaration to avoid including headers */
class Simulation;
class BoundaryMesh;
class BezierMesh;

class MeshInput {
private:
    FILE *node_file;
    FILE *ele_file;
    FILE *edge_file;
    FILE *bdry_file;

    /* This struct is used to hold the node_file information untill it can be added to
     * the mesh. It takes as input a line from the node file.
     */
    struct Node {
        int num;
        bool added;
        Point2D p;
        LinearData d;
        Node( char *node_file_line ); // destroys the line
        void print();
    };

    /* These maps match id numbers to cells that have already been created, thus when we create
     * a new cell we add it to the appropriate map, so we can look it up later when inserting
     * cells of higher order
     */
    hashers::hash_map<unsigned, BoundaryVertex*> bdry_verts;
    hashers::hash_map<unsigned, BoundaryEdge*> bdry_edges;
    hashers::hash_map<unsigned, BoundaryFace*> bdry_faces;
    hashers::hash_map<unsigned, BezierVertex*> bez_verts;
    hashers::hash_map<unsigned, BezierEdge*> bez_edges;

    struct BoundaryVertexData {
        unsigned idx;
        unsigned node;
    };

    struct BoundaryEdgeData {
        unsigned idx;
        unsigned v0, v1;
        bool closed;
        double restlength;
        int fixed;
        int color;
        std::vector<Point2D> d;
        std::vector<double> k;
    };

    struct BoundaryFaceData {
        unsigned idx;
        double min_angle;
        int color;
        std::vector<BoundaryEdge*> edges;
    };

    struct BezierEdgeData {
        unsigned idx;
        unsigned v0, v1, v2;
        bool is_bdry;
        int bdry;
        double u0, u1;
    };

    struct BezierTriangleData {
        unsigned idx;
        bool inverted;
        unsigned bdry_face;
        unsigned e0, e1, e2;
    };

    int read_boundary_vertex_data( BoundaryVertexData *data );
    int read_boundary_edge_data( BoundaryEdgeData *data );
    int read_boundary_face_data( BoundaryFaceData *data );
    int read_bezier_edge_data( BezierEdgeData *data );
    int read_bezier_triangle_data( BezierTriangleData *data );

    BezierMesh *bezier_mesh;
    BoundaryMesh *bdry_mesh;

public:
    MeshInput(BezierMesh* _bezier_mesh, BoundaryMesh* _bdry_mesh) :
        bezier_mesh(_bezier_mesh), bdry_mesh(_bdry_mesh) {}

    bool read(const char *filename);
};

class MeshOutput{
private:
    FILE *node_file;
    FILE *ele_file;
    FILE *edge_file;
    FILE *bdry_file;

    /* These hashes are used to build up a mapping from CPs or Cells to unique integers*/
    hashers::hash_map<ControlPoint, unsigned, ControlPointHasher> node_hash;
    hashers::hash_map<BezierEdge*, unsigned> bez_edge_hash;
    hashers::hash_map<BoundaryVertex*, unsigned> bdry_vert_hash;
    hashers::hash_map<BoundaryEdge*, unsigned> bdry_edge_hash;
    hashers::hash_map<BoundaryFace*, unsigned> bdry_face_hash;

    /* These are helper functions to write out Cell information to
     * the file format specified by the ruby version
     */
    int node_to_file( ControlPoint cp, DataPoint dp );
    int edge_to_file( BezierEdge *edge );
    int ele_to_file( BezierTriangle *tri, BezierMesh *bezier_mesh );
    int bdry_vert_to_file( BoundaryVertex *vert );
    int bdry_edge_to_file( BoundaryEdge *edge );
    int bdry_face_to_file( BoundaryFace *face );

    BezierMesh *bezier_mesh;
    BoundaryMesh *bdry_mesh;
public:
    MeshOutput(BezierMesh* _bezier_mesh, BoundaryMesh* _bdry_mesh) :
        bezier_mesh(_bezier_mesh), bdry_mesh(_bdry_mesh) {}

    bool write(const char *filename);
};


class MeshBinaryInput
{
    public:
        MeshBinaryInput(Simulation* _sim);
        bool read(const char *filename); //filename must end in extension ".geo"

    private:
        Simulation *sim;
        BezierMesh *bezier_mesh;
        BoundaryMesh *bdry_mesh;
};


class MeshBinaryOutput
{
    public:
        MeshBinaryOutput(Simulation* _sim);
        MeshBinaryOutput(BezierMesh *_bezier_mesh, BoundaryMesh *_bdry_mesh);
        bool write(const char *filename); //filename must end in extension ".geo"

        static bool write(const char *filename, BezierMesh *bez, 
                          BoundaryMesh *bdry);
        static bool write(const char *filename, Simulation *sim);


    private:
        Simulation *sim;
        BezierMesh *bezier_mesh;
        BoundaryMesh *bdry_mesh;

};

#endif /* MESHIO_H */

---