hp2D/bf_laplace.hh

Go to the documentation of this file.

/* @bf_laplace.hh Bilinear forms for Laplace operator for hp 2D FEM
 */

#ifndef hp2dbf_laplace_hh
#define hp2dbf_laplace_hh

#include <memory>
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "toolbox/sharedPointer.hh"
#include "geometry/sharedJacobian.hh"
#include "operator/bilinearForm.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 vectorial {
  // forward declarations
  template<class F, class G>
  class BilinearForm;
}

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

  class InfiniteLaguerreQuad;

  using concepts::Real;


  // *********************************************************** LaplaceBase **

  template<class F = Real, class G = typename concepts::Realtype<F>::type>
  class LaplaceBase : public BilinearFormHelper_1_1<F,G> {
  public:
    typedef typename concepts::Combtype<F,G>::type value_type;

    LaplaceBase(const concepts::ElementFormulaContainer<F> frm, bool all = false);

    LaplaceBase(const concepts::ElementFormulaContainer<concepts::Mapping<G,2> > frm
                , bool all = false);
  protected:
    bool all_;
    
    bool assemble_(const Quad<Real>* elmX, const Quad<Real>* elmY, 
                   concepts::ElementMatrix<value_type>& em);
  };


  // *************************************************************** Laplace **

  template<class F = Real>
  class Laplace : public concepts::BilinearForm<F>,
                  public LaplaceBase<F> {
  public:
    Laplace(const concepts::ElementFormulaContainer<F> 
            frm = concepts::ElementFormulaContainer<F>()
            , bool all = false);

    virtual ~Laplace();
    virtual Laplace<F>* clone() const;
    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_;
    
    concepts::ElementMatrix<Real> stiff1D_, mass1D_;

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

  // ********************************************************* LaplaceMatrix **

  template<class F = Real>
  class LaplaceMatrix : public concepts::BilinearForm<F>,
                        public LaplaceBase<Real,F> {
  public:
    typedef typename concepts::ElementFormulaContainer<concepts::Mapping<F,2> >
    FrmE_Matrix;
    
    LaplaceMatrix(const FrmE_Matrix frm = FrmE_Matrix()
                  , bool all = false);
    virtual ~LaplaceMatrix();
    virtual LaplaceMatrix<F>* clone() const;
    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;
  };

  // *********************************************************** setupLaplace **

  template<class F>
  void setupLaplace
  (vectorial::BilinearForm<F, typename concepts::Realtype<F>::type>& bf,
   const concepts::ElementFormulaContainer<F,typename concepts::Realtype<F>::type> 
   frm = concepts::ElementFormulaContainer<F,typename concepts::Realtype<F>::type>());


} // namespace hp2D

#endif // hp2dbf_laplace_hh