graphics/dataDX.hh

Go to the documentation of this file.

/* graphics in OpenDX
 */

#ifndef dataDX_hh
#define dataDX_hh

#if __ICC == 800
#  include <slist>
#  define __gnu_cxx std
#else
#  if __GNUC__ > 2
#    include <ext/slist>
#    if __GNUC__ == 3 && __GNUC_MINOR__ < 1
#      define __gnu_cxx std
#    endif
#  else
#    include <slist>
#    define __gnu_cxx std
#  endif
#endif

#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_;

    __gnu_cxx::slist<std::string> names_;

    std::auto_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_;

    VertexList* vtxList_;

    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::auto_ptr<const concepts::Formula<Real> > frm_;

    const concepts::ElementFormula<Real>* efrm_;

    concepts::Array<Real> coeff_;

    concepts::Array<Real> shpfnc_;

    concepts::Array<Real> vertexSol_;

    uint vertexSolIndex_;

    std::string name_;

    uint pc_;

    VertexList* vtxList_;

    concepts::Array<Real> vtxData_;
  };

} // namespace graphics

#endif // dataDX_hh