models/Eddy2D_E.hh

Go to the documentation of this file.

#ifndef Eddy2D_E_hh
#define Eddy2D_E_hh

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

namespace hp2D {

  using concepts::Real;
  using concepts::Cmplx;

  class InputEddy2D_E;

  // ************************************************************** Eddy2D_E **
  
  class Eddy2D_E : public AdaptiveModel<Cmplx>,
       public concepts::MaxwellModel,
       public concepts::MaxwellBoundary {
    friend class concepts::ModelControl<Eddy2D_E>;
  public:
    Eddy2D_E(concepts::EddyGeometry2D& geom,
       enum concepts::MaxwellBoundary::boundaryType bType = PEC,
       const Real omega = OMEGA50, const Real mu = MU0,
       const uint geomRefAttrib = 100);
    Eddy2D_E(concepts::EddyGeometry2D& geom, InputEddy2D_E& input,
       enum boundaryType bType = PEC, const uint geomRefAttrib = 100);
    virtual ~Eddy2D_E() {}
    virtual hpAdaptiveSpaceHCurl_H1& space() const { return *spc_; }
    virtual Real dissipation();
    virtual Real magnEnergy();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    virtual hpFull& prebuild_() { return spc_->spcE().prebuild(); }
    virtual const std::string mshAbbr_() { return geom_.meshAbbreviation(); }
  private:
    void constructor_();

    concepts::EddyGeometry2D& geom_;
    std::auto_ptr<hpAdaptiveSpaceHCurl_H1> spc_;
    std::auto_ptr<hpAdaptiveSpaceHCurl> spcE_;
    std::auto_ptr<hpAdaptiveSpaceH1> spcN_;
    std::auto_ptr<concepts::BoundaryConditions> bcE_, bcN_;
    std::auto_ptr<concepts::CellConditions> cc_;

    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_;
    // load vector
    std::auto_ptr<concepts::Vector<Cmplx> > rhs_;

    const Real omega_;
    const Real mu_;

    void constructSpace_();
    virtual void solve_();
    void matrices_();
    void rotrotMatrix_();
    void identityMatrix_();
    void regMatrix_();
    void linearform_();

    std::auto_ptr<Real> dissipation_;
    std::auto_ptr<Real> magnEnergy_;
    double solvetime_, matrixtime_, spacetime_;
  };

  // ********************************************************* InputEddy2D_E **

  class InputEddy2D_E : public concepts::InputParameter {
  public:
    InputEddy2D_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);
    bool solving() const { return solving_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    bool solving_;
  };

} // namespace hp2D

namespace concepts {

  // ****************************************** ModelControl<hp2D::Eddy2D_E> **

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

    virtual hp2D::Eddy2D_E& model() {
      return static_cast<hp2D::Eddy2D_E&>(model_);
    }
    virtual const hp2D::Eddy2D_E& model() const {
      return static_cast<const hp2D::Eddy2D_E&>(model_);
    }
    virtual void matrices();
    virtual Real solve();
    void storeMatricesToMatlab(const std::string matrixFile) const;
    void storeMatricesToOctave(const std::string matrixFile) const;
    void checkRanks() const;
    hp2D::hpFull& prebuild() { return model().prebuild_(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };

} // namespace concepts

#endif // Eddy2D_E_hh