src/tetmesh/tetmesh.h

Go to the documentation of this file.

/***************************************************************************
                          tetmesh.h  -  description
                             -------------------
    begin                : Mon Dec 15 2003
    copyright            : (C) 2003 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TETMESH_H
#define TETMESH_H

#include <limits>
#include <map>
#include <string>
#include <utility>
#include <vector>
#include <iostream>
#include "utility/triple.h"
#include "point.h"
#include "edge.h"
#include "face.h"
#include "tet.h"
#include <fstream>
#include "looseoctree.h"

#include "materials.h"

namespace mesh {

class TetMesh {
public: /* public types */
    typedef std::vector<Tet>::iterator tet_iterator;
    typedef std::vector<Face>::iterator face_iterator;
    typedef std::vector<Edge>::iterator edge_iterator;
    typedef std::vector<Point>::iterator point_iterator;
    class surface_iterator {
        friend class TetMesh;
    public:
        surface_iterator()
        { }
        Face* operator*() const
        { return &*cur_; }
        surface_iterator& operator++ () {
            ++ cur_;
            search();
            return *this;
        }
        bool operator== (const surface_iterator& rhs) const
        { return cur_ == rhs.cur_; }
        bool operator!= (const surface_iterator& rhs) const
        { return cur_ != rhs.cur_; }
    protected:
        surface_iterator(const face_iterator& current, const face_iterator& end)
            : cur_(current), end_(end) { }
        void search()
        { while (cur_ != end_ && !((*cur_).on_boundary())) ++ cur_; }
    private:
        face_iterator cur_;
        face_iterator end_;
    };

public: /* public methods */

    TetMesh();

    virtual ~TetMesh();

private:
    TetMesh(const TetMesh&);

    TetMesh& operator=(const TetMesh&);

public:
    virtual void initPoint(int nofPoint);

    virtual void insertPoint(int id, double x, double y, double z);
  
    virtual void initTet(int nofTet);

    virtual void insertTet(id_t global_id, id_t id0, id_t id1, id_t id2, id_t id3, id_t material);

    void setBoundaryOnFace(id_t face);
  
    void setSymmetryPlaneOnFace(id_t face, int symId);

    void generateEdges();

    void generateFaces();

    void load_materials(const char* fileName);

    Materials* get_materials() const;
    
    Tet* get_tet(id_t id) const;
    
    Face* get_face(id_t id) const;
    
    Edge* get_edge(id_t id) const;
    
    Point* get_point(id_t id) const;
    
    const id_t& get_nof_tets() const
    { return _nofTet; }
 
    const id_t& get_nof_faces() const
    { return _nofFace; }

    const id_t& get_nof_edges() const
    { return _nofEdge; }
    const id_t& get_nof_points() const
    { return _nofPoint; }
    LooseOctree<Tet>* get_octree() const
    { return _octree; }
    void get_bounding_box(Vector3& center, Vector3& extent) const;

    id_t insertEdge(id_t node0, id_t node1);

    id_t insertFace(id_t tet, id_t node0, id_t node1, id_t node2);

    virtual id_t lookupEdge(id_t node0, id_t node1);

    virtual id_t lookupFace(id_t node0, id_t node1, id_t node2);
    virtual void finalize_mesh(int nofSym);
    void log_mesh_info();
    void construct_octree();

    bool is_inside(const Vector3& p) const {
        std::vector<Tet *> tets;
        find_tets_by_point(p, tets);
        return tets.size() > 0;
    }

    void find_tets_by_point(const Vector3& p, std::vector<Tet *>& tets) const;

    template <typename CurveType>
    double find_boundary(const CurveType& curve, double x_in, double x_out) const {
        const double eps = std::numeric_limits<double>::epsilon();

        Vector3 a(curve(x_in));
        assert(is_inside(a));

        Vector3 b(curve(x_out));
        assert(!is_inside(b));

        // Bisection until interval as small as machine precision
        while (fabs(x_in - x_out) > eps * fabs(x_in)) {
            double x_mid = 0.5 * (x_in + x_out);
            if (is_inside(curve(x_mid)))
                x_in = x_mid;
            else
                x_out = x_mid;
        }

        // Return point which at the boundary but inside the mesh.
        return x_in;
    }

    tet_iterator tet_begin()
    { return _tets.begin(); }

    tet_iterator tet_end()
    { return _tets.end(); }

    face_iterator face_begin()
    { return _faces.begin(); }

    face_iterator face_end()
    { return _faces.end(); }

    edge_iterator edge_begin()
    { return _edges.begin(); }

    edge_iterator edge_end()
    { return _edges.end(); }

    point_iterator point_begin()
    { return _points.begin(); }

    point_iterator point_end()
    { return _points.end(); }

    surface_iterator surface_begin() {
        surface_iterator it(face_begin(), face_end());
        it.search();
        return it;
    }

    surface_iterator surface_end() {
        return surface_iterator(face_end(), face_end());
    }

     static TetMesh* get_instance() {
        return instance_;
     }
protected:
    void dump_face_map(std::ostream& os);
    
private: // Private types    
    typedef std::pair<id_t, id_t> EdgeMapKey;
    typedef utility::triple<id_t, id_t, id_t> FaceMapKey;
    typedef std::map<EdgeMapKey,id_t> EdgeMap;
    typedef std::map<FaceMapKey,id_t> FaceMap;

private: // Private members
    id_t _nofTet;
    id_t _nofPoint;
    id_t _nofEdge;
    id_t _nofFace;

    Materials* _materials;

    int _nofSym;
    id_t _tetCounter;
    std::vector<Tet> _tets;
    std::vector<Face> _faces;
    std::vector<Edge> _edges;
    std::vector<Point> _points;
    EdgeMap _edgeMap;
    FaceMap _faceMap;
    LooseOctree<Tet>* _octree;
    static TetMesh* instance_;
};

} // namespace mesh 

#endif

---