EMM_LandauLifschitzRelaxation.h

Go to the documentation of this file.

#ifndef EMM_LandauLifschitzRelaxation_H
#define EMM_LandauLifschitzRelaxation_H


#include "EMM_LandauLifschitzSystem.h"

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

   
private:

    
    tUCInt mTimeIntegrationOrder;
    
    //time data
    tUInteger mTimeStep;
    tReal mDt;
    tReal mT;
    
    //M variable: the normalized magnetization field at t into current time step
    SP::EMM_RealField mMt;

 
    //the complete excitation field at t into current time step
    SP::EMM_RealField mHt;

 
    //states wich defines the relaxation process:
    //===========================================
   
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_LandauLifschitzRelaxation(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_LandauLifschitzRelaxation(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;
    }
    

   

    
    //MAGNETIZATION field methods
    //===========================
protected:
    inline EMM_RealField& getMagnetizationFieldAtTime() const {
        return *mMt.get();
    }
    inline EMM_RealField& getMagneticExcitationFieldAtTime() const {
        return *mHt.get();
    }

   
    
protected:
    virtual tBoolean integrateMagnetizationFieldAtTime(const tReal& t,
                                                       const tFlag& order,
                                                       const EMM_RealArray& sigma,
                                                       const EMM_RealField& dM_dt0,
                                                       const EMM_RealField& M0,
                                                       EMM_RealField& Mt)=0;
    
public:
    inline tBoolean integrateMagnetizationFieldAtTime(const tReal& t,
                                                      EMM_RealField& Mt) {
        return integrateMagnetizationFieldAtTime(t,
                                                 mTimeIntegrationOrder,
                                                 getSigma(),
                                                 getMagnetizationFieldTimeDerivative(),
                                                 Mt,
                                                 Mt);
        
    }
    
    inline tBoolean computeMagnetizationFieldAtTime(const tReal& dt,
                                                    EMM_RealField& Mt) {
        
        tBoolean succeeds=integrateMagnetizationFieldAtTime(dt,mTimeIntegrationOrder,
                                                            getSigma(),
                                                            getMagnetizationFieldTimeDerivative(),
                                                            getMagnetizationField(),
                                                            Mt);
        Mt.normalize();
        return succeeds;
    }
    

    


    //ENERGY methods
    //==============
   
   
   
    tReal computeEnergyTimeDerivativeAtTime(const tReal& t,const tFlag& order,tReal& dE_dt);
    
    tReal computeEnergyAtTime(const tReal& t,const tFlag& order);
    
  
   
    
    //Integration methods
    //===================


public:
  
    
    void computeFieldsAtTime(const tReal& t,
                             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) {
        makeRelaxation(isRestoring,retCode);
    }
    
    void makeRelaxation(const tBoolean& isRestoring,tSInt& retCode);


   
    
private:
    void computeFieldsAtTime(const tReal& t);
    
    
    //BACKUP & LOG methods
    //====================
public:

   



};

#endif