models/Maxwell2D_E.hh

Go to the documentation of this file.

#ifndef Maxwell2D_E_hh
#define Maxwell2D_E_hh

#include "adaptiveModels.hh"
#include "operator/sparseMatrix.hh"
#include "hp2Dedge/hpAdaptiveSpaceHCurl.hh"
#include "formula/boundary.hh"
#include "models/maxwell.hh"
#include "models/maxwellConstants.hh"
#include "models/Eddy2D_geometries.hh"

namespace hp2D {
  
  using concepts::Real;
  using concepts::Cmplx;

  class InputMaxwell2D_E;

  // *********************************************************** Maxwell2D_E **
  
  class Maxwell2D_E : public AdaptiveModel<Cmplx>,
          public concepts::MaxwellModel,
          public concepts::MaxwellBoundary {
    friend class concepts::ModelControl<Maxwell2D_E>;
  public:
    enum solverType { SUPERLU = 0, BICGSTAB};
    Maxwell2D_E(concepts::EddyGeometry2D& geom, enum boundaryType bType = PEC,
    enum solverType type = SUPERLU, bool diagPrecond = true,
    bool afterIter = false,
    const Real eps = EPS0, const Real omega = OMEGA50,
    const Real mu = MU0, const uint geomRefAttrib = 100);
    Maxwell2D_E(concepts::EddyGeometry2D& geom, InputMaxwell2D_E& input,
    const uint geomRefAttrib = 100);
    virtual ~Maxwell2D_E() {}
    virtual hp2D::hpAdaptiveSpaceHCurl& space() const { return *spc_; }
    virtual Real dissipation();
    virtual Real magnEnergy();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    virtual hpFull& prebuild_() { return spc_->prebuild(); }
    virtual const std::string mshAbbr_() { return geom_.meshAbbreviation(); }
  private:
    void constructor_();

    concepts::EddyGeometry2D& geom_;
    std::auto_ptr<hp2D::hpAdaptiveSpaceHCurl> spc_;
    std::auto_ptr<concepts::BoundaryConditions> bc_;

    enum solverType type_;
    bool diagPrecond_;
    bool afterIter_, statusAfterIter_;
    std::auto_ptr<concepts::Vector<Cmplx> > residual_;
    std::auto_ptr<Real> residualNorm_;
    std::auto_ptr<concepts::SparseMatrix<Cmplx> > S_;
    std::auto_ptr<concepts::SparseMatrix<Real> > A_, M_eddy_, M_wave_;
    // load vector
    std::auto_ptr<concepts::Vector<Cmplx> > rhs_;
    const Real eps_;
    const Real omega_;
    const Real mu_;
    virtual void solve_();
    void matrices_();
    void rotrotMatrix_();
    void identityMatrix_();
    void linearform_();
    std::auto_ptr<Real> dissipation_;
    std::auto_ptr<Real> magnEnergy_;
    double solvetime_, matrixtime_, spacetime_;
  };

  // ****************************************************** InputMaxwell2D_E **

  class InputMaxwell2D_E : public concepts::InputParameter {
  public:
    InputMaxwell2D_E(concepts::InOutParameters& input);
    virtual std::ostream& letters(std::ostream& os) const;
    virtual std::ostream& arguments(std::ostream& os) const;
    virtual std::ostream& description(std::ostream& os) const;
    virtual int input(int opt, const char* optarg);
    enum Maxwell2D_E::solverType type() const { return type_; } 
    enum concepts::MaxwellBoundary::boundaryType boundary() const { 
      return bType_;
    }
    bool solving() const { return solving_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    enum concepts::MaxwellBoundary::boundaryType bType_;
    enum Maxwell2D_E::solverType type_;
    bool solving_;
  };

} // namespace hp2D

namespace concepts {

  // *************************************** ModelControl<hp2D::Maxwell2D_E> **

  template<>
  class ModelControl<hp2D::Maxwell2D_E> : 
    public ModelControlBase<Model<Cmplx> > {
  public:
    ModelControl(hp2D::Maxwell2D_E& model);
    virtual ~ModelControl() {}

    virtual hp2D::Maxwell2D_E& model() {
      return static_cast<hp2D::Maxwell2D_E&>(model_);
    }
    virtual const hp2D::Maxwell2D_E& model() const {
      return static_cast<const hp2D::Maxwell2D_E&>(model_);
    }
    virtual void matrices();
    void solverType(enum hp2D::Maxwell2D_E::solverType type,
        bool diagPrecond);
    virtual Real solve();
    void storeMatricesToMatlab(const std::string matrixFile) const;
    hp2D::hpFull& prebuild() { return model().prebuild_(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };

} // namespace concepts

#endif // Maxwell2D_E_hh