graphics/matlabBinaryGraphics.hh

Go to the documentation of this file.

#ifndef MATLAB_BINARY_HH
#define MATLAB_BINARY_HH

#include "matrixBasis.hh"
#include "matfile/matfileOutput.hh"
#include "basics/outputMatlab.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/vectorsMatricesForward.hh"

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


namespace graphics {

  class MatlabBinaryGraphics {

  public:

    static uint noPoints;

    MatlabBinaryGraphics() {
    };

    template<class G>
    MatlabBinaryGraphics(const concepts::Space<G>& spc,
        const std::string filename, const uint dim = 2);

    MatlabBinaryGraphics(concepts::Mesh& msh, const std::string filename,
        const uint dim = 2, const uint points = noPoints);

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

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

    template<class G, class F>
    MatlabBinaryGraphics(const concepts::Space<G>& spc,
        const std::string filename, const concepts::ElementFormula<F, G>& frm,
        const uint dim = 2);

    virtual ~MatlabBinaryGraphics() {
    }
    ;

    template<class G>
    inline void clearMapping(
        std::map<std::string, concepts::DenseMatrix<G>*>& dense_ptr_) {

      delete (dense_ptr_["x"]);

      if (dim_ > 1)
        delete (dense_ptr_["y"]);
      if (dim_ > 2)
        delete (dense_ptr_["z"]);

      //FIXME DIMENSION 3: add deleting FaceMesh

      if (dim_ > 1) {
        delete (dense_ptr_["edgemsh"]);
        delete (dense_ptr_["vtxmsh"]);
      }
      delete (dense_ptr_["Attr"]);
      delete (dense_ptr_["edgAttr"]);

      //store informations to plot solution
      if (data_) {
        delete (dense_ptr_["p"]);
        delete (dense_ptr_["u"]);
        // Cell attribute on each quadrature points
        delete (dense_ptr_["pattr"]);
        delete (dense_ptr_["w"]);
        delete (dense_ptr_["msh"]);
      }
      dense_ptr_.clear();
    }
    ;

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

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

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

  private:

    template<class G>
    void createMatrices_(bool data, uint count[], std::map<std::string,
        concepts::DenseMatrix<G>*>& dense_ptr_);

    template<class G, class F>
    void storeData_(bool data, std::string filename, std::map<std::string,
        concepts::DenseMatrix<G>*>& dense_ptr_,
        concepts::DenseMatrix<F>* functionValue = 0,
        concepts::DenseMatrix<F>** function_ptr_ = 0, int numOfFunction = 0);

    uint data_;

    uint dim_;

    uint outputDimension_;
  };

  template<class G, class F>
  MatlabBinaryGraphics::MatlabBinaryGraphics(const concepts::Space<G>& spc,
      const std::string filename, const concepts::Vector<F>& sol,
      const concepts::ElementFunction<F, G>* fun, const uint dim) {

    dim_ = dim;
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);

    //output dimension for ex. n = 1 if fun = Value or n = 2 if fun = Grad
    if (fun)
      outputDimension_ = fun->n();
    else
      outputDimension_ = 1;

    //declare mapping
    std::map<std::string, concepts::DenseMatrix<G>*> dense_ptr_;

    //declare FunctionValues u
    concepts::DenseMatrix<F>* functionValue;

    // Post processor on cell
    MatrixBaseDataCell<F, G> bdc(dense_ptr_, functionValue, sol, fun);

    //calculate size of the matrices / size of data
    postProcess(bdc);

    //Now the we know the size of the matrices, so create them.
    createMatrices_(true, bdc.dimensionsOfMatrices, dense_ptr_);

    //Now the we know the number of evaluations of the function, so create the valuevector.
    functionValue = new concepts::DenseMatrix<F>(outputDimension_,
        bdc.dimensionsOfMatrices[0]);

    //the MatrixBaseDataCell should know that everything is counted i.e. it can read data in the matrices
    bdc.counted = true;

    //run GlobalPostprocess with bdc to fill the concepts::DenseMatrix<> with mesh/solution informations.
    postProcess(bdc);

    //store the matrices
    storeData_(true, filename, dense_ptr_, functionValue);

    //deletes dense matrix pointer
    delete (functionValue);

    //Deletes the Dense matrices in the mapping
    clearMapping(dense_ptr_);
  }
  //TODO
  template<class G, class F>
  MatlabBinaryGraphics::MatlabBinaryGraphics(const concepts::Space<G>& spc,
      const std::string filename, std::vector<concepts::Vector<F> >& sol,
      int numOfFunction, const concepts::ElementFunction<F, G>* fun,
      const uint dim) {

    dim_ = dim;

    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);

    //output dimension for ex. n = 1 if fun = Value or n = 2 if fun = Grad
    if (fun)
      outputDimension_ = fun->n();
    else
      outputDimension_ = 1;

    //declare mapping
    std::map<std::string, concepts::DenseMatrix<G>*> dense_ptr_;

    //declare mapping
    concepts::DenseMatrix<F>* function_ptr[numOfFunction];

    // Post processor on cell
    MatrixBaseDataCell<F, G> bdc(dense_ptr_, function_ptr[0], sol[0], fun);

    //calculate size of the matrices / size of data
    postProcess(bdc);


    //Now the we know the size of the matrices, so create them.
    createMatrices_(true, bdc.dimensionsOfMatrices, dense_ptr_);

    //Now the we know the number of evaluations of the function, so create the valuevectors.
    for (int i = 0; i < numOfFunction; ++i)
      function_ptr[i] = new concepts::DenseMatrix<F>(outputDimension_,
          bdc.dimensionsOfMatrices[0]);


    //the MatrixBaseDataCell should know that everything is counted i.e. it can read data in the matrices
    bdc.counted = true;

    MatrixSolutionEvaluationCell<F, G> sec(dense_ptr_, function_ptr[0],
        &(sol[0]), fun);

    for (uint i = 0; i < 4; ++i)
      sec.dimensionsOfMatrices[i] = bdc.dimensionsOfMatrices[i];
    sec.counted = true;

    //run GlobalPostprocess with bdc to fill the concepts::DenseMatrix<> with solution informations.
    postProcess(bdc);

    for (int i = 0; i < numOfFunction; i++) {
      sec.setSolVec(&sol[i]);
      sec.setFunValue(function_ptr[i]);
      postProcess(sec);
      sec.resetCounter();
    }

    //store the matrices
    storeData_<G, F> (true, filename, dense_ptr_, 0, function_ptr,
        numOfFunction);

    //deletes dense matrix pointer
    for (int i = 0; i < numOfFunction; ++i)
      delete (function_ptr[i]);

    //Deletes the Dense matrices in the mapping
    clearMapping(dense_ptr_);
  }

  template<class G>
  MatlabBinaryGraphics::MatlabBinaryGraphics(const concepts::Space<G>& spc,
      const std::string filename, const uint dim) {

    dim_ = dim;
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);

    //declare mapping
    std::map<std::string, concepts::DenseMatrix<G>*> dense_ptr_;

    // Post processor on cell
    MatrixBaseMeshCell bdc(dense_ptr_, dim_);

    //calculate size of the matrices / size of data
    postProcess(bdc);

    //Now we know the size of the matrices, so create them.
    createMatrices_(false, bdc.dimensionsOfMatrices, dense_ptr_);

    //the MatrixBaseMeshCell should know that everything is counted i.e. it can read data in the matrices
    bdc.counted = true;

    //run GlobalPostprocess with bdc to fill the concepts::DenseMatrix<> with mesh/solution informations.
    postProcess(bdc);

    //store the matrices
    storeData_<G, Real> (true, filename, dense_ptr_);

    //Deletes the Dense matrices in the mapping
    clearMapping(dense_ptr_);
  }

  template<class G, class F>
  MatlabBinaryGraphics::MatlabBinaryGraphics(const concepts::Space<G>& spc,
      const std::string filename, const concepts::ElementFormula<F, G>& frm,
      const uint dim) {

    //save dimension
    dim_ = dim;

    //output dimension for ex. n = 1 if fun = Value or n = 2 if fun = Grad
    outputDimension_ = Size<F>::n();

    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);

    //declare mapping
    std::map<std::string, concepts::DenseMatrix<G>*> dense_ptr_;

    //declare FunctionValues u
    concepts::DenseMatrix<F>* functionValue;

    // Post processor on cell
    MatrixBaseElementFormulaCell<F, G>
        bdc(dense_ptr_, functionValue, dim_, frm);

    //calculate size of the matrices / size of data
    postProcess(bdc);

    //Now we know the size of the matrices, so lets inatialize them.
    createMatrices_(true, bdc.dimensionsOfMatrices, dense_ptr_);

    //Now the we know the number of evaluations of the function, so create the valuevector.
    functionValue = new concepts::DenseMatrix<F>(outputDimension_,
        bdc.dimensionsOfMatrices[0]);

    //the MatrixBaseMeshCell should know that everything is counted i.e. it can read data in the matrices
    bdc.counted = true;

    //run GlobalPostprocess with bdc to fill the concepts::DenseMatrix<> with mesh/solution informations.
    postProcess(bdc);

    //store the matrices
    storeData_(true, filename, dense_ptr_, functionValue);

    //Delete the Dense matrices in the mapping and function value
    delete (functionValue);
    clearMapping(dense_ptr_);
  }

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

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

  template<class G>
  void MatlabBinaryGraphics::createMatrices_(bool data, uint count[], std::map<
      std::string, concepts::DenseMatrix<G>*>& dense_ptr_) {

    data_ = data;
    // coordinates

    dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("x",
        new concepts::DenseMatrix<G>(1, count[0])));
    if (dim_ > 1)
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("y",
          new concepts::DenseMatrix<G>(1, count[0])));
    if (dim_ > 2)
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("z",
          new concepts::DenseMatrix<G>(1, count[0])));

    //FIXME DIMENSION 3: add FaceMesh

    dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>(
        "edgAttr", new concepts::DenseMatrix<G>(1, count[2])));

    if (dim_ > 1) {
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>(
          "edgemsh", new concepts::DenseMatrix<G>(2, count[2])));
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>(
          "vtxmsh", new concepts::DenseMatrix<G>(5, count[3])));
    }
    dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("Attr",
        new concepts::DenseMatrix<G>(1, count[3])));

    //store informations to plot solution
    if (data) {
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("p",
          new concepts::DenseMatrix<G>(2, count[3])));
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("u",
          new concepts::DenseMatrix<G>(outputDimension_, count[0])));
      // Cell attribute on each quadrature points
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>(
          "pattr", new concepts::DenseMatrix<G>(1, count[0])));
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>("w",
          new concepts::DenseMatrix<G>(1, count[0])));
      dense_ptr_.insert(std::pair<std::string, concepts::DenseMatrix<G>*>(
          "msh", new concepts::DenseMatrix<G>(5, count[1])));
    }

  }//end Create matrices


  //Save the matrices that hold informations
  template<class G, class F>
  void MatlabBinaryGraphics::storeData_(bool data, std::string filename,
      std::map<std::string, concepts::DenseMatrix<G>*>& dense_ptr_,
      concepts::DenseMatrix<F>* functionValue,
      concepts::DenseMatrix<F>** function_ptr_, int numOfFunction) {

    concepts::MatfileOutput mo(filename);

    //Save coord
    mo.addDense(dense_ptr_["x"], "x");
    if (dim_ > 1)
      mo.addDense(dense_ptr_["y"], "y");
    if (dim_ > 2)
      mo.addDense(dense_ptr_["z"], "z");

    //FIXME DIMENSION 3: add FaceMesh

    mo.addDense(dense_ptr_["edgAttr"], "edgAttr");
    mo.addDense(dense_ptr_["Attr"], "Attr");

    if (dim_ > 1) {
      mo.addDense(dense_ptr_["edgemsh"], "edgemsh");
      mo.addDense(dense_ptr_["vtxmsh"], "vtxmsh");

    }

    //store informations to plot solution
    if (data_) {
      mo.addDense(dense_ptr_["p"], "p");
      if (functionValue) {
        mo.addDense(functionValue, "u");
      }
      mo.addDense(dense_ptr_["pattr"], "pattr");
      mo.addDense(dense_ptr_["w"], "w");
      mo.addDense(dense_ptr_["msh"], "msh");
    }//ENDIF

    if (numOfFunction)
      for (int i = 0; i < numOfFunction; ++i) {
        stringstream streamName;
        streamName << "u" << i;
        mo.addDense(function_ptr_[i], streamName.str());
      }

    //close file
    mo.closeMatfile();

  }//end store data


} // namespace graphics


#endif // graphBinMatlab_hh