SM_BeamCycle.h

#ifndef SM_BeamCycle_H
#define SM_BeamCycle_H
 
//inherits header
#include "CORE_Object.h"
 
//beam header
#include "SM_Beam.h"
 
//stochastic output header
#include "SM_StochasticOutputComponent.h"
 
template<class CYCLE_CLASS>
class SM_BeamCycle : public CORE_Object {
   
    //attributes
private :
 
    //class type
    typedef  SM_BeamCycle<CYCLE_CLASS> SelfClass;
    typedef  CORE_Object SuperClass;
    
    tBoolean mIsSeedUpdated;
    tULLInt mSeed;
    tBoolean mIsRestoring;
    tBoolean mIsOutputSavedAtEachStep;
    
public:
    // CONSTRUCTORS 
    SM_BeamCycle(void) {
        mIsSeedUpdated=true;
        mSeed=0;
        mIsRestoring=false;
        mIsOutputSavedAtEachStep=true;
    }
  
    // DESTRUCTORS 
    virtual ~SM_BeamCycle(void) {
    }
    
 
 
public : 
    // CREATE class
   
 
    //SET & GET methods
 
   
 
    
      //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    
    // MAIN Method
 
public:
  
public:
 
    inline void setIsStochasticOutputSavedAtEachStep(const tBoolean& b) {
        mIsOutputSavedAtEachStep=b;
    }
    inline const tBoolean& isStochasticOutputSavedAtEachStep() const {
        return mIsOutputSavedAtEachStep;
    }
    
    inline void setIsSeedUpdatedPerCycleStep(const tBoolean& b) {
        mIsSeedUpdated=b;
    }
 
    inline const tBoolean& isSeedUpdatedPerCycleStep() const {
        return mIsSeedUpdated;
    }
    
    inline void setSeedPerCycleStep(const tULLInt& seed) {
        mSeed=seed;
    }
 
    inline const tULLInt& getSeedPerCycleStep() const {
        return mSeed;
    }
        
    
    inline void setIsRestoring(const tBoolean& v) {
        mIsRestoring=v;
    }
    inline const tBoolean& isRestoring() const{
        return mIsRestoring;
    }
    
public:
 
    
    inline tBoolean open(SM_Beam& beam,
                         SM_StochasticOutputComponent& stochasticOutput,
                         const tInteger& outputId,
                         tIndex& iCycleStep) {
        return static_cast< CYCLE_CLASS*>(this)->open(beam,stochasticOutput,outputId,iCycleStep);
    }
   
    inline void  nextCycleStep(const tIndex& iCycleStep,SM_Beam& beam,const SM_StochasticOutputComponent& output) {
       return nextCycleStep(iCycleStep,beam,0,output);
    }
    inline void  nextCycleStep(const tIndex& iCycleStep,SM_Beam& beam,const tInteger& outputId,const SM_StochasticOutputComponent& output) {
        static_cast< CYCLE_CLASS*>(this)->nextCycleStep(iCycleStep,beam,outputId,output);
    }
    inline tBoolean  isCycleFinished(const tIndex& iCycle,const SM_Beam& beam) {
        return static_cast< CYCLE_CLASS*>(this)->isCycleFinished(iCycle,beam);
    }
    inline tBoolean close(const tIndex& iCycle,const SM_Beam& beam) {
    
        return static_cast<CYCLE_CLASS*>(this)->close(iCycle,beam);
    }
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"\t is seed updated at each step of cycle:"<<((mIsSeedUpdated)?"true":"false")<<"\n";
        ret<<"\t updated seed at each step of cycle:"<<mSeed<<"\n";
        ret<<"\t is restoring:"<<mIsRestoring<<"\n";
        ret<<"\t stochastic output saved at each step:"<<mIsOutputSavedAtEachStep<<"\n";
        return ret.str();
    }
 
};
 
 
#endif