graphics/matlab.hh

Go to the documentation of this file.

/* graphics in Matlab
 */

#ifndef graphMatlab_hh
#define graphMatlab_hh

#include "basis.hh"
#include "basics/outputMatlab.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/vectorsMatricesForward.hh"

#define MatlabGraphConstr_D 0

namespace concepts {
  
  // forward declaration
  template<class F>
  class Formula;
}


namespace graphics {

  using concepts::Real;
  using concepts::Real2d;

  // ********************************************************** matlabEnding **

  std::string matlabEnding(const std::string& filename);

  // ******************************************************** MatlabGraphics **

  class MatlabGraphics : public OutputBase {
  public:
    template<class G>
    MatlabGraphics(const concepts::Space<G>& spc, const std::string filename,
                   const uint dim = 2);
    MatlabGraphics(concepts::Mesh& msh, const std::string filename,
       const uint dim = 2, const uint points = noPoints);

    template<class F, class G>
    MatlabGraphics(const concepts::Space<G>& spc, const std::string filename,
                   const concepts::Vector<F>& sol, const uint dim = 2,
                   const concepts::ElementFunction<F,G>* fun = 0);

    template<class F, class G>
    MatlabGraphics(const concepts::Space<G>& spc, const std::string filename,
                   const concepts::ElementFormula<F,G>& frm,
                   const uint dim = 2);
    template<class F>
    MatlabGraphics(concepts::Mesh& msh, const std::string filename,
                   const concepts::PiecewiseFormulaBase<F>& frm, 
                   const uint dim = 2, const uint points = noPoints);

    virtual ~MatlabGraphics() {}

    template<class F, class G>
    void operator()(const concepts::Space<G>& spc,
                    const concepts::Vector<F>& sol,
                    const concepts::ElementFunction<F,G>* fun = 0);

    template<class F, class G>
    void operator()(const concepts::Space<G>& spc,
                    const concepts::Formula<F>& frm);
    template<class F, class G>
    void operator()(concepts::Mesh& msh, const concepts::Formula<F>& frm,
                    const uint points = 5);

    static uint noPoints;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    template<class F>
    void write_(concepts::GlobalPostprocess<F>& postProcess,
    BaseOutputCell<F>& matlab, bool data = false);
    void createStreams_(bool data);
    void closeStreams_(const uint& n);

    std::map<std::string, std::ostream*> s_ptr_;
    uint dim_;
    uint cnt_;
  };

  template<class G>
  MatlabGraphics::MatlabGraphics(const concepts::Space<G>& spc,
         const std::string filename, const uint dim)
    : OutputBase(matlabEnding(filename)), dim_(dim), cnt_(0)
  {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseMeshCell matlab(s_ptr_, dim, concepts::ElementGraphicsBase::MATLAB);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, matlab);
  }

  template<class F, class G>
  MatlabGraphics::MatlabGraphics(const concepts::Space<G>& spc,
                                 const std::string filename,
                                 const concepts::Vector<F>& sol,
                                 const uint dim,
                                 const concepts::ElementFunction<F,G>* fun)
    : OutputBase(matlabEnding(filename)), dim_(dim), cnt_(0) {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseDataCell<F,G> matlab(s_ptr_, dim,
           concepts::ElementGraphicsBase::MATLAB, sol, fun);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, matlab, true);
  }

  template<class F, class G>
  MatlabGraphics::MatlabGraphics(const concepts::Space<G>& spc,
         const std::string filename,
         const concepts::ElementFormula<F,G>& frm,
         const uint dim)
    : OutputBase(matlabEnding(filename)), dim_(dim), cnt_(0) {
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
    // Post processor on cell
    BaseElementFormulaCell<F,G> matlab
      (s_ptr_, dim, concepts::ElementGraphicsBase::MATLAB, frm);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, matlab, true);
  }

  template<class F>
  MatlabGraphics::MatlabGraphics(concepts::Mesh& msh, const std::string filename,
                                 const concepts::PiecewiseFormulaBase<F>& frm, 
                                 const uint dim, const uint points)
    : OutputBase(matlabEnding(filename)), dim_(dim), cnt_(0) {
    // Post processor (global)
    concepts::GlobalPostprocess<Real> postProcess(msh);
    // Post processor on cell
    BaseFormulaCell<F,Real> matlab(s_ptr_, dim,
                                   concepts::ElementGraphicsBase::MATLAB, frm,
                                   points);
    // Creates streams, writes to streams, writes to file and clear
    // and delete all streams.
    write_(postProcess, matlab, true);
  }

  template<class F, class G>
  void MatlabGraphics::operator()(const concepts::Space<G>& spc,
                                  const concepts::Vector<F>& sol,
                                  const concepts::ElementFunction<F,G>* fun) {
    
  }

  template<class F, class G>
  void MatlabGraphics::operator()(const concepts::Space<G>& spc,
          const concepts::Formula<F>& frm) {
    
  }

  template<class F, class G>
  void MatlabGraphics::operator()(concepts::Mesh& msh,
          const concepts::Formula<F>& frm,
          const uint points) {
    
  }

  template<class F>
  void MatlabGraphics::write_(concepts::GlobalPostprocess<F>& postProcess,
                              BaseOutputCell<F>& matlab, bool data) 
  {
    // Create the streams
    createStreams_(data);
    // set counter to zero
    matlab.count().assign(1, 0);
    // Post processor on cell
    DEBUGL(MatlabGraphConstr_D, matlab);
    // loop over cells or elements and write into streams
    postProcess(matlab);
    // write to file, clear and delete streams
    closeStreams_(matlab.n());
  }

 // ************************************************************* MatlabMesh **

  class MatlabMesh : public concepts::OutputOperator {
  public:
    static void writeMesh(const concepts::Cell& cell, 
        std::map<std::string, std::ostream*>& os,
        const concepts::Array<uint>& np, uint& cnt,
        bool boundary = false, bool coord = true);
    template<class F>
    static void writeFormula(const concepts::Cell& cell, 
                             std::map<std::string, std::ostream*>& os,
                             const concepts::Array<uint>& np, uint& cnt,
                             const concepts::PiecewiseFormulaBase<F>* frm);
    static void writeAttributes(const concepts::Connector& cntr,
        std::map<std::string, std::ostream*>& os);
    template<uint dim>
    static void writeCoord(typename concepts::Point<Real, dim> x,
                           std::map<std::string, std::ostream*>& os);
    static void writeCoord(concepts::Point<Real, 2> x,
         std::map<std::string, std::ostream*>& os);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static void writeMesh_(const concepts::Quad2d& quad, 
                           std::map<std::string, std::ostream*>& os,
                           const concepts::Array<uint>& np, uint& cnt,
                           bool boundary = false, bool coord = true);
    static void writeMesh_(const concepts::InfiniteQuad2d& quad, 
                           std::map<std::string, std::ostream*>& os,
                           const concepts::Array<uint>& np, uint& cnt,
                           bool boundary = false, bool coord = true);
    static void writeMesh_(const concepts::Edge2d& quad, 
                           std::map<std::string, std::ostream*>& os,
                           const concepts::Array<uint>& np, uint& cnt,
                           bool boundary = false, bool coord = true);
  };


  template<uint dim>
  void MatlabMesh::writeCoord(typename concepts::Point<Real, dim> x,
            std::map<std::string, std::ostream*>& os) {
    *os["x"] << x[0] << " ";
    if (dim > 1) {
      *os["y"] << x[1] << " ";
      if (dim > 2)
  *os["z"] << x[2] << " ";
    }
  }

  template<class F>
  void MatlabMesh::writeFormula(const concepts::Cell& cell, 
                                std::map<std::string, std::ostream*>& os,
                                const concepts::Array<uint>& np, uint& cnt,
                                const concepts::PiecewiseFormulaBase<F>* frm) {
    DEBUGL(MatlabMeshWriteFormula_D, "cell = " << cell);

    // writes mesh, but not the coordinates
    writeMesh(cell, os, np, cnt, false, false);

    F f;       // formula value    

    // 2D quadrilaterial
    const concepts::Quad2d* cellQ = 
      dynamic_cast<const concepts::Quad2d*>(&cell);
    if (cellQ) {
      Real2d x;  // coordinates
      for (uint j = 0; j < np[1]; ++j) {
        Real py = (Real)j / (np[1]-1);
        for (uint i = 0; i < np[0]; ++i) {
          x = cellQ->chi((Real)i/(np[0]-1), py);
          // write coordinates
          writeCoord(x, os);
          // write value (particularly components)
          f = (*frm)(cell.connector(), x);
          DEBUGL(MatlabMeshWriteFormula_D, "f = " << f);
          *os["u"] << concepts::OutputMatlab<F>(f) << ' ';
        } // for i
      } // for j
    } // cellQ
  }

} // namespace graphics

#endif // graphMatlab_hh