bilinearForm.hh

Go to the documentation of this file.

 
#ifndef bilinearform1D_hh
#define bilinearform1D_hh
 
#include "basics/typedefs.hh"
#include "basics/vectorsMatricesForward.hh"
#include "operator/bilinearForm.hh"
#include "formula.hh"
 
namespace concepts {
  // forward declarations
  template<class F>
  class Element;
 
  template<class F>
  class ElementMatrix;
 
  template<class F>
  class Array;
}
 
namespace hp1D {
 
  using concepts::Real;
 
  // *************************************************************** Laplace **
 
  template<class F = Real>
  class Laplace : public concepts::BilinearForm<F,Real>,
                  public BilinearFormHelper<1,1,F> {
  public:
    Laplace(const concepts::ElementFormulaContainer<F> 
            frm = concepts::ElementFormulaContainer<F>()) 
      : BilinearFormHelper<1,1,F>(frm)
    { }
    virtual ~Laplace();
 
    void operator()(const concepts::Element<Real>& elmX,
                    const concepts::Element<Real>& elmY, 
                    concepts::ElementMatrix<F>& em) const;
    virtual Laplace<F>* clone() const { return new Laplace<F>(this->frm_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ************************************************************** Identity **
 
  template<class F = Real>
  class Identity : public concepts::BilinearForm<F,Real>,
                   public BilinearFormHelper<0,0,F> {
  public:
    Identity(const concepts::ElementFormulaContainer<F> 
             frm = concepts::ElementFormulaContainer<F>());
    virtual ~Identity();
 
    void operator()(const concepts::Element<Real>& elmX,
                    const concepts::Element<Real>& elmY, 
                    concepts::ElementMatrix<F>& em) const;
    virtual Identity<F>* clone() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
  };
 
  // ****************************************************** IdentityParallel **
 
  template<class F = Real>
  class IdentityParallel : public concepts::BilinearForm<F,Real>,
                           public BilinearFormHelper<0,0,F> {
  public:
    IdentityParallel(const concepts::ElementFormulaContainer<F> 
                     frm = concepts::ElementFormulaContainer<F>(),
                     const concepts::Real3d
                     shiftX = concepts::Real3d(),
                     const concepts::Real3d
                     shiftY = concepts::Real3d(),
                     const bool negShift = false
                    );
    virtual ~IdentityParallel();
 
    void operator()(const concepts::Element<Real>& elmX,
                    const concepts::Element<Real>& elmY, 
                    concepts::ElementMatrix<F>& em) const;
    virtual IdentityParallel<F>* clone() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const concepts::Point<Real,3> shiftX_;
    const concepts::Point<Real,3> shiftY_;
    const bool negShift_;
  };
  
 
  // *************************************************************** Bi-Laplace **
 
   template<class F = Real>
   class BiLaplace: public concepts::BilinearForm<F, Real>,
       public BilinearFormHelper<2, 2, F> {
   public:
     BiLaplace(const concepts::ElementFormulaContainer<F> frm =
         concepts::ElementFormulaContainer<F>()) :
         BilinearFormHelper<2, 2, F>(frm) {
     }
 
     virtual ~BiLaplace();
 
     void operator()(const concepts::Element<Real>& elmX,
         const concepts::Element<Real>& elmY, concepts::ElementMatrix<F>& em) const;
 
     virtual BiLaplace<F>* clone() const {
       return new BiLaplace<F>(this->frm_);
     }
 
   protected:
     virtual std::ostream& info(std::ostream& os) const;
   };
 
   // *************************************************************** Bi-Laplace **
 
   template<class F = Real>
   class Jump1Jump1: public concepts::BilinearForm<F, Real>,
       public BilinearFormVtxHelper<F> {
   public:
 
     Jump1Jump1(const concepts::ElementFormulaContainer<F> frm =
         concepts::ElementFormulaContainer<F>()) :
         BilinearFormVtxHelper<F>(frm) {
     }
 
     virtual ~Jump1Jump1();
 
     void operator()(const concepts::Element<Real>& elmX,
         const concepts::Element<Real>& elmY, concepts::ElementMatrix<F>& em) const;
 
     virtual Jump1Jump1<F>* clone() const {
       return new Jump1Jump1<F>(this->frm_);
     }
 
   protected:
     virtual std::ostream& info(std::ostream& os) const;
 
   };
 
   // *************************************************************** Bi-Laplace **
 
   template<class F = Real>
   class Mean2Jump1: public concepts::BilinearForm<F, Real>,
       public BilinearFormVtxHelper<F> {
   public:
 
     Mean2Jump1(const concepts::ElementFormulaContainer<F> frm =
         concepts::ElementFormulaContainer<F>()) :
         BilinearFormVtxHelper<F>(frm) {
     }
 
     virtual ~Mean2Jump1();
 
     void operator()(const concepts::Element<Real>& elmX,
         const concepts::Element<Real>& elmY, concepts::ElementMatrix<F>& em) const;
 
     virtual Mean2Jump1<F>* clone() const {
       return new Mean2Jump1<F>(this->frm_);
     }
 
   protected:
     virtual std::ostream& info(std::ostream& os) const;
 
     const concepts::ElementFormulaContainer<F> frm_;
   };
 
} // namespace hp1D
 
#endif // bilinearform1D_hh