formula/frmE_sum.hh

Go to the documentation of this file.

#ifndef sumelementformula_hh
#define sumelementformula_hh

#include "basics/typedefs.hh"
#include "basics/vectorsMatricesForward.hh"
#include "elementFormulaContainer.hh"
#include "exceptions.hh"

#define SumElemFormConstr_D 0
#define SumElemFormDestr_D  0
#define SumElemFormClone_D  0

namespace concepts {
   
 
 // **************************************************************** FrmE_Sum **

  template<class F, class H = F, class J = F,
           class G  = typename Realtype<F>::type>
  class FrmE_Sum : public ElementFormula<F,G> {
  public:
    FrmE_Sum(const ElementFormulaContainer<H> frm1,
             const ElementFormulaContainer<J> frm2) 
      : frm1_(frm1), frm2_(frm2), a_(0.0)
    {
      if (frm1.empty()) throw(PointerToEmptyElementFormula());
      if (frm2.empty()) throw(PointerToEmptyElementFormula());
    }
    FrmE_Sum(const ElementFormulaContainer<H> frm1,
             const F a) 
      : frm1_(frm1), frm2_(), a_(a)
    {
      DEBUGL(SumElemFormConstr_D, "frm1 = " << frm1);
      if (frm1.empty()) throw(PointerToEmptyElementFormula());
    }
    virtual ~FrmE_Sum() {
      DEBUGL(SumElemFormDestr_D, "Delete " << *this)
    }


    virtual F operator() (const ElementWithCell<G>& elm, const Real p,
                          const Real t = 0.0) const
    {
      F v = frm1_(elm, p,t);
      if (!frm2_.empty())
        v += frm2_(elm, p,t);
      
      return v + a_;
    }
    virtual F operator() (const ElementWithCell<G>& elm, const Real2d& p,
                          const Real t = 0.0) const 
    {
      F v = frm1_(elm, p,t);
      if (!frm2_.empty())
        v += frm2_(elm, p,t);
      
      return v + a_;
    }
    virtual F operator() (const ElementWithCell<G>& elm, const Real3d& p,
                          const Real t = 0.0) const 
    {
      F v = frm1_(elm, p,t);
      if (!frm2_.empty())
        v += frm2_(elm, p,t);

      return v + a_;
    }

    virtual FrmE_Sum<F,H,J,G>* clone() const {
      DEBUGL(SumElemFormClone_D, *this << " = *" << this);
      return new FrmE_Sum<F,H,J,G>(frm1_, frm2_, a_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      os << "FrmE_Sum(" << frm1_;
      if (!frm2_.empty())
        os << " + " << frm2_;
      if (!(a_ == F(0.0)))
        os << " + " << a_;
      return os << ")";
    }
  private:
    ElementFormulaContainer<H> frm1_;
    ElementFormulaContainer<J> frm2_;
    F a_;

    FrmE_Sum(const ElementFormulaContainer<H> frm1,
             const ElementFormulaContainer<J> frm2,
             const F a) 
      : frm1_(frm1), frm2_(frm2), a_(a) 
    {
      DEBUGL(SumElemFormConstr_D, 
             "frm1 = " << frm1 << ", frm2 = " << frm2 << ", a = " << a);
      if (frm1.empty()) throw(PointerToEmptyElementFormula());
    }
  };


  // ************************************************************ operator+ **


  ElementFormulaContainer<Real> 
  operator+(const ElementFormulaContainer<Real> frm, const Real  a);
  
  ElementFormulaContainer<Cmplx> 
  operator+(const ElementFormulaContainer<Cmplx> frm, const Real  a);
  
  ElementFormulaContainer<Cmplx> 
  operator+(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
  
  ElementFormulaContainer<Cmplx> 
  operator+(const ElementFormulaContainer<Real> frm, const Cmplx a);

  //                             ************     

  ElementFormulaContainer<Real2d> 
  operator+(const ElementFormulaContainer<Real2d> frm, const Real2d  a);
  
  ElementFormulaContainer<Cmplx2d> 
  operator+(const ElementFormulaContainer<Cmplx2d> frm, const Real2d  a);
  
  ElementFormulaContainer<Cmplx2d> 
  operator+(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx2d a);
  
  ElementFormulaContainer<Cmplx2d> 
  operator+(const ElementFormulaContainer<Real2d> frm, const Cmplx2d a);


  ElementFormulaContainer<Real> 
  operator+(const ElementFormulaContainer<Real> frm1,
            const ElementFormulaContainer<Real> frm2);

  ElementFormulaContainer<Cmplx> 
  operator+(const ElementFormulaContainer<Cmplx> frm1,
            const ElementFormulaContainer<Real> frm2);

  ElementFormulaContainer<Cmplx> 
  operator+(const ElementFormulaContainer<Real> frm1,
            const ElementFormulaContainer<Cmplx> frm2);

  ElementFormulaContainer<Cmplx> 
  operator+(const ElementFormulaContainer<Cmplx> frm1,
            const ElementFormulaContainer<Cmplx> frm2);

  //                             ************     

  ElementFormulaContainer<Real2d> 
  operator+(const ElementFormulaContainer<Real2d> frm1,
            const ElementFormulaContainer<Real2d> frm2);

  ElementFormulaContainer<Cmplx2d> 
  operator+(const ElementFormulaContainer<Cmplx2d> frm1,
            const ElementFormulaContainer<Real2d> frm2);

  ElementFormulaContainer<Cmplx2d> 
  operator+(const ElementFormulaContainer<Real2d> frm1,
            const ElementFormulaContainer<Cmplx2d> frm2);

  ElementFormulaContainer<Cmplx2d> 
  operator+(const ElementFormulaContainer<Cmplx2d> frm1,
            const ElementFormulaContainer<Cmplx2d> frm2);


  ElementFormulaContainer<Real> 
  operator-(const ElementFormulaContainer<Real> frm, const Real  a);
  
  ElementFormulaContainer<Cmplx> 
  operator-(const ElementFormulaContainer<Cmplx> frm, const Real  a);
  
  ElementFormulaContainer<Cmplx> 
  operator-(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
  
  ElementFormulaContainer<Cmplx> 
  operator-(const ElementFormulaContainer<Real> frm, const Cmplx a);

  //                             ************     

  ElementFormulaContainer<Real2d> 
  operator-(const ElementFormulaContainer<Real2d> frm, const Real2d  a);
  
  ElementFormulaContainer<Cmplx2d> 
  operator-(const ElementFormulaContainer<Cmplx2d> frm, const Real2d  a);
  
  ElementFormulaContainer<Cmplx2d> 
  operator-(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx2d a);
  
  ElementFormulaContainer<Cmplx2d> 
  operator-(const ElementFormulaContainer<Real2d> frm, const Cmplx2d a);

  ElementFormulaContainer<Real> 
  operator-(const ElementFormulaContainer<Real> frm1,
            const ElementFormulaContainer<Real> frm2);

  ElementFormulaContainer<Cmplx> 
  operator-(const ElementFormulaContainer<Cmplx> frm1,
            const ElementFormulaContainer<Real> frm2);

  ElementFormulaContainer<Cmplx> 
  operator-(const ElementFormulaContainer<Real> frm1,
            const ElementFormulaContainer<Cmplx> frm2);

  ElementFormulaContainer<Cmplx> 
  operator-(const ElementFormulaContainer<Cmplx> frm1,
            const ElementFormulaContainer<Cmplx> frm2);

  //                             ************     

  ElementFormulaContainer<Real2d> 
  operator-(const ElementFormulaContainer<Real2d> frm1,
            const ElementFormulaContainer<Real2d> frm2);

  ElementFormulaContainer<Cmplx2d> 
  operator-(const ElementFormulaContainer<Cmplx2d> frm1,
            const ElementFormulaContainer<Real2d> frm2);

  ElementFormulaContainer<Cmplx2d> 
  operator-(const ElementFormulaContainer<Real2d> frm1,
            const ElementFormulaContainer<Cmplx2d> frm2);

  ElementFormulaContainer<Cmplx2d> 
  operator-(const ElementFormulaContainer<Cmplx2d> frm1,
            const ElementFormulaContainer<Cmplx2d> frm2);

} // namespace concepts


#endif // sumelementformula_hh