bilinearForm.hh

Go to the documentation of this file.

 
#ifndef hp2dEdgeBilinearform_hh
#define hp2dEdgeBilinearform_hh
 
#include <memory>
#include "operator/bilinearForm.hh"
#include "basics/typedefs.hh"
#include "basics/vectorsMatricesForward.hh"
#include "formula/elementFormula.hh"
#include "formula/boundary.hh"
#include "geometry/sharedJacobian.hh"
#include "hp2D/quad.hh"
#include "hp2D/formula.hh"
#include "hp2D/bilinearFormHelper.hh"
#include "hp2D/arrayElementFormula.hh"
 
#include "hp2Dedge/bf_identity.hh"
#include "hp2Dedge/bf_graduv.hh"
#include "hp2Dedge/bf_advection.hh"
 
namespace concepts {
  // forward declarations
  template<class F>
  class Element;
 
  template<class F>
  class ElementMatrix;
 
  template<class F>
  class Array;
 
  template<class F>
  class RCP;
}
 
namespace hp2Dedge {
  // forward declarations
  template<class F>
  class Quad;
 
  template<class F>
  class Edge;
 
  using concepts::Real;
  using concepts::Cmplx;
 
  // ************************************************************** RotRot **
 
  template<typename F = Real>
  class RotRot : public concepts::BilinearForm<F>,
                 public hp2D::BilinearFormHelper_2_2<F> {
  public:
    RotRot(const concepts::ElementFormulaContainer<F>
           frm = concepts::ElementFormulaContainer<F>());
    virtual ~RotRot() {}
    virtual RotRot<F>* clone() const { return new RotRot<F>(this->frm_); }
    void operator()(const concepts::Element<Real>& elmX,
                    const concepts::Element<Real>& elmY, 
                    concepts::ElementMatrix<F>& em) const;
    void operator()(const Quad<Real>& elmX, const Quad<Real>& elmY,
                    concepts::ElementMatrix<F>& em) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // *************************************************************** Rotuv **
 
  class Rotuv : public concepts::BilinearForm<Real>, 
                public hp2D::BilinearFormHelper_2_2<Real> {
  public:
    Rotuv(const concepts::ElementFormulaContainer<Real> 
          frm = concepts::ElementFormulaContainer<Real>());
    virtual ~Rotuv() {}
    void operator()(const concepts::Element<Real>& elmX,
                    const concepts::Element<Real>& elmY, 
                    concepts::ElementMatrix<Real>& em) const;
    void operator()(const hp2D::Quad<Real>& elmX, const Quad<Real>& elmY,
                    concepts::ElementMatrix<Real>& em) const;
    void operator()(const hp2D::l2::Quad<Real>& elmX, const Quad<Real>& elmY,
                    concepts::ElementMatrix<Real>& em) const;
    virtual Rotuv* clone() const { return new Rotuv(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ********************************************************** EdgeIdentity **
 
  class EdgeIdentity : public concepts::BilinearForm<Real> {
  public:
    void operator()(const concepts::Element<Real>& elmX,
                    const concepts::Element<Real>& elmY, 
                    concepts::ElementMatrix<Real>& em) const;
    void operator()(const Edge<Real>& elmX, const Edge<Real>& elmY, 
                    concepts::ElementMatrix<Real>& em) const;
    virtual EdgeIdentity* clone() const { return new EdgeIdentity(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  }; 
 
} // namespace hp2Dedge
 
#endif // hp2dEdgeBilinearform_hh