SM_BeamTimeStepRange.h

#ifndef SM_BeamTimeStepRange_H
#define SM_BeamTimeStepRange_H
 
//inherits header
#include "SM_BeamCycle.h"
 
//LL system header
#include "SM_LandauLifschitzSystem.h"
 
class SM_BeamTimeStepRange: public SM_BeamCycle<SM_BeamTimeStepRange> {
   
    //attributes
private :
 
    //class type
    typedef  SM_BeamTimeStepRange SelfClass;
    typedef  SM_BeamCycle<SelfClass> SuperClass;
    
    std::array<tReal,3> mTimeStepLogRange;//log of time
    tString mDtFileName;//time steps file
    tReal mRelaxedTime;//adimensionized relaxed time
    tReal mTargetTime;//adimensionized target time
    
public:
    // CONSTRUCTORS 
    SM_BeamTimeStepRange(void) {
       
    }
  
    // DESTRUCTORS 
    virtual ~SM_BeamTimeStepRange(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+=mTimeStepLogRange.size()*sizeof(tReal);//mTimeStepRange
        mem+=mDtFileName.length()*sizeof(tChar);
        return mem;
    }
    
    //New method
    static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SelfClass::Delete()); 
        
    }
 
public:
  
public:
    
    inline void setTimeStepRange(const std::array<tReal,3>& range) {
        const tReal *iRange=range.data();
        for(auto& Tk:mTimeStepLogRange) {
            Tk=(*iRange);
            iRange++;
        }
       
    }
 
 
    inline void setTimeStepsFileName(const tString& dtfile) {
        mDtFileName=dtfile;
       
    }
    
public:
 
    inline tBoolean open(SM_Beam& beam,SM_StochasticOutputComponent& stochasticOutput,
                         const tInteger& outputId,tIndex& iCycleStep) {
        iCycleStep=0;
   
        //system
        SM_System& system=beam.getSystem();
 
        //characteristic time step in s
        const tReal& tc=system.getMaterial().getCharacteristicTime();
       
        
        SM_LandauLifschitzSystem *llSystem=dynamic_cast<SM_LandauLifschitzSystem *>(&system);
        if (llSystem==null) return false;
 
       
        
        //get the number of steps
        const tIndex& nPS=beam.getPreconditioningStepsNumber();
        const tIndex& nLS=beam.getStepsNumber();
        
        //set the adimensionized time step
        const tReal& ldt=mTimeStepLogRange[0];//log(dt) in ps
        tReal dt=pow(10,ldt-12)/tc;//dt=10^{log(dt)-12) is s
        llSystem->getTimeStepper().setTimeStep(dt);
 
        //adimensionized relaxed time 
        mRelaxedTime=nPS*dt;
        
        //adimensionized target time
        mTargetTime=nLS*dt;
      
 
        //open time steps  file
        if (outputId==0) {
            std::ofstream file(mDtFileName.c_str(),std::ios::out);
            if (!file) {
                std::cout<<"impossible to open TimeStep Range file "<<mDtFileName<<"\n";
                return false;
            }
            
            //print header in temperature file
            printHeader(file,beam,stochasticOutput.getOutputDescription());
            
            //close the file
            file.close();
        }
        
      
        
        return true;
    }
    inline void  nextCycleStep(const tIndex& iCycleStep,SM_Beam& beam,const tInteger& outputId,const SM_StochasticOutputComponent& output) {
 
       
        
        //system
        SM_System& system=beam.getSystem();
 
        //LL -system
        SM_LandauLifschitzSystem *llSystem=dynamic_cast<SM_LandauLifschitzSystem *>(&system);
        if (llSystem==null) return;
        
        //get the current adimensionized time step
        tReal dt=llSystem->getTimeStepper().getTimeStep();
        
        //caracteristic time in s
        const tReal& tc=system.getMaterial().getCharacteristicTime();
 
        //save the data
        if (outputId==0) {
            std::ofstream file(mDtFileName.c_str(),std::ios::app);
            //time step in s
            file<<(dt*tc)<<"\t";
            //precondition time steps
            file<<beam.getPreconditioningStepsNumber()<<"\t";
            //time steps
            file<<beam.getStepsNumber()<<"\t";
            const std::valarray<tReal> &outputs=output.getOutputValues();
            //print the output values
            for(const auto& r:outputs) {
                file<<r<<"\t";
            }
            file<<"\n";
            file.close();
 
        }
        //log of dt is ps at next cycle
        tReal ldt=mTimeStepLogRange[0]+mTimeStepLogRange[2]*(iCycleStep+1);//log(dt) in ps
        //next timme step
        dt=pow(10,ldt-12)/tc;//dt=10^{log(dt)-12) is s
        llSystem->getTimeStepper().setTimeStep(dt);
 
 
        //set the next steps in order to keep target & relaxed tilme unchanged
        beam.setPreconditioningStepsNumber(mRelaxedTime/dt);
        beam.setStepsNumber(mTargetTime/dt);
       
      
    }
    
    inline tBoolean  isCycleFinished(const tIndex& iCycleStep,const SM_Beam& beam) {
        const SM_LandauLifschitzSystem *llSystem=dynamic_cast<const SM_LandauLifschitzSystem *>(&(beam.getSystem()));
        if (llSystem==null) return true;
        tReal ldt=mTimeStepLogRange[0]+mTimeStepLogRange[2]*iCycleStep;//log(dt) in ps
        return (ldt>=mTimeStepLogRange[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 time step range:"<<functions_array::toString(mTimeStepLogRange)<<"\n";
        return ret.str();
    }
private:
    inline void printHeader(std::ofstream& file,const SM_Beam& beam,const std::vector<tString>& outputDescription) const {
        
        file<<"# TimeStep Range cycle Beam generated by soft:"<<CORE_Run::GetSoftName()<<" Version:"<<CORE_Run::GetVersion()<<"\n";
        tString str="Log of Time Step in ps  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<<"#<dt in s> <number of preconditioning steps> <number of statistic steps>";
        for(const auto& d:outputDescription) file<<"\t"<<d;
        file<<"\n";
    }
 
   
 
};
 
 
#endif