SM_BeamTemperatureRange.h

#ifndef SM_BeamTemperatureRange_H
#define SM_BeamTemperatureRange_H
 
//inherits header
#include "SM_BeamCycle.h"
 
 
class SM_BeamTemperatureRange: public SM_BeamCycle<SM_BeamTemperatureRange> {
   
    //attributes
private :
 
    //class type
    typedef  SM_BeamTemperatureRange SelfClass;
    typedef  SM_BeamCycle<SelfClass> SuperClass;
    
    std::array<tReal,3> mTemperatureRange;
    tString mKFileName;//temperature file
    tIndex mBeamSize;
    
public:
    // CONSTRUCTORS 
    SM_BeamTemperatureRange(void) {
       
    }
  
    // DESTRUCTORS 
    virtual ~SM_BeamTemperatureRange(void) {
    }
    
 
 
public : 
    // CREATE class
   
 
    //SET & GET methods
 
   
 
    
      //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=3*SM_Constants::DIM*sizeof(tReal);//mTemperatureRange
        mem+=mKFileName.length()*sizeof(tChar);
        return mem;
    }
    
    //New method
    static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SelfClass::Delete()); 
        
    }
 
public:
  
public:
    
    inline void setTemperatureRange(const std::array<tReal,3>& range) {
        const tReal *iRange=range.data();
        for(auto& Tk:mTemperatureRange) {
            Tk=(*iRange);
            iRange++;
        }
       
    }
 
 
    inline void setTemperaturesFileName(const tString& Kfile) {
        mKFileName=Kfile;
       
    }
    
public:
 
    
    inline tBoolean open(SM_Beam& beam,SM_StochasticOutputComponent& stochasticOutput,
                         const tInteger& outputId,tIndex& iCycleStep) {
        iCycleStep=0;
  
        //system
        SM_System& system=beam.getSystem();
        
 
        //set the temperature of the system
        system.setNoiseTemperature(mTemperatureRange[0]);
 
        //open temperatures file
        if (outputId==0) {
            std::ofstream file(mKFileName.c_str(),std::ios::out);
            if (!file) {
                std::cout<<"impossible to open Temperature Range file "<<mKFileName<<"\n";
                return false;
            }
            
            
            //print header in temperature file
            printHeader(file,beam,stochasticOutput.getOutputDescription());
            
            //close the file
            file.close();
        }
      
        if (mTemperatureRange[0]==0) {
            //store beam size
            mBeamSize=beam.getBeamSize();
            //only one simulation is needed
            beam.setBeamSize(1);
        }
        
        return true;
    }
    inline void  nextCycleStep(const tIndex& iCycleStep,SM_Beam& beam,
                               const tInteger& outputId,const SM_StochasticOutputComponent& output) {
       
        //system
        SM_System& system=beam.getSystem();
 
        //S
        const SM_RealField& S=system.getMagneticMomentDirections();
 
 
        //save the data
        if (outputId==0) {
            std::ofstream file(mKFileName.c_str(),std::ios::app);
            const std::valarray<tReal>& outputs=output.getOutputValues();
            for(const auto& r:outputs) {
                file<<std::setprecision(12)<<r<<"\t";
            }
            file<<"\n";
            file.close();
 
        }
        
        //set the next temperature
        tReal T=beam.getSystem().getNoiseTemperature();
        if (T==0) {
            //restore beam size
            beam.setBeamSize(mBeamSize);
        }
        
        T+=mTemperatureRange[2];
        
        system.setNoiseTemperature(T);
        
 
        //set the next initial direction to last magnetic moment direction computed
        system.updateInitialMagneticMomentDirections(S);
      
    }
    
    inline tBoolean  isCycleFinished(const tIndex& iCycle,const SM_Beam& beam) {
        return (beam.getSystem().getNoiseTemperature()>=mTemperatureRange[1]);
    }
    inline tBoolean close(const tIndex& iCycle,const SM_Beam& beam) {
        return true;
    }
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"\t Cycle temperature range:"<<functions_array::toString(mTemperatureRange)<<"\n";
        return ret.str();
    }
private:
    inline void printHeader(std::ofstream& file,const SM_Beam& beam,const std::vector<tString>& outputDescription) const {
        
        file<<"# Temperature Range cycle Beam generated by soft:"<<CORE_Run::GetSoftName()<<" Version:"<<CORE_Run::GetVersion()<<"\n";
        tString str="Temperature Range :"+this->toString();
        functions_string::replaceAll("\n","\n#",str);
        file<<"#"<<str<<"\n";
        
        str="beam:"+beam.toString();
        functions_string::replaceAll("\n","\n#",str);
        file<<"#"<<str<<"\n";
 
        file<<"#";
        for(const auto& d:outputDescription) file<<"\t"<<d;
        file<<"\n";
    }
 
   
 
};
 
 
#endif