SM_Beam.hpp

#ifndef SM_Beam_HPP
#define SM_Beam_HPP
 
 
template<class System,class StochOutputImplement>
tBoolean SM_Beam::run(SM_StochasticOutput<StochOutputImplement>& outputSData) {
    tString routineName="SM_Beam::run<S,O>";
    CORE_Profiler::StartCallRoutine(routineName);
    
    tBoolean ok=true;
    
    //get the system
    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;
    }
    
    if (!this->hasStochasticFunctions()) {   
        //deterministic case with no stochastic function
        //----------------------------------------------
       
        
        //St=S0
        //std::cout<<"initialize magnetic directions ..\n";
        if (!system.initializeMagneticMomentDirections()) {
            throw CORE_Exception("stochmagnet/core",
                                 "SM_Beam::run(SM_StochasticOutput<StochOutputImplement>& outputSData)",
                                 "initialization of S(t=0) failed");
        }
 
        //std::cout<<"->begin run with no stoch function\n";
        //std::cout<<" open SO \n";
        //open the stochastic output the simulation  0 of the system
        outputSData.open(0,system);
        
        //running the system from the equilibrium
        ok= ok && system.deterministicRun(mPreconditioningStepsNumber+mStepsNumber,outputSData);
        
        //close the stochastic output the simulation 0 of the system
        //std::cout<<"close SO ..\n";
        outputSData.close(0,system,ok);
        //std::cout<<"->end run with no stoch function \n";
        
      
    } else {
 
        tIndex s0,s1;
        getBeamSize(s0,s1);
        //casting with stochastic function
        SM_MultiStochasticFunctionsInterface& sf=getStochasticFunctions();
        //std::cout<<"beam size ["<<s0<<","<<s1<<"[\n";
        for (tIndex s=s0;s<s1;s++) {
          
            
            //St=S0
            if (!system.initializeMagneticMomentDirections()) {
                throw CORE_Exception("stochmagnet/core",
                                     "SM_Beam::run(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
            //std::cout<<"preconditionning run \n";
            ok=system.stochasticRun(mPreconditioningStepsNumber,sf);
            
            //running the system   during loop steppers number
            //
            //std::cout<<"statistic run \n";
            ok= ok && system.stochasticRun(mStepsNumber,sf,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