hp2D/hpAdaptiveSpaceH1.hh

Go to the documentation of this file.

#ifndef hpAdaptSpace2DH1_hh
#define hpAdaptSpace2DH1_hh

#include "basics/typedefs.hh"
#include "toolbox/inputOutput.hh"
#include "hp2D/hpAdaptiveSpace.hh"
#include "hp2D/buildH1TColumns.hh"

namespace concepts {

  // forward declarations
  template<class F>
    class SMatrixBase;

  class SMatrix1D;
}

namespace hp2D {

  using concepts::Real;

  // forward declarations
  template<class F>
    class Quad;

  class hpAdaptiveSpaceH1;

  // ******************************************** hpAdaptiveSpaceH1FromInput **

   hpAdaptiveSpaceH1*
   hpAdaptiveSpaceH1FromInput(concepts::Mesh2& msh,
                              const concepts::InOutParameters input,
                              bool verbose = false);

  // ***************************************************** hpAdaptiveSpaceH1 **

  class hpAdaptiveSpaceH1 : public hpAdaptiveSpace<Real> {
    public:
      typedef concepts::Scan<hp2D::Element<Real> > Scan;

      hpAdaptiveSpaceH1(concepts::Mesh2& msh, uint l, uint p,
                        concepts::BoundaryConditions* bc = 0,
                        concepts::CellConditions* cc = 0);

      hpAdaptiveSpaceH1(hpFull& prebuild, 
                        concepts::BoundaryConditions* bc = 0,
                        concepts::CellConditions* cc = 0 , uint spcNo = 0,
                        uint* offset = 0, uint* idx = 0);

      hpAdaptiveSpaceH1(const hpAdaptiveSpaceH1& spc);
      virtual ~hpAdaptiveSpaceH1();

      void buildVertexDofs(const BuildTColumnsBase<Real>* b) {
        setBuildVertexDofs_(b);
      }
      void buildEdgeDofs(const BuildTColumnsBase<Real>* b) {
        setBuildEdgeDofs_(b);
      }
      void buildInnerDofs(const BuildTColumnsBase<Real>* b) {
        setBuildInnerDofs_(b);
      }

      virtual void recomputeShapefunctions();
    protected:
      virtual std::ostream& info(std::ostream& os) const;

      virtual Element<Real>* newElement_(concepts::Cell2& cell, ushort* pMax,
          concepts::TColumn<Real>* T0,
          concepts::TColumn<Real>* T1) const;

      virtual concepts::TColumn<Real>*
        applySmatrices_(const concepts::Element<Real>& elm, uint i,
            const concepts::TColumn<Real>* T0,
            const concepts::TColumn<Real>* T1);
    private:
      void recomputeSmatrices_(const Quad<Real>& elm);

      std::auto_ptr<concepts::SMatrix1D> S1left_, S1right_;

      std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2H_[2];

      std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2V_[2];

      std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices4_[4];

  };

} // namespace hp2D

#endif // hpAdaptSpace2DH1_hh