operator/bilinearForm.hh

Go to the documentation of this file.

/* Bilinear Form
 */

#ifndef BilinearForm_hh
#define BilinearForm_hh

#include <memory>
#include "basics/outputOperator.hh"
#include "basics/cloneable.hh"
#include "space/elementPairs.hh"

namespace concepts {

  // forward declaration
  template<class F>
  class Element;

  template<class F>
  class ElementMatrix;

  // ********************************************************** BilinearForm **

  template<class F, class G = typename Realtype<F>::type>
    class BilinearForm : public Cloneable, virtual public OutputOperator {
      public:
        virtual void operator()(const Element<G>& elmX, const Element<G>& elmY,
            ElementMatrix<F>& em) = 0;
        virtual void operator()(const Element<G>& elmX, const Element<G>& elmY,
            ElementMatrix<F>& em, const ElementPair<G>& ep) {
          operator()(elmX, elmY, em); }
      protected:
        virtual std::ostream& info(std::ostream& os) const;
    };

  // ****************************************************** BilinearFormLiCo **

  template<class F, class G = typename Realtype<F>::type>
    class BilinearFormLiCo : public BilinearForm<F,G> {
      public:
        BilinearFormLiCo(BilinearForm<F,G>& bfA,
            BilinearForm<F,G>& bfB,
            const F cA = 1.0, const F cB = 1.0) :
          bfAptr_(0), bfBptr_(0),
          bfA_(&bfA), bfB_(&bfB), cA_(cA), cB_(cB), em_() {}
        BilinearFormLiCo(const BilinearFormLiCo& b);
        virtual ~BilinearFormLiCo() {}
        virtual void operator()(const Element<G>& elmX,
            const Element<G>& elmY, 
            ElementMatrix<F>& em);
        virtual BilinearFormLiCo<F,G>* clone() const;
      protected:
        virtual std::ostream& info(std::ostream& os) const;
      private:
        std::auto_ptr<BilinearForm<F,G> > bfAptr_, bfBptr_;
        BilinearForm<F,G>* bfA_, * bfB_;
        const F cA_;
        const F cB_;
        ElementMatrix<F> em_;
    };

} // namespace concepts

#endif // BilinearForm_hh