SMOMPI_LandauLifschitzBeam.hpp

#ifndef SMOMPI_LandauLifschitzBeam_HPP
#define SMOMPI_LandauLifschitzBeam_HPP
 
 
//stochastic functions headers for templated casting
#include "SM_TRNGStochasticFunctions.h"
#include "SM_TRNGStochasticFunctions_MT19937.h"
#include "SM_BoostStochasticFunctions.h"
#include "SM_STDStochasticFunctions.h"
#include "SM_MTStochasticFunctions.h"
 
//noise rate functions headers  for templated casting
#include "SM_ConstantNoiseRateFunction.h"
#include "SM_InverseNoiseRateFunction.h"
template<class StochOutputImplement>
tBoolean SMOMPI_LandauLifschitzBeam::runWithSCStochasticFunctions(SM_StochasticOutput<StochOutputImplement>& outputSData) {
    
    //casting with stochastic function
    SM_MultiStochasticFunctionsInterface * sf=&this->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  SMOMPI_LandauLifschitzBeam::runWithSCStochasticFunctions(SM_MultiStochasticFunctions<StochFunctionsImplement>& stochFunctions,
                                                                   SM_StochasticOutput<StochOutputImplement>& outputSData) {
    //casting with stochastic function
    SM_NoiseRateFunctionInterface * gNRF=&this->getLLSystem().getNoiseRateFunction();
    
    SM_ConstantNoiseRateFunction *cNRF=dynamic_cast<SM_ConstantNoiseRateFunction *>(gNRF);
    if (cNRF!=null) {
        return runWithSCStochasticFunctions(stochFunctions,*cNRF,outputSData);
    }
    SM_InverseNoiseRateFunction *iNRF=dynamic_cast<SM_InverseNoiseRateFunction *>(gNRF);
    if (iNRF!=null) {
        return runWithSCStochasticFunctions(stochFunctions,*iNRF,outputSData);
    }
    //default runs
    return run(outputSData);
     
} 
 
template<class StochFunctionsImplement, class NoiseRateFunctionImplement,class StochOutputImplement>
tBoolean SMOMPI_LandauLifschitzBeam::runWithSCStochasticFunctions(SM_MultiStochasticFunctions<StochFunctionsImplement>& stochFunctions,
                                                                  const SM_NoiseRateFunction<NoiseRateFunctionImplement>& noiseRateFunction,
                                                                  SM_StochasticOutput<StochOutputImplement>& outputSData) {
    tString routineName="SMOMPI_LandauLifschitzBeam::templatedRun<S,N,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 outputSData
    if (!outputSData.open(*this)) {
        std::cout<<"stochastic output "<<outputSData.getIdentityString()<<" not compatble with the system \n";
        return false;
    }
 
    
    //make all the simulations
    for (tIndex s=s0;s<s1;s++) {
      
        //St=S0
        if (!system.initializeMagneticMomentDirections()) {
            throw CORE_Exception("stochmagnet/core",
                                 "SMOMPI_LandauLifshitzSystemBeam::runWithSCStochasticFunctions(StochFunction,noiseRate,outputSData)",
                                 "initialization of S(t=0) failed");
        }
          
        //open the data for s-th simulation
        outputSData.open(s,system);
 
        //make the  steps to equilibrium
        ok=system.stochasticRunWithSCStochasticFunctions(getPreconditioningStepsNumber(),stochFunctions,noiseRateFunction);
        
        //make the  steps for stochastic
        ok=system.stochasticRunWithSCStochasticFunctions(getStepsNumber(),stochFunctions,noiseRateFunction,outputSData);
        //if the simulation has succed, compute the raw esperance
        outputSData.close(s,system,ok);
        
    }
    //if all simulations are beed fullfiled compute the esperance from raw data
    outputSData.close(*this);
 
    CORE_Profiler::EndCallRoutine(routineName);
    return true;
}
 
 
#endif