bf_identity.hh

Go to the documentation of this file.

 
#ifndef hp2Dedge_bf_identity_hh
#define hp2Dedge_bf_identity_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;
 
  // ************************************************************** IdentityBase **
 
  template<class F = Real, class G = typename concepts::Realtype<F>::type>
  class IdentityBase : public hp2D::BilinearFormHelper_1_1<F, G>
  {
  public:
    typedef typename concepts::Combtype<F, G>::type value_type;
 
    IdentityBase(const concepts::ElementFormulaContainer<F> frm, bool all =
        false);
 
    IdentityBase(
        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) const;
  };
 
  // ************************************************************** Identity **
 
  template<typename F = Real>
  class Identity : public concepts::BilinearForm<F>, public IdentityBase<F>
  {
  public:
    Identity(const concepts::ElementFormulaContainer<F> frm =
        concepts::ElementFormulaContainer<F>());
    virtual ~Identity()
    {
    }
    virtual Identity<F>*
    clone() const
    {
      return new Identity<F>(this->frm_);
    }
    void
    operator()(const concepts::Element<Real>& elmX,
               const concepts::Element<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
    void
    operator()(const Quad<Real>& elmX, const Quad<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ************************************************************** IdentityMatrix **
 
  template<typename F = Real>
  class IdentityMatrix : public concepts::BilinearForm<F>,
                         public IdentityBase<Real, F>
  {
  public:
 
    typedef typename concepts::ElementFormulaContainer<concepts::Mapping<F, 2> > FrmE_Matrix;
 
    IdentityMatrix(const FrmE_Matrix frm = FrmE_Matrix());
    virtual ~IdentityMatrix()
    {
    }
    virtual IdentityMatrix<F>*
    clone() const
    {
      return new IdentityMatrix<F>(this->frmM_);
    }
    virtual void
    operator()(const concepts::Element<Real>& elmX,
               const concepts::Element<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
    virtual void
    operator()(const Quad<Real>& elmX, const Quad<Real>& elmY,
               concepts::ElementMatrix<F>& em) const;
  protected:
    virtual std::ostream&
    info(std::ostream& os) const;
  };
 
} // namespace hp2Dedge
 
#endif // hp2Dedge_bf_identity