SimRunner Class Reference

Performs the setup of the Metapop and SimComponents and runs the simulation. More...

#include <simulation.h>

Inheritance diagram for SimRunner:

Collaboration diagram for SimRunner:

Public Member Functions
	SimRunner (Metapop *pop)
	~SimRunner ()
	Dstror. More...
bool	init ()
	Checks simulation parameters and init the FileServices with the base filename. More...
bool	init_components (map< string, string > &simparams)
	Performs the initialization of the different components of the simulation. More...
void	setLifeCycle ()
	Sets the list of LifeCyckeEvent's currently active. More...
void	setForFirstGeneration ()
	Sets the population and the services ready for the first generation of a new replicate. More...
void	init_random_seed ()
	Initialize the seed of the random generator. More...
void	reset ()
	Resets all the parameters to the unset state, resets the services. More...
std::string	setElapsedTime (clock_t time)
	Compute and print the simulation's elapsed time to stdout. More...
void	register_component (SimComponent *cmpt)
	Register the different Handler's attached to a SimComponent. More...
void	register_component_handlers ()
	Register all the Handlers of the currently active simulation components. More...
void	reset_services ()
	Resets the FileServices and StatServices. More...
FileServices *	get_FileServices ()
	Returns the FileServices. More...
StatServices *	get_StatServices ()
	Returns the StatServices. More...
list< StatRecBase * >	get_allRegisteredStats ()
	Returns the complete list of the stat recorders loaded after parameters initialization. More...
bool	run (int ARGC, char **ARGV)
	First loop of the simulation, performs the simulations stored in the ParamManager base class. More...
bool	run ()
	First loop of the simulation, performs the simulations stored in the ParamManager base class. More...
bool	run_event (string &name)
	Execute one specific life cycle event, if present in the list of current events. More...
void	step (unsigned int nb_gen)
	Iterates the life cycle. More...
void	attach_pop (Metapop *pop)
	Attach a pop to the simulation. More...
Metapop *	get_pop ()
	Accessor to the pop ptr. More...
bool	build_pop ()
	Calls the Metapop init procedure with current traits and LCEs. More...
void	setCurrentGeneration (unsigned int gen)
unsigned int	getCurrentGeneration ()
void	setGenerations (unsigned int gen)
unsigned int	getGenerations ()
void	setCurrentReplicate (unsigned int repl)
unsigned int	getCurrentReplicate ()
void	setReplicates (unsigned int repl)
unsigned int	getReplicates ()
int	getCurrentRankInLifeCycle ()
void	printLogHeader ()
void	printLog ()
void	runPostExec ()
	Run the post-exec script after all simulations have finished. More...
void	runPostExecReplicateWise ()
	Run the post-exec script after each replicate, adds filename and replicate number as args. More...
Main loops
void	Replicate_LOOP ()
	Replicate loop, iterates the life cycle _replicates times. More...
void	Cycle (char *startTime)
	Life cycle loop, executes the list of LCEs _generations times. More...
Public Member Functions inherited from SimBuilder
	SimBuilder ()
	SimBuilder (const SimBuilder &SB)
	copy cstor. More...
	~SimBuilder ()
bool	build_currentParams (map< string, string > &simparams)
	Builds the list of parameters from user's defined input parameters. More...
map< trait_t, TraitPrototype * > &	build_currentTraits ()
	Selects the trait prototypes that have their parameters set. More...
void	build_LifeCycle ()
	Selects the life cycle events that have their parameters set. More...
TraitPrototype *	get_current_trait (trait_t type)
	Accessor to the list of current trait prototypes. More...
TraitPrototype *	get_current_traitWithParameter (string &param)
	Accessor to the current trait prototypes conditioned on ownership of a specified parameter. More...
LifeCycleEvent *	get_current_event (string &name)
	Accessor to the list of current LCEs. More...
LifeCycleEvent *	get_current_eventWithParameter (string &param)
	Accessor to the current LCEs conditioned on ownership of a specified parameter. More...
list< ParamSet * > &	get_currentParams ()
	Accessor to the list of the selected parameter sets. More...
age_t	getFirstRequiredAgeInLifeCycle ()
Public Member Functions inherited from ParamManager
	ParamManager ()
	Cstor. More...
	~ParamManager ()
void	add_paramset (ParamSet *paramset)
	Adds a ParamSet to the list of the parameter sets of the simulation. More...
ParamSet *	get_paramset (string &name)
	Looks for paramset with "name" in the list of parameter sets. More...
void	build_allParams ()
	Clears and fills the _allParams list with the ParamSet's of the simulation components. More...
list< ParamSet * > &	get_allParams ()
	Accessor of the whole list of the parameter sets. More...
bool	set_parameters (map< string, string > &simparams, bool silent)
	Sets the parameters of the simulation with the argument strings given in input. More...
bool	param_consistency_check ()
	Checks if all the mandatory parameters are set so that the simulation can be launched. More...
void	build_records (map< string, vector< string > > &initParams)
	Builds the list of simulation parameters from the parsed input file(s). More...
list< map< string, string > > &	get_simRecords ()
	Accessor to the simulations parameter list. More...
map< string, string > &	get_firstRecord ()
	Accessor to the first element in the simulations parameter list. More...
int	get_nbSims ()
	Accessor to the size of the simulations parameter list, i.e. More...
Public Member Functions inherited from ComponentManager
	ComponentManager ()
	~ComponentManager ()
void	build_component_list ()
	Clears and builds the list of all components from the lists of trait prototype templates and life cycle event templates. More...
void	add_component (SimComponent *cmpt)
	Push a component at the back of the component list. More...
void	add_trait (TraitPrototype *trait)
	Add a trait prototype to the template and component lists. More...
void	add_LCE (LifeCycleEvent *event)
	Add a life cycle event to the template and component lists. More...
TraitPrototype *	get_trait (string name)
	Search for component with "name" in the trait prototype list. More...
LifeCycleEvent *	get_LCE (string name)
	Search for component with "name" in the life cycle events list. More...

Public Attributes
FileServices	_FileServices
StatServices	_StatServices
UpdaterServices	_ParamUpdaterManager

Private Attributes
MPImanager *	_my_mpi_manager
Metapop *	_thePop
std::string	_logfile
char	_startTime [20]
char	_endTime [20]
std::string	_simElapsedTime
clock_t	_meanReplElapsedTime
	Clock counter, for logging. More...
unsigned int	_meanGenLength
	Generation counter, for logging. More...
unsigned int	_generations
	Number of generations to iterate. More...
unsigned int	_replicates
	Number of replicates to iterate. More...
unsigned int	_currentReplicate
	The current replicate in the replicate loop, starts at 1. More...
unsigned int	_currentGeneration
	The current generation in the generation loop, starts at 1. More...
int	_currentRankInLifeCycle
	The current rank in the life cycle, corresponds to the rank of the current LCE, before it executes. More...
unsigned long	_random_seed
	The startup random seed of the random generator. More...
std::string	_modeArg
	The run mode ('overwrite', 'run', 'skip', 'dryrun', 'create_init'). More...
unsigned int	_mode
	The run mode code (0 = run, 1 = overwrite, 2 = skip, 3 = dryrun, 4 = create_init) More...
bool	_doRun
	Boolean set when not in dryrun mode. More...
std::string	_postexec_script
	The path to the script to be executed after last simulation. More...
std::string	_postexec_args
	Arguments to pass to the post-exec script. More...
bool	_do_postexec_replicatewise
	Boolean to trigger replicate-wise execution of post script. More...
bool	_do_postexec
	Boolean set when a post-exec script must be executed. More...

Additional Inherited Members
Protected Types inherited from SimBuilder
typedef map< int, LifeCycleEvent * >::const_iterator	LCE_ITER
typedef map< trait_t, TraitPrototype * >::const_iterator	TRAIT_ITER
Protected Attributes inherited from SimBuilder
list< ParamSet * >	_currentParams
	List of the selected simulation components from the user defined input parameters. More...
map< trait_t, TraitPrototype * >	_currentTraits
	List of the selected trait prototypes from the user defined input parameters. More...
map< int, LifeCycleEvent * >	_LifeCycle
	List of the selected life cycle events from the user defined input parameters. More...
Protected Attributes inherited from ParamManager
list< ParamSet * >	_allParams
	A list of all the parameter sets of all the simulation components loaded in the _component list of the ComponentManager. More...
map< string, string >	_inputParams
	A map of the parameters and their arguments of the current (running) simulation. More...
map< unsigned int, list< pair< string, string > > >	_temporalParams
	Lists of parameters to be updated during a simulation indexed by generation update time. More...
list< map< string, string > >	_simRecords
	Sets of parameters of all the simulations to perform. More...
ParamSet	_paramSet
	The ParamSet param set of the simulation. More...
Protected Attributes inherited from ComponentManager
list< SimComponent * >	_components
	List of all the simulation components. More...
list< TraitPrototype * >	_TTrait_Templates
	List of all trait prototypes of the simulation, a subset of _components list. More...
list< LifeCycleEvent * >	_LCE_Templates
	List of all the life-cycle events of the simulation, a subset of _components list. More...

Detailed Description

Performs the setup of the Metapop and SimComponents and runs the simulation.

This class implements the two main loops of a simulation, the replicate and the generation loops. The replicate loop iterates the generation loop which itself iterates the life cycle loop composed of the LCEs selected by the user. A SimRunner brings together the basic simulation components and a metapopulation on which they act. It perfoms the setups necessary to have a Metapop ready for the simulation and runs the different simulations stored in its ParamManager base class. Also hosts the file and stat services.

Constructor & Destructor Documentation

SimRunner()

SimRunner::SimRunner ( Metapop *  pop )

inline

                             : _my_mpi_manager(0), _do_postexec_replicatewise(0), _do_postexec(0)
  {
    attach_pop(pop);
  }

References attach_pop().

~SimRunner()

SimRunner::~SimRunner

(

)

Dstror.

{
#ifdef _DEBUG_
  message("SimRunner::~SimRunner\n");
#endif
  
  reset();
  
}

References message(), and reset().

Member Function Documentation

attach_pop()

void SimRunner::attach_pop ( Metapop *  pop )

inline

Attach a pop to the simulation.

Adds it to the components list.

Parameters

pop	ptr to the pop object

{_thePop = pop;this->_components.push_back(_thePop);}

References ComponentManager::_components, and _thePop.

Referenced by SimRunner().

build_pop()

bool SimRunner::build_pop

(

)

Calls the Metapop init procedure with current traits and LCEs.

Cycle()

void SimRunner::Cycle

(

char *

startTime

)

Life cycle loop, executes the list of LCEs _generations times.

Parameters

startTime

the starting time of the current replicate.

{
 
  time_t t;
  // ------------------------------ CYCLE --------------------------------
 
  for(_currentGeneration = 1; !(_currentGeneration > _generations); _currentGeneration++) {
 
    // -------------------------- PRINT STUFF ------------------------------
#if !defined(LOW_VERBOSE) && !defined(USE_MPI)
 
    if( !(_currentGeneration % 100) || _currentGeneration < 100){
      //update timer:
      t = time(0);
      strftime(startTime, 10, "%H:%M:%S", localtime(&t));
 
      message("\r    replicate %i/%i [%s] %i/%i", _currentReplicate, _replicates
          ,startTime, _currentGeneration, _generations);
 
      fflush(stdout);
    }
#endif
    
#ifdef _DEBUG_
    message("____Generation %i/%i____\n", _currentGeneration, _generations);
#endif    
    
    // -------------------------- STEP ONE GEN ------------------------------
    _thePop->setCurrentGeneration(_currentGeneration);
    
    // do one iteration of the life cycle:
    if(_thePop->isAlive())
      
      step(1);
    
    else {
#if !defined(LOW_VERBOSE) && !defined(USE_MPI)
      message("\r    replicate %i/%i [%s] %i/%i -> Pop extinction !\n", _currentReplicate, _replicates
              ,startTime, _currentGeneration, _generations); 
#endif
      _currentGeneration++;
      break;
    }
    
  }
  // --------------------------- END OF CYCLE --------------------------
}

References _currentGeneration, _currentReplicate, _generations, _replicates, _thePop, Metapop::isAlive(), message(), Metapop::setCurrentGeneration(), and step().

Referenced by Replicate_LOOP().

get_allRegisteredStats()

list<StatRecBase*> SimRunner::get_allRegisteredStats ( )

inline

Returns the complete list of the stat recorders loaded after parameters initialization.

{return _StatServices.getAllStats();}

References _StatServices, and StatServices::getAllStats().

get_FileServices()

FileServices* SimRunner::get_FileServices ( )

inline

Returns the FileServices.

{return &_FileServices;}

References _FileServices.

Referenced by Metapop::loadPopFromTraitFile().

get_pop()

Metapop* SimRunner::get_pop ( )

inline

Accessor to the pop ptr.

Returns

the pop ptr

{return _thePop;}

References _thePop.

get_StatServices()

StatServices* SimRunner::get_StatServices ( )

inline

Returns the StatServices.

{return &_StatServices;}

References _StatServices.

Referenced by LCE_StatServiceNotifier::LCE_StatServiceNotifier().

getCurrentGeneration()

unsigned int SimRunner::getCurrentGeneration ( )

inline

{return _currentGeneration;}

References _currentGeneration.

Referenced by SIMenv::getCurrentGeneration().

getCurrentRankInLifeCycle()

int SimRunner::getCurrentRankInLifeCycle ( )

inline

{return _currentRankInLifeCycle;}

References _currentRankInLifeCycle.

Referenced by SIMenv::getCurrentRankInLifeCycle().

getCurrentReplicate()

unsigned int SimRunner::getCurrentReplicate ( )

inline

{return _currentReplicate;}

References _currentReplicate.

Referenced by SIMenv::getCurrentReplicate().

getGenerations()

unsigned int SimRunner::getGenerations ( )

inline

{return _generations;}

References _generations.

Referenced by SIMenv::getGenerations().

getReplicates()

unsigned int SimRunner::getReplicates ( )

inline

{return _replicates;}

References _replicates.

Referenced by SIMenv::getReplicates().

init()

bool SimRunner::init

(

)

Checks simulation parameters and init the FileServices with the base filename.

{
  if( !(_paramSet.isSet("filename")) ) {
    return error("parameter \"filename\" is not properly set!\n");
  }
  
  _FileServices.setBasename(_paramSet.getArg("filename"));
  
  if(_paramSet.isSet("root_dir")) {
    _FileServices.setRootDir(_paramSet.getArg("root_dir"));
  }
  
  if(_paramSet.isSet("run_mode")) {
    
    _modeArg = _paramSet.getArg("run_mode");
    
    if(_modeArg == "run"){
 
      _FileServices.setMode(0);
      _doRun = true;
      _mode = 0;
      SILENT_RUN = false;  //declared in output.h
 
    } else if( _modeArg == "overwrite" ) {
 
      _FileServices.setMode(1);
      _doRun = true;
      _mode = 1;
      SILENT_RUN = false;
 
    } else if(_modeArg == "skip"){
 
      _FileServices.setMode(2);
      _doRun = true;
      _mode = 2;
      SILENT_RUN = false;
 
    } else if(_modeArg == "dryrun" || _modeArg == "dry"){
 
      _FileServices.setMode(3);
      _doRun = false;
      _mode = 3;
      SILENT_RUN = false;
 
    } else if(_modeArg == "create_init"){ //the logWriter creates an ini file, see FileServices::log_simparams() 
 
      _FileServices.setMode(4);
      _doRun = false;
      _mode = 4;
      SILENT_RUN = false;
 
    } else if(_modeArg == "silent_run" || _modeArg == "silent"){
 
      _FileServices.setMode(2);  // skip simulation if files from previous sims are found, o/w it hangs
      _doRun = true;
      _mode = 2;
      SILENT_RUN = true;
 
    } else {
 
      error("simulation run mode \"%s\" unknown\n",_modeArg.c_str());
 
      return false;
 
    }
    // else, set default run mode values (skip):
  } else {
    _modeArg = "skip";
    _doRun = true;
    _FileServices.setMode(2);
    SILENT_RUN = false;
  }
  
  _replicates = (unsigned int)_paramSet.getValue("replicates");
  
  _generations = (unsigned int)_paramSet.getValue("generations");
  
  
  if( _paramSet.isSet("logfile") ) {
    _logfile = _paramSet.getArg("logfile");
  } else {
    _logfile = "nemo.log";
  }
  
  // create the simulation logging file
  printLogHeader();
  
  // set POSTEXEC options:
  if( _paramSet.isSet("postexec_script") ) {
    _postexec_script = _paramSet.getArg("postexec_script");
    _do_postexec = true;
    
    if( _paramSet.isSet("postexec_args") )
      _postexec_args = _paramSet.getArg("postexec_args");
    else
      _postexec_args = "";
    
    if( _paramSet.isSet("postexec_replicate_wise") )
      _do_postexec_replicatewise = true;
    else
      _do_postexec_replicatewise = false;
 
    
  } else
    _do_postexec = false;
  
  return true;
}

References _do_postexec, _do_postexec_replicatewise, _doRun, _FileServices, _generations, _logfile, _mode, _modeArg, ParamManager::_paramSet, _postexec_args, _postexec_script, _replicates, error(), ParamSet::getArg(), ParamSet::getValue(), ParamSet::isSet(), printLogHeader(), FileServices::setBasename(), FileServices::setMode(), FileServices::setRootDir(), and SILENT_RUN.

Referenced by init_components().

init_components()

bool SimRunner::init_components

(

map< string, string > &

simparams

)

Performs the initialization of the different components of the simulation.

Builds the list of the simulation parameters and load the components that have their ParamSet in the set state. Builds the population, the TraitPrototype, and life cycle, register the various services and init the StatServices and ParameterUpdaterManager.

Parameters

simparams

the hashtable containing the parameters and their arguments parsed from the init file

{
#ifdef _DEBUG_
  message("SimRunner::init_components\n");
#endif  
  //first reset all paramSets and services (clear the handlers' lists)
  reset();
  
  _FileServices.set_pop_ptr(_thePop);
  _StatServices.set_pop_ptr(_thePop);
  
#ifdef _DEBUG_
  message("SimRunner::init_components: building current params\n");
#endif
  
  //build the list of active component parameters from the simulation record:
  if(!this->build_currentParams(simparams)){
    error("SimRunner::init_components:couldn't build current params\n");
    return false;
  }
  
  //initialize the random generator's seed:
  //if(_myenv->isMaster()) // in MPI context, all processes must initialize the generator
  init_random_seed();
  
  //init the sim and pop (set parameters from input values)
  if( !init() || !_thePop->init() ) return false;
  
  //propagate replicate and generation numbers to metapop, often used by LCEs
  _thePop->setReplicates(_replicates);
  _thePop->setGenerations(_generations);
 
  //the traits and LCEs components are set only after the simulation and 
  //population parameters are set
  
  //build the Individual prototype, and init the TTraits
  //---> SimComponents::setParameters() is called here, this will also build the genetic map
  _thePop->makePrototype( build_currentTraits() );
  
  //build the list of life cycle events, and init LCEs 
  //---> SimComponent::setParameters() is called here
  setLifeCycle( );
  
  //load the stat-, file-, and updater-handlers of the simulation components:
  register_component_handlers();
  
  //StatServices: build the lists of stat recorders:
  if( !_StatServices.init() ) return false;
  
  if( !_ParamUpdaterManager.init() ) return false;
  
  if( _ParamUpdaterManager.hasTemporals() ) {
    LCE_ParamUpdaterNotifier* updater = new LCE_ParamUpdaterNotifier();
    updater->setManager( &_ParamUpdaterManager );
    updater->init(_thePop);
    _LifeCycle[ -1 ] = updater; //this is never destroyed...
  }
  
  return true;
}

References _FileServices, _generations, SimBuilder::_LifeCycle, _ParamUpdaterManager, _replicates, _StatServices, _thePop, SimBuilder::build_currentParams(), SimBuilder::build_currentTraits(), error(), UpdaterServices::hasTemporals(), Metapop::init(), init(), StatServices::init(), UpdaterServices::init(), LifeCycleEvent::init(), init_random_seed(), IndFactory::makePrototype(), message(), register_component_handlers(), reset(), FileServices::set_pop_ptr(), StatServices::set_pop_ptr(), Metapop::setGenerations(), setLifeCycle(), LCE_ParamUpdaterNotifier::setManager(), and Metapop::setReplicates().

Referenced by run().

init_random_seed()

void SimRunner::init_random_seed

(

)

Initialize the seed of the random generator.

{
  if(_myenv->isMaster()) {
 
    if(this->_paramSet.isSet("random_seed")) {
 
      _random_seed = (unsigned long) this->_paramSet.getValue("random_seed");
 
      message( "setting random seed from input value: %i\n", _random_seed);
 
    } else {
      //set the random seed from the current time
      _random_seed =  2*time(0)+1;
 
      message( "setting random seed from current time: %i\n", _random_seed);
    }
  }
  
#if defined(USE_MPI) && defined(HAS_SPRNG)
 
  // broadcast the random seed, needs to be equal on all processes with SPRNG
  MPI_Bcast(&_random_seed,1,MPI_LONG,0,MPI_COMM_WORLD );
 
#else
#endif
 
  //initialization in any case
  RAND::init(_random_seed);
 
}

References _myenv, ParamManager::_paramSet, _random_seed, ParamSet::getValue(), RAND::init(), MPIenv::isMaster(), ParamSet::isSet(), and message().

Referenced by init_components().

printLog()

void SimRunner::printLog

(

)

{
  ofstream FH(_logfile.c_str(),ios::app);
  
  if(!FH.is_open()){
    error("could not open simulation logfile \"%s\"\n",_logfile.c_str());
    return;
  }
  
  FH<<"| ";
  FH.width(40);
  FH.setf(ios::left,ios::adjustfield);
  FH << _FileServices.getBaseFileName( );
  
  FH <<"| "<< _startTime <<" | "<< _endTime <<" | ";
  
  FH.width(10);
  FH.setf(ios::right,ios::adjustfield);
  FH<< _simElapsedTime <<" | ";
  
  FH.width(9);
  FH << _replicates <<" | ";
  
  FH.width(10);
  FH << setElapsedTime( _meanReplElapsedTime ) << " | ";
  
  FH.width(8);
  FH << _meanGenLength <<" | ";
  
  FH<<" "<<MAIN_VERSION<<"."<<MINOR_VERSION<<"."<<REVISION<<RELEASE
  <<" "<<VERSION_DATE;
  
  FH<<" | ";
  FH.width(20);
  FH.setf(ios::left,ios::adjustfield);
  char* host;
  if( (host = getenv("HOST")) != NULL )
    FH << host << " |";
  else if ( (host = getenv("HOSTNAME")) != NULL )
    FH << host << " |";
  else
    FH << "-" << " |";
  
  FileServices::file_it file = _FileServices.getFirstWriter(), last = _FileServices.getLastWriter() ;
  
  for(;file != last; file++)
    FH << " \"" << (*file)->get_extension() << "\":" << (*file)->get_path();
  
  FH << std::endl;
  
  FH.close();
}

References _endTime, _FileServices, _logfile, _meanGenLength, _meanReplElapsedTime, _replicates, _simElapsedTime, _startTime, error(), FileServices::getBaseFileName(), FileServices::getFirstWriter(), FileServices::getLastWriter(), MAIN_VERSION, MINOR_VERSION, RELEASE, REVISION, setElapsedTime(), and VERSION_DATE.

Referenced by run().

printLogHeader()

void SimRunner::printLogHeader

(

)

{
  ofstream FH;
  ifstream IF;
  //check is the logfile already exists:
  IF.open(_logfile.c_str(),ios::in);
  if(IF){
    IF.close();
    return;
  }
  IF.close();
  
  FH.open(_logfile.c_str(),ios::out);
  if(!FH) {
    error("could not create simulation logfile \"%s\"\n",_logfile.c_str());
    return;
  }
  
  FH<<"--- N E M O ---\n"
  <<"    LOGFILE\n\n\n";
  FH<<"| basename                                |      start time     |      stop time      | e-time CPU |"
  <<" repl done | rpl e-time | mean gen | version               | hostname             | output files \n";
  
  FH.close();
}

References _logfile, and error().

Referenced by init().

register_component()

void SimRunner::register_component

(

SimComponent *

cmpt

)

Register the different Handler's attached to a SimComponent.

Parameters

cmpt	a SimComponent

{
  _FileServices.load(cmpt);
  _StatServices.load(cmpt);
  _ParamUpdaterManager.load(cmpt);
}

References _FileServices, _ParamUpdaterManager, _StatServices, FileServices::load(), StatServices::load(), and UpdaterServices::load().

Referenced by register_component_handlers().

register_component_handlers()

void SimRunner::register_component_handlers

(

)

Register all the Handlers of the currently active simulation components.

{
  register_component(_thePop);
  
  for(TRAIT_ITER trait = _currentTraits.begin(); trait != _currentTraits.end(); trait++)
    register_component(trait->second);
  
  for(LCE_ITER LCE = _LifeCycle.begin(); LCE != _LifeCycle.end(); LCE++)
    register_component(LCE->second);  
}

References SimBuilder::_currentTraits, SimBuilder::_LifeCycle, _thePop, and register_component().

Referenced by init_components().

Replicate_LOOP()

void SimRunner::Replicate_LOOP

(

)

Replicate loop, iterates the life cycle _replicates times.

{
  
#ifndef USE_MPI
  
  clock_t start;
  clock_t stop;
  time_t t;
  char t_buff[10];
  
  _meanReplElapsedTime = 0;
  _meanGenLength = 0;
  _currentGeneration = 0;
  
  //---------------------------------- REPLICATE LOOP -------------------------------------
  for(_currentReplicate = 1; !(_currentReplicate > _replicates); ++_currentReplicate) {
    
    
    // -------------------------- PRINT STUFF ------------------------------
    t=time(0);
    //print some output:
    strftime(t_buff,10,"%H:%M:%S",localtime(&t));
    
#ifdef LOW_VERBOSE
    message("    replicate %i/%i [%s] \n",_currentReplicate, _replicates, t_buff);
#else
    message("\r    replicate %i/%i [%s] 1/%i                ",_currentReplicate, _replicates, t_buff, _generations);
    fflush(stdout);
#endif
    
    //---------------- SET POPULATION FOR FIRST GENERATION ------------------
    
    setForFirstGeneration();
     
    //--------------------------- GENERATION LOOP ---------------------------   
    start = clock();
    
    Cycle(t_buff);
    
    stop = clock();
    //-----------------------------------------------------------------------
    
    _meanReplElapsedTime += (stop - start);
        
    _meanGenLength += _currentGeneration - 1;
    
    //call the file services to print the replicate stats in case of pop extinction 
    if( !_thePop->isAlive() && _currentGeneration-1 <= _generations ) {
      _currentGeneration = _generations;
      _thePop->setCurrentGeneration(_generations);
      _FileServices.notify();
    }
   
    if( _do_postexec_replicatewise ) runPostExecReplicateWise(); //will execute on each node
  }
  //--------------------------------- /REPLICATE LOOP -------------------------------------
  
  if( !_thePop->isAlive() && _currentGeneration <= _generations ) {
    _currentGeneration = _generations;
    _currentReplicate  = _replicates;
    _thePop->setCurrentGeneration(_generations);
    _thePop->setCurrentReplicate(_replicates);
    _FileServices.notify();
  }
  
  _meanReplElapsedTime /= _replicates;
  _meanGenLength /= _replicates;
 
#else
  //else ifndef USE_MPI
  //------------------------------- MPI REPLICATE LOOP ------------------------------------
  _currentReplicate = _my_mpi_manager->init( &_StatServices );
  
  while ( _currentReplicate <= _replicates )
    _my_mpi_manager->iterate( this, &_StatServices, &_currentGeneration, &_currentReplicate );
 
  _my_mpi_manager->finish( &_StatServices, &_currentGeneration, _currentReplicate );
  
  if( _myenv->isMaster() ) {
    _currentGeneration = _generations;
    _currentReplicate  = _replicates;
    _thePop->setCurrentGeneration(_generations);
    _thePop->setCurrentReplicate(_replicates);
    
    //write the stat files, only if "save_stats" LCE is part of the life cycle
    if(get_LCE("save_stats")->get_paramset()->isSet()) {
      FileHandler& statWriter = dynamic_cast<LCE_StatServiceNotifier*> ( get_LCE("save_stats") )->getFH();
      for (unsigned int i = 1; i <= _replicates; ++i) {
        _currentReplicate = i;
        statWriter.FHwrite();
      }
    }
  }
  //------------------------------ /MPI REPLICATE LOOP ------------------------------------
#endif
  //endif USE_MPI
  
  //delete all individuals present in the population and delete the patches:
  _thePop->clear();
}

References _currentGeneration, _currentReplicate, _do_postexec_replicatewise, _FileServices, _generations, _meanGenLength, _meanReplElapsedTime, _my_mpi_manager, _myenv, _replicates, _StatServices, _thePop, Metapop::clear(), Cycle(), FileHandler::FHwrite(), MPImanager::finish(), ComponentManager::get_LCE(), ParamManager::get_paramset(), MPImanager::init(), Metapop::isAlive(), MPIenv::isMaster(), MPImanager::iterate(), message(), FileServices::notify(), runPostExecReplicateWise(), Metapop::setCurrentGeneration(), Metapop::setCurrentReplicate(), and setForFirstGeneration().

Referenced by run().

reset()

void SimRunner::reset

(

)

Resets all the parameters to the unset state, resets the services.

{
#ifdef _DEBUG_
  message("SimRunner::reset\n");
#endif
  //reset all the parameter to the "unset" state
  list<ParamSet*>::iterator current_paramset = this->_allParams.begin();
  while(current_paramset != this->_allParams.end()) {
    (*current_paramset)->reset();
    current_paramset++;
  }
  
  reset_services();
}

References ParamManager::_allParams, message(), and reset_services().

Referenced by init_components(), and ~SimRunner().

reset_services()

void SimRunner::reset_services

(

)

Resets the FileServices and StatServices.

{
  _FileServices.reset();
  _StatServices.reset();
  _ParamUpdaterManager.reset();
#ifdef _DEBUG_
  message("SimRunner::reset_services::done\n");
#endif
}

References _FileServices, _ParamUpdaterManager, _StatServices, message(), FileServices::reset(), StatServices::reset(), and UpdaterServices::reset().

Referenced by reset().

run() [1/2]

bool SimRunner::run

(

)

First loop of the simulation, performs the simulations stored in the ParamManager base class.

{
  time_t t;
  unsigned int sim = 0, simnbre = _simRecords.size();
  
  list< map< string,string > >::iterator currentSim = _simRecords.begin();
  
  //first loop: perform all simulations contained in _simRecords:
  //---------------------------------------------------------------------------------------
  while(currentSim != _simRecords.end()) {
    
    sim++;
    
    //clear and build the lists of traits, LCEs, stats and files handlers, random seed
    //create trait prototypes and the genetic map within IndFactory::makePrototype
    if(!init_components(*currentSim))  return false;
    
    //output a few info:
    if ( _myenv->isMaster() ) {
 
      t = time(NULL);
 
      strftime(_startTime, 20, "%d-%m-%Y %H:%M:%S", localtime(&t));
 
      message("\n--- SIMULATION %i/%i ---- [ %s ]\n\n",sim,simnbre,_FileServices.getBaseFileName().c_str());
      message("    start: %s\n",_startTime);
      message("    mode: %s\n",_modeArg.c_str());
      message("    population: 2 stages, %i patch%s",
          _thePop->getPatchNbr(), (_thePop->getPatchNbr() > 1 ? "es" : ""));
 
      // Wright-Fisher population?
      if(get_LCE("breed")->get_parameter("mating_isWrightFisher")->isSet() ||
          get_LCE("breed_selection")->get_parameter("mating_isWrightFisher")->isSet())
        message(", Wright-Fisher\n");
      else
        message(", non Wright-Fisher\n");
 
      message("    traits: ");
      
      map<trait_t, TraitPrototype* >::iterator trait = _currentTraits.begin();
 
      while(trait != _currentTraits.end()) {
        message("%s",trait->first.c_str());
        message("(%i)", _thePop->getTraitIndex(trait->first.c_str()));
        trait++;
        if(trait != _currentTraits.end()) message(", ");
      }
 
      message("\n    LCEs: ");
      
      LCE_ITER LCE = _LifeCycle.begin();
      while( LCE != _LifeCycle.end()) {
        message("%s(%i)",LCE->second->get_event_name().c_str(),LCE->first);
        LCE++;
        if(LCE != _LifeCycle.end()) message(", ");
      }
 
      message("\n");
    }
    
    //init the file services:
    //->files check, false means the user wants to skip this simulation.
    if( !(_FileServices.init(this->_currentParams)) ) {
      currentSim++;
      _thePop->clearPrototype();
      continue;
    }
    
    // Load the population from a source file?
    if(_thePop->isSourceLoad()) {
      message("    loading population from: %s (%s)\n",_thePop->getSourceName().c_str(),
              _thePop->getSourceFileType().c_str());
    } // endif isSourceLoad
    
    if ( _myenv->isMaster() ) message("\n");
 
    //->save simulation parameters in log files, add the current random seed
    // this is where ini files are created in `run_mode create_init' (mode == 4)
    _FileServices.log_simparams();
    _FileServices.log("#random_seed "+tstring::ulong2str( _random_seed ));
 
    clock_t start = clock();
 
    //run the simulation
    //-------------------------------------------------------------------------------------
    if(_doRun) Replicate_LOOP( );
 
    clock_t stop = clock();
 
    t = time(NULL);
 
    strftime(_endTime, 20, "%d-%m-%Y %H:%M:%S", localtime(&t));
 
    _simElapsedTime = setElapsedTime(stop - start);
 
    if ( _myenv->isMaster() && _mode != 3 && _mode != 4) {
      printLog();
      message("\n\n    end: %s\n",_endTime);
      message("--- done (CPU time: %ss)\n",_simElapsedTime.c_str());
      //don't log this when in 'dryrun' or 'create_init' mode:
      _FileServices.log("\n# simulation finished " + string(_endTime));
      _FileServices.log("# CPU time used: " + _simElapsedTime + "s");
    }
 
    _thePop->clearPrototype();
 
    // free all allocated memory of the random number generator
    // it will be re-allocated in `init_components -> ini_random_seed'
    RAND::free();
 
    currentSim++;
  }
  //---------------------------------------------------------------------------------------
  if( _do_postexec && _myenv->isMaster() ) runPostExec();
  
  return true;
}

References SimBuilder::_currentTraits, _do_postexec, _doRun, _endTime, _FileServices, SimBuilder::_LifeCycle, _mode, _modeArg, _myenv, _random_seed, _simElapsedTime, ParamManager::_simRecords, _startTime, _thePop, IndFactory::clearPrototype(), RAND::free(), ComponentManager::get_LCE(), FileServices::getBaseFileName(), Metapop::getPatchNbr(), Metapop::getSourceFileType(), Metapop::getSourceName(), IndFactory::getTraitIndex(), FileServices::init(), init_components(), MPIenv::isMaster(), Metapop::isSourceLoad(), FileServices::log(), FileServices::log_simparams(), message(), printLog(), Replicate_LOOP(), runPostExec(), setElapsedTime(), and tstring::ulong2str().

Referenced by run().

run() [2/2]

bool SimRunner::run	(	int	ARGC,
		char **	ARGV
	)

First loop of the simulation, performs the simulations stored in the ParamManager base class.

{
 
  //initialize the MPI environment:  
  _myenv = new MPIenv( &ARGC, &ARGV, _my_mpi_manager );
  
 
  // initialize the random number generator with default seed
  // it will be reinitialized later with user-provided seed, if any
  RAND::init(time(0));
 
  //--------------------------------------------------------------------
  if(_myenv->isMaster()) {
 
    START_MESSAGE();
 
  }
  
  //--------------------------------------------------------------------  
  //check for the presence of a metapop:
  if(_thePop == NULL) fatal("SimRunner::run: no population is attached at startup!\n");
  
  //--------------------------------------------------------------------  
  //build the list of params from the components list
  this->build_allParams();
  
  //--------------------------------------------------------------------  
  //get the input parameters from the input parameter file
 
  // create a stream parser attached to the file reader
  FileParser Reader("");
 
  if (ARGC == 1)
    build_records(Reader.getParsedParameters("Nemo2.ini")); // this calls StreamParser::ParamParser::getParsedParameters
  else
    for (int i = 1; i < ARGC; ++i)
      build_records(Reader.getParsedParameters(ARGV[i]));
  
  //--------------------------------------------------------------------  
  //run the simulation
  bool status = run();
  
  _myenv->finish(_my_mpi_manager);
  
  delete _myenv;
  
  return status;
}

References _my_mpi_manager, _myenv, _thePop, ParamManager::build_allParams(), ParamManager::build_records(), fatal(), MPIenv::finish(), ParamsParser::getParsedParameters(), RAND::init(), MPIenv::isMaster(), run(), and START_MESSAGE().

Referenced by main().

run_event()

bool SimRunner::run_event

(

string &

name

)

Execute one specific life cycle event, if present in the list of current events.

Parameters

name	the name of the (paramSet of the) LifeCycleEvent to execute.

{
  //before calling that fction, first set the params and call init_components()!!
  
  LifeCycleEvent* event = this->get_current_event(name);
  
  if(event == NULL) {
        error("SimRunner::run_event:event \"%s\" not found in set events!\n",name.c_str());
        return false;
  }
  
  if( !(event->get_paramset()->isSet()) ) return false;//highly unlikely!!
  
  event->execute();
  
  return true;
}

References error(), and SimBuilder::get_current_event().

runPostExec()

void SimRunner::runPostExec

(

)

Run the post-exec script after all simulations have finished.

{
  ifstream script(_postexec_script.c_str(),ios::in);
  string cmd;
 
  if(!script.is_open()) {
    error("could not open post simulation shell script!\n");
    return;
  }
 
  message("Executing shell script \"%s\" ",_postexec_script.c_str());
  fflush(stdout);
 
  cmd = "sh " + _postexec_script + " " + _postexec_args;
 
  if(system(cmd.c_str()) < 0){
    error("execution of `sh %s %s' failed: %s\n",_postexec_script.c_str(), _postexec_args.c_str(),strerror(errno));
    return;
  }
 
  message("...done\n");
}

References _postexec_args, _postexec_script, error(), and message().

Referenced by run().

runPostExecReplicateWise()

void SimRunner::runPostExecReplicateWise

(

)

Run the post-exec script after each replicate, adds filename and replicate number as args.

{
  ifstream script(_postexec_script.c_str(),ios::in);
  string cmd;
  
  if(!script.is_open()) {
    error("could not open post simulation shell script!\n");
    return;
  }
  
  message("Executing shell script \"%s\" ",_postexec_script.c_str());
  fflush(stdout);
  
  // runs the script with base sim filename and replicate number as two first arguments
  cmd = "sh " + _postexec_script + _FileServices.getBaseFileName() + tstring::int2str(_currentReplicate) + " " + _postexec_args;
  
  if(system(cmd.c_str()) < 0){
    error("execution of `sh %s %s' failed: %s\n",_postexec_script.c_str(), _postexec_args.c_str(),strerror(errno));
    return;
  }
  
  message("...done\n");
}

References _currentReplicate, _FileServices, _postexec_args, _postexec_script, error(), FileServices::getBaseFileName(), tstring::int2str(), and message().

Referenced by Replicate_LOOP().

setCurrentGeneration()

void SimRunner::setCurrentGeneration ( unsigned int  gen )

inline

{_currentGeneration = gen; _thePop->setCurrentGeneration(gen);}

References _currentGeneration, _thePop, and Metapop::setCurrentGeneration().

setCurrentReplicate()

void SimRunner::setCurrentReplicate ( unsigned int  repl )

inline

{_currentReplicate = repl; _thePop->setCurrentReplicate(repl);}

References _currentReplicate, _thePop, and Metapop::setCurrentReplicate().

setElapsedTime()

std::string SimRunner::setElapsedTime

(

clock_t

time

)

Compute and print the simulation's elapsed time to stdout.

Parameters

time	elapsed time in ticks count

{
  int e_time = time / CLOCKS_PER_SEC;
  int hour =  e_time / 3600;
  int minute =  ((e_time % 3600) / 60);
  int sec = (e_time % 3600) % 60;
  
  std::ostringstream out(ios::out);
  
  out.fill('0');
  out.width(2);
  out<<hour<<":";
  out.width(2);
  out<<minute<<":";
  out.precision(2);
  out.fill('0');
  out.width(2);
  out<<sec;
  
  return(out.str());
}

Referenced by printLog(), and run().

setForFirstGeneration()

void SimRunner::setForFirstGeneration

(

)

Sets the population and the services ready for the first generation of a new replicate.

{
  _thePop->setCurrentGeneration(0);
  
  //reset temporal parameters/components to their first generation value/state
  _ParamUpdaterManager.notify(0);
  
  //reset stat recording iterator to first occurrence
  _StatServices.resetCurrentOccurrence();
  
  //build metapopulation for the current replicate (build first generation)
  _thePop->setPopulation(_currentReplicate, _replicates);  
 
}

References _currentReplicate, _ParamUpdaterManager, _replicates, _StatServices, _thePop, UpdaterServices::notify(), StatServices::resetCurrentOccurrence(), Metapop::setCurrentGeneration(), and Metapop::setPopulation().

Referenced by Replicate_LOOP().

setGenerations()

void SimRunner::setGenerations ( unsigned int  gen )

inline

{_generations = gen; _thePop->setGenerations(gen);}

References _generations, _thePop, and Metapop::setGenerations().

setLifeCycle()

void SimRunner::setLifeCycle

(

)

Sets the list of LifeCyckeEvent's currently active.

{
  build_LifeCycle();
 
  for( LCE_ITER LCE = _LifeCycle.begin(); LCE != _LifeCycle.end(); LCE++)
    LCE->second->init(_thePop);
}

References SimBuilder::_LifeCycle, _thePop, and SimBuilder::build_LifeCycle().

Referenced by init_components().

setReplicates()

void SimRunner::setReplicates ( unsigned int  repl )

inline

{_replicates = repl; _thePop->setReplicates(repl);}

References _replicates, _thePop, and Metapop::setReplicates().

step()

void SimRunner::step

(

unsigned int

nb_gen

)

Iterates the life cycle.

Parameters

nb_gen

number of iterations to perform.

{
  LCE_ITER LCE = _LifeCycle.begin();
  
  while(LCE != _LifeCycle.end()) {
    _currentRankInLifeCycle = LCE->second->get_rank();
#ifdef _DEBUG_
    message("LCE rank %i: %s\n", _currentRankInLifeCycle, LCE->second->get_event_name().c_str());
#endif
     LCE->second->execute();
    _thePop->setCurrentAge(LCE->second);
    LCE++;
  }
}

References _currentRankInLifeCycle, SimBuilder::_LifeCycle, _thePop, message(), and Metapop::setCurrentAge().

Referenced by Cycle().

Member Data Documentation

_currentGeneration

unsigned int SimRunner::_currentGeneration

private

The current generation in the generation loop, starts at 1.

Referenced by Cycle(), getCurrentGeneration(), Replicate_LOOP(), and setCurrentGeneration().

_currentRankInLifeCycle

int SimRunner::_currentRankInLifeCycle

private

The current rank in the life cycle, corresponds to the rank of the current LCE, before it executes.

Referenced by getCurrentRankInLifeCycle(), and step().

_currentReplicate

unsigned int SimRunner::_currentReplicate

private

The current replicate in the replicate loop, starts at 1.

Referenced by Cycle(), getCurrentReplicate(), Replicate_LOOP(), runPostExecReplicateWise(), setCurrentReplicate(), and setForFirstGeneration().

_do_postexec

bool SimRunner::_do_postexec

private

Boolean set when a post-exec script must be executed.

Referenced by init(), and run().

_do_postexec_replicatewise

bool SimRunner::_do_postexec_replicatewise

private

Boolean to trigger replicate-wise execution of post script.

Referenced by init(), and Replicate_LOOP().

_doRun

bool SimRunner::_doRun

private

Boolean set when not in dryrun mode.

Referenced by init(), and run().

_endTime

char SimRunner::_endTime[20]

private

Referenced by printLog(), and run().

_FileServices

FileServices SimRunner::_FileServices

Referenced by get_FileServices(), init(), init_components(), Metapop::loadPopFromBinarySource(), printLog(), register_component(), Replicate_LOOP(), reset_services(), run(), runPostExecReplicateWise(), and LCE_Selection_base::set_std_rate_of_change().

_generations

unsigned int SimRunner::_generations

private

Number of generations to iterate.

Referenced by Cycle(), getGenerations(), init(), init_components(), Replicate_LOOP(), and setGenerations().

_logfile

std::string SimRunner::_logfile

private

Referenced by init(), printLog(), and printLogHeader().

_meanGenLength

unsigned int SimRunner::_meanGenLength

private

Generation counter, for logging.

Referenced by printLog(), and Replicate_LOOP().

_meanReplElapsedTime

clock_t SimRunner::_meanReplElapsedTime

private

Clock counter, for logging.

Referenced by printLog(), and Replicate_LOOP().

_mode

unsigned int SimRunner::_mode

private

The run mode code (0 = run, 1 = overwrite, 2 = skip, 3 = dryrun, 4 = create_init)

Referenced by init(), and run().

_modeArg

std::string SimRunner::_modeArg

private

The run mode ('overwrite', 'run', 'skip', 'dryrun', 'create_init').

Referenced by init(), and run().

_my_mpi_manager

MPImanager* SimRunner::_my_mpi_manager

private

Referenced by Replicate_LOOP(), and run().

_ParamUpdaterManager

UpdaterServices SimRunner::_ParamUpdaterManager

Referenced by init_components(), register_component(), reset_services(), and setForFirstGeneration().

_postexec_args

std::string SimRunner::_postexec_args

private

Arguments to pass to the post-exec script.

Referenced by init(), runPostExec(), and runPostExecReplicateWise().

_postexec_script

std::string SimRunner::_postexec_script

private

The path to the script to be executed after last simulation.

Referenced by init(), runPostExec(), and runPostExecReplicateWise().

_random_seed

unsigned long SimRunner::_random_seed

private

The startup random seed of the random generator.

Referenced by init_random_seed(), and run().

_replicates

unsigned int SimRunner::_replicates

private

Number of replicates to iterate.

Referenced by Cycle(), getReplicates(), init(), init_components(), printLog(), Replicate_LOOP(), setForFirstGeneration(), and setReplicates().

_simElapsedTime

std::string SimRunner::_simElapsedTime

private

Referenced by printLog(), and run().

_startTime

char SimRunner::_startTime[20]

private

Referenced by printLog(), and run().

_StatServices

StatServices SimRunner::_StatServices

Referenced by get_allRegisteredStats(), get_StatServices(), init_components(), register_component(), Replicate_LOOP(), reset_services(), and setForFirstGeneration().

_thePop

Metapop* SimRunner::_thePop

private

Referenced by attach_pop(), Cycle(), get_pop(), init_components(), register_component_handlers(), Replicate_LOOP(), run(), setCurrentGeneration(), setCurrentReplicate(), setForFirstGeneration(), setGenerations(), setLifeCycle(), setReplicates(), and step().

---

The documentation for this class was generated from the following files:

• simulation.h
• simulation.cc