dataDX.hh

Go to the documentation of this file.

 
#ifndef dataDX_hh
#define dataDX_hh
#include <forward_list> 
#include <fstream>
#include <memory>
#include "space/postProcess.hh"
#include "space/element.hh"
#include "space/formula.hh"
#include "function/basis.hh"
#include "spaceTraits.hh"
 
namespace concepts {
  // forward declaration
  template<class F>
  class Vector;
 
  template<class F>
  class Formula;
 
  template<class F, class G>
  class ElementFormula;
}
 
namespace graphics {
 
  using concepts::Real;
 
  // forward declartions
  class VertexList;
 
  // ********************************************************** Space traits **
 
  template<typename T, typename traits = spaceTraits<T> >
  struct spcPosCon {
    static inline uint positionConnection() {
      return traits::positionConnection();
    }
    static inline uint boundary() {
      return traits::boundaryElements();
    }
  };
 
  template<typename T>
  bool spacePosCon(const T& spc) { return spcPosCon<T>::positionConnection(); }
 
  template<typename T>
  bool spaceBoundary(const T& spc) { return spcPosCon<T>::boundary(); }
 
  // **************************************************************** DataDX **
 
  template<class F>
  class DataDX {
  public:
    DataDX(concepts::Space<F>& spc, const std::string filename,
     bool pc = false, bool boundary = false, const uint dim = 2);
    DataDX(const DataDX<F>& dx);
    ~DataDX();
 
    DataDX<F>& operator=(const DataDX<F>& dx);
 
    void operator()(const concepts::Vector<Real>& solution,
                    const std::string& name);
    void operator()(const concepts::Formula<Real>& frm, const std::string& name);
    void operator()(const concepts::ElementFormula<F>& frm,
                    const std::string& name);
  private:
    concepts::Space<F>* spc_;
 
    std::string filename_;
 
    concepts::GlobalPostprocess<F> postProcess_;
 
    uint countp_;
 
    uint countq_;
 
    bool pc_;
 
    std::forward_list<std::string> names_;
 
    std::unique_ptr<VertexList> vtxList_;
  };
 
  template<typename T>
  DataDX<Real> drawDataDX(T& spc, const std::string filename,
        const uint dim = 2) {
    return DataDX<Real>(spc, filename, spacePosCon(spc),
      spaceBoundary(spc), dim);
  }
 
  // ********************************************************** DataDXCounts **
 
  class DataDXCounts : public concepts::CellPostprocess<Real> {
 
  public:
    DataDXCounts(VertexList* vtxList = 0);
 
    void add(uint a) { counts_ += a; }
 
    uint counts() const;
 
    virtual void operator() (const concepts::Element<Real>& elm);
    virtual void operator() (const concepts::Cell&) {}
  private:
    uint counts_;
 
    VertexList* vtxList_;
  };
 
  // ***************************************************** DataDXCoordinates **
 
  class DataDXCoordinates : public concepts::CellPostprocess<Real> {
 
  public:
    DataDXCoordinates(std::ostream& os, const uint count, 
          VertexList* vtxList = 0, const uint dim = 2);
    virtual ~DataDXCoordinates();
 
    void add(uint a) { counts_ += a; }
 
    void inc() { cntCoords_++; }
 
    uint counts() const;
 
    virtual void operator() (const concepts::Element<Real>& elm);
    virtual void operator() (const concepts::Cell&) {}
 
    void write(const float x) const;
  private:
    std::ostream& os_;
 
    VertexList* vtxList_;
 
    const uint dim_;
 
    uint counts_;
 
    uint cntCoords_;
  };
 
  // ***************************************************** DataDXConnections **
 
  class DataDXConnections : public concepts::CellPostprocess<Real> {
 
  public:
    DataDXConnections(std::ostream& os, const uint count, 
          VertexList* vtxList = 0, const uint dim = 2);
    virtual ~DataDXConnections();
    virtual void operator() (const concepts::Element<Real>& elm);
    virtual void operator() (const concepts::Cell&) {}
 
    void add(uint a) { counts_ += a; }
 
    uint counts() const { return counts_; }
 
    void write(const int x) const;
  private:
    std::ostream& os_;
 
    uint counts_;
 
    const uint dim_;
  };
 
  // ************************************************************ DataDXData **
 
  class DataDXData : public concepts::CellPostprocess<Real> {
 
  public:
    DataDXData(std::ostream& os, const concepts::Vector<Real>& solution, 
               const uint count, const std::string& name,
               VertexList* vtxList = 0);
 
    DataDXData(std::ostream& os, const concepts::Formula<Real>& frm,
               const uint count, const std::string& name,
               VertexList* vtxList = 0);
 
    DataDXData(std::ostream& os, const concepts::ElementFormula<Real>& frm,
               const uint count, const std::string& name,
               VertexList* vtxList = 0);
 
    virtual ~DataDXData();
    virtual void operator() (const concepts::Element<Real>& elm)
      throw(concepts::MissingFeature);
    virtual void operator() (const concepts::Cell&) {}
 
    const concepts::Formula<Real>* formula() const { return frm_.get(); }
    const concepts::Array<Real>& coeff() const { return coeff_; }
    const concepts::ElementFormula<Real>* elementFormula() const
    { return efrm_; }
 
    void write(const float x) const;
  private:
    std::ostream& os_;
 
    const concepts::Vector<Real>* solution_;
 
    std::unique_ptr<const concepts::Formula<Real> > frm_;
 
    const concepts::ElementFormula<Real>* efrm_;
 
    concepts::Array<Real> coeff_;
 
    concepts::Array<Real> shpfnc_;
 
    concepts::Array<Real> vertexSol_;
 
    std::string name_;
 
    uint pc_;
 
    VertexList* vtxList_;
 
    concepts::Array<Real> vtxData_;
  };
 
} // namespace graphics
 
#endif // dataDX_hh