Maxwell2D_H_eField.hh

/*  @file models/Maxwell2D_H_eField.hh
 
    Element function to get electric field from magnetic field
    in translation-symmetric Maxwell's equations
    @author Kersten Schmidt, 2005
*/
 
#ifndef Maxwell2D_H_eField_hh
#define Maxwell2D_H_eField_hh
 
#include "basics.hh"
#include "geometry/formula.hh"
#include "hp2D/function.hh"
#include "models/maxwellConstants.hh"
 
namespace hp2D {
 
  using concepts::Real;
  using concepts::Real2d;
  using concepts::Cmplx;
 
  // ****************************************************** Maxwell2D_eField **
 
  class Maxwell2D_eField : public hp2D::ElementFunction<2,Cmplx> {
  public:
    Maxwell2D_eField(const concepts::PiecewiseFormulaBase<Real2d>& J0,
         const concepts::PiecewiseFormulaBase<Cmplx>&
         iOmegaEps_plus_Sigma_Inv);
    Maxwell2D_eField(const concepts::PiecewiseFormulaBase<Real>& J0x,
         const concepts::PiecewiseFormulaBase<Real>& J0y,
         const concepts::PiecewiseFormulaBase<Cmplx>&
         iOmegaEps_plus_Sigma_Inv);
    virtual ~Maxwell2D_eField() {}
 
    virtual Maxwell2D_eField* clone() const {
      if (J0_.get())
  return new Maxwell2D_eField(*J0_, *iOmegaEps_plus_Sigma_Inv_);
      return new Maxwell2D_eField(*J0x_, *J0y_, *iOmegaEps_plus_Sigma_Inv_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual void compute_(const Quad<>& elm,
        const concepts::Array<Cmplx>& coeff,
        concepts::Array<Cmplx>& val,
        const uint i[2]) const;
    virtual void compute_(const Quad<>& elm, const uint j[2],
        concepts::Array<Cmplx>& val,
        const uint i[2]) const;
    virtual void compute_(const Quad<>& elm,
        const concepts::Array<Cmplx>& coeff,
        concepts::Array<Cmplx>& val,
        const Real2d& p, const Real t = 0.0) const;
    void convert_(const Quad<>& elm, concepts::Array<Cmplx>& val,
      const Real2d& p, const Real t = 0.0) const;
    std::unique_ptr<concepts::PiecewiseFormulaBase<Real2d> > J0_;
    std::unique_ptr<concepts::PiecewiseFormulaBase<Real> > J0x_;
    std::unique_ptr<concepts::PiecewiseFormulaBase<Real> > J0y_;
    std::unique_ptr<concepts::PiecewiseFormulaBase<Cmplx> > 
      iOmegaEps_plus_Sigma_Inv_ ;
    PlCurl<Cmplx> plcurl_;
  };
 
  // ************************************************* Maxwell2D_dissipation **
 
  class Maxwell2D_dissipation : public ElementFunction<1,Cmplx> {
  public:
    Maxwell2D_dissipation(const concepts::PiecewiseConstFormula<Real>& sigma,
        const Real eps = EPS0, const Real omega = OMEGA50);
    virtual ~Maxwell2D_dissipation() {}
    virtual Maxwell2D_dissipation* clone() const {
      return new Maxwell2D_dissipation(sigma_, eps_, omega_);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual void compute_(const Quad<>& elm,
        const concepts::Array<Cmplx>& coeff,
        Cmplx& val, const uint i[2]) const;
    virtual void compute_(const Quad<>& elm, const uint j[2],
        Cmplx& val, const uint i[2]) const;
    virtual void compute_(const Quad<>& elm,
        const concepts::Array<Cmplx>& coeff, Cmplx& val,
        const Real2d& p, const Real t = 0.0) const;
    void convert_(const Quad<>& elm, const concepts::Array<Cmplx>& gradh,
      Cmplx& val) const;
    const concepts::PiecewiseConstFormula<Real>& sigma_;
    const Real eps_, omega_;
    Grad<Cmplx> grad_;
  };
 
} // namespace hp2D
 
#endif // Maxwell2D_H_eField_hh