meshDX.hh

Go to the documentation of this file.

 
#ifndef graphMeshDX_hh
#define graphMeshDX_hh
 
#include <iostream>
#include <string>
#include <list>
#include "space/postProcess.hh"
#include "basics/typedefs.hh"
#include "basics/exceptions.hh"
#include "spaceTraits.hh"
#include "geometry/topology.hh"
 
namespace hp2D {
  // forward declaration
  class Space;
}
 
namespace hp3D {
  // forward declaration
  class Space;
}
 
namespace graphics {
 
  using concepts::Real;
 
  // forward declartions
  class VertexList;
 
  // ********************************************************** Space traits **
 
  template<typename T, typename traits = spaceTraits<T> >
  struct spcDim {
    static inline uint dim() { return traits::dim(); }
  };
 
  template<typename T>
  uint spaceDimension(const T& spc) {
    return spcDim<T>::dim();
  }
 
  // **************************************************************** MeshDX **
 
  template<class F>
  class MeshDX {
  public:
    MeshDX(concepts::Mesh& msh, std::string filename)
      throw(concepts::Assertion);
 
    MeshDX(concepts::Space<F>& spc, std::string filename, uint dim)
      throw(concepts::Assertion);
  private:
    concepts::Space<F>* spc_;
 
    concepts::Mesh* msh_;
 
    std::string filename_;
 
    void constructor_(concepts::GlobalPostprocess<F>& postProcess,
          std::string& filename, uint nelm, uint dim);
  };
 
  MeshDX<Real> drawMeshDX(concepts::Mesh& msh, std::string filename);
 
  template<typename T>
  MeshDX<Real> drawMeshDX(T& spc, std::string filename) {
    return MeshDX<Real>(spc, filename, spaceDimension(spc));
  }
 
  // ************************************************************ MeshDXCell **
 
  template<class F>
  class MeshDXCell : public concepts::CellPostprocess<F> {
  public:
    MeshDXCell(std::ostream& os, VertexList& vtxList, uint nelms, uint nfaces,
         uint dim = 2);
 
    virtual ~MeshDXCell();
 
    virtual void operator() (const concepts::Element<F>& elm)
      throw(concepts::MissingFeature);
    virtual void operator() (const concepts::Cell& cell)
      throw(concepts::MissingFeature, concepts::Assertion);
  private:
    std::ostream& os_;
 
    VertexList& vtxList_;
 
    uint dim_;
  };
 
  // ******************************************************** BoundaryDXCell **
 
  template<typename F>
  class BoundaryDXCell : public concepts::CellPostprocess<F> {
  public:
    BoundaryDXCell(VertexList& vtxList) : vtxList_(vtxList) {}
    virtual ~BoundaryDXCell();
 
    virtual void operator() (const concepts::Element<F>& elm)
      throw(concepts::MissingFeature);
    virtual void operator() (const concepts::Cell& cell)
      throw(concepts::MissingFeature, concepts::Assertion);
 
    const std::list<const concepts::Connector*>& faces() const
    { return faces_; }
  private:
    VertexList& vtxList_;
 
    std::list<const concepts::Connector*> faces_;
  };
 
} // namespace graphics
 
#endif // graphMeshDX_hh