SimRunner Class Reference

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

#include <simulation.h>

Inheritance diagram for SimRunner:

[legend]

Collaboration diagram for SimRunner:

[legend]

List of all members.

Public Member Functions
	SimRunner (Metapop *pop)
	~SimRunner ()
	Dstror.
bool	init ()
	Checks simulation parameters and init the FileServices with the base filename.
bool	init_components (map< string, string > &simparams)
	Performs the initialization of the different components of the simulation.
void	setLifeCycle ()
	Sets the list of LifeCyckeEvent's currently active.
void	init_random_seed ()
	Initialize the seed of the random generator.
void	reset ()
	Resets all the parameters to the unset state, resets the services.
std::string	setElapsedTime (clock_t time)
	Compute and print the simulation's elapsed time to stdout.
void	register_component (SimComponent *cmpt)
	Register the different Handler's attached to a SimComponent.
void	register_component_handlers ()
	Register all the Handlers of the currently active simulation components.
void	reset_services ()
	Resets the FileServices and StatServices.
FileServices *	get_FileServices ()
	Returns the FileServices.
StatServices *	get_StatServices ()
	Returns the StatServices.
list< StatRecBase * >	get_allRegisteredStats ()
	Returns the complete list of the stat recorders loaded after parameters initialization.
bool	run (int ARGC, char **ARGV)
	First loop of the simulation, performs the simulations stored in the ParamManager base class.
bool	run ()
	First loop of the simulation, performs the simulations stored in the ParamManager base class.
bool	run_event (string &name)
	Execute one specific life cycle event, if present in the list of current events.
void	step (unsigned int nb_gen)
	Iterates the life cycle.
void	attach_pop (Metapop *pop)
	Attach a pop to the simulation.
Metapop *	get_pop ()
	Accessor to the pop ptr.
bool	build_pop ()
	Calls the Metapop init procedure with current traits and LCEs.
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 ()
void	printLogHeader ()
void	printLog ()
void	runPostExec ()
Main loops
void	Replicate_LOOP ()
	Replicate loop, iterates the life cycle _replicates times.
void	Cycle (char *startTime)
	Life cycle loop, executes the list of LCEs _generations times.
Public Attributes
FileServices	_FileServices
StatServices	_StatServices
UpdaterServices	_ParamUpdaterManager
Private Attributes
MPImanager *	_my_mpi_manager
Metapop *	_thePop
std::string	_logfile
std::string	_mode
bool	_doRun
std::string	_postexec_script
bool	_do_postexec
char	_startTime [20]
char	_endTime [20]
std::string	_simElapsedTime
clock_t	_meanReplElapsedTime
	Clock counter, for logging.
unsigned int	_meanGenLength
	Generation counter, for logging.
unsigned int	_generations
	Number of generations to iterate.
unsigned int	_replicates
	Number of replicates to iterate.
unsigned int	_currentReplicate
	The current replicate in the replicate loop, starts at 1.
unsigned int	_currentGeneration
	The current generation in the generation loop, starts at 1.

---

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.

Definition at line 53 of file simulation.h.

---

Constructor & Destructor Documentation

SimRunner::SimRunner

(

Metapop *

pop

)

[inline]

Definition at line 97 of file simulation.h.

                             : _my_mpi_manager(0)
  {
    attach_pop(pop);
  }

SimRunner::~SimRunner

(

)

Dstror.

Definition at line 120 of file simulation.cc.

{
  //  message("SimRunner::~SimRunner\n");
  reset();
}

---

Member Function Documentation

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

Definition at line 155 of file simulation.h.

Referenced by SimRunner().

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

bool SimRunner::build_pop

(

)

Calls the Metapop init procedure with current traits and LCEs.

void SimRunner::Cycle

(

char *

startTime

)

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

Parameters:

startTime

the starting time of the current replicate.

Definition at line 463 of file simulation.cc.

Referenced by Replicate_LOOP().

{
  
  // ------------------------------ CYCLE --------------------------------
  
  for(_currentGeneration = 1; !(_currentGeneration > _generations); _currentGeneration++) {
        
    // -------------------------- PRINT STUFF ------------------------------
#if !defined(LOW_VERBOSE) && !defined(USE_MPI)
    if( !(_currentGeneration % 100) ){
      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 --------------------------
}

list<StatRecBase*> SimRunner::get_allRegisteredStats

(

)

[inline]

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

Definition at line 139 of file simulation.h.

{return _StatServices.getAllStats();}

FileServices* SimRunner::get_FileServices

(

)

[inline]

Returns the FileServices.

Definition at line 135 of file simulation.h.

Referenced by Metapop::loadPopFromTraitFile().

{return &_FileServices;}

Metapop* SimRunner::get_pop

(

)

[inline]

Accessor to the pop ptr.

Returns:

the pop ptr

Definition at line 159 of file simulation.h.

{return _thePop;}

StatServices* SimRunner::get_StatServices

(

)

[inline]

Returns the StatServices.

Definition at line 137 of file simulation.h.

{return &_StatServices;}

unsigned int SimRunner::getCurrentGeneration

(

)

[inline]

Definition at line 177 of file simulation.h.

Referenced by SIMenv::getCurrentGeneration().

{return _currentGeneration;}

unsigned int SimRunner::getCurrentReplicate

(

)

[inline]

Definition at line 181 of file simulation.h.

Referenced by SIMenv::getCurrentReplicate().

{return _currentReplicate;}

unsigned int SimRunner::getGenerations

(

)

[inline]

Definition at line 179 of file simulation.h.

Referenced by SIMenv::getGenerations(), and StatHandlerBase::init().

{return _generations;}

unsigned int SimRunner::getReplicates

(

)

[inline]

Definition at line 183 of file simulation.h.

Referenced by SIMenv::getReplicates(), and StatHandlerBase::init().

{return _replicates;}

bool SimRunner::init

(

)

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

Definition at line 58 of file simulation.cc.

Referenced by init_components(), and init_random_seed().

{
  if( !(_paramSet.isSet("filename")) ) {
        error("parameter \"filename\" is not properly set!\n");
        return false;
  }
  
  _FileServices.setBasename(_paramSet.getArg("filename"));
  
  if(_paramSet.isSet("root_dir")) {
    _FileServices.setRootDir(_paramSet.getArg("root_dir"));
  }
  
  if(_paramSet.isSet("run_mode")) {
    
    _mode = _paramSet.getArg("run_mode");
    
    if(_mode.compare("run")==0){
      _FileServices.setMode(0);
      _doRun = true;
    } else if(_mode.compare("overwrite")==0) {
      _FileServices.setMode(1);
      _doRun = true;
    } else if(_mode.compare("skip")==0){
      _FileServices.setMode(2);
      _doRun = true;
    } else if(_mode.compare("dryrun")==0){
      _FileServices.setMode(3);
      _doRun = false;
    } else {
      error("simulation run mode \"%s\" unknown\n",_mode.c_str());
      return false;
    }
  } else {
    _mode = "run";
    _doRun = true;
    _FileServices.setMode(0);
  }
  
  _replicates = (unsigned int)_paramSet.getValue("replicates");
  
  _generations = (unsigned int)_paramSet.getValue("generations");
  
  
  if( _paramSet.isSet("logfile") ) {
    _logfile = _paramSet.getArg("logfile");
  } else 
    _logfile = "nemo.log";
  
  printLogHeader();
  
  if( _paramSet.isSet("postexec_script") ) {
    _postexec_script = _paramSet.getArg("postexec_script");
    _do_postexec = true;
  } else
    _do_postexec = false;
  
  return true;
}

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

Definition at line 183 of file simulation.cc.

Referenced by run().

{
  //first reset all paramSets and services (clear the handlers' lists)
  reset();
  
  _FileServices.set_pop_ptr(_thePop);
  _StatServices.set_pop_ptr(_thePop);
  
  //build the list of parameters from the record:
#ifdef _DEBUG_
  message("SimRunner::init_components: building current params\n");
#endif
  if(!this->build_currentParams(simparams)){
    error("SimRunner::init_components:couldn't build current params\n");
    return false;
  }
  
  //initialize the random generator's seed:
  init_random_seed();
  
  //init the sim and pop
  if( !init() || !_thePop->init() ) return false;
    //temporary fix v2.0.8:
  _thePop->setReplicates(_replicates);
  _thePop->setGenerations(_generations);

  //build the Individual prototype, and init the TTraits:
  _thePop->makePrototype( build_currentTraits() );
  
  //build the list of life cycle events, and init LCEs:
  setLifeCycle( );
  
  //load the stats, files, and updaters 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;
  }
  
  return true;
}

void SimRunner::init_random_seed

(

)

Initialize the seed of the random generator.

Definition at line 235 of file simulation.cc.

Referenced by init_components().

{
  unsigned long seed;
  
  if(this->_paramSet.isSet("random_seed")) {
    seed = (unsigned long) this->_paramSet.getValue("random_seed");
    message( "setting random seed from input value: %i\n", seed);
  } else
    seed =  2*time(0)+1;
  
  RAND::init(seed);  
}

void SimRunner::printLog

(

)

Definition at line 592 of file simulation.cc.

Referenced by run().

{
  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();
}

void SimRunner::printLogHeader

(

)

Definition at line 564 of file simulation.cc.

Referenced by init().

{
  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();
}

void SimRunner::register_component

(

SimComponent *

cmpt

)

Register the different Handler's attached to a SimComponent.

Parameters:

cmpt

a SimComponent

Definition at line 151 of file simulation.cc.

Referenced by register_component_handlers().

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

void SimRunner::register_component_handlers

(

)

Register all the Handlers of the currently active simulation components.

Definition at line 160 of file simulation.cc.

Referenced by init_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);  
}

void SimRunner::Replicate_LOOP

(

)

Replicate loop, iterates the life cycle _replicates times.

Definition at line 376 of file simulation.cc.

Referenced by run().

{
  
#ifndef USE_MPI
  
  clock_t start;
  clock_t stop;
  time_t t;
  char t_buff[10];
  
  _meanReplElapsedTime = 0;
  _meanGenLength = 0;
  _currentGeneration = 0;
  
  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 ------------------
    _thePop->setCurrentGeneration(0);
    
    //reset temporal parameters/components to their first generation value/state
    _ParamUpdaterManager.notify(0);
    
    //build metapopulation for the current replicate (build first generation)
        _thePop->setPopulation(_currentReplicate, _replicates);
    
    start = clock();
    //--------------------------- GENERATION LOOP ---------------------------
    
    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();
    }
    
  } //END_REPLICATE_LOOP
  
#else
  //else ifndef USE_MPI
  //------------------------------- MPI REPLICATE LOOP ------------------------------------
  _currentReplicate = _my_mpi_manager->init( &_statHandler );
  while ( _currentReplicate <= _replicates )
    _my_mpi_manager->iterate( this, &_statHandler, &_currentGeneration, &_currentReplicate );
  _my_mpi_manager->finish( &_statHandler, &_currentGeneration, _currentReplicate );
  //------------------------------ /MPI REPLICATE LOOP ------------------------------------
#endif
  //endif USE_MPI
  
  if( !_thePop->isAlive() && _currentGeneration < _generations ) {
    _currentGeneration = _generations;
    _currentReplicate  = _replicates;
    _thePop->setCurrentGeneration(_generations);
    _thePop->setCurrentReplicate(_replicates);
    _FileServices.notify();
  }
  
  _meanReplElapsedTime /= _replicates;
  _meanGenLength /= _replicates;
  
  //delete all individuals present in the population and delete the patches:
  _thePop->clear();
}

void SimRunner::reset

(

)

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

Definition at line 128 of file simulation.cc.

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

{
  //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();
}

void SimRunner::reset_services

(

)

Resets the FileServices and StatServices.

Definition at line 142 of file simulation.cc.

Referenced by reset().

{
  _FileServices.reset();
  _StatServices.reset();
  _ParamUpdaterManager.reset();
}

bool SimRunner::run

(

)

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

Definition at line 296 of file simulation.cc.

Referenced by run().

{
  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, etc.
    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",_mode.c_str());
      message("    traits: ");
      
      map<trait_t, TraitPrototype* >::iterator trait = _currentTraits.begin();
      while(trait != _currentTraits.end()) {
        message("%s",trait->first.c_str());
        trait++;
        if(trait != _currentTraits.end()) message(", ");
      }
      message("\n    LCEs: ");
     
      for(LCE_ITER LCE = _LifeCycle.begin(); LCE != _LifeCycle.end(); LCE++) {
        message("%s(%i)",LCE->second->get_event_name().c_str(),LCE->first);
        if(LCE != _LifeCycle.end()) message(", ");
      }
      message("\n");
        }
    
        //init the file services:
        //->files check, false means the user wants to skip this simulation.
        //->save simparameters in log files
        if( !(_FileServices.init(this->_currentParams)) ) {
      currentSim++;
      continue;
        }
    message("\n");
    
        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() ) printLog();
    
    if ( _myenv->isMaster() ) {
      message("\n\n    end: %s\n",_endTime);
      message("--- done (CPU time: %ss)\n",_simElapsedTime.c_str());
    }
    
    currentSim++;
  }
  //---------------------------------------------------------------------------------------
  if( _do_postexec && _myenv->isMaster() ) runPostExec();
  
  return true;
}

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

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

Definition at line 250 of file simulation.cc.

Referenced by main().

{  
  //initialize the MPI environment:  
  _myenv = new MPIenv( ARGC, ARGV, _my_mpi_manager );    
  
  //--------------------------------------------------------------------
  if(_myenv->isMaster()) {
    cout<<"\n  N E M O "<<MAIN_VERSION<<"."<<MINOR_VERSION<<"."<<REVISION<<RELEASE<<"  "<<VERSION_DATE<<endl;
    message("\n  Copyright (C) 2006-2009 Frederic Guillaume");
    message("\n  This is free software; see the source for copying");
    message("\n  conditions. There is NO warranty; not even for ");
    message("\n  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.");
    message("\n  http://nemo2.sourceforge.net");
    message("\n------------------------------------------------\n");
  }
  
  //--------------------------------------------------------------------  
  //check for the presence of a metapop:
  if(_thePop == NULL) fatal("SimRunner::run: no population is attached at start up!\n");
  
  //--------------------------------------------------------------------  
  //build the list of params from the components list
  this->build_allParams();
  
  //--------------------------------------------------------------------  
  //get the input parameters
  FileParser Reader("");
  if (ARGC == 1)
    build_records(Reader.getParsedParameters("Nemo2.ini"));
  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;
}

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.

Definition at line 506 of file simulation.cc.

{
  //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;
}

void SimRunner::runPostExec

(

)

Definition at line 645 of file simulation.cc.

Referenced by run().

{
  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;
  
  if(system(cmd.c_str()) < 0){
        error("execution of `sh %s' failed: %s\n",_postexec_script.c_str(),strerror(errno));
        return;
  }
  
  message("...done\n");
}

void SimRunner::setCurrentGeneration

(

unsigned int

gen

)

[inline]

Definition at line 176 of file simulation.h.

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

void SimRunner::setCurrentReplicate

(

unsigned int

repl

)

[inline]

Definition at line 180 of file simulation.h.

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

std::string SimRunner::setElapsedTime

(

clock_t

time

)

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

Parameters:

time

elapsed time in ticks count

Definition at line 539 of file simulation.cc.

Referenced by printLog(), and run().

{
  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());
}

void SimRunner::setGenerations

(

unsigned int

gen

)

[inline]

Definition at line 178 of file simulation.h.

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

void SimRunner::setLifeCycle

(

)

Sets the list of LifeCyckeEvent's currently active.

Definition at line 173 of file simulation.cc.

Referenced by init_components().

{
  build_LifeCycle();

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

void SimRunner::setReplicates

(

unsigned int

repl

)

[inline]

Definition at line 182 of file simulation.h.

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

void SimRunner::step

(

unsigned int

nb_gen

)

Iterates the life cycle.

Parameters:

nb_gen

number of iterations to perform

Definition at line 526 of file simulation.cc.

Referenced by Cycle().

{
  LCE_ITER LCE = _LifeCycle.begin();
  
  while(LCE != _LifeCycle.end()) {
     LCE->second->execute();
    _thePop->setCurrentAge(LCE->second);
    LCE++;
  }
}

---

Member Data Documentation

unsigned int SimRunner::_currentGeneration [private]

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

Definition at line 85 of file simulation.h.

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

unsigned int SimRunner::_currentReplicate [private]

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

Definition at line 83 of file simulation.h.

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

bool SimRunner::_do_postexec [private]

Definition at line 68 of file simulation.h.

Referenced by init(), and run().

bool SimRunner::_doRun [private]

Definition at line 64 of file simulation.h.

Referenced by init(), and run().

char SimRunner::_endTime[20] [private]

Definition at line 70 of file simulation.h.

Referenced by printLog(), and run().

FileServices SimRunner::_FileServices

Definition at line 89 of file simulation.h.

Referenced by get_FileServices(), init(), init_components(), printLog(), register_component(), Replicate_LOOP(), reset_services(), and run().

unsigned int SimRunner::_generations [private]

Number of generations to iterate.

Definition at line 79 of file simulation.h.

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

std::string SimRunner::_logfile [private]

Definition at line 60 of file simulation.h.

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

unsigned int SimRunner::_meanGenLength [private]

Generation counter, for logging.

Definition at line 75 of file simulation.h.

Referenced by printLog(), and Replicate_LOOP().

clock_t SimRunner::_meanReplElapsedTime [private]

Clock counter, for logging.

Definition at line 73 of file simulation.h.

Referenced by printLog(), and Replicate_LOOP().

std::string SimRunner::_mode [private]

Definition at line 62 of file simulation.h.

Referenced by init(), and run().

MPImanager* SimRunner::_my_mpi_manager [private]

Definition at line 56 of file simulation.h.

Referenced by Replicate_LOOP(), and run().

UpdaterServices SimRunner::_ParamUpdaterManager

Definition at line 93 of file simulation.h.

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

std::string SimRunner::_postexec_script [private]

Definition at line 66 of file simulation.h.

Referenced by init(), and runPostExec().

unsigned int SimRunner::_replicates [private]

Number of replicates to iterate.

Definition at line 81 of file simulation.h.

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

std::string SimRunner::_simElapsedTime [private]

Definition at line 71 of file simulation.h.

Referenced by printLog(), and run().

char SimRunner::_startTime[20] [private]

Definition at line 70 of file simulation.h.

Referenced by printLog(), and run().

StatServices SimRunner::_StatServices

Definition at line 91 of file simulation.h.

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

Metapop* SimRunner::_thePop [private]

Definition at line 58 of file simulation.h.

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

---

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

• simulation.h
• simulation.cc