graphics/meshDX.hh

Go to the documentation of this file.

/* graphics of the mesh in OpenDX
 */

#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