ParamManager Class Reference

Class to manage the sets of parameters of the simulation components. More...

#include <basicsimulation.h>

Inheritance diagram for ParamManager:

[legend]

Collaboration diagram for ParamManager:

[legend]

List of all members.

Public Member Functions
	ParamManager ()
	Cstor.
	~ParamManager ()
void	add_paramset (ParamSet *paramset)
	Adds a ParamSet to the list of the parameter sets of the simulation.
ParamSet *	get_paramset (string &name)
	Looks for paramset with "name" in the list of parameter sets.
void	build_allParams ()
	Clears and fills the _allParams list with the ParamSet's of the simulation components.
list< ParamSet * > &	get_allParams ()
	Accessor of the whole list of the parameter sets.
bool	set_parameters (map< string, string > &simparams, bool silent)
	Sets the parameters of the simulation with the argument strings given in input.
bool	param_consistency_check ()
	Checks if all the mandatory parameters are set so that the simulation can be launched.
void	build_records (map< string, vector< string > > &initParams)
	Builds the list of simulation parameters from the parsed input file(s).
list< map< string, string > > &	get_simRecords ()
	Accessor to the simulations parameter list.
map< string, string > &	get_firstRecord ()
	Accessor to the first element in the simulations parameter list.
int	get_nbSims ()
	Accessor to the size of the simulations parameter list, i.e.
Protected Attributes
list< ParamSet * >	_allParams
	A list of all the parameter sets of all the simulation components loaded in the _component list of the ComponentManager.
map< string, string >	_inputParams
	A map of the parameters and their arguments of the current (running) simulation.
map< unsigned int, list< pair < string, string > > >	_temporalParams
	Lists of parameters to be updated during a simulation indexed by generation update time.
list< map< string, string > >	_simRecords
	Sets of parameters of all the simulations to perform.
ParamSet	_paramSet
	The ParamSet param set of the simulation.
Private Member Functions
string	setFilename (string &fstring, unsigned int sim, vector< string > &args, vector< unsigned int > &arg_no, bool check_arg_no)
string	stripFormatString (string &str, unsigned int &index)
string	setArgString (string &fmt, string &arg, unsigned int arg_pos)
string	lowercase (string &input)

---

Detailed Description

Class to manage the sets of parameters of the simulation components.

This class performs parameters setting and checking for the whole set of the simulation components. Provides access to derived classes to the complete list of parameter sets. Also sets the list of simulations parameters in case of sequential parameters found in input. It stores and builds the simulation parameters set.

See also:

ParamsParser and derived classes. These are the input parameters providers.

Definition at line 89 of file basicsimulation.h.

---

Constructor & Destructor Documentation

ParamManager::ParamManager

(

)

Cstor.

Builds the simulation PramaSet.

Definition at line 97 of file basicsimulation.cc.

{
  _paramSet.setName("simulation");
  _paramSet.setIsRequired(true);
  _paramSet.setOwner(NULL);
  _paramSet.add_param("filename",STR,true,false,0,0);
  _paramSet.add_param("root_dir",STR,false,false,0,0);
  _paramSet.add_param("logfile",STR,false,false,0,0);
  _paramSet.add_param("postexec_script",STR,false,false,0,0);
  _paramSet.add_param("random_seed",INT,false,false,0,0);
  _paramSet.add_param("replicates",INT,true,false,0,0);
  _paramSet.add_param("generations",INT,true,false,0,0);
  _paramSet.add_param("run_mode",STR,false,false,0,0);
}

ParamManager::~ParamManager

(

)

[inline]

Definition at line 93 of file basicsimulation.h.

{/*message("ParamManager::~ParamManager\n");*/}

---

Member Function Documentation

void ParamManager::add_paramset

(

ParamSet *

paramset

)

[inline]

Adds a ParamSet to the list of the parameter sets of the simulation.

Definition at line 95 of file basicsimulation.h.

Referenced by BinaryDataLoader::extractPop().

{_allParams.push_back(paramset);}

void ParamManager::build_allParams

(

)

Clears and fills the _allParams list with the ParamSet's of the simulation components.

Definition at line 114 of file basicsimulation.cc.

Referenced by BinaryDataLoader::extractPop(), SIMenv::loadDefaultComponents(), SimRunner::run(), and SimBuilder::SimBuilder().

{
  list< SimComponent* >::iterator cmpt = _components.begin();

  _allParams.clear();
  
  _allParams.push_back(&_paramSet);
  
  while(cmpt != _components.end()) {
    _allParams.push_back( (*cmpt)->get_paramset() );
    cmpt++;
  }
}

void ParamManager::build_records

(

map< string, vector< string > > &

initParams

)

Builds the list of simulation parameters from the parsed input file(s).

Definition at line 197 of file basicsimulation.cc.

Referenced by SimRunner::run().

{
  map< string, string > params;
  map< string, string > paramsToExpand;
  map< string, string >::iterator param_iter;
  map< string, vector<string> >::iterator Pit;
  unsigned int RecNb = 1, ArgNb, SeqParam = 0, BlockSize, seq_pos, num_seq_arg = 0;
  vector<unsigned int> sequence; //stores the number of args of each sequence parameters
  vector<string> currSeqArg;
  vector<unsigned int> currSeqPos;
  vector<string> currCombinArg;
  vector<unsigned int> currCombinPos;
  string NAME;
  bool SEQUENCE = 0;
    
  //find sequencial and combinatorial parameters:
  for(Pit = initParams.begin(); Pit != initParams.end(); ++Pit) {
        if(Pit->second.size() > 1) {
      //fetch the number of the current sequence parameter:
      sequence.push_back(Pit->second.size());
      num_seq_arg++;
      //increase the total number of simulations records:
      RecNb *= Pit->second.size();
    } else if(Pit->second[0].find_first_of('[') != string::npos) {
      //process sequential arg
    }

  }
  
  if(RecNb > 1)
    //we have a sequence of simulations:
    SEQUENCE = true;
  
  for(unsigned int i = 0; i < RecNb; ++i) {
    //now build the simulation records with the right params!
    //the map 'param' will get all the params used for one simulation
    //it is then added to the list of simulations' parameters map
    
    SeqParam = 0;//used as index of the 'sequence' vector
    
    for(Pit = initParams.begin(); Pit != initParams.end(); ++Pit) {
      
      if(!(Pit->first.compare("filename")==0) &&
         !(Pit->first.compare("stat")==0)) {
        
        //get the number of arguments for the current parameter:
        ArgNb = Pit->second.size();
        
        if(ArgNb > 1) {
          //the current param is a sequence param
          //increase the index of the sequence parameter
          SeqParam++;
          //then compute the right argument to give to the current simulation record:
          BlockSize = RecNb;
          
          for(unsigned int j = 0; j < SeqParam; ++j)
            BlockSize /= sequence[j];
          
          seq_pos = (i/BlockSize) % ArgNb;
          //we store the argument position in its sequence and the actual argument string to build the filename:
          currSeqPos.push_back( seq_pos );
          currSeqArg.push_back(Pit->second[ seq_pos ]);
          //assign the right argument to the parameter:
          params[Pit->first] = Pit->second[ seq_pos ];
          
        } else if (ArgNb == 1) {
          //the current param isn't a sequence param but gets an argument
          //we might have to do some name expansion:
          string arg =  Pit->second[0];
          if(arg.find_first_of('%') != string::npos)
            paramsToExpand[Pit->first] = arg;
          else 
            params[Pit->first] = arg;
          
        } else
          //current param has no argument (bool type param) we give it value 1 (true)
          params[Pit->first] = "1";
        
      } else if (Pit->first.compare("stat") == 0){
        
        params["stat"].assign("");
        //build a string with all the stats arguments
        for(unsigned int k = 0; k < Pit->second.size(); ++k)
          params["stat"] += Pit->second[k] + " ";
        
      } else if (Pit->first.compare("filename")==0) {
        
        if(SEQUENCE)
          NAME = Pit->second[0];
        else
          params["filename"] = Pit->second[0];
        
      }
    }
    
    if(SEQUENCE) {
      params["filename"] = setFilename(NAME, i+1, currSeqArg, currSeqPos, true);
      
      for(param_iter = paramsToExpand.begin(); param_iter != paramsToExpand.end(); param_iter++)
        params[param_iter->first] = setFilename(param_iter->second, i+1, currSeqArg, currSeqPos, false); 
    }
    
    //add all the params previously computed to the main simulation recorder list (of maps)
    _simRecords.push_back(params);
    
    currSeqArg.clear();
    currSeqPos.clear();
  }
  /*
   RecNb = 1;
   for(RecIt = SimRecorder.begin();RecIt != SimRecorder.end();++RecIt){
     message("\nSimulation "<<RecNb++;
             for(P2 = RecIt->begin();P2 != RecIt->end();++P2)
             message("\n  "<<P2->first<<"\t"<<P2->second;
   }
*/
}

list<ParamSet*>& ParamManager::get_allParams

(

)

[inline]

Accessor of the whole list of the parameter sets.

Returns:

the reference to the list of ParamSet

Definition at line 105 of file basicsimulation.h.

{return _allParams;}

map< string,string >& ParamManager::get_firstRecord

(

)

[inline]

Accessor to the first element in the simulations parameter list.

Definition at line 131 of file basicsimulation.h.

{return (*_simRecords.begin());}

int ParamManager::get_nbSims

(

)

[inline]

Accessor to the size of the simulations parameter list, i.e.

the number of simulations to perform.

Definition at line 133 of file basicsimulation.h.

{return _simRecords.size();}

ParamSet * ParamManager::get_paramset

(

string &

name

)

Looks for paramset with "name" in the list of parameter sets.

Returns:

NULL if parameter set "name" not found

Definition at line 179 of file basicsimulation.cc.

{
  list<ParamSet*>::iterator pset = _allParams.begin();
  
  while(pset != _allParams.end()) {
    
    if( (*pset)->getName().compare(name) == 0)
      return (*pset);
    
    pset++;
  }
  
  return NULL;
}

list< map< string,string > >& ParamManager::get_simRecords

(

)

[inline]

Accessor to the simulations parameter list.

Definition at line 129 of file basicsimulation.h.

{return _simRecords;}

string ParamManager::lowercase

(

string &

input

)

[private]

Definition at line 495 of file basicsimulation.cc.

{
  for(unsigned int i=0;i<input.size();++i)
    input[i] = tolower(input[i]);
  return input;
}

bool ParamManager::param_consistency_check

(

)

Checks if all the mandatory parameters are set so that the simulation can be launched.

Returns:

TRUE if all ParamSet::check_consistency() returned true

Definition at line 130 of file basicsimulation.cc.

Referenced by set_parameters().

{
  list<ParamSet*>::iterator current_paramset = _allParams.begin();
  
  bool check = true;
  
  while(current_paramset != _allParams.end()){
    if(!(*current_paramset)->check_consistency()){
      error("ParamManager::param_consistency_check::consistency not satisfied for \"%s\"\n",
            (*current_paramset)->getName().c_str());
      check = false;
    }
    current_paramset++;
  }
  return check;
}

bool ParamManager::set_parameters	(	map< string, string > &	simparams,
		bool	silent
	)

Sets the parameters of the simulation with the argument strings given in input.

Scans the _allParams list to set the parameters present in the input map simparams. Each ParamSet checks internally for the presence of a Param with the given name string and sets its value with the given argument, if present.

Note: all ParamSet owning a Param with the same name will use the same argument string. The input map is not a multimap, each param name is present only once.

Parameters:

	simparams	a map containing the parameter names and their argument string
	silent	will be silent about parameters that could not be set.

Returns:

the status of the param_consistency_check() function

Definition at line 149 of file basicsimulation.cc.

Referenced by SimBuilder::build_currentParams().

{
  _inputParams = simparams;
  list<ParamSet*>::iterator current_paramset = _allParams.begin();
  map< string,string >::iterator IT = _inputParams.begin();
  bool set = false;
  
  while(IT != _inputParams.end()) {
    
    current_paramset = _allParams.begin();
    
    while(current_paramset != _allParams.end()){
      set |= (*current_paramset)->set_param((string&)IT->first,IT->second);
      //is true if at least one paramset could set the param
      current_paramset++;
    }
    
    if(!set && !silent){
      //error("ParamManager::could not set param \"%s\"\n",IT->first.c_str());
      //    return false;
    }
    set = false;
    IT++;
  }
  
  return param_consistency_check();
}

string ParamManager::setArgString	(	string &	fmt,
		string &	arg,
		unsigned int	arg_pos
	)			[private]

Definition at line 423 of file basicsimulation.cc.

Referenced by setFilename().

{
  unsigned int pos = 0, width, digits;
  double value;
  bool is_dotless = 0;
  string out, arg_str;
  
  if(fmt.size() != 0) {
    
    if(fmt[0] == '.') {
      is_dotless = true;
      fmt = fmt.substr(1, string::npos);
    }
    
    if( !isdigit(fmt[0]) ) fatal("syntax error in format string for filename parameter.\n---> first argument must be a number\n");
    
    width =  (unsigned int) strtol(fmt.c_str(), NULL, 10);
    
    digits = (unsigned int) log10((double)width) +1;
    
    fmt = fmt.substr(digits, string::npos);
        
    if(fmt[0] == '[') {
      
      if( (pos = fmt.find(']')) == string::npos)
        fatal("syntax error in format string for filename parameter.\n---> enclosing ']' not found\n");
      
      arg_str = fmt.substr(1, pos-1);
      
      if(arg_str[0] == '+') {
        
        ostringstream ostr;
        ostr.width(width);
        ostr.fill('0');
        ostr << arg_pos+1;
        
        out = ostr.str();
        
      } else
        for(unsigned int i = 0, start = arg_pos*width; i < width; i++)
          out += arg_str[start + i];
      
    } else {
      
      value = strtod(arg.c_str(), 0);
      
      if(is_dotless) {
        //take the decimal part:
        double dummy;
        value = modf(value, &dummy);
        value *= pow(10.0, (double)width);
      }
      
      ostringstream ostr;
      ostr.width(width);
      ostr.fill('0');
      ostr << value;
      
      out = ostr.str();
    }
    
  } else {
    
    out = arg;
    
  }
  
  return out;
}

string ParamManager::setFilename	(	string &	fstring,
		unsigned int	sim,
		vector< string > &	args,
		vector< unsigned int > &	arg_no,
		bool	check_arg_no
	)			[private]

Definition at line 317 of file basicsimulation.cc.

Referenced by build_records().

{
  string out, tail, fmt;
  string::size_type pos = fstring.find_first_of('%');
  string::size_type next;
  unsigned int index, nstr_args = (pos != string::npos ? 1 : 0);
  bool add_sim_no = false;
  static bool has_warned = false;
  
  while(pos != string::npos)
    nstr_args += ( (pos = fstring.find('%', pos+1)) != string::npos);
  
  if(check_arg_no && nstr_args < args.size()) {
    if(!has_warned) warning("missing sequential arguments in filename parameter, adding simulation number to filename.\n");
    has_warned = true;
    add_sim_no = true;
  }
  
//  if(nstr_args > args.size()) fatal("too many sequential arguments in \"%s\"\n",fstring.c_str());
  
  pos = fstring.find_first_of('%');
  
  if(pos != string::npos) {
    
    if(pos > 0) out = fstring.substr(0, pos);
    
    tail = fstring.substr(pos+1, string::npos);
    
    fmt = stripFormatString(tail, index);
    
    if(index > args.size()) fatal("too many sequential arguments in \"%s\"\n",fstring.c_str());
    
    out += setArgString(fmt, args[index-1], arg_no[index-1]);
    
    next = tail.find_first_of('%');
    
    while(next != string::npos){
    
      out += tail.substr(0, next);
      
      tail = tail.substr(next+1, string::npos);
      
      fmt = stripFormatString(tail, index);
      
      if(index > args.size()) fatal("too many sequential arguments in \"%s\"\n",fstring.c_str());

      out += setArgString(fmt, args[index-1], arg_no[index-1]);
      
      next = tail.find_first_of('%');
    }
    
    out += tail.substr(0, next);

  } else
    out = fstring;
  
  if(add_sim_no) {
    
    ostringstream ostr;
    ostr << sim;    
    
    out += "-" + ostr.str();
  }
  
  return out;
}

string ParamManager::stripFormatString	(	string &	str,
		unsigned int &	index
	)			[private]

Definition at line 389 of file basicsimulation.cc.

Referenced by setFilename().

{
  string fmt;
  unsigned int digits, fmt_end;
  
  //check for the presence of a format string, enclose by two \'
  if(str[0] == '\'') {
    
    fmt_end = str.find('\'', 1);
    
    if(fmt_end == string::npos) fatal("format string not closed in filename parameter\n");
    
    fmt = str.substr(1, fmt_end-1);
    
    str = str.substr(fmt_end +1, string::npos);
    
  } else {
    
    fmt = "";
    
  }
  
  index = (unsigned int) strtol(str.c_str(), NULL, 10);
  
  digits = (unsigned int) log10((double)index) +1;
  
  str = str.substr(digits, string::npos);
  
  return fmt;
  
}

---

Member Data Documentation

list< ParamSet* > ParamManager::_allParams [protected]

A list of all the parameter sets of all the simulation components loaded in the _component list of the ComponentManager.

Definition at line 137 of file basicsimulation.h.

Referenced by add_paramset(), build_allParams(), SimBuilder::build_currentParams(), get_allParams(), get_paramset(), param_consistency_check(), SimRunner::reset(), and set_parameters().

map< string, string > ParamManager::_inputParams [protected]

A map of the parameters and their arguments of the current (running) simulation.

Definition at line 139 of file basicsimulation.h.

Referenced by set_parameters().

ParamSet ParamManager::_paramSet [protected]

The ParamSet param set of the simulation.

Definition at line 145 of file basicsimulation.h.

Referenced by build_allParams(), SimRunner::init(), SimRunner::init_random_seed(), ParamManager(), and SimBuilder::SimBuilder().

list< map< string, string > > ParamManager::_simRecords [protected]

Sets of parameters of all the simulations to perform.

Definition at line 143 of file basicsimulation.h.

Referenced by build_records(), get_firstRecord(), get_nbSims(), get_simRecords(), and SimRunner::run().

map< unsigned int, list < pair< string, string> > > ParamManager::_temporalParams [protected]

Lists of parameters to be updated during a simulation indexed by generation update time.

Definition at line 141 of file basicsimulation.h.

---

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

• basicsimulation.h
• basicsimulation.cc