EMMH_Hysteresis.h

Go to the documentation of this file.

#ifndef EMMH_Hysteresis_H
#define EMMH_Hysteresis_H

#include "EMM_Object.h"


#include "EMMH_HysteresisFile.h"

#include "EMM_LandauLifschitzSystem.h"

DEFINE_SPTR(EMMH_Hysteresis);
class EMMH_Hysteresis : public EMM_Object {
    SP_OBJECT(EMMH_Hysteresis);
    
    //attributes
private :

    //number of cycles
    tUInteger mHalfCyclesNumber;
    
     //number of steps by cycle
    tUInteger mStepsNumber;

    //steps for generating output
    tUInteger mOutputSteps;

    //indicates if the hysteresis file has to be restored
    tBoolean mIsRestoring;
    
    //external magnetic field
    EMM_RealArray mHext;

    //to set the magnetization at the begining of the hysteresis process
    tString  mMInit;
    
    //equilibrium magnetim indicators
    EMM_RealArray mM;

    //flush for writing hysteresis file
    tUSInt mFlowSize;

    //indicates to remove old backup files
    tBoolean mIsBackupOldFilesRemoving;

    //indicates if the magntzaisation time integration log is printed
    tBoolean mAreSystemLogsPrinted;
    
    //hysteresis file
    SP::EMMH_HysteresisFile mFile;

    //system to compute the hystereis
    SP::EMM_LandauLifschitzSystem mSystem;
 
    
protected: 
    // CONSTRUCTORS 
    EMMH_Hysteresis(void);
  
    // DESTRUCTORS 
    virtual ~EMMH_Hysteresis(void);
    
public:
    inline static SP::EMMH_Hysteresis New() {
        SP::EMMH_Hysteresis p(new EMMH_Hysteresis(),EMMH_Hysteresis::Delete());
        p->setThis(p);
        return p;
    };

    //SET methods
    //============


    inline void setIsOldBackupFilesRemoved(const tBoolean& v) {
        mIsBackupOldFilesRemoving=v;
    }

    inline void setAreSystemLogsPrinted(const tBoolean& v) {
        mAreSystemLogsPrinted=v;
    }

    inline void setFlowSize(const tUSInt& n) {
        mFlowSize=n;
    }
    
    inline void setHysteresisFile(const tString& fileName) {
        mFile=EMMH_HysteresisFile::New();
        mFile->setFileName(fileName);
    }
    inline void setInitialMagnetizationField(const tString& initValue) {
        mMInit=initValue;
    }

    inline void setStepsNumber(const tUInteger& n) {
        mStepsNumber=n;    
    }
    inline void setHalfCyclesNumber(const tUInteger& n) {
        mHalfCyclesNumber=n;    
    }

    inline void setOutputSteps(const tUInteger& n) {
        mOutputSteps=n;
    }

    inline void setIsRestoring(const tBoolean& v) {
        mIsRestoring=v;
    }
    inline void setInitialExternalMagneticExcitationField(const tReal H[3]) {
        mHext.setSize(6);
        mHext[0]=H[0];
        mHext[1]=H[1];
        mHext[2]=H[2];
    }
    
    inline void setFinalExternalMagneticExcitationField(const tReal H[3]) {
        mHext.setSize(6);
        mHext[3]=H[0];
        mHext[4]=H[1];
        mHext[5]=H[2];
    }


    inline void setExternalMagneticExcitationField(const tString& fn) {
        if (fn.compare("")!=0) mHext.loadFromFieldFile(fn);
    }


    inline void setSystem(SP::EMM_LandauLifschitzSystem s) {
        mSystem=s;
    }
    
    inline static tString getSuffix(const tUInteger& i,const tUInteger& iHCycle) {
         return CORE_Integer::toString(iHCycle,2)+"_"+CORE_Integer::toString(i,5);
    }
private:
    void setInitialMagnetizationField(const EMM_RealArray& Hext,
                                      const tString& MinitFile,
                                      EMM_LandauLifschitzSystem& system) const;
public:
    //runner method
    //=============
    tBoolean run();
    
};


#endif