denseMatrixGraphics.hh

Go to the documentation of this file.

 
#ifndef densematrixgraphics_hh_
#define densematrixgraphics_hh_
 
#include "toolbox/sharedPointer.hh"
#include "matrixBasis.hh"
#include <map>
 
using concepts::Real;
 
namespace graphics {
 
  // ************************************************* DenseMatrixCollection **
 
  template<class G>
  class DenseMatrixCollection: public std::map<std::string,
      concepts::ElementMatrix<G>* const > {
  public:
 
    DenseMatrixCollection(MatrixCounterCell& counter, bool data = true);
 
    virtual ~DenseMatrixCollection();
 
  protected:
 
    int dim_;
 
    bool data_;
 
    void createMatrix_(const std::string name, uint nrows, uint ncols);
 
    void createMatrices_(MatrixCounterCell& counter);
  };
 
  // ************************************************** DenseMatrixGraphics **
 
  class DenseMatrixGraphics {
  public:
 
    DenseMatrixGraphics();
 
    virtual ~DenseMatrixGraphics();
 
    static uint noPoints;
 
  protected:
    template<class F, class G>
    concepts::RCP<concepts::ElementMatrix<F> >
    getSolution(const concepts::Space<G>& spc, const concepts::Vector<F>& sol,
        const concepts::ElementFunction<F, G>* fun = 0);
 
    template<class F, class G>
    concepts::RCP<concepts::ElementMatrix<typename concepts::Datatype<F>::type> >
    getFunction(const concepts::Space<G>& spc,
        const concepts::ElementFormula<F, G>& frm);
 
    template<class G>
    DenseMatrixCollection<G>
    getSpace(const concepts::Space<G>& spc);
 
    DenseMatrixCollection<Real>
    getMesh(concepts::Mesh& msh, const uint points = 5);
  };
 
  // Extract the solution (depends on function fun), corresponding to
  // the space and the solution vector and returns it.
  template<class F, class G>
  concepts::RCP<concepts::ElementMatrix<F> > DenseMatrixGraphics::getSolution(
      const concepts::Space<G>& spc, const concepts::Vector<F>& sol,
      const concepts::ElementFunction<F, G>* fun) {
 
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
 
    // output dimension for ex. n = 1 if fun = Value or n = 2 if fun = Grad
    int functionOutputDimension;
    if (fun)
      functionOutputDimension = fun->n();
    else
      {
        // We retrieve the default space dimension
        functionOutputDimension = spc.getOutputDimension();
        // We multiply by the components of the vector solution
        if(std::is_same<F, concepts::Real2d>::value || std::is_same<F, concepts::Cmplx2d>::value)
          functionOutputDimension *=2u;
        if(std::is_same<F, concepts::Real3d>::value || std::is_same<F, concepts::Cmplx3d>::value)
          functionOutputDimension *=3u;
      }
 
 
    // Calculate dimensions of the matrix
    MatrixCounterCell counter;
    postProcess(counter);
 
    // Build solution vector Matrix
    concepts::ElementMatrix<F>* functionValue = new concepts::ElementMatrix<F>(
        functionOutputDimension, counter.getDimensionsOfMatrices(0));
 
    //declare cell postprocessor that extract the graphical solution vector
    MatrixSolutionEvaluationCell<F, G> sec(functionValue, sol, fun, counter.getDim());
 
    //store data
    postProcess(sec);
 
    return concepts::RCP<concepts::ElementMatrix<F> >(functionValue);
  }
 
  template<class G>
  DenseMatrixCollection<G> DenseMatrixGraphics::getSpace(
      const concepts::Space<G>& spc) {
 
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
 
    // Calculate dimensions of the matrix
    MatrixCounterCell counter;
 
    postProcess(counter);
 
    DenseMatrixCollection<G> dmc(counter, true);
 
    // Write informations in the matrices
    MatrixSpaceOutputCell<G> mbdc(dmc, counter.getDim());
    postProcess(mbdc);
 
    return dmc;
  }
 
  // Extract the solution (depends on function fun), corresponding to
  // the space and the solution vector and returns it.
  template<class F, class G>
  concepts::RCP<concepts::ElementMatrix<typename concepts::Datatype<F>::type> > DenseMatrixGraphics::getFunction(
      const concepts::Space<G>& spc, const concepts::ElementFormula<F, G>& frm) {
 
    // Post processor (global)
    concepts::GlobalPostprocess<G> postProcess(spc);
 
    //output dimension for ex. n = 1 if fun = Value or n = 2 if fun = Grad
    int functionOutputDimension = Size<F>::n();
 
    //Calculate dimensions of the matrix
    MatrixCounterCell counter;
    postProcess(counter);
 
    //Build solution vector Matrix
    typedef typename concepts::Datatype<F>::type dataType;
    concepts::ElementMatrix<dataType>* functionValue =
        new concepts::ElementMatrix<dataType>(functionOutputDimension,
            counter.getDimensionsOfMatrices(0));
 
    // Write informations in the matrices
    MatrixBaseElementFormulaCell<F, G> bdc(functionValue, counter.getDim(), frm);
 
    //calculate size of the matrices / size of data
    postProcess(bdc);
 
    return concepts::makeRCP(functionValue);
  }
 
} // namespace graphics
 
#endif // densematrixgraphics_hh_