SM_Beam.h

#ifndef SM_Beam_H
#define SM_Beam_H
 
//define the std::valarray object
#include <valarray>
//define the std::array object
#include <array>
 
//base class
#include "SM_Object.h"
 
//system class
#include "SM_System.h"
 
//stochastic functions per threads
#include "SM_MultiStochasticFunctions.h"
 
//stochastic output
#include "SM_StochasticOutput.h"
 
 
class SM_Beam : public SM_Object {
    
    //attributes
private :
    
    
    //number of simulations
    tIndex mBeamSize;
    tIndex mBeginSimulationIndex;
    tIndex mEndSimulationIndex;
    
    //associations
    //============
 
    //system
    CORE_UniquePointer<SM_System> mSystem;
    
    //stochastic functions per thread
    CORE_UniquePointer<SM_MultiStochasticFunctionsInterface> mMultiStochasticFunctions;
    
 
    tIndex mPreconditioningStepsNumber;
    tIndex mStepsNumber;
    
  
protected:
    // CONSTRUCTORS 
    SM_Beam(void) {
        mBeamSize=1;
        mPreconditioningStepsNumber=0;
        mStepsNumber=1000;
        mBeginSimulationIndex=0;
        mEndSimulationIndex=mBeamSize;
    }
    
    // DESTRUCTORS 
    virtual ~SM_Beam(void) {
    }
    
public : 
  
    //MEMORY
    
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=(mMultiStochasticFunctions.get()==null)?0:mMultiStochasticFunctions->getMemorySize();
        mem+=(mSystem.get()==null)?0:mSystem->getMemorySize();
        return mem;
    }
 
    
    //SET & GET methods
 
 
    //data
    //====
    inline void setBeamSize(const tIndex& n) {
        mBeamSize=n;
        mBeginSimulationIndex=0;
        mEndSimulationIndex=n;
    }
    inline void setBeamSize(const tIndex& s0,const tIndex& s1) {
        mBeamSize=s1-s0;
        mBeginSimulationIndex=s0;
        mEndSimulationIndex=s1;
    }
    inline const tIndex& getBeamSize() const {
        return mBeamSize;
    }
    inline const tIndex& getBeamSize(tIndex& s0,tIndex& s1) const {
        s0= mBeginSimulationIndex;
        s1= mEndSimulationIndex;
        return mBeamSize;
    }
 
 
    //steps data
    //=============
 
    inline void setPreconditioningStepsNumber(const tIndex& n) {
        mPreconditioningStepsNumber=n;
 
    }
    inline const tIndex& getPreconditioningStepsNumber() const {
        return mPreconditioningStepsNumber;
 
    }
    inline void setStepsNumber(const tIndex& n) {
        mStepsNumber=n;
    }
    inline const tIndex& getStepsNumber() const {
        return mStepsNumber;
 
    }
    //Stochastic functions
    //====================
    
    inline void resetStochasticFunctions() {
        mMultiStochasticFunctions.reset();
        
    }
    inline void setStochasticFunctions(CORE_UniquePointer<SM_MultiStochasticFunctionsInterface>& f) {
        mMultiStochasticFunctions=std::move(f);
       
    }
 
    inline tBoolean hasStochasticFunctions() const {
        return (mMultiStochasticFunctions.get()!=null);
    }
    inline const SM_MultiStochasticFunctionsInterface&  getStochasticFunctions() const {
        return *mMultiStochasticFunctions.get();
    }
    inline  SM_MultiStochasticFunctionsInterface&  getStochasticFunctions()  {
        return *mMultiStochasticFunctions.get();
    }
   
 
    //noise
 
   
    
    //System
    //====
 
    inline void setSystem(CORE_UniquePointer<SM_System> system) {
        mSystem=std::move(system);
    }
    
    inline const SM_System& getSystem() const {
        return *mSystem.get();
    }
 
    inline SM_System& getSystem() {
        return *mSystem.get();
    }
    
    inline  tBoolean hasSystem() const {
        return (mSystem.get()!=null);
    }
    
    // MAIN Method
public:
 
   
    inline void normalize(const tBoolean& isAdimensionized) {
        getSystem().normalize(isAdimensionized);
    }
    inline void discretize() {
 
        //discretize the system
        getSystem().discretize();
 
    }
   
                         
    template<class System,class StochOutputImplement>
    tBoolean run(SM_StochasticOutput<StochOutputImplement>& outputSData);
 
     
    
    
    virtual tString toString() const override {
        std::stringstream ret;
        //print id
        ret<<SM_Object::toString()<<"\n";
        //print beam size
        ret<<"beam size: "<<mBeamSize<<"\n";
        ret<<"preconditioning steps number: "<<mPreconditioningStepsNumber<<"\n";
        ret<<"steps number: "<<mStepsNumber<<"\n";
        
        ret<<"stochastic Function:";
        if (mMultiStochasticFunctions.get()!=null) 
            ret<<mMultiStochasticFunctions->toString()<<"\n";
        else
            ret<<"null\n";
        
        ret<<"system:";
        if (hasSystem()) 
            ret<<getSystem().toString()<<"\n";
        else
            ret<<"null\n";
        return ret.str();
        
    }
    
};
 
#include "SM_Beam.hpp"
 
#endif