EMM_ZeemanOperator.h

Go to the documentation of this file.

#ifndef EMM_ZeemanOperator_H
#define EMM_ZeemanOperator_H

#include "EMM_MagneticExcitationOperator.h"


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

  
private:
  
    
    
public:
   

    // ASSOCIATION
 
private:
   
    SP::EMM_RealField mHext;

    //initialization data file
    tString mInitialDataFile;
    SP::EMM_RealField  mInitialData;

protected: 

    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_ZeemanOperator(void);
  
    // DESTRUCTORS 
    
    virtual ~EMM_ZeemanOperator(void);   
  
  
public:
    inline static SP::EMM_ZeemanOperator New() {
        SP::EMM_ZeemanOperator p(new EMM_ZeemanOperator(),
                                 EMM_ZeemanOperator::Delete());
        p->setThis(p);
        return p;
    };
   
    virtual tBoolean isAffine() const {
        return true;
    };
    virtual tBoolean isGradientComputationable() const {
        return true;
    };
   
    inline void setInitialMagneticExcitation(const tString& dataFile) {
        mInitialDataFile=dataFile;
    }
    inline void setInitialMagneticExcitation(const tReal data[3]) {
        mInitialData->setSize(1);
        EMM_RealField &H=*mInitialData.get();
        H.setValue(0,data);
        mInitialDataFile="";
    }
    inline void setInitialMagneticExcitation(const CORE_RealArray& data) {
        setInitialMagneticExcitation(&data[0]);
    }
    inline void setInitialMagneticExcitation(const EMM_RealField& data) {
        mInitialData->copy(data);
        mInitialDataFile="";
    }
    
private:
    inline void setExternalMagneticExcitationField(const EMM_RealField& Hext) {
        if (Hext.getSize()==0) {
            mHext->initField(0.,0.,0.);
        }
        else  {
            mHext->copy(Hext);
        }
    }
    inline void setExternalMagneticExcitationField(const tReal H[3]) {
        mHext->setSize(1);
        mHext->initField(H[0],H[1],H[2]);
     
    }
   
    inline tBoolean setExternalMagneticExcitationField(const tString& HextFile) {
        return mHext->loadFromFile(HextFile);
    }

public:
    tBoolean isNull() const {
        tUIndex index;
        return (mHext->normMax(index)<1.e-12);
    }


    //FIELDS methods
    //================

    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 computeFieldsAtNextTimeStep(const tReal& dt,
                                                 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;
    }
    
    virtual  tUSInt getDataFieldsNumber() const {
        return 1;
    }
   
    virtual tBoolean getDataFieldSpace(const tUSInt& index,tString& dataName,tFlag& supportType,tString& dFieldType,tUIndex& n,tDimension& dim) const {
        if (index>1) return false;
        
        dataName="Hext";
        supportType=EMM_Grid3D::ELEMENT;
        n=mHext->getSize();
        dim=3;
        dFieldType=mHext->getTypeToString();
        return true;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const float *& values) const {
        if (index>1) return false;
        dataName="Hext";
        dim=mHext->getDimension();
        tBoolean succeeds=mHext->getValues(n,values);
        n/=dim;
        return succeeds;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const double *& values) const {
        if (index>1) return false;
        dataName="Hext";
        dim=mHext->getDimension();
        tBoolean succeeds=mHext->getValues(n,values);
        n/=dim;
        return succeeds;
        
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const long double *& values) const {
        if (index>1) return false;
        dataName="Hext";
        dim=mHext->getDimension();
        tBoolean succeeds=mHext->getValues(n,values);
        n/=dim;
        return succeeds;
        
    }


    //DATA methods
    //============
    
    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);
    

    virtual tBoolean resetToInitialState(const EMM_LandauLifschitzSystem& system);
    
   
    //MAGNETIC Excitation methods
    //==========================
    
    
    virtual void computeMagneticExcitationField(const EMM_RealArray& sigma,
                                                const EMM_RealField& M,
                                                EMM_RealField& H) const {
       
        H.copy(*mHext.get());
    }
    
    virtual tBoolean computeMagneticExcitationFieldGradient(const EMM_RealArray& sigma,
                                                            const EMM_RealField& M,
                                                            const EMM_RealField& D,
                                                            EMM_RealField& gradH) const {
        return false;
    }
    


    //ENERGY methods
    //===============
   

protected:
    virtual tReal computeEnergyWithMagneticExcitation(const tReal& t,
                                                      const EMM_RealArray& sigma,
                                                      const EMM_RealField& Mt,
                                                      const EMM_RealField& Ht)  const {
        return -2*getElementVolume()*Mt.dot(sigma,*mHext.get());
    }
    
    
public:
    
    virtual tReal computeEnergy(const tReal& t,
                                const EMM_RealArray& sigma,
                                const EMM_RealField& Mt,
                                EMM_RealField& W) const {
        return -2*getElementVolume()*Mt.dot(sigma,*mHext.get());
    }
    
};

#endif