hp2D/bf_partialderiv.hh

Go to the documentation of this file.

#ifndef hp2dbf_partialderiv_hh
#define hp2dbf_partialderiv_hh

#include <memory>
#include "operator/bilinearForm.hh"
#include "basics/typedefs.hh"
#include "geometry/sharedJacobian.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;


  // ********************************************************* partDerivType **

  enum partDerivType { NO_DERIV = 0, X_DERIV = 1, Y_DERIV = 2};

  // ********************************************** BilinearFormOnePartDeriv **

  template<class F = Real>
  class BilinearFormOnePartDeriv : public concepts::BilinearForm<F>,
                                   public BilinearFormHelper_0_1_Part<F>
  {
  public:
    BilinearFormOnePartDeriv(const enum partDerivType i,
                             const concepts::ElementFormulaContainer<F> 
                             frm = concepts::ElementFormulaContainer<F>());

    virtual ~BilinearFormOnePartDeriv() {}

    virtual BilinearFormOnePartDeriv<F>* clone() const { 
      return new BilinearFormOnePartDeriv<F>(i_, this->frm_);
    }

    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:
    const enum partDerivType i_;

    concepts::ElementMatrix<Real> stiff1D_, mass1D_;

    bool operator()(const hp2D::Quad<Real>* elmX, 
                    const hp2D::Quad<Real>* elmY, 
                    concepts::ElementMatrix<F>& em);

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

  // ********************************************** BilinearFormTwoPartDeriv **

  template<class F = Real>
  class BilinearFormTwoPartDeriv : public concepts::BilinearForm<F>,
                                   public BilinearFormHelper_1_1<F>
  {
  public:
    BilinearFormTwoPartDeriv(const enum partDerivType i,
                             const enum partDerivType j,
                             const concepts::ElementFormulaContainer<F> 
                             frm = concepts::ElementFormulaContainer<F>());

    virtual ~BilinearFormTwoPartDeriv() {}

    virtual BilinearFormTwoPartDeriv<F>* clone() const { 
      return new BilinearFormTwoPartDeriv<F>(i_, j_, this->frm_);
    }

    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:
    const enum partDerivType i_, j_;

    bool operator()(const Quad<Real>* elmX, 
                    const Quad<Real>* elmY, 
                    concepts::ElementMatrix<F>& em);
  };

} // namespace hp2D

#endif // hp2dbf_partialderiv_hh