bilinearForm.hh

Go to the documentation of this file.

 
#ifndef BilinearForm_hh
#define BilinearForm_hh
 
#include <memory>
#include "basics/outputOperator.hh"
#include "basics/cloneable.hh"
#include "space/elementPairs.hh"
#include "toolbox/sharedPointer_std.hh"
#include "basics/exceptions.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, public virtual OutputOperator {
  public:
    virtual void operator()(const Element<G>& elmX, const Element<G>& elmY,
          ElementMatrix<F>& em) const = 0;
    virtual void operator()(const Element<G>& elmX, const Element<G>& elmY,
          ElementMatrix<F>& em, const ElementPair<G>& ep) const{
      operator()(elmX, elmY, em); 
    }
 
    virtual BilinearForm* clone() const = 0;
 
  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_(nullptr), bfBptr_(nullptr),
      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) const;
    virtual BilinearFormLiCo<F,G>* clone() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::unique_ptr<BilinearForm<F,G> > bfAptr_, bfBptr_;
    BilinearForm<F,G>* bfA_, * bfB_;
 
 
    concepts::RCP<BilinearForm<F,G> > bA, bB;
 
    const F cA_;
    const F cB_;
    mutable ElementMatrix<F> em_;
  };
 
  // ************************************************* BilinearFormContainer **
 
 template<class F, typename G = typename Realtype<F>::type>
 class BilinearFormContainer : public BilinearForm<F,G> {
 public:
     BilinearFormContainer() {}
 
     BilinearFormContainer(const BilinearForm<F,G>& bf);
 
     BilinearFormContainer(const RCP<const BilinearForm<F,G> > frm);
 
     explicit BilinearFormContainer(const BilinearForm<F,G>* frm);
 
     BilinearFormContainer(const BilinearFormContainer<F,G>& frm);
 
     virtual void operator()(const Element<G>& elmX,
                             const Element<G>& elmY,
                             ElementMatrix<F>& em) const;
 
     virtual BilinearFormContainer<F,G>* clone() const {
       return new BilinearFormContainer<F,G>(*this);
     }
 
     bool empty() const { return bf_.get() == 0; }
 
     void transpose() {
       transpose_ = !transpose_;
     }
 
     virtual ~BilinearFormContainer();
   protected:
     virtual std::ostream& info(std::ostream& os) const;
     RCP<const BilinearForm<F,G> > bf_;
   private:
     bool transpose_;
   };
 
 
 // ******************************************* PointerToEmptyBilinearForm **
 
 class PointerToEmptyBilinearForm : public ExceptionBase {
 public:
   PointerToEmptyBilinearForm()
   {
     errorMessage_ = "Empty RCP<BilinearForm>";
   }
   virtual ~PointerToEmptyBilinearForm() throw() {}
 protected:
   virtual std::ostream& info(std::ostream& os) const throw();
 private:
   std::string errorMessage_;
 };
 
 
 
 // ********************************************************* BilinearF_Sum **
template<class F, class H = F, class J = F, class G = typename Realtype<F>::type>
 class BilinearF_Sum : public BilinearForm<F,G> {
  public:
   BilinearF_Sum(const BilinearFormContainer<H,G> bf1,
                 const BilinearFormContainer<J,G> bf2)
      : bf1_(bf1), bf2_(bf2)
    {
      if (bf1_.empty()) throw(PointerToEmptyBilinearForm());
      if (bf2_.empty()) throw(PointerToEmptyBilinearForm());
    }
 
   virtual ~BilinearF_Sum(){};
 
   void operator()(const Element<G>& elmX,
                                      const Element<G>& elmY,
                                      ElementMatrix<F>& em) const
   {
     //intermediate Matrix
     ElementMatrix<H> em_H(elmX.T().m(), elmY.T().m());
     ElementMatrix<J> em_J(elmX.T().m(), elmY.T().m());
     em.resize(elmX.T().m(), elmY.T().m());
     em_H.zeros();
     em_J.zeros();
     em.zeros();
 
     bf1_(elmX, elmY, em_H);
     bf2_(elmX, elmY, em_J);
     F* emData = (F*)em;
 
     H* em_H_Data = (H*)em_H;
     J* em_J_Data = (J*)em_J;
 
     for (uint i = 0; i < elmX.T().m()*elmY.T().m(); ++i, emData++, em_H_Data++, em_J_Data++) {
         *emData = *em_H_Data + *em_J_Data;
     }
   }
 
 
  virtual BilinearF_Sum<F,H,J,G>* clone() const {
      return new BilinearF_Sum<F,H,J,G>(bf1_, bf2_);
    }
 
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << typeOf(*this) << "(" << bf1_
          << " , " << bf2_ << ")";
    }
  private:
    BilinearFormContainer<H,G> bf1_;
    BilinearFormContainer<J,G> bf2_;
  };
 
 
 
 
// ********************************************************* BilinearF_W **
  template<class F, class H = F, class J = F, class G = typename Realtype<F>::type>
  class BilinearF_W : public BilinearForm<F,G> {
   public:
    BilinearF_W(const BilinearFormContainer<H,G> bf1,
                  const J w)
       : bf1_(bf1), w_(w)
     {
       if (bf1_.empty()) throw(PointerToEmptyBilinearForm());
     }
 
    virtual ~BilinearF_W(){};
 
    void operator()(const Element<G>& elmX,
                    const Element<G>& elmY,
                    ElementMatrix<F>& em) const
    {
      concepts::ElementMatrix<H> tmp(elmX.T().m(), elmY.T().m());
      tmp.zeros();
 
      bf1_(elmX, elmY, tmp);
 
      F* emData = (F*)em;
      H* tmpData = (H*)tmp;
 
      for (uint i = 0; i < elmX.T().m()*elmY.T().m(); ++i, emData++, tmpData++) {
          *emData = *tmpData * w_;
      }
    }
 
 
   virtual BilinearF_W<F,H,J,G>* clone() const {
       return new BilinearF_W<F,H,J,G>(bf1_, w_);
     }
 
   protected:
     virtual std::ostream& info(std::ostream& os) const {
       return os << typeOf(*this) << "(" << bf1_
           << " , " << w_ << ")";
     }
   private:
     BilinearFormContainer<H,G> bf1_;
     J w_;
   };
 
 
 
 
 
 
 BilinearFormContainer<Real>
 operator+(const BilinearFormContainer<Real> frm1,
           const BilinearFormContainer<Real> frm2);
 
 BilinearFormContainer<Cmplx>
 operator+(const BilinearFormContainer<Cmplx> frm1,
           const BilinearFormContainer<Real> frm2);
 
 BilinearFormContainer<Cmplx>
 operator+(const BilinearFormContainer<Real> frm1,
           const BilinearFormContainer<Cmplx> frm2);
 
 BilinearFormContainer<Cmplx>
 operator+(const BilinearFormContainer<Cmplx> frm1,
           const BilinearFormContainer<Cmplx> frm2);
 
 
 
 BilinearFormContainer<Real>
 operator*(const BilinearFormContainer<Real> frm1,
           const Real w);
 
 BilinearFormContainer<Cmplx>
 operator*(const BilinearFormContainer<Real> frm1,
           const Cmplx w);
 
 BilinearFormContainer<Cmplx>
 operator*(const BilinearFormContainer<Cmplx> frm1,
           const Real w);
 
 BilinearFormContainer<Cmplx>
 operator*(const BilinearFormContainer<Cmplx> frm1,
           const Cmplx w);
 
 //Multiplikation from left
 BilinearFormContainer<Real>
 operator*(const Real w,
           const BilinearFormContainer<Real> frm1);
 
 BilinearFormContainer<Cmplx>
 operator*(const Cmplx w,
           const BilinearFormContainer<Real> frm1);
 
 BilinearFormContainer<Cmplx>
 operator*(const Real w,
           const BilinearFormContainer<Cmplx> frm1);
 
 BilinearFormContainer<Cmplx>
 operator*(const Cmplx w,
           const BilinearFormContainer<Cmplx> frm1);
 
 
 
 BilinearFormContainer<Real>
 operator-(const BilinearFormContainer<Real> frm1,
           const BilinearFormContainer<Real> frm2);
 
 BilinearFormContainer<Cmplx>
 operator-(const BilinearFormContainer<Cmplx> frm1,
           const BilinearFormContainer<Real> frm2);
 
 BilinearFormContainer<Cmplx>
 operator-(const BilinearFormContainer<Real> frm1,
           const BilinearFormContainer<Cmplx> frm2);
 
 BilinearFormContainer<Cmplx>
 operator-(const BilinearFormContainer<Cmplx> frm1,
           const BilinearFormContainer<Cmplx> frm2);
 
 
 
 
} // namespace concepts
 
#endif // BilinearForm_hh