basis.hh

Go to the documentation of this file.

 
#ifndef graphicsbasis_hh
#define graphicsbasis_hh
 
#include <fstream>
#include "basics/debug.hh"
#include "basics/exceptions.hh"
#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "toolbox/array.hh"
#include "toolbox/elementGraphics.hh"
#include "toolbox/sequence.hh"
#include "geometry/cell2D.hh"
#include "space/function.hh"
#include "space/postProcess.hh"
#include "space/space.hh"
 
namespace concepts {
  template<class F>
  class Vector;
 
  template<class F, class G>
  class ElementFormula;
 
  template<class F>
  class PiecewiseFormulaBase;
}
 
namespace graphics {
 
  using concepts::Real;
 
  // ****************************************************************** Size **
 
  template<class F>
  struct Size {
    const uint n() = 0;
  };
 
  template<>
  struct Size<Real> {
    static const uint n() { return 1; }
  };
 
  template<>
  struct Size<concepts::Cmplx> {
    static const uint n() { return 1; }
  };
 
  template<class F, uint dim>
  struct Size<concepts::Point<F, dim> > {
    static const uint n() { return Size<F>::n() * dim; }
  };
 
  template<class F, uint dim>
  struct Size<concepts::Mapping<F, dim> > {
    static const uint n() { return Size<F>::n() * dim * dim; }
  };
 
  // ************************************************************ OutputBase **
 
  class OutputBase : public concepts::OutputOperator {
  public:
    OutputBase(const std::string filename, const bool append = false);
    virtual ~OutputBase() { ofs_.reset(0); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    std::unique_ptr<std::ofstream> ofs_;
  };
 
  // ******************************************************** BaseOutputCell **
 
  template<class F = Real>
  class BaseOutputCell :  public concepts::CellPostprocess<F> {
  public:
    BaseOutputCell(std::map<std::string, std::ostream*>& os, const uint dim,
       const concepts::ElementGraphicsBase::graphicsType type) 
      : type_(type), dim_(dim), os_(os) {}
    virtual void operator()(const concepts::Element<F>& elm) = 0;
    virtual void operator()(const concepts::Cell& cell) = 0;
    std::map<std::string, std::ostream*>& write() { return os_; }
    uint streams() const { return os_.size(); }
//     uint& count() { return cnt_; }
    std::vector<uint>& count() { return cnt_; }
//     uint& elm() { return elm_; }
    uint dim() const { return dim_; }
    virtual uint n() const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    const enum concepts::ElementGraphicsBase::graphicsType type_;
    concepts::Sequence<uint> cnt_;
//     uint elm_;
    const uint dim_;
    std::map<std::string, std::ostream*>& os_;
  };
 
  // ********************************************************** BaseDataCell **
 
  template<class F, class G = typename concepts::Realtype<F>::type>
  class BaseDataCell : public BaseOutputCell<G> {
  public:
    BaseDataCell(std::map<std::string, std::ostream*>& os, 
     const uint dim,
     const concepts::ElementGraphicsBase::graphicsType type,
     const concepts::Vector<F>& sol,
     const concepts::ElementFunction<F,G>* fun = 0);
    virtual void operator()(const concepts::Element<G>& elm);
    virtual void operator()(const concepts::Cell& cell);
    const concepts::Array<F>& coeff() const { return coeff_; }
    const concepts::ElementFunction<F,G>*& elementFunction() 
    { return fun_; }
    const concepts::Vector<F>& sol() const { return sol_; }
    virtual uint n() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::Array<F> coeff_;
    const concepts::Vector<F>& sol_;
    const concepts::ElementFunction<F,G>* fun_;
  };
 
  // ************************************************ BaseElementFormulaCell **
 
  template<class F, class G = typename concepts::Realtype<F>::type>
  class BaseElementFormulaCell : public BaseOutputCell<G> {
  public:
    BaseElementFormulaCell
    (std::map<std::string, std::ostream*>& os, const uint dim,
     const concepts::ElementGraphicsBase::graphicsType type,
     const concepts::ElementFormula<F,G>& fun);
    virtual void operator()(const concepts::Element<G>& elm);
    virtual void operator()(const concepts::Cell& cell);
    const concepts::ElementFormula<F,G>& elementFormula() 
    { return fun_; }
    virtual uint n() const { return Size<F>::n(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    const concepts::ElementFormula<F,G>& fun_;
  };
 
  // ******************************************************* BaseFormulaCell **
 
  template<class F, class G = typename concepts::Realtype<F>::type>
  class BaseFormulaCell : public BaseOutputCell<G> {
  public:
    BaseFormulaCell(std::map<std::string, std::ostream*>& os, 
                    const uint dim, 
                    const concepts::ElementGraphicsBase::graphicsType type,
                    const concepts::PiecewiseFormulaBase<F>& frm,
                    const uint points = 5);
    virtual void operator()(const concepts::Element<G>& elm);
    virtual void operator()(const concepts::Cell& cell);
    const concepts::PiecewiseFormulaBase<F>* formula() const { return &frm_; }
    virtual uint n() const { return Size<F>::n(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const concepts::PiecewiseFormulaBase<F>& frm_;
    const concepts::Array<uint> Points_;
  };
 
  // ********************************************************** BaseMeshCell **
 
  class BaseMeshCell : public BaseOutputCell<Real> {
  public:
    BaseMeshCell(std::map<std::string, std::ostream*>& os, const uint dim,
     const concepts::ElementGraphicsBase::graphicsType type,
     const uint points = 5);
    virtual void operator()(const concepts::Element<Real>& elm);
    virtual void operator()(const concepts::Cell& cell);
    virtual uint n() const { return 0; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const concepts::Array<uint> Points_;
  };
 
} // namespace concepts
 
#endif // graphicsbasis_hh