hp2D/bf_advection.hh

Go to the documentation of this file.

#ifndef hp2dbf_advection_hh
#define hp2dbf_advection_hh

#include <memory>
#include "operator/bilinearForm.hh"
#include "basics/typedefs.hh"
#include "geometry/sharedJacobian.hh"
#include "hp2D/bilinearFormHelper.hh"
#include "arrayElementFormula.hh"


namespace concepts {
  // forward declarations
  template<class F>
  class Array;

  template<class F, int dim>
  class Point;

  template<class F>
  class Element;

  template<class F>
  class ElementMatrix;

  template<typename F, typename G>
  class ElementFormula;
}

namespace hp2D {
  // forward declarations
  template<class F>
  class Quad;

  class InfiniteLaguerreQuad;

  using concepts::Real;


  // ************************************************************* Advection **

  template<class F = Real>
  class Advection : public concepts::BilinearForm<F,Real>,
                    public hp2D::BilinearFormHelper_0_1<F> 
  {
  public:
    Advection(const concepts::ElementFormulaContainer<F> frm1,
              const concepts::ElementFormulaContainer<F> frm2, bool all=false) 
      : hp2D::BilinearFormHelper_0_1<F>(frm1, frm2)
      , all(all) 
    {}

    Advection(const concepts::ElementFormulaContainer<concepts::Point<F, 2> > frm
              , bool all=false) 
      : hp2D::BilinearFormHelper_0_1<F>(frm)
      , all(all) 
    {}

//     Advection(const concepts::ElementFormula<concepts::Point<F,2> >& frm
//               , bool all=false) 
//       : hp2D::BilinearFormHelper_0_1<F>(concepts::makeRCP_weak(&frm))
//       , all(all) 
//     {}

    virtual ~Advection() {}

    virtual Advection<F>* clone() const { 
      return new Advection<F>(this->frm_, all);
    }

    virtual void operator()(const concepts::Element<Real>& elmX,
                            const concepts::Element<Real>& elmY, 
                            concepts::ElementMatrix<F>& em); 

  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    bool all;

    bool operator()(const Quad<Real>* elmX, 
                    const Quad<Real>* elmY, 
                    concepts::ElementMatrix<F>& em);
    bool operator()(const InfiniteLaguerreQuad* elmX,
                    const InfiniteLaguerreQuad* elmY, 
                    concepts::ElementMatrix<F>& em);
  };


} // namespace hp2D

#endif // hp2dbf_advection_hh