EMM_AnisotropyOperator.h

Go to the documentation of this file.

#ifndef EMM_AnisotropyOperator_H
#define EMM_AnisotropyOperator_H


#include "EMM_MagneticExcitationOperator.h"

#include "EMM_AnisotropyDirectionsField.h"

DEFINE_SPTR(EMM_AnisotropyOperator);
class EMM_AnisotropyOperator : public virtual EMM_MagneticExcitationOperator {
    
    SP_OBJECT(EMM_AnisotropyOperator);
    // ATTRIBUTES
    
    
private:

    
public:
   

    // ASSOCIATION
 
private:
    
    //crystal type
    CORE_UCharMorseArray mCrystalType;

    //K1 adimensionized anisotropy
    CORE_RealMorseArray mK1;
    
    //K2 adimensionized anisotropy
    CORE_RealMorseArray mK2;

    //morse matrix
    CORE_RealMorseArray mA;

   
    
    //work size
    tUCInt mLDW;
  

    
protected: 

    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_AnisotropyOperator(void);
  
    // DESTRUCTORS 
    
    virtual ~EMM_AnisotropyOperator(void);   
  
  
public:
   
   
    // SET methods
    // ===========
    virtual tBoolean isAffine() const {
        return false;
    }
    virtual tBoolean isGradientComputationable() const {
        return true;
    };
    // GET methods
    // ===========
    virtual tULLInt getMemorySize() const {
        return EMM_Operator::getMemorySize()+mCrystalType.getMemorySize()+mA.getMemorySize()+mK1.getMemorySize()+mK2.getMemorySize()+mLDW*sizeof(tReal);
        
    }

 
   
public:    
  
    //DATA Methods
    //============
    
    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);

   
    inline const CORE_RealMorseArray& getK1() const {
        return mK1;
        
    }
    inline const CORE_RealMorseArray& getK2() const {
        return mK2;
        
    }    
    inline const CORE_RealMorseArray& getAnisotropyMatrix() const {
        return mA;
        
    }
 

protected:
    virtual void buildAnisotropyMatrix(const tUIndex& nCells,
                                       const EMM_Grid3D& mesh,
                                       const CORE_UCharMorseArray& crystal,
                                       const CORE_RealMorseArray& directions,
                                       CORE_RealMorseArray& A) const;
    

    //OPERATOR FIELDS Methods
    //=========================
    virtual tBoolean resetToInitialState(const EMM_LandauLifschitzSystem& system) {
        return true;
    }
    
    virtual tBoolean computeFieldsAtTime(const tReal& t,
                                         const tFlag& order,
                                         const EMM_RealArray& sigma,
                                         const EMM_RealField& dM_dt0,
                                         const EMM_RealField& M0) {
        return true;
    }
    
    
    virtual tBoolean updateAtNextTimeStep(const tReal& dt,
                                         const EMM_RealArray& sigma,
                                         const EMM_RealField& Mt) {
        return true;
    }
    //MAGNETIC Excitation field
    //==========================
    
    virtual void computeMagneticExcitationField(const tUIndex& nCells,
                                                const tDimension& dim,
                                                const EMM_RealArray& sigma,
                                                const tReal* M,
                                                tReal *H) const;
    
    
    virtual tBoolean computeMagneticExcitationFieldGradient(const tUIndex& nCells,
                                                            const tDimension& dim,
                                                            const EMM_RealArray& sigma,
                                                            const tReal *M,
                                                            const tReal *D,
                                                            tReal  *gradH)const;


    //ENERGY Methods
    //==============
  
    
    virtual tReal computeEnergyWithMagneticExcitation(const tUIndex& nCells,const tDimension& dim,
                                                      const EMM_RealArray& sigma,
                                                      const tReal* M,const tReal* H) const;
    
    
  

};

#endif