EMM_MagnetostrictionOperator.h

Go to the documentation of this file.

#ifndef EMM_MagnetostrictionOperator_H
#define EMM_MagnetostrictionOperator_H

#include "EMM_MagneticExcitationOperator.h"

#include "EMM_DisplacementOperator.h"


#include "CORE_MorseArray.h"

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

  
private:
  
    tReal mMagneticExcitationAdimensionizedParameter;
    tBoolean mIsMagneticAdimension;
    
public:
   

    // ASSOCIATION
 
private:

  
    
    //displacement operator
    SP::EMM_DisplacementOperator mDisplacementOperator;

 
    
protected: 

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

     
    // SET methods
    // ===========
  
    virtual tBoolean isAffine() const {
        return false;
    }
    virtual tBoolean isGradientComputationable() const {
        return false;
    };
    
    virtual tULLInt getMemorySize() const {
        return EMM_Operator::getMemorySize()+
            mDisplacementOperator->getMemorySize();
    }

    //OPERATOR FIELDS Methods
    //====================

    inline void setIsMagneticAdimension(const tBoolean& v) {
        mIsMagneticAdimension=v;
    }
    
    void setDisplacementMethod(const tString& m);
    
    
    void setDisplacementOperator(SP::EMM_DisplacementOperator  op);
    
    void resetDisplacementOperator();
    
    inline const EMM_DisplacementOperator& getDisplacementOperator()  const {
        return *mDisplacementOperator.get();
    }
    inline EMM_DisplacementOperator& getDisplacementOperator()   {
        return *mDisplacementOperator.get();
    }
    

  
    virtual  tUSInt getDataFieldsNumber() const {
        return mDisplacementOperator->getDataFieldsNumber();
    }
   
    virtual tBoolean getDataFieldSpace(const tUSInt& index,tString& dataName,tFlag& supportType,tString& dFieldType,tUIndex& n,tDimension& dim) const {
      
        return mDisplacementOperator->getDataFieldSpace(index,dataName,supportType,dFieldType,n,dim);
      
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const float *& values) const {
        
        return mDisplacementOperator->getDataField(index,dataName,n,dim,values);
    }
    
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const double *& values) const { 
       
        return mDisplacementOperator->getDataField(index,dataName,n,dim,values);
       
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const long double *& values) const {
      
        return mDisplacementOperator->getDataField(index,dataName,n,dim,values);
            
    }
public:
    virtual tBoolean backup(const tString& prefix,const tString& suffix,const tString& ext) const;
    virtual tBoolean restore(const EMM_LandauLifschitzSystem& system,
                             const tString& prefix,const tString& suffix,const tString& ext);
    
public:
    virtual tBoolean computeFieldsAtTime(const tReal& t,
                                         const tFlag& order,
                                         const EMM_RealArray& sigma,
                                         const EMM_RealField& dM_dt0,
                                         const EMM_RealField& M0);
    
    
  
     
    virtual tBoolean updateAtNextTimeStep(const tReal& dt,
                                         const EMM_RealArray& sigma,
                                          const EMM_RealField& Mt);
        
    //DATA methods
    //============
  
    virtual void adimensionize(const tReal& Le,const tReal& Ms,const tReal& T,const tReal& L) {
        
        if (mIsMagneticAdimension) mMagneticExcitationAdimensionizedParameter=Le/(EMM_Object::Mu0*Ms*Ms);
        else mMagneticExcitationAdimensionizedParameter=1.;
        
        mDisplacementOperator->adimensionize(Le,Ms,T,L);
    }
    
    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);

    virtual tBoolean resetToInitialState(const EMM_LandauLifschitzSystem& system);
    

    //MAGNETIC Excitation field methods
    //==================================
    
protected:
     
    virtual void computeMagneticExcitationField(const tUIndex& nCells,
                                                const tDimension& dim,
                                                const EMM_RealArray& sigma,
                                                const tReal* M,
                                                tReal *H) const;

    
public:
    virtual tBoolean computeMagneticExcitationFieldGradient(const tUIndex& nCells,
                                                            const tDimension& dim,
                                                            const EMM_RealArray& sigma,
                                                            const tReal *M,
                                                            const tReal *D,
                                                            tReal  *gradH)const {
        throw EMM_Exception("emicrom/operators/magnetostriction",
                            "EMM_MagnetostrictionOperator::computeMagneticExcitationFieldGradient()",
                            "gradient of operator is not computationable");
        return true;
    }

    //ENERGY Methods
    //===============

protected:
    
    tReal computeEnergy(const tReal& t,
                        const tUIndex& nCells,const tDimension& dim,
                        const EMM_RealArray& sigma,
                        const tReal* M) const;



    
   
    
    virtual tString toString() const;
    

};

#endif