SMOMPI_BeamRunner.hpp

#ifndef SMOMPI_BeamRunner_HPP
#define SMOMPI_BeamRunner_HPP
 
//runner header
#include "CORE_Run.h"
 
//LL beam
#include "SMOMPI_LandauLifschitzBeam.h"
 
//loader headers
#include "SM_LandauLifschitzLoader.h"
#include "SM_MonteCarloLoader.h"
 
//cycle  loader header
#include "SM_CycleLoader.h"
 
//stochastic output loader header
#include "SM_StochasticOutputLoader.h"
 
//mpi header
#include "MPI_Run.h"
#include "MPI_WorldToWorldMessage.h"
#include "MPI_Chrono.h"
 
 
template<class BEAM,class STOCHASTIC_OUTPUT> requires ( ! functions_type::isBaseOf<SM_StochasticJs,STOCHASTIC_OUTPUT>) 
tBoolean SMOMPI_BeamRunner::RunBeam(const tBoolean& isTemplatedRun,
                                    BEAM& beam,
                                    STOCHASTIC_OUTPUT& stochasticOutput) {
    
    if (isTemplatedRun) {
        return beam.runWithSCStochasticFunctions(stochasticOutput);
    } else {
        return beam.run(stochasticOutput);
    }
}
 
//BEAM RUNNER
//===========
template<class STOCHASTIC_OUTPUT>
tBoolean SMOMPI_BeamRunner::Run(const CORE_Run& runner,
                                STOCHASTIC_OUTPUT& stochasticOutput,
                                const CORE_OptionsList& options)  {
 
 
    tBoolean succeeds=true;
   
   
   
    //MPI environment
    const MPI_Environment& mpiEnv=MPI_Run::GetEnvironment();
    
    //current id of the MPI core
    const tMPICoreId& coreId=mpiEnv.getCoreId();
    
    //number of MPI cores
    const tMPICoreId& coresNumber=mpiEnv.getCoresNumber();
 
 
    //prefix of core
    int nDigits=(int)(log(coresNumber)/log(10.)+1);
    tString corePrefix="_g"+functions_numeric::toString(coreId,nDigits)+"p"+functions_numeric::toString(coresNumber,nDigits);
       
 
    //memory size
    std::valarray<tMemSize> memorySizePerCore;
    tString memorySizeSymbol="Mo";
    tReal memorySizeUnit=1024*1024;
    tMemSize memSize;
    
    try {
        //run the program
        MPI_Chrono chrono;
        chrono.start();
 
        
        //1. loader Step
        //=================
 
 
        //read the IO data from options
        
        tString outputPath,outputPrefix;
        runner.ReadOutputOptions(options,outputPath,outputPrefix);
        
        //std::cout<<"outputPath:"<<outputPath<<"\n";
        //std::cout<<"outputPrefix:"<<outputPrefix<<"\n";
        //create output path
        if (!CORE_IO::Exists(outputPath)) CORE_IO::CreatePath(outputPath);
        
        
        if (coreId==0) {
            //allocate only core 0 memory
            memorySizePerCore.resize(coresNumber);
            
            //save the options into default file
            options.saveToFile();
            
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            
            //print the header of the log file or append
            log<<"log file created  by "+runner.GetSoftName()<<"  "<<runner.GetVersion()<<" at date ";
            log<<CORE_Chrono::GetDate();
            log<<"\n";
           
            //print the number of threads in log
            log<<"number of cores:"<<coresNumber<<"\n";
            
            log<<"size of int :"<<sizeof(tInteger)<<"\n";
            log<<"size of real :"<<sizeof(tReal)<<"\n";
        
            
 
        }
        
        
        //create the beam
        CORE_UniquePointer<SM_Beam>  uBeam=runner.GetClassFactory().NewUniqueInstance<SM_Beam>("SM_Beam",options);
 
        //verify the beam can be created
        if (uBeam.get()==null) {
            std::cout<<"impossible to create the beam from options values \n";
            return false;
        }
        
        //casting for templated method
        SMOMPI_LandauLifschitzBeam *llBeam=dynamic_cast<SMOMPI_LandauLifschitzBeam*>(uBeam.get());
        SM_MonteCarloBeam *mcBeam=dynamic_cast<SM_MonteCarloBeam*>(uBeam.get());
 
        //load the beam form options
        if (llBeam!=null) succeeds=SM_LandauLifschitzLoader::LoadLandauLifschitzBeamFromOptions(*llBeam,options);
        if (mcBeam!=null) succeeds=SM_MonteCarloLoader::LoadMonteCarloBeamFromOptions(*mcBeam,options);
 
        //verify the beam option has been loaded
        if (succeeds==false) {
            std::cout<<"impossible to load the beam from options values \n";
            return false;
            
        }
 
        //random jump
        uBeam->getStochasticFunctions().randomSeed(coresNumber,coreId);
       
        //load the stochastic data
        SM_StochasticOutputLoader::LoadStochasticOutputFromOptions(stochasticOutput,options);
 
        //set the index of the stochastic output 
        stochasticOutput.setIndex(coreId,-1,coresNumber);
        
        //adimensionize the stochastic data
        stochasticOutput.adimensionize(uBeam->getSystem().getMaterial());
  
        //simulate the data
        tBoolean isTemplatedRun=false;
        options.getOptionValue("is-templated-run",isTemplatedRun);
        
        //save S at cycle
        tBoolean isSSaved=true;
        options.getOptionValue("is-S-Saved",isSSaved);
        
       
     
        
        //duration of initialization 
        tULLInt loaderDuration=chrono.stop();//duration in ss
        MPI_WorldToWorldMessage::AllReduce(mpiEnv,loaderDuration,MPI_MAX);
       
 
        //2.discretization step
        
        //start the chrono
        chrono.start();
        
        //discretize the beam
        uBeam->discretize();
 
 
        //save the network
        uBeam->getSystem().getNetwork().saveToFile(CORE_IO::GetAbsolutePath(outputPath+"/"+outputPrefix+corePrefix+".net"));
        
        //duration of discretization
        tULLInt discretizationDuration=chrono.stop();//duration in s
        MPI_WorldToWorldMessage::AllReduce(mpiEnv,discretizationDuration,MPI_MAX);
 
        //memory size per core array;
        memSize=uBeam->getMemorySize();
        memSize+=stochasticOutput.getMemorySize();
        MPI_WorldToWorldMessage::Gather(mpiEnv,0,memSize,memorySizePerCore);
        
        if (coreId==0) {
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            
            //print the beam in log
            log<<"\n\n beam:"<<uBeam->toString()<<"\n";
            //templated run
            log<<"templated run : "<<isTemplatedRun<<"\n";
            //print the stochastic
            log<<"\n\n stochastic Output:"<<stochasticOutput.toString()<<"\n";
 
            log<<"Memory size for all cores after discretization: "<<(((tReal)memSize)/memorySizeUnit)<<"\n";
            
            log<<"loader duration :"<<loaderDuration<<" s="<<chrono.ConvertDurationToString(loaderDuration)<<" \n";
            
            //get the output stream created from options command line
            log<<"discretization duration :"<<discretizationDuration<<" s="<<chrono.ConvertDurationToString(discretizationDuration)<<" \n";
           
            tInteger c=0;
            memSize=0;
            for (const auto& mem:memorySizePerCore) {
                log<<"\t memory for core "<<c<<":"<<(((tReal) mem)/memorySizeUnit)<<" "<<memorySizeSymbol<<"\n";
                memSize+=mem;
            }
          
        }
        
        
 
        //start the chrono
        chrono.start();
        
        if (llBeam!=null) succeeds=RunBeam(isTemplatedRun,*llBeam,stochasticOutput);
        else if (mcBeam!=null) succeeds=RunBeam(isTemplatedRun,*mcBeam,stochasticOutput);
        
        //end the chrono
        tULLInt runningDuration=chrono.stop();//duration in s
        MPI_WorldToWorldMessage::AllReduce(mpiEnv,runningDuration,MPI_MAX);
        if (coreId==0) {
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            log<<"running duration  :"<<runningDuration<<" s="<<chrono.ConvertDurationToString(runningDuration)<<"\n";
        }
        //memory size 
        memSize=uBeam->getMemorySize();
        memSize+=stochasticOutput.getMemorySize();
        MPI_WorldToWorldMessage::Gather(mpiEnv,0,memSize,memorySizePerCore);
        
        //save the last value of S
        if (coreId==0) {
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            
            tInteger c=0;
            memSize=0;
            for (const auto& mem:memorySizePerCore) {
                log<<"\t memory for core "<<c<<":"<<(((tReal)mem)/memorySizeUnit)<<" "<<memorySizeSymbol<<"\n";
                memSize+=mem;
            }
            log<<"Memory size for all cores after running beam: "<<(((tReal)memSize)/memorySizeUnit)<<"\n";
 
          
            tULLInt totalDuration=loaderDuration+discretizationDuration+runningDuration;
            log<<"total duration :"<<totalDuration<<" s="<<chrono.ConvertDurationToString(totalDuration)<<"\n";
 
           
        }
        
        //save S at end of time
        if (isSSaved) {    
            std::stringstream comment;
            comment<<"Direction of magnetic moments at end of last simulation for "<<coreId<<"/"<<coresNumber<<" nParticles:"<<uBeam->getSystem().getNetwork().getParticlesNumber()<<" nHaloParticles:"<<uBeam->getSystem().getNetwork().getHaloParticlesNumber()<<" ";
            if (llBeam!=null) comment<<"time="<<llBeam->getLLSystem().getTime();
            comment<<"\n";
            uBeam->getSystem().getMagneticMomentDirections().saveToFile(comment.str(),CORE_IO::GetAbsolutePath(outputPath+"/"+outputPrefix+corePrefix+"-St.txt"),12);
 
        }
        
    } catch(SM_Exception& e) {
        std::cerr<<e.getMessage()<<"\n";
    }
    return succeeds;
    
    
}
 
//CYCLE BEAM RUNNER
//==================
template<class BEAM_CYCLE,class STOCHASTIC_OUTPUT>
tBoolean SMOMPI_BeamRunner::Run(const CORE_Run& runner,
                                SM_BeamCycle<BEAM_CYCLE>& cycleManager,
                                STOCHASTIC_OUTPUT& stochasticOutput,
                                const CORE_OptionsList& options)  {
    
    
    
    
    
    //MPI environment
    const MPI_Environment& mpiEnv=MPI_Run::GetEnvironment();
    
    //current id of the MPI core
    const tMPICoreId& coreId=mpiEnv.getCoreId();
    
    //number of MPI cores
    const tMPICoreId& coresNumber=mpiEnv.getCoresNumber();
    
    tBoolean succeeds=true;
    
    //prefix of core
    int nDigits=(int)(log(coresNumber)/log(10.)+1);
    tString corePrefix="_g"+functions_numeric::toString(coreId,nDigits)+"p"+functions_numeric::toString(coresNumber,nDigits);
    
    //memory size
    std::valarray<tULLInt> memorySizePerCore;
    tString memorySizeSymbol="Mo";
    tULLInt memorySizeUnit=1024*1024;
    tULLInt memSize;
    
    try {
          
        //chrono of the program
        MPI_Chrono totalChrono;
        totalChrono.start();
        
        //step chrono
        MPI_Chrono chrono;
        chrono.start();
        
        //step duration
        tULLInt duration=0;
 
        
        //1. loader Step
        //=================
 
 
        //read the IO data from options
        
        tString outputPath,outputPrefix;
        runner.ReadOutputOptions(options,outputPath,outputPrefix);
        
        //std::cout<<"outputPath:"<<outputPath<<"\n";
        //std::cout<<"outputPrefix:"<<outputPrefix<<"\n";
        //create output path
        if (!CORE_IO::Exists(outputPath)) CORE_IO::CreatePath(outputPath);
           
        //simulate the data
        tBoolean isTemplatedRun=false;
        options.getOptionValue("is-templated-run",isTemplatedRun);
        
        //save S at cycle
        tBoolean isSSaved=true;
        options.getOptionValue("is-S-Saved",isSSaved);
        
        
        if (coreId==0) {
      
        
            //allocate only core 0 memory
            memorySizePerCore.resize(coresNumber);
            
            //save the options into default file
            options.saveToFile();
            
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            
            //print the header of the log file or append
            log<<"log file created  by "+runner.GetSoftName()<<"  "<<runner.GetVersion()<<" at date ";
            log<<CORE_Chrono::GetDate();
            log<<"\n";
            
            //print the number of threads in log
            log<<"number of cores:"<<coresNumber<<"\n";
            
            log<<"size of int :"<<sizeof(tInteger)<<"\n";
            log<<"size of real :"<<sizeof(tReal)<<"\n";
        }
        
        
        //create the beam
        CORE_UniquePointer<SM_Beam>  uBeam=runner.GetClassFactory().NewUniqueInstance<SM_Beam>("SM_Beam",options);
        if (uBeam.get()==null) {
            std::cout<<"impossible to create the beam from options values \n";
            return false;
        }
 
        //verify the beam can be created
        if (uBeam.get()==null) {
            std::cout<<"impossible to create the beam from options values \n";
            return false;
        }
        
        //beam casting
        SMOMPI_LandauLifschitzBeam *llBeam=dynamic_cast<SMOMPI_LandauLifschitzBeam*>(uBeam.get());
        SM_MonteCarloBeam *mcBeam=dynamic_cast<SM_MonteCarloBeam*>(uBeam.get());
        
        //load the bam
        if (llBeam!=null) succeeds=SM_LandauLifschitzLoader::LoadLandauLifschitzBeamFromOptions(*llBeam,options);
        if (mcBeam!=null) succeeds=SM_MonteCarloLoader::LoadMonteCarloBeamFromOptions(*mcBeam,options);
        
        if (succeeds==false) {
            std::cout<<"impossible to load the beam from options values \n";
            return false;
            
        }
        
        
        //random seed
        if (uBeam->hasStochasticFunctions()) {
            uBeam->getStochasticFunctions().randomSeed(coresNumber,coreId);
        } 
        
        
        
        //Load the cycle
        SM_CycleLoader::LoadCycleFromOptions(cycleManager,options);
        
        //load the stochastic data
        SM_StochasticOutputLoader::LoadStochasticOutputFromOptions(stochasticOutput,options);
        
        //set ndex of the stochoutput which is the index of core
        stochasticOutput.setIndex(coreId,-1,coresNumber);
        
        //prefix of the stochastic output
        tString soPrefix=stochasticOutput.getPrefix();
        
        //adimensionize the stochastic data
        stochasticOutput.adimensionize(uBeam->getSystem().getMaterial());
        
        //duration of loader
        duration=chrono.stop();//duration in ss
        MPI_WorldToWorldMessage::AllReduce(mpiEnv,duration,MPI_MAX);
        
        //start the chrono
        chrono.start();
        
        //discretize the beam
        uBeam->discretize();
        
        //memory size 
        memSize=uBeam->getMemorySize();
        MPI_WorldToWorldMessage::Gather(mpiEnv,0,memSize,memorySizePerCore);
        
        //duration of discretization
        duration=chrono.stop();//duration in s
        MPI_WorldToWorldMessage::AllReduce(mpiEnv,duration,MPI_MAX);
        if (coreId==0) {
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            
            //print the beam in log
            log<<"\n\n beam:"<<uBeam->toString()<<"\n";
            log<<"templated run : "<<isTemplatedRun<<"\n";
            
            //print the cycle:
            log<<"\n\n cycle manager:"<<cycleManager.toString()<<"\n";
            
            //print the stochastic
            log<<"\n\n stochastic Output:"<<stochasticOutput.toString()<<"\n";
            
            
            log<<"loader duration :"<<duration<<" s="<<chrono.ConvertDurationToString(duration)<<" \n";
            
            log<<"duration for discretization :"<<duration<<" ms="<<chrono.ConvertDurationToString(duration)<<"\n";
            
            
            tInteger c=0;
            memSize=0;
            for (const auto& mem:memorySizePerCore) {
                log<<"\t memory for core "<<c<<":"<<((tReal)(mem/memorySizeUnit))<<" "<<memorySizeSymbol<<"\n";
                memSize+=mem;
            }
            log<<"Memory size for all cores after discretization: "<<((tReal)(memSize/memorySizeUnit))<<"\n";
        }
        
        
        tIndex iCycleStep=0;
        
        //open the cycle 
        if (!cycleManager.open(*uBeam.get(),stochasticOutput,coreId,iCycleStep)) {
            std::cout<<"impossible to init cycle step \n";
            return false;
        }
        
        
        while (!cycleManager.isCycleFinished(iCycleStep,*uBeam.get())) {
            
            //start the chrono for the cycle step
            chrono.start();
            
            //update seed if necessary
            
            if (uBeam->hasStochasticFunctions())  {
                if (cycleManager.isSeedUpdatedPerCycleStep()) {
                    if (coreId==0) {
                        std::cout<<"set the seed for the step of cycle "<<iCycleStep<<" to "<<cycleManager.getSeedPerCycleStep()<<"\n";
                    }
                    uBeam->getStochasticFunctions().setSeed(cycleManager.getSeedPerCycleStep());
            
                }
                
            }
            
            //run the step of cycle with prefix indexed with the index of the cycle
            if (cycleManager.isStochasticOutputSavedAtEachStep()) {
                stochasticOutput.setPrefix(soPrefix+"-"+std::to_string(iCycleStep)+"c");
            } else {
                stochasticOutput.setPrefix("");
            }
 
            //std::cout<<"begin running Beam for "<<iCycleStep<<"  cycle step for core "<<coreId<<" isTemplatedRun:"<<isTemplatedRun<<"\n";
            if (llBeam!=null) succeeds=RunBeam(isTemplatedRun,*llBeam,stochasticOutput);
            else if (mcBeam!=null) succeeds=RunBeam(isTemplatedRun,*mcBeam,stochasticOutput);
            //std::cout<<"end running Beam for "<<iCycleStep<<"  cycle step for core "<<coreId<<"\n";
            
            //duration of the cycle step
            duration=chrono.stop();//duration in s
            MPI_WorldToWorldMessage::AllReduce(mpiEnv,duration,MPI_MAX);
            
            //save the last value of S
            if (coreId==0) {
                //get the output stream created from options command line
                CORE_Out& log=runner.Out();
                //end the chrono
                log<<" duration for beam run at cycle "<<iCycleStep<<":"<<duration<<" s="<<chrono.ConvertDurationToString(duration)<<"\n";
            }
            //save S at end of time
            if (isSSaved) {    
                std::stringstream comment;
                comment<<"Direction of magnetic moments at end of last simulation for "<<coreId<<"/"<<coresNumber<<" nParticles:"<<uBeam->getSystem().getNetwork().getParticlesNumber()<<" nHaloParticles:"<<uBeam->getSystem().getNetwork().getHaloParticlesNumber()<<" ";
                if (llBeam!=null) comment<<"time="<<llBeam->getLLSystem().getTime();
                comment<<"\n";
                uBeam->getSystem().getMagneticMomentDirections().saveToFile(comment.str(),CORE_IO::GetAbsolutePath(outputPath+"/"+outputPrefix+corePrefix+"-St.txt"),12);
                
            }
 
            //next step of the cycle
            //std::cout<<"next cycle step for core "<<coreId<<"\n";
            cycleManager.nextCycleStep(iCycleStep,*uBeam.get(),coreId,stochasticOutput);
 
            //synchronize before next step
            mpiEnv.synchronize();
            iCycleStep++;
            
        }   
        //std::cout<<" cycle is closed for core "<<coreId<<"\n";
        //close the cycle
        cycleManager.close(iCycleStep,*uBeam.get());
        
        duration=totalChrono.stop();
        MPI_WorldToWorldMessage::AllReduce(mpiEnv,duration,MPI_MAX);
        
        //memory size 
        memSize=uBeam->getMemorySize();
        MPI_WorldToWorldMessage::Gather(mpiEnv,0,memSize,memorySizePerCore);
        
 
        if (coreId==0) {
            //get the output stream created from options command line
            CORE_Out& log=runner.Out();
            log<<"cycle duration :"<<duration<<" s="<<chrono.ConvertDurationToString(duration)<<"\n";
 
            tInteger c=0;
            memSize=0;
            for (const auto& mem:memorySizePerCore) {
                log<<"\t memory for core "<<c<<":"<<((tReal)(mem/memorySizeUnit))<<" "<<memorySizeSymbol<<"\n";
                memSize+=mem;
            }
            log<<"Memory size for all cores after running cycle: "<<((tReal)(memSize/memorySizeUnit))<<"\n";
        }
        
        //re-update the prefix
        stochasticOutput.setPrefix(soPrefix);
        
    } catch(SM_Exception& e) {
        std::cerr<<e.getMessage()<<"\n";
    }
    return succeeds;
    
    
}
 
 
 
 
#endif