geometry/mesh.hh

Go to the documentation of this file.

/* Meshes
 * Combining cells to a mesh to represent a computational domain
 */

#ifndef mesh_hh
#define mesh_hh

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include "basics/outputOperator.hh"
#include "basics/exceptions.hh"
#include "toolbox/scannerConnectors.hh"
#include "toolbox/sequence.hh"
#include "cell.hh"
#include "cell1D.hh"
#include "cell3D.hh"

namespace concepts {

  // forward declaration
  class Vertex;
  class Edge;
  class Triangle;
  class Tetrahedron;
  template<class T>
  class DynArray;

  // ***************************************************************** ScanX **

  template <>
  class Scan<Cell1> : public Scan<Cell> {
  public:
    Cell1& operator++(int) = 0;
  };

  template <>
  class Scan<Cell2> : public Scan<Cell> {
  public:
    Cell2& operator++(int) = 0;
  };

  template <>
  class Scan<Cell3> : public Scan<Cell> {
  public:
    Cell3& operator++(int) = 0;
  };

  typedef Scan<Cell1> Scan1;

  typedef Scan<Cell2> Scan2;

  typedef Scan<Cell3> Scan3;

  // ****************************************************************** Mesh **

  class Mesh : public OutputOperator {
  public:
    virtual uint ncell() const = 0;

    virtual Scan<Cell>* scan() = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };

  // ***************************************************************** Mesh1 **

  class Mesh1 : public Mesh {
  public:
    virtual Scan1* scan() = 0;
  };

  // ***************************************************************** Mesh2 **

  class Mesh2 : public Mesh {
  public:
    virtual Scan2* scan() = 0;
  };

  // ***************************************************************** Mesh3 **

  class Mesh3 : public Mesh {
  public:
    virtual Scan3* scan() = 0;
  };

  // **************************************************** InnerOuterBoundary2d **
  
  class InnerOuterBoundary2d {
  public:
    virtual ~InnerOuterBoundary2d();

    inline const Sequence<Edge2d*>& outerBoundary() const {
      return outerBoundary_;
    }
    inline const Sequence<Sequence<Edge2d*> >& innerBoundary() const {
      return innerBoundary_;
    }

    void addInnerBoundary(const Sequence<Edge2d*>& innerBoundary);
  protected:
    Sequence<Edge2d*>            outerBoundary_;
    Sequence<Sequence<Edge2d*> > innerBoundary_;
  };

  // ******************************************************* Mesh2withBoundary **

  class Mesh2withBoundary : public Mesh2, public InnerOuterBoundary2d {
  public:
    virtual ~Mesh2withBoundary();
  };

  // ******************************************************* Import3DTetMesh **

  class Import3DTetMesh : public Mesh3 {
  public:
    Import3DTetMesh(const std::string coord, const std::string elms,
        const std::string dirichlet, const bool leftHand = false);
    virtual ~Import3DTetMesh();
    virtual uint ncell() const { return cell_.size(); }
    virtual Scan3* scan() { return new S(cell_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell3> {
    public:
      inline S(std::vector<Tetrahedron3d*>& cell) :
  idx_(cell.begin()), cell_(cell) {}
      inline S(const S& scan) : idx_(scan.idx_), cell_(scan.cell_) {}
      inline bool eos() const { return idx_ == cell_.end(); }
      inline Tetrahedron3d& operator++(int) {
  return *(*idx_++);
      }
      inline Scan3* clone() const { return new S(*this); }
    private:
      std::vector<Tetrahedron3d*>::iterator idx_;
      std::vector<Tetrahedron3d*>& cell_;
    };
    class Tet {
    private:
      uint nodes_[4];
    public:
      Tet(const uint one, const uint two, const uint three, const uint four) {
  nodes_[0] = one; nodes_[1] = two;
  nodes_[2] = three; nodes_[3] = four;
      }
      uint operator[](const uint i) const {
  conceptsAssert(i < 4, Assertion()); return nodes_[i];
      }
    };

    unsigned long long int twoIndex_(const uint j, const uint k) const;

    unsigned long long int threeIndex_(const uint x, const uint y,
               const uint z) const;

    Triangle* createTriangle_(const uint x, const uint y, const uint z,
            const std::map<unsigned long long int, Edge*>&
            edges,
            const uint bc = 0) const;

    std::vector<Vertex*> vtx_;
    std::vector<Edge*> edg_;
    std::vector<Triangle*> tri_;
    std::vector<Tetrahedron*> tet_;
    std::vector<Tetrahedron3d*> cell_;
  };

} // namespace concepts

#endif // mesh_hh