bf_graduv.hh

Go to the documentation of this file.

 
#ifndef HP2DEDGE_BF_GRADUV_HH_
#define HP2DEDGE_BF_GRADUV_HH_
 
#include <memory>
#include "operator/bilinearForm.hh"
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.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 "toolbox/sharedPointer.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;
 
// ************************************************************** GraduvBase **
 
  template<class F = Real, class G = typename concepts::Realtype<F>::type>
  class GraduvBase : public hp2D::BilinearFormHelper_1_1<F, G>
  {
  public:
    typedef typename concepts::Combtype<F, G>::type value_type;
 
    GraduvBase(const concepts::ElementFormulaContainer<F> frm,
               bool all = false);
 
    GraduvBase(
        const concepts::ElementFormulaContainer<concepts::Mapping<G, 2> > frm,
        bool all = false);
  protected:
    bool all_;
 
    bool
    assemble_(const hp2D::Quad<Real>* elmX, const Quad<Real>* elmY,
              concepts::ElementMatrix<value_type>& em) const;
 
  private:
    mutable concepts::Array<F> factor_;
    mutable concepts::Array<concepts::Mapping<F, 2> > jacobianInv_;
  };
 
// *************************************************************** Graduv **
 
  template<class F = Real>
  class Graduv : public concepts::BilinearForm<F>,
                 public hp2Dedge::GraduvBase<F>
  {
  public:
    Graduv(const concepts::ElementFormulaContainer<F> frm =
           concepts::ElementFormulaContainer<F>());
    virtual ~Graduv()
    {
    }
    void
    operator()(const concepts::Element<Real>& elmX,
               const concepts::Element<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
    void
    operator()(const hp2D::Quad<Real>& elmX, const Quad<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
    virtual Graduv<F>*
    clone() const
    {
      return new Graduv(this->frm_);
    }
  protected:
    virtual std::ostream&
    info(std::ostream& os) const;
  };
 
// *************************************************************** GraduvMatrix **
 
  template<class F = Real>
  class GraduvMatrix : public concepts::BilinearForm<F>,
                       public hp2Dedge::GraduvBase<Real, F>
  {
  public:
 
    typedef typename concepts::ElementFormulaContainer<concepts::Mapping<F, 2> > FrmE_Matrix;
 
    GraduvMatrix(const FrmE_Matrix frm = FrmE_Matrix());
    virtual ~GraduvMatrix()
    {
    }
    void
    operator()(const concepts::Element<Real>& elmX,
               const concepts::Element<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
    void
    operator()(const hp2D::Quad<Real>& elmX, const Quad<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
    virtual GraduvMatrix<F>*
    clone() const
    {
      return new GraduvMatrix(this->frmM_);
    }
  protected:
    virtual std::ostream&
    info(std::ostream& os) const;
  };
 
} // namespace hp2Dedge
 
#endif /* HP2DEDGE_BF_GRADUV_HH_ */