SM_MonteCarloBeam.hpp

#ifndef SM_MonteCarloBeam_HPP
#define SM_MonteCarloBeam_HPP
 
 
//stochastic functions header for templated casting
#include "SM_TRNGStochasticFunctions.h"
#include "SM_TRNGStochasticFunctions_MT19937.h"
#include "SM_BoostStochasticFunctions.h"
#include "SM_STDStochasticFunctions.h"
#include "SM_MTStochasticFunctions.h"
 
    
template<class StochOutputImplement>
tBoolean SM_MonteCarloBeam::runWithSCStochasticFunctions(SM_StochasticOutput<StochOutputImplement>& outputSData) {
    
    //casting with stochastic function
    SM_MultiStochasticFunctionsInterface * sf=&getStochasticFunctions();
    
    SM_MultiStochasticFunctions<SM_STDStochasticFunctions_MT19937>* fstd=dynamic_cast<SM_MultiStochasticFunctions<SM_STDStochasticFunctions_MT19937>*>(sf);
    if (fstd!=null) {
        return runWithSCStochasticFunctions(*fstd,outputSData);
    }
    
    SM_MultiStochasticFunctions<SM_BoostStochasticFunctions_MT19937>* fboost=dynamic_cast<SM_MultiStochasticFunctions<SM_BoostStochasticFunctions_MT19937>*>(sf);
    if (fboost!=null) {
        return runWithSCStochasticFunctions(*fboost,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MT19937>* ftrng=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MT19937>*>(sf);
    if (ftrng!=null) {
        return runWithSCStochasticFunctions(*ftrng,outputSData);
    }
    
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_LCG64>* ftrngp_lcg64=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_LCG64>*>(sf);
    if (ftrngp_lcg64!=null) {
        return runWithSCStochasticFunctions(*ftrngp_lcg64,outputSData);
    }
 
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_YARN2>* ftrngp_yarn2=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_YARN2>*>(sf);
    if (ftrngp_yarn2!=null) {
        return runWithSCStochasticFunctions(*ftrngp_yarn2,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG2>* ftrngp_mrg2=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG2>*>(sf);
    if (ftrngp_mrg2!=null) {
        return runWithSCStochasticFunctions(*ftrngp_mrg2,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG3>* ftrngp_mrg3=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG3>*>(sf);
    if (ftrngp_mrg3!=null) {
        return runWithSCStochasticFunctions(*ftrngp_mrg3,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG3s>* ftrngp_mrg3s=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG3s>*>(sf);
    if (ftrngp_mrg3s!=null) {
        return runWithSCStochasticFunctions(*ftrngp_mrg3s,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG4>* ftrngp_mrg4=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG4>*>(sf);
    if (ftrngp_mrg4!=null) {
        return runWithSCStochasticFunctions(*ftrngp_mrg4,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG5>* ftrngp_mrg5=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG5>*>(sf);
    if (ftrngp_mrg5!=null) {
        return runWithSCStochasticFunctions(*ftrngp_mrg5,outputSData);
    }
    SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG5s>* ftrngp_mrg5s=dynamic_cast<SM_MultiStochasticFunctions<SM_TRNGStochasticFunctions_MRG5s>*>(sf);
    if (ftrngp_mrg5s!=null) {
        return runWithSCStochasticFunctions(*ftrngp_mrg5s,outputSData);
    }
    SM_MultiStochasticFunctions<SM_MTStochasticFunctions_MT19937>* fvampire=dynamic_cast<SM_MultiStochasticFunctions<SM_MTStochasticFunctions_MT19937>*>(sf);
    if (fvampire!=null) {
        return runWithSCStochasticFunctions(*fvampire,outputSData);
    }
 
    //default runs
    return run(outputSData);
    
}
 
 
 
template<class StochFunctionsImplement, class StochOutputImplement>
tBoolean SM_MonteCarloBeam::runWithSCStochasticFunctions(SM_MultiStochasticFunctions<StochFunctionsImplement>& stochFunctions,
                                                         SM_StochasticOutput<StochOutputImplement>& outputSData) {
 
    tString routineName="SM_MonteCarloBeam::templatedRun<S,O>()";
    CORE_Profiler::StartCallRoutine(routineName);
    
    //get the size of the beam
    tIndex s0,s1;
    getBeamSize(s0,s1);
 
    //has simulation  succeeded
    tBoolean ok=true;
    
    //system of the beam
    System& system=*dynamic_cast<System*>(&getSystem());
  
    //open the stochastic at the beginning of the simulations running of the beam
    if (!outputSData.open(*this)) {
        std::cout<<"stochastic output "<<outputSData.getIdentityString()<<" not compatible with the system \n";
        return false;
    }
    
    for (tIndex s=s0;s<s1;s++) {
      
        //St=S0
        if (!system.initializeMagneticMomentDirections()) {
              //St=S0
            
            throw CORE_Exception("stochmagnet/monteCarlo",
                                 "SM_MonteCarloBeam::runWithSCStochasticFunctions(stochF,SM_StochasticOutput<StochOutputImplement>& outputSData)",
                                 "initialization of S(t=0) failed");
        
        }
  
        //open the stochastic output the simulation  0 of the system
        outputSData.open(s,system);
 
        
        //running the system until the equilibrium
        ok=system.stochasticRunWithSCStochasticFunctions(getPreconditioningStepsNumber(),stochFunctions);
        
        //running the system   during loop steppers number
        ok= ok && system.stochasticRunWithSCStochasticFunctions(getStepsNumber(),stochFunctions,outputSData);
        
        
        //close the outputSData for simulation s at the end of simulations
        outputSData.close(s,system,ok); 
    }  
    
    
    //close the stochastic output at the end of the runnings  of the simulations
    outputSData.close(*this);
    CORE_Profiler::EndCallRoutine(routineName);
    return true;
}
#endif