linearForm.hh

Go to the documentation of this file.

 
#ifndef hp2dlinearform_hh
#define hp2dlinearform_hh
 
#include <memory>
#include "basics/typedefs.hh"
#include "function/linearForm.hh"
#include "linearFormHelper.hh"
#include "arrayElementFormula.hh"
 
namespace concepts {
  // forward declarations
  template<class F>
  class Formula;
 
  template<class F, uint dim>
  class Point;
 
  class BoundaryConditions;
 
  template<class F>
  class Element;
 
  template<class F>
  class ElementMatrix;
 
  template<class F>
  class Array;
}
 
namespace vectorial {
 
  template<class F, class G>
  class LinearForm;
}
 
namespace hp2D {
  // forward declarations
  template<class F>
  class Quad;
 
  using concepts::Real;
 
 
  // ***************************************************************** Riesz **
 
  template<class F = Real>
  class Riesz : public concepts::LinearForm<F>,
                public LinearFormHelper_0<F>,
                public concepts::LinearFormChoice {
  public:
    Riesz(const concepts::ElementFormulaContainer<F> frm,
          concepts::BoundaryConditions* bc = 0,
          bool ignoreMissingElem = false);
 
    Riesz(const std::string& str,
          concepts::BoundaryConditions* bc = 0,
          bool ignoreMissingElem = false);
 
    virtual ~Riesz();
 
    void operator()(const concepts::Element<Real>& elm,
                    concepts::ElementMatrix<F>& em) const;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    mutable concepts::Array<Real> jacobian_;
 
    void operator()(const Quad<Real>& elm, concepts::ElementMatrix<F>& em) const;
 
    concepts::BoundaryConditions* bc_;
    bool ignoreMissingElem;
  };
 
  // ************************************************************ setupRiesz **
 
  template<class F>
  void setupRiesz
  (vectorial::LinearForm<F,typename concepts::Realtype<F>::type>& lf,
   const concepts::ElementFormulaContainer<concepts::Point<F,2> > frm);
 
 
  // ******************************************************** GradLinearForm **
 
  template<class F = concepts::Real>
  class GradLinearForm : public concepts::LinearForm<F>,
                         public LinearFormHelper_1<F>,
                         public concepts::LinearFormChoice {
  public:
    GradLinearForm(const concepts::ElementFormulaContainer<F> frm1,
                   const concepts::ElementFormulaContainer<F> frm2,
                   bool ignoreMissingElem = false);
    GradLinearForm
    (const concepts::ElementFormulaContainer<concepts::Point<F, 2> > frm,
     bool ignoreMissingElem = false);
 
    virtual void operator()(const concepts::Element<Real>& elm,
                            concepts::ElementMatrix<F>& em) const;
 
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual void operator()(const Quad<Real>& elm,
                            concepts::ElementMatrix<F>& em) const;
 
    bool ignoreMissingElem_;
  };
 
  // *************************************************** setupGradLinearForm **
 
  template<class F>
  void setupGradLinearForm
  (vectorial::LinearForm<F,typename concepts::Realtype<F>::type>& lf,
   const concepts::ElementFormulaContainer<concepts::Point<F,2> > frm1,
   const concepts::ElementFormulaContainer<concepts::Point<F,2> > frm2);
 
  // ****************************************************** PlCurlLinearForm **
 
  template<class F>
  class PlCurlLinearForm : public GradLinearForm<F> {
  public:
    PlCurlLinearForm(const concepts::ElementFormulaContainer<F> frm1,
                     const concepts::ElementFormulaContainer<F> frm2);
    PlCurlLinearForm
    (const concepts::ElementFormulaContainer<concepts::Point<F,2> > frm);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  namespace l2 {
 
    // *************************************************************** Riesz **
 
    template<class F = Real>
    class Riesz : public concepts::LinearForm<F>,
                  public LinearFormHelper_2<F> {
    public:
      Riesz(const concepts::ElementFormulaContainer<F> frm,
            bool ignoreMissingElem = false);
      virtual ~Riesz();
 
      void operator()(const concepts::Element<Real>& elm,
                      concepts::ElementMatrix<F>& em) const;
 
    protected:
      virtual std::ostream& info(std::ostream& os) const;
    private:
      void operator()(const Quad<Real>& elm, concepts::ElementMatrix<F>& em) const;
 
      bool ignoreMissingElem;
    };
 
  } // namespace hp2D::l2
 
} // namespace hp2D
 
#endif // hp2dlinearform_hh