matrixBasis.hh

Go to the documentation of this file.

 
#ifndef matrix_base_hh
#define matrix_base_hh
 
#include "basics.hh"
#include "toolbox.hh"
#include "geometry.hh"
#include "function.hh"
#include "operator.hh"
#include "space.hh"
#include "basis.hh"
 
namespace graphics {
 
  using concepts::Real;
 
  //forward declaration
  template<class G>
  class DenseMatrixCollection;
 
  // ****************************************************** MatrixCounterCell **
 
  class MatrixCounterCell: public concepts::CellPostprocess<Real> {
  public:
    MatrixCounterCell(const concepts::ElementGraphicsBase::graphicsType type =
        concepts::ElementGraphicsBase::DENSEMATRIX, const uint points = 5);
 
    virtual ~MatrixCounterCell();
 
    inline int getDimensionsOfMatrices(uint i) {
      return this->dimensionsOfMatrices[i];
    }
 
    inline int getDim() {
      return dim_;
    }
    ;
    inline void setDim(int dim) {
      dim_ = dim;
    }
    ;
 
    virtual void operator()(const concepts::Element<Real>& elm);
 
    virtual void operator()(const concepts::Cell& cell);
 
    uint dimensionsOfMatrices[5];
 
    std::map<std::string, uint> noRows;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
 
    int dim_;
 
    const enum concepts::ElementGraphicsBase::graphicsType type_;
 
    concepts::Array<uint> points_;
 
  };
 
  // ************************************************* MatrixBasisOutputCell **
 
  template<class G = Real>
  class MatrixBasisOutputCell: public concepts::CellPostprocess<G> {
  public:
 
    MatrixBasisOutputCell(
        const enum concepts::ElementGraphicsBase::graphicsType type =
            concepts::ElementGraphicsBase::DENSEMATRIX, uint dim = 2) :
        dim_(dim), type_(type) {
      resetCounter();
    }
 
    virtual ~MatrixBasisOutputCell() {
    }
 
    virtual void operator()(const concepts::Element<G>& elm) = 0;
 
    virtual void operator()(const concepts::Cell& cell) = 0;
 
    inline uint dim() const {
      return dim_;
    }
 
    inline virtual void resetCounter() {
      indexOfPoints = 0;
    }
 
    uint indexOfPoints;
 
  protected:
 
    uint dim_;
 
    const enum concepts::ElementGraphicsBase::graphicsType type_;
  };
 
  // ************************************************* MatrixSpaceOutputCell **
 
  template<class G = Real>
  class MatrixSpaceOutputCell: public MatrixBasisOutputCell<G> {
 
  public:
 
    MatrixSpaceOutputCell(DenseMatrixCollection<G> & dense_ptr, uint dim = 2,
        const enum concepts::ElementGraphicsBase::graphicsType type =
            concepts::ElementGraphicsBase::DENSEMATRIX) :
        MatrixBasisOutputCell<G>(type, dim), dense_ptr_(dense_ptr) {
      resetCounter();
    }
 
    virtual ~MatrixSpaceOutputCell() {
    }
 
    virtual void operator()(const concepts::Element<G>& elm) {
      elm.graphics()->operator()(elm, this->type_, *this);
    }
 
    virtual void operator()(const concepts::Cell& cell) {
      throw conceptsException(concepts::MissingFeature("cell not supported"));
    }
 
    uint indexOfMesh;
 
    uint indexOfFaceMesh;
 
    uint indexOfEdgeMesh;
 
    uint indexOfVertexMesh;
 
    uint indexOfAttributes;
 
    uint indexOfEdgAttr;
 
    uint indexOfFaceAttr;
 
    uint indexOfVtxAttr;
 
    uint indexOfPolynomialDegree;
 
    uint counter;
 
    inline virtual void resetCounter() {
      this->indexOfPoints = 0;
      indexOfMesh = 0;
      indexOfEdgeMesh = 0;
      indexOfEdgAttr = 0;
      indexOfVertexMesh = 0;
      indexOfAttributes = 0;
      indexOfVtxAttr = 0;
      indexOfPolynomialDegree = 0;
      indexOfFaceMesh = 0;
      counter = 0;
      indexOfFaceAttr = 0;
    }
 
    inline DenseMatrixCollection<G>& getMapping() {
      return dense_ptr_;
    }
 
  protected:
    DenseMatrixCollection<G>& dense_ptr_;
  };
 
  // ****************************************** MatrixBaseElementFormulaCell **
 
  template<class F, class G = typename concepts::Realtype<F>::type>
  class MatrixBaseElementFormulaCell: public MatrixBasisOutputCell<G> {
  public:
    typedef typename concepts::Datatype<F>::type dataType;
 
    MatrixBaseElementFormulaCell(concepts::ElementMatrix<dataType>*& funValue,
        const uint dim, const concepts::ElementFormula<F, G>& fun) :
        MatrixBasisOutputCell<G>(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 conceptsException(concepts::MissingFeature("cell not supported"));
    }
 
    const concepts::ElementFormula<F, G>& elementFormula() {
      return fun_;
    }
 
    virtual uint n() const {
      return Size<F>::n();
    }
 
    virtual concepts::ElementMatrix<dataType>* funValue() const {
      return funValue_;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      os << concepts::typeOf(*this)<<"(funValue = ";
      if (funValue_)
        os << *funValue_;
      else
        os << "0";
      return os << ", frm = " << fun_ << ")";
    }
 
    concepts::ElementMatrix<dataType>*& funValue_;
 
    const concepts::ElementFormula<F, G>& fun_;
  };
 
  // ****************************************** MatrixSolutionEvaluationCell **
 
  template<class F, class G = typename concepts::Realtype<F>::type>
  class MatrixSolutionEvaluationCell: public MatrixBasisOutputCell<G> {
  public:
 
    MatrixSolutionEvaluationCell(concepts::ElementMatrix<F>* funValue,
        const concepts::Vector<F>& solution,
        const concepts::ElementFunction<F, G>* fun = 0, uint dim = 2) :
        MatrixBasisOutputCell<G>(concepts::ElementGraphicsBase::DENSEMATRIX,
            dim), fun_(fun), funValue_(funValue), sol_(solution) {
    }
 
    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::ElementMatrix<F>* funValue() const {
      return funValue_;
    }
 
    inline const concepts::Array<F>& coeff() const {
      return coeff_;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      os << concepts::typeOf(*this)<<"(funValue = ";
      if (funValue_)
        os << *funValue_;
      else
        os << "0";
      os << ", fun = ";
      if (fun_)
              os << *fun_;
            else
              os << "0";
      return os << ")";
    }
  private:
    const concepts::ElementFunction<F, G>* fun_;
 
    concepts::Array<F> coeff_;
 
    concepts::ElementMatrix<F>* funValue_;
 
    const concepts::Vector<F>& sol_;
 
  };
 
  // **************************************************** MatrixBaseMeshCell **
 
  class MatrixBaseMeshCell: public MatrixSpaceOutputCell<Real> {
  public:
 
    MatrixBaseMeshCell(DenseMatrixCollection<Real>& dense_ptr, const uint dim =
        2, const uint points = 5,
        const enum concepts::ElementGraphicsBase::graphicsType type =
            concepts::ElementGraphicsBase::MESH_DENSEMATRIX) :
        MatrixSpaceOutputCell<Real>(dense_ptr, dim, type), points_(dim, points) {
    }
 
    virtual ~MatrixBaseMeshCell();
 
    virtual void operator()(const concepts::Element<Real>& elm);
 
    virtual void operator()(const concepts::Cell& cell);
 
  private:
    const concepts::Array<uint> points_;
  };
 
} //namespace graphics
 
#endif // matrix_base_hh