graphics/matrixBasis.hh

Go to the documentation of this file.

/* Basis classes for graphical output over dense matrices
 */

#ifndef MATRIX_BASE_HH
#define MATRIX_BASE_HH

#include "basics.hh"
#include "toolbox.hh"
#include "geometry.hh"
#include "hp2D.hh"
#include "function.hh"
#include "operator.hh"
#include "space.hh"
//some typedefs
#include "basis.hh"

namespace graphics {

  // ************************************************** MatrixBaseOutputCell **

  template<class G = Real>
  class MatrixBaseOutputCell: public concepts::CellPostprocess<G> {
  public:
    MatrixBaseOutputCell(
        std::map<std::string, concepts::DenseMatrix<G>*>& dense_ptr,
        const enum concepts::ElementGraphicsBase::graphicsType type =
            concepts::ElementGraphicsBase::DENSEMATRIX, uint dim = 2) :
      dim_(dim), dense_ptr_(dense_ptr), type_(type) {
      resetCounter();
      counted = false;
    }

    virtual ~MatrixBaseOutputCell() {
    }

    virtual void operator()(const concepts::Element<G>& elm) = 0;

    virtual void operator()(const concepts::Cell& cell) = 0;

    inline std::map<std::string, concepts::DenseMatrix<G>*>& getMapping() {
      return dense_ptr_;
    }

    inline uint dim() const {
      return dim_;
    }

    uint indexOfPoints;

    uint indexOfMesh;

    uint indexOfEdgeMesh;

    uint indexOfVertexMesh;

    uint indexOfAttributes;

    uint indexOfEdgAttr;

    uint indexOfVtxAttr;

    uint indexOfPolynomialDegree;

    uint counter;

    uint dimensionsOfMatrices[4];

    bool counted;

    /*
     * Resets all counter (but not the boolean counted)
     */
    inline void resetCounter() {
      indexOfPoints = 0;
      indexOfMesh = 0;
      indexOfEdgeMesh = 0;
      indexOfEdgAttr = 0;
      indexOfVertexMesh = 0;
      indexOfAttributes = 0;
      indexOfVtxAttr = 0;
      indexOfPolynomialDegree = 0;
      counter = 0;
      for (uint i = 0; i < 4; ++i)
        dimensionsOfMatrices[i] = 0;
    }
  protected:
    uint dim_;

    std::map<std::string, concepts::DenseMatrix<G>*>& dense_ptr_;

    const enum concepts::ElementGraphicsBase::graphicsType type_;

  };

  // **************************************************** MatrixBaseDataCell **

  template<class F, class G = typename concepts::Realtype<F>::type>
  class MatrixBaseDataCell: public MatrixBaseOutputCell<G> {
  public:
    MatrixBaseDataCell(
        std::map<std::string, concepts::DenseMatrix<G>*>& dense_ptr,
        concepts::DenseMatrix<F>*& funValue,
        const concepts::Vector<F>& solution, const concepts::ElementFunction<F,
            G>* fun = 0, uint dim = 2) :
      MatrixBaseOutputCell<G> (dense_ptr,
          concepts::ElementGraphicsBase::DENSEMATRIX, dim), fun_(fun),
          funValue_(funValue), sol_(solution) {
    }

    virtual ~MatrixBaseDataCell() {
    }

    inline virtual void operator()(const concepts::Element<G>& elm) {
      elm.T().extract(sol_, coeff_);
      elm.graphics()->operator()(elm, this->type_, *this);
    }

    virtual void operator()(const concepts::Cell& cell) {
      throw conceptsException(concepts::MissingFeature("cell not supported"));
    }

    inline const concepts::ElementFunction<F, G>* elementFunction() {
      if (fun_)
        return fun_;
      else
        return 0;
    }

    inline uint n() {
      if (!fun_)
        return 1;
      return fun_->n();
    }

    virtual concepts::DenseMatrix<F>* funValue() const {
      return funValue_;
    }

    inline const concepts::Array<F>& coeff() const {
      return coeff_;
    }

  private:


    const concepts::ElementFunction<F, G>* fun_;

    concepts::Array<F> coeff_;

    concepts::DenseMatrix<F>*& funValue_;

    const concepts::Vector<F>& sol_;
  };

  // ****************************************** MatrixBaseElementFormulaCell **

  template<class F, class G = typename concepts::Realtype<F>::type>
  class MatrixBaseElementFormulaCell: public MatrixBaseOutputCell<G> {
  public:
    MatrixBaseElementFormulaCell(std::map<std::string,
        concepts::DenseMatrix<G>*>& dense_ptr,
        concepts::DenseMatrix<F>*& funValue, const uint dim,
        const concepts::ElementFormula<F, G>& fun) :
      MatrixBaseOutputCell<G> (dense_ptr,
          concepts::ElementGraphicsBase::DENSEMATRIX, dim),
          funValue_(funValue), fun_(fun) {
    }

    virtual ~MatrixBaseElementFormulaCell() {
    }

    virtual void operator()(const concepts::Element<G>& elm) {
      elm.graphics()->operator()(elm, this->type_, *this);
    }

    virtual void operator()(const concepts::Cell& cell)
        throw (concepts::MissingFeature) {
      throw conceptsException(concepts::MissingFeature("cell not supported"));
    }

    const concepts::ElementFormula<F, G>& elementFormula() {
      return fun_;
    }

    virtual uint n() const {
      return Size<F>::n();
    }

    virtual concepts::DenseMatrix<F>* funValue() const {
      return funValue_;
    }
  protected:

    concepts::DenseMatrix<F>*& funValue_;

    const concepts::ElementFormula<F, G>& fun_;
  };

  template<class F, class G = typename concepts::Realtype<F>::type>
  class MatrixSolutionEvaluationCell: public MatrixBaseOutputCell<G> {
  public:
    MatrixSolutionEvaluationCell(std::map<std::string,
        concepts::DenseMatrix<G>*>& dense_ptr,
        concepts::DenseMatrix<F>* funValue,
        const concepts::Vector<F>* solution, const concepts::ElementFunction<F,
            G>* fun = 0, uint dim = 2) :
      MatrixBaseOutputCell<G> (dense_ptr,
          concepts::ElementGraphicsBase::DENSEMATRIX, dim), fun_(fun),
          funValue_(funValue), sol_(solution) {
      writeMesh = true;
    }

    virtual ~MatrixSolutionEvaluationCell() {
    }

    inline virtual void operator()(const concepts::Element<G>& elm) {
      elm.T().extract(*sol_, coeff_);
      elm.graphics()->operator()(elm, this->type_, *this);
    }

    virtual void operator()(const concepts::Cell& cell) {
      throw conceptsException(concepts::MissingFeature("cell not supported"));
    }

    inline const concepts::ElementFunction<F, G>* elementFunction() {
      if (fun_)
        return fun_;
      else
        return 0;
    }



    inline uint n() {
      if (!fun_)
        return 1;
      return fun_->n();
    }

    virtual concepts::DenseMatrix<F>* funValue() const {
      return funValue_;
    }

    virtual void setSolVec(const concepts::Vector<F>* newsol) {
      sol_ = newsol;
    }
    virtual void setFunValue(concepts::DenseMatrix<F>* newFunVal) {
      funValue_ = newFunVal;
    }

    inline const concepts::Array<F>& coeff() const {
      return coeff_;
    }

    bool writeMesh;

  private:

    const concepts::ElementFunction<F, G>* fun_;

    concepts::Array<F> coeff_;

    concepts::DenseMatrix<F>* funValue_;

    const concepts::Vector<F>* sol_;
  };

  // **************************************************** MatrixBaseMeshCell **

  class MatrixBaseMeshCell: public MatrixBaseOutputCell<concepts::Real> {
  public:
    //TODO DOKU
    MatrixBaseMeshCell(std::map<std::string, concepts::DenseMatrix<
        concepts::Real>*>& dense_ptr, const uint dim = 2,
        const uint points = 5,
        const enum concepts::ElementGraphicsBase::graphicsType type =
            concepts::ElementGraphicsBase::MESH_DENSEMATRIX) :
      graphics::MatrixBaseOutputCell<concepts::Real>(dense_ptr, type, dim),
          points_(2, points) {
    }

    virtual ~MatrixBaseMeshCell() {
    }

    virtual void operator()(const concepts::Element<Real>& elm) {

      elm.graphics()->operator()(elm, this->type_, *this);
    }

    virtual void operator()(const concepts::Cell& cell);

  private:

    const concepts::Array<uint> points_;
  };

} //namespace graphics

#endif //MATRIX_BASE_HH