hp1D/element.hh

Go to the documentation of this file.

/* abstract base class for hp elements in 1D
 */

#ifndef Element1D_h
#define Element1D_h 

#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "geometry/connector.hh"
#include "geometry/cell1D.hh"
#include "geometry/integral.hh"
#include "space/element.hh"
#include "space/tmatrix.hh"
#include "integration/quadRule.hh"
#include "integration/karniadakis.hh"
#include "lineGraphics.hh"


namespace hp1D {
  using concepts::Real;

  // ********************************************************* IntegrableElm **

  class IntegrableElm : public concepts::IntegrationCell {
  public:
    IntegrableElm(const concepts::EdgeNd& cell);

    const concepts::Real3d chi(const Real x) const { return cell_.elemMap(x); }

    inline Real jacobianDeterminant(const Real x) const {
      // factor comes due to integration over [-1,1]^2
      return cell_.jacobianDeterminant(x) * 0.5; 
    }

    const concepts::QuadratureRule* integration() const { 
      return int_.get();
    }

    static concepts::QuadRuleFactory& rule() { return rule_; }

    virtual bool quadraturePoint(uint i, intPoint& p,
                                 intFormType form = ZERO,
                                 bool localCoord = false) const;
  protected:
    const concepts::EdgeNd& cell_;
    std::auto_ptr<concepts::QuadratureRule> int_;
    // Factory for the integration rule
    static concepts::QuadRuleFactory rule_;
  };

  // *************************************************************** Element **

  template<class F>
  class Element : public concepts::ElementWithCell<F>, public IntegrableElm {
  public:
    Element(const concepts::EdgeNd& cell, uint p,
            concepts::TColumn<F>* T0, concepts::TColumn<F>* T1);
    virtual ~Element();

    virtual const concepts::Edge& support() const {
      return cell_.connector(); }
    virtual concepts::Real3d vertex(uint i) const;
    virtual const concepts::EdgeNd& cell() const { return cell_; }

    virtual const concepts::TMatrix<F>& T() const { return T_; }
    void appendT(concepts::TColumn<F>* T) { T_.append(T); }

    ushort p() const { return p_; }

    void recomputeShapefunctions();

    const concepts::Karniadakis<1,0>* shpfct() const { return shpfct_.get(); }
    const concepts::Karniadakis<1,1>* shpfctD() const {
      return shpfctD_.get(); }

    virtual const concepts::ElementGraphics<Real>* graphics() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;

    concepts::TMatrix<Real> T_;
  private:
    std::auto_ptr<concepts::Karniadakis<1,0> > shpfct_;
    std::auto_ptr<concepts::Karniadakis<1,1> > shpfctD_;

    ushort p_;
    static std::auto_ptr<LineGraphics> graphics_;
  };

} // namespace hp1D

namespace concepts {

  // ****************************************************************** Scan **


  template<class F>
  class Scan<hp1D::Element<F> > : public Scan<ElementWithCell<F> > {
  public:  
    hp1D::Element<F>& operator++(int) = 0;
  };

} // namespace concepts


#endif // Element1D_h