tecplot.hh

Go to the documentation of this file.

 
#ifndef graphTecplot_hh
#define graphTecplot_hh
 
#include <vector>
#include "basis.hh"
#include "basics/outputTecplot.hh"
#include "basics/output.hh"
#include "basics/vectorsMatricesForward.hh"
#include "geometry/arrays.hh"
 
#define TecplotGraphConstr_D 0
#define TecplotMeshWriteFormula_D 0
 
namespace concepts {
  
  // forward declaration
  template<class F>
  class Formula;
}
 
namespace graphics {
 
  using concepts::Real;
  using concepts::Real2d;
 
  // ********************************************************* tecplotEnding **
 
  std::string tecplotEnding(const std::string& filename);
 
  // ******************************************************* TecplotGraphics **
 
  class TecplotGraphics : public OutputBase {
  public:
    enum elementTypes {TRIANGLE, QUADRILATERAL, TETRAHEDRON , BRICK,
           MAX_TYPE };
    template<class G>
    TecplotGraphics(const concepts::Space<G>& spc, const std::string filename,
        const std::string title,
        const enum elementTypes type = QUADRILATERAL);
    TecplotGraphics(concepts::Mesh& msh, const std::string filename,
        const std::string title,
        const enum elementTypes type = QUADRILATERAL,
        const uint points = noPoints);
 
    template<class F, class G>
    TecplotGraphics(const concepts::Space<G>& spc, const std::string filename,
                    const std::string title,
                    const concepts::Vector<F>& sol, 
                    const enum elementTypes type = QUADRILATERAL,
                    const concepts::ElementFunction<F,G>* fun = 0,
                    const bool append = false);
 
    template<class F, class G>
    TecplotGraphics(const concepts::Space<G>& spc, const std::string filename,
                    const std::string title,
                    const concepts::Formula<F>& frm, 
                    const enum elementTypes type = QUADRILATERAL);
    template<class F, class G>
    TecplotGraphics(const concepts::Space<G>& spc, const std::string filename,
                    const std::string title,
                    const concepts::ElementFormula<F,G>& frm, 
                    const enum elementTypes type = QUADRILATERAL);
    template<class F>
    TecplotGraphics(concepts::Mesh& msh, const std::string filename,
                    const std::string title,
                    const concepts::Formula<F>& frm, 
                    const enum elementTypes type = QUADRILATERAL,
                    const uint points = noPoints);
 
    virtual ~TecplotGraphics() {}
 
    static uint noPoints;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    template<class F, class G>
    void write_(concepts::GlobalPostprocess<G>& postProcess,
    BaseOutputCell<G>& tecplot, const F v);
    void createStreams_();
    void closeStreams_(const std::vector<uint>& cnt);
    const uint dim_() const;
    const std::string typeStr_() const;
 
    std::map<std::string, std::ostream*> s_ptr_;
    const std::string title_;
    const enum elementTypes type_;
  };
 
  template<class G>
  TecplotGraphics::TecplotGraphics(const concepts::Space<G>& spc,
           const std::string filename, 
           const std::string title, 
           const enum elementTypes type)
    : OutputBase(tecplotEnding(filename)), title_(title), type_(type)
  {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseMeshCell tecplot(s_ptr_, dim_(),
       concepts::ElementGraphicsBase::TECPLOT, noPoints);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, tecplot, 0);
  }
 
  template<class F, class G>
  TecplotGraphics::TecplotGraphics(const concepts::Space<G>& spc,
           const std::string filename,
           const std::string title,
           const concepts::Vector<F>& sol,
           const enum elementTypes type,
           const concepts::ElementFunction<F,G>* fun,
           const bool append)
    : OutputBase(tecplotEnding(filename), append), title_(title), type_(type)
  {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseDataCell<F,G> tecplot(s_ptr_, dim_(),
            concepts::ElementGraphicsBase::TECPLOT,
            sol, fun);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams. Header has to be written during the output
    // inside stream "header".
    write_(postProcess, tecplot, (F)0);
  }
 
  template<class F, class G>
  TecplotGraphics::TecplotGraphics(const concepts::Space<G>& spc,
           const std::string filename,
           const std::string title,
           const concepts::Formula<F>& frm,
           const enum elementTypes type)
    : OutputBase(tecplotEnding(filename)),
      title_(title), type_(type) {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseFormulaCell<F,G> tecplot(s_ptr_, dim_(),
         concepts::ElementGraphicsBase::TECPLOT, frm,
         noPoints);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, tecplot, true);
  }
 
  template<class F, class G>
  TecplotGraphics::TecplotGraphics(const concepts::Space<G>& spc,
           const std::string filename,
           const std::string title,
           const concepts::ElementFormula<F,G>& frm,
           const enum elementTypes type)
    : OutputBase(tecplotEnding(filename)), title_(title), type_(type)
  {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseElementFormulaCell<F,G> tecplot
      (s_ptr_, dim_(), concepts::ElementGraphicsBase::TECPLOT, frm);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, tecplot, (F)0);
  }
 
  template<class F>
  TecplotGraphics::TecplotGraphics(concepts::Mesh& msh,
           const std::string filename,
           const std::string title,
           const concepts::Formula<F>& frm,
           const enum elementTypes type,
           const uint points)
    : OutputBase(tecplotEnding(filename)), title_(title ), type_(type)
  {
    // Post processor (global)
    concepts::GlobalPostprocess<Real> postProcess(msh);
    // Post processor on cell
    BaseFormulaCell<F,Real> tecplot(s_ptr_, dim_(),
            concepts::ElementGraphicsBase::TECPLOT,
            frm, points);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, tecplot, F(1));
  }
 
  template<class F, class G>
  void TecplotGraphics::write_(concepts::GlobalPostprocess<G>& postProcess,
             BaseOutputCell<G>& tecplot, const F v) {
    // Create the streams
    createStreams_();
    if (v != F(0)) {
      concepts::OutputTecplot<F>(v).header(*ofs_ << ", ", "v");
      *ofs_ << std::endl;
    }
    // set counter to zero
    tecplot.count().assign(2, 0);
    // Post processor on cell
    DEBUGL(TecplotGraphConstr_D, tecplot);
    // loop over cells or elements and write into streams
    postProcess(tecplot);
    // write to file, clear and delete streams
    closeStreams_(tecplot.count());
  }
 
 // ************************************************************ TecplotMesh **
 
  class TecplotMesh : public concepts::OutputOperator {
  public:
    static void writeMesh(const concepts::Cell& cell, 
        std::map<std::string, std::ostream*>& os,
        const concepts::Array<uint>& np,
        std::vector<uint>& cnt);
    template<class F>
    static void writeFormula(const concepts::Cell& cell, 
                             std::map<std::string, std::ostream*>& os,
                             const concepts::Array<uint>& np, 
                             std::vector<uint>& cnt,
                             const concepts::PiecewiseFormulaBase<F>* frm);
    template<uint dim, class F>
    static void writeData
    (const concepts::Array<concepts::Point<Real, dim> >& coord,
     std::ostream& os, const F* values = 0);
    static void writeConnect(const concepts::Quad2d& quad, std::ostream& os,
                             const concepts::Array<uint>& np,
                             std::vector<uint>& cnt);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
 
    template<uint dim>
    static void writeCoord_(concepts::Point<Real, dim> x, std::ostream& os);
 
  };
 
  template<class F>
  void TecplotMesh::writeFormula(const concepts::Cell& cell, 
                                 std::map<std::string, std::ostream*>& os,
                                 const concepts::Array<uint>& np,
                                 std::vector<uint>& cnt,
                                 const concepts::PiecewiseFormulaBase<F>* frm)
  {
    DEBUGL(TecplotMeshWriteFormula_D, "cell = " << cell);
 
    // 2D quadrilaterial
    const concepts::Quad2d* cellQ = 
      dynamic_cast<const concepts::Quad2d*>(&cell);
    if (cellQ) {
      // coordinates in the cell
      const concepts::ArrayCoord<2> X
        (*cellQ, 
         concepts::Array<Real>(np[0], 0, 1./(np[0]-1)),
         concepts::Array<Real>(np[1], 0, 1./(np[1]-1)));
      const concepts::Real2d* x = (const concepts::Real2d*)X;
      // array for the formula values
      concepts::Array<F> V(X.size()); F* v = (F*)V;
      for (uint i = X.size(); i--; )
        *v++ = (*frm)(cell.connector(), *x++);
      writeData(X, *os["data"], (const F*)V);
      writeConnect(*cellQ, *os["connect"], np, cnt);
    } // cellQ
  }
 
  template<uint dim, class F>
  void TecplotMesh::writeData
  (const concepts::Array<concepts::Point<Real, dim> >& coord,
   std::ostream& os, const F* v) {
    const concepts::Point<Real, dim>* x = 
      (const concepts::Point<Real, dim>*)coord;
    bool values = v != 0;
    for(uint i = coord.size(); i--; ) {
      writeCoord_(*x++, os);
      if (values) os << " " << concepts::OutputTecplot<F>(*v++);
      os << std::endl;
    }
  }
 
  template<uint dim>
  void TecplotMesh::writeCoord_(concepts::Point<Real, dim> x, std::ostream& os) 
  {
    os << x[0] << " ";
    if (dim > 1) {
      os << x[1] << " ";
      if (dim > 2)
  os << x[2] << " ";
    }
  }
 
} // namespace graphics
 
#endif // graphTecplot_hh