linInnerProd.hh

//#ifndef hp2dlinInnerProd_own_hh
//#define hp2dlinInnerProd_own_hh
//
//#include <memory>
//#include "basics/typedefs.hh"
//#include "function/linearForm.hh"
//#include "hp2D/linearFormHelper.hh"
//#include "hp2D/arrayElementFormula.hh"
//#include "hp1D.hh"
//
//
//namespace hp1D{
//
// * Computes   formula * theta_n on a nEdge where theta_n are the two shapefunctions of order 1.
// * 1-x, x
// *
// *This is needed for the approximated moments, just for two orders dont change polynomial degree,
// *for generell use hp1D::riesz,
// *
// *
// *Alternative : Nutze riesz aber nur für polynomgrad 2.
// *
// */
//template<class F = Real>
// class LinInnerProd_0 : public concepts::LinearForm<F>, public hp1D::LinearFormHelper<0,F> {
// public:
//   /** Constructor.
//
//       @param frm The formula, given elementwise
//   */
//   LinInnerProd_0(const concepts::ElementFormulaContainer<F> frm,
//       const concepts::BoundaryConditions* bc = 0);
//
//   virtual ~LinInnerProd_0();
//
//   /** Computes on an element the inner product of the element-wise
//    *  given formula and the linear vertex basis in all 2 points,
//    *  there are the loops over all quadrature
//    *
//       @param elm The element for which the 2 inner products are computed
//       @param em  The computed inner product for the 2 nodal-basis functions. (traced)
//   */
//   void operator()(const concepts::Element<Real>& elm,
//                   concepts::ElementMatrix<F>& em);
// protected:
//   virtual std::ostream& info(std::ostream& os) const;
// private:
//
// };
//
//} //hp1D
//
//
//
//
//
//
//
//
//
//namespace hp2D {
//
//  // forward declarations
//  template<class F>
//  class Quad;
//
//  using concepts::Real;
//
//
//      This linear form computes
//      \f[ \int_K f \theta_n \, dx, n=0,1,2,3  \f]
//
//      where \f[\theta_n\f] are nodal and edge basis functions, not interiors
//      they are computed first x , then y direction-wise
//      Currently only on quadrilaterals.
//
//
//      Robert
//  */
//  template<class F = Real>
//  class LinInnerProd_0 : public concepts::LinearForm<F>, public LinearFormHelper_0<F> {
//  public:
//    /** Constructor.
//
//        @param frm The formula, given elementwise
//    */
//    LinInnerProd_0(const concepts::ElementFormulaContainer<F> frm,
//          bool ignoreMissingElem = false);
//    virtual ~LinInnerProd_0();
//
//    /** Computes on an element the inner product of the element-wise
//     *  given formula and the linear vertex basis in all 4 points,
//     *  there are the loops over all quadrature
//        points and the loops over the four shape functions (tensorized).
//
//        @param elm The element for which the 4 inner products are computed
//        @param em  The computed inner product for all 4 nodal-basis functions.
//    */
//    void operator()(const concepts::Element<Real>& elm,
//                    concepts::ElementMatrix<F>& em);
//  protected:
//    virtual std::ostream& info(std::ostream& os) const;
//  private:
//    /// Intermediate data for element matrix computation
//    concepts::Array<Real> jacobian_;
//
//    void operator()(const Quad<Real>& elm, concepts::ElementMatrix<F>& em);
//
//    bool ignoreMissingElem;
//  };
//
//  /** Linear form in 2D.
//
//        This linear form computes
//        \f[ \int_K \vec{f} \cdot \mbox{\bf grad}{v} \, dx \f]
//        for a given 2D function f and v is one of the four first order shape functions.
//        Currently only on quadrilaterals.
//
//        compare to GradLinearForm just with 4 Shapefunctions only.
//    */
//    template<class F = concepts::Real>
//    class LinInnerProd_1 : public concepts::LinearForm<F>, public LinearFormHelper_1<F> {
//    public:
//      /** Constructor.
//          @param frm Vectorial formula
//          @param ignoreMissingElem do not throw an exceptiont for incompatible elements,
//                   just ignore elements like GfemQuads
//      */
//      LinInnerProd_1(const concepts::ElementFormulaContainer<concepts::Point<F, 2> > frm,
//       bool ignoreMissingElem = false);
//
//      /** Computes a 4x1 element load vector. As for the computation of an
//          element stiffness matrix, there are the loops over all quadrature
//          points and the loops over all shape functions.
//          @param elm The element for which the load vector should be computed.
//          @param em  The load vector in local degrees of freedom corresponding to local shapefunctions
//      */
//      virtual void operator()(const concepts::Element<Real>& elm,
//                              concepts::ElementMatrix<F>& em);
//    protected:
//      virtual std::ostream& info(std::ostream& os) const;
//    private:
//      virtual void operator()(const Quad<Real>& elm,
//                              concepts::ElementMatrix<F>& em);
//
//      bool ignoreMissingElem_;
//    };
//
//
//
//}
//
//#endif // hp2dlinInnerProd_own_hh