bilinearForm.hh

Go to the documentation of this file.

 
#ifndef hp3dbilinearform_hh
#define hp3dbilinearform_hh
 
#include <memory>
#include "basics/typedefs.hh"
#include "basics/vectorsMatricesForward.hh"
#include "formula/formula.hh"
#include "formula/elementFormulaContainer.hh"
#include "operator/bilinearForm.hh"
#include "linearFormHelper.hh"
 
 
namespace concepts {
  // forward declarations
  template<class F>
  class Element;
 
  template<class F>
  class ElementMatrix;
 
  template<class F>
  class Array;
 
  class InOutParameters;
}
 
namespace vectorial {
  //forward declaration
  template<class F, class G>
  class BilinearForm;
}
 
namespace hp3D {
  // forward declarations
  class Hexahedron;
 
  using concepts::Real;
 
  // *************************************************************** Laplace **
 
  template <class F = Real>
  class Laplace : public concepts::BilinearForm<F> {
  public:
    Laplace();
    virtual ~Laplace();
 
    virtual void operator()(const concepts::Element<Real>& elmX,
          const concepts::Element<Real>& elmY, 
          concepts::ElementMatrix<F>& em) const;
    void operator()(const Hexahedron& elmX, const Hexahedron& elmY, 
        concepts::ElementMatrix<F>& em) const;
    virtual Laplace<F>* clone() const { return new Laplace(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    mutable concepts::Array<F> jacobian_;
    mutable concepts::Array<concepts::MapReal3d> jacobianInv_;
 
    mutable const Hexahedron* oldElm_;
  };
 
  // ************************************************************** Identity **
 
  template <class F = Real>
  class Identity : public concepts::BilinearForm<F> {
  public:
    Identity( const concepts::ElementFormulaContainer<F> 
              frm = concepts::ElementFormulaContainer<F>());
    virtual ~Identity();
 
    virtual void operator()(const concepts::Element<Real>& elmX,
          const concepts::Element<Real>& elmY, 
          concepts::ElementMatrix<F>& em) const;
    void operator()(const Hexahedron& elmX, const Hexahedron& elmY, 
        concepts::ElementMatrix<F>& em) const;
 
    static void setTimings(concepts::InOutParameters* timings);
    static bool timings();
    virtual Identity* clone() const { return new Identity(frm_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    mutable concepts::Array<F> jacobian_;
 
    mutable const Hexahedron* oldElm_;
 
    concepts::ElementFormulaContainer<F> frm_;    
 
    static concepts::InOutParameters* timings_;
    static uint timeCntr_;
  };
  
  // *********************************************************** setupIdentity **
 
  template<class F>
  void setupIdentity
  (vectorial::BilinearForm<F,typename concepts::Realtype<F>::type>& bf);
 
  template<class F>
  void setupIdentity
  (vectorial::BilinearForm<F,typename concepts::Realtype<F>::type>& bf,
   const concepts::ElementFormulaContainer<concepts::Mapping<F,3> > frm,
   bool transposed = false);
 
  // ************************************************************* Advection **
 
  template<class F = Real>
  class Advection : public concepts::BilinearForm<F,Real>,
                    public hp3D::LinearFormHelper_1<F> 
  {
  public:
    Advection(const concepts::ElementFormulaContainer<F> frm1,
              const concepts::ElementFormulaContainer<F> frm2,
              const concepts::ElementFormulaContainer<F> frm3,
              bool all = false) 
      : hp3D::LinearFormHelper_1<F>(frm1, frm2, frm3), all_(all) 
    {}
 
    Advection
    (const concepts::ElementFormulaContainer<concepts::Point<F, 3> > frm,
     bool all = false) 
      : hp3D::LinearFormHelper_1<F>(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) const;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    bool all_;
 
    bool operator()(const Hexahedron* elmX, 
                    const Hexahedron* elmY, 
                    concepts::ElementMatrix<F>& em) const;
  };
 
  // ********************************************************** setupAdvection **
 
  template<class F>
  void setupAdvection
  (vectorial::BilinearForm<F,typename concepts::Realtype<F>::type>& bf,
   const concepts::ElementFormulaContainer<concepts::Point<F,3> > frm);
  
} // namespace hp3D
 
#endif // hp3dbilinearform_hh