EMM_LandauLifschitzODE.h

Go to the documentation of this file.

#ifndef EMM_LandauLifschitzODE_H
#define EMM_LandauLifschitzODE_H


#include "EMM_LandauLifschitzSystem.h"


#include "EMM_ODETimeStep.h"

DEFINE_SPTR(EMM_LandauLifschitzODE);
class EMM_LandauLifschitzODE : public  EMM_LandauLifschitzSystem {
  
    SP_OBJECT(EMM_LandauLifschitzODE);
    // ATTRIBUTES
  
public:
   
 
   
private:

    //integration order for displacement field
    tUCInt mTimeIntegrationOrder;
    
    //time data
    tUInteger mTimeStep;
    tReal mDt;
    tReal mT;
   
    

    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_LandauLifschitzODE(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_LandauLifschitzODE(void);   
  
  
public:

    //NEW constructor
protected:
   
    
    //DATA methods
    //=============
public:

    inline void setTimeIntegrationOrder(const int& order) {
        mTimeIntegrationOrder=order;
    }

    inline const tUCInt&  getTimeIntegrationOrder() const {
        return mTimeIntegrationOrder;
    }
           
    virtual const tUInteger& getTimeStepsNumber() const {
        return mTimeStep;
    }
    virtual const tReal& getTime() const {
        return mT;
    }
    virtual  const tReal& getTimeStep() const {
        return mDt;
    }

   

   
 
    //Integration methods
    //===================
    
    
public:
    virtual tReal integrateMagnetizationFieldAtTime(tReal& dt,
                                                    const tFlag& errorNorm,
                                                    const tReal& epsilon,
                                                    tUSInt& nEvaluations,
                                                    const EMM_RealField& dM_dt0,
                                                    const EMM_RealField& M0,
                                                    EMM_RealField& Mt)=0;
    

        
  


    //fields methods
    //==============
public:
    
    tBoolean computeFieldsAtTime(EMM_ODETimeStep& stepper,
                                 tReal& dt,
                                 tReal& dtNew,
                                 const tFlag& order,
                                 const EMM_RealArray& sigma,
                                 const EMM_RealField& dM_dt0,
                                 const EMM_RealField& M0,
                                 EMM_RealField& Mt);
    
    virtual void  integrate(const tBoolean& isRestoring,tSInt& retCode) {
        solveODE(isRestoring,retCode);
    }
    
    void solveODE(const tBoolean& isRestoring,tSInt& retCode);



};

#endif