ParamManager Class Reference

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

#include <basicsimulation.h>

Inheritance diagram for ParamManager:

Collaboration diagram for ParamManager:

Public Member Functions
	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...

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. 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...

Private Member Functions
string	setFilename (string &fstring, unsigned int sim, vector< string > &args, vector< unsigned int > &arg_no, vector< bool > &is_linked, vector< string > &names, 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.

Constructor & Destructor Documentation

ParamManager()

ParamManager::ParamManager

(

)

Cstor.

Builds the simulation PramaSet.

{
  _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("postexec_args",STR,false,false,0,0);
  _paramSet.add_param("postexec_replicate_wise", BOOL, 0,0,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);
}

References _paramSet, ParamSet::add_param(), BOOL, INT, ParamSet::setIsRequired(), ParamSet::setName(), ParamSet::setOwner(), and STR.

~ParamManager()

ParamManager::~ParamManager ( )

inline

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

Member Function Documentation

add_paramset()

void ParamManager::add_paramset ( ParamSet *  paramset )

inline

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

  {
    _allParams.push_back(paramset);
  }

Referenced by BinaryDataLoader::extractPop().

Here is the caller graph for this function:

build_allParams()

void ParamManager::build_allParams

(

)

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

{
  list< SimComponent* >::iterator cmpt = _components.begin();
 
  _allParams.clear();
  
  _allParams.push_back(&_paramSet);
  
  while(cmpt != _components.end()) {
    _allParams.push_back( (*cmpt)->get_paramset() );
    cmpt++;
  }
}

References _allParams, ComponentManager::_components, and _paramSet.

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

Here is the caller graph for this function:

build_records()

void ParamManager::build_records

(

map< string, vector< string > > &

initParams

)

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

{
  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<bool>   currSeqIsLinked;
  vector<string> currSeqNames;
  vector<string> currCombinArg;
  vector<unsigned int> currCombinPos;
  string NAME;
  string ARG;
  bool SEQUENCE = 0;
    
  //pre-pass: detect and unwrap linked-sequential parameters written as 'name [v1 v2 v3]'.
  //All such parameters share a single sequence dimension and must declare the same number of values.
  set<string> linked_names;
  unsigned int linked_N = 0;
  string linked_first_name;
 
  for(Pit = initParams.begin(); Pit != initParams.end(); ++Pit) {
 
    if(Pit->second.size() != 1) continue;
    if(Pit->second[0].empty() || Pit->second[0][0] != '[') continue;
 
    string val = Pit->second[0];
    size_t close = val.find_last_of(']');
    if(close == string::npos) {
      fatal("linked-sequential parameter \"%s\" has unterminated '[' (closing ']' not found)\n",
            Pit->first.c_str());
    }
    string body = val.substr(1, close - 1);
    body = tstring::replaceChar(body, '\t', ' ');
    body = tstring::replaceChar(body, '\n', ' ');
 
    vector<string> tokens = tstring::splitExcludeEnclosedDelimiters(body, ' ');
    vector<string> vals;
    for(unsigned int k = 0; k < tokens.size(); ++k)
      if(!tokens[k].empty()) vals.push_back(tokens[k]);
 
    if(vals.empty()) {
      fatal("linked-sequential parameter \"%s\" has no values inside '[ ]'\n", Pit->first.c_str());
    }
 
    if(linked_names.empty()) {
      linked_N = vals.size();
      linked_first_name = Pit->first;
    } else if(vals.size() != linked_N) {
      fatal("linked-sequential parameter \"%s\" has %u values, but \"%s\" set the group size to %u; "
            "all linked-sequential parameters must share the same number of values\n",
            Pit->first.c_str(), (unsigned)vals.size(), linked_first_name.c_str(), linked_N);
    }
 
    if(vals.size() == 1) {
      warning("linked-sequential parameter \"%s\" has only one value; brackets have no effect\n",
              Pit->first.c_str());
    }
 
    Pit->second = vals;
    linked_names.insert(Pit->first);
  }
 
  //the linked group, if any, claims sequence[0] as the outer dimension.
  if(!linked_names.empty()) {
    sequence.push_back(linked_N);
    num_seq_arg++;
    RecNb *= linked_N;
  }
 
  //find combinatorial sequential parameters (every multi-value param not part of the linked group):
  for(Pit = initParams.begin(); Pit != initParams.end(); ++Pit) {
 
    if(linked_names.count(Pit->first)) continue;  //already counted as part of the linked group
 
    if(Pit->second.size() > 1) {
      sequence.push_back(Pit->second.size());
      num_seq_arg++;
      RecNb *= Pit->second.size();
    }
  }
  
  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
 
    //all linked-sequential params share this position (they advance in lockstep as the outer dim)
    unsigned int linked_pos = 0;
    if(!linked_names.empty()) {
      BlockSize = RecNb / sequence[0];
      linked_pos = (i / BlockSize) % linked_N;
    }
 
    //SeqParam indexes the 'sequence' vector; start past the linked slot if any
    SeqParam = (linked_names.empty() ? 0 : 1);
 
    for(Pit = initParams.begin(); Pit != initParams.end(); ++Pit) {
 
      //linked-sequential params: pick the value at the shared position and apply name expansion
      if(linked_names.count(Pit->first)) {
        ARG = Pit->second[linked_pos];
        currSeqPos.push_back(linked_pos);
        currSeqArg.push_back(ARG);
        currSeqIsLinked.push_back(true);
        currSeqNames.push_back(Pit->first);
 
        if(ARG.find_first_of('%') != string::npos) {
          if(!SEQUENCE) fatal("found name expansion string '%%' without multi-value parameters in the input file.\n");
          paramsToExpand[Pit->first] = ARG;
        } else
          params[Pit->first] = ARG;
 
        continue;
      }
 
      if(!(Pit->first.compare("filename")==0) &&
         !(Pit->first.compare("stat")==0) &&
         !(Pit->first.compare("postexec_args")==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 ]);
          currSeqIsLinked.push_back(false);
          currSeqNames.push_back(Pit->first);
          
          //assign the right argument to the parameter:
          //params[Pit->first] = Pit->second[ seq_pos ];
          
          ARG =  Pit->second[ seq_pos ];
          //we can expand a string argument of a sequential parameter as well
          if(ARG.find_first_of('%') != string::npos) {
 
            if(!SEQUENCE) fatal("found name expansion string '%%' without multi-value parameters in the input file.\n");
 
            paramsToExpand[Pit->first] = ARG;
 
          } else
            params[Pit->first] = ARG;
          
        } else if (ArgNb == 1) {
          //the current param isn't a sequence param but gets an argument
          //we might have to do some name expansion:
          ARG =  Pit->second[0];
          
          if(ARG.find_first_of('%') != string::npos) {
 
            if(!SEQUENCE) fatal("found name expansion string '%%' without multi-value parameters in the input file.\n");
 
            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];
        
      } else if (Pit->first.compare("postexec_args") == 0){
        
        ARG = "";
 
        //build a string with all the postexec arguments
        for(unsigned int k = 0; k < Pit->second.size(); ++k)
          ARG += Pit->second[k] + " ";
          
        params["postexec_args"] = ARG;
        
        if(ARG.find_first_of('%') != string::npos)
          paramsToExpand["postexec_args"] = ARG;
      }
    }
    
    if(SEQUENCE) { //perform expansion of param arguments containing the '%' marker
      
      params["filename"] = setFilename(NAME, i+1, currSeqArg, currSeqPos, currSeqIsLinked, currSeqNames, true);
 
      for(param_iter = paramsToExpand.begin(); param_iter != paramsToExpand.end(); param_iter++)
        params[param_iter->first] = setFilename(param_iter->second, i+1, currSeqArg, currSeqPos, currSeqIsLinked, currSeqNames, false);
    }
    
    //add all the params previously computed to the main simulation recorder list (of maps)
    _simRecords.push_back(params);
    
    currSeqArg.clear();
    currSeqPos.clear();
    currSeqIsLinked.clear();
    currSeqNames.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;
   }
*/
}

References _simRecords, fatal(), tstring::replaceChar(), setFilename(), tstring::splitExcludeEnclosedDelimiters(), and warning().

Referenced by SimRunner::run().

Here is the caller graph for this function:

get_allParams()

list<ParamSet*>& ParamManager::get_allParams ( )

inline

Accessor of the whole list of the parameter sets.

Returns

the reference to the list of ParamSet

  {
    return _allParams;
  }

get_firstRecord()

map< string,string >& ParamManager::get_firstRecord ( )

inline

Accessor to the first element in the simulations parameter list.

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

get_nbSims()

int ParamManager::get_nbSims ( )

inline

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

the number of simulations to perform.

{return _simRecords.size();}

get_paramset()

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

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

References _allParams.

Referenced by SimRunner::Replicate_LOOP().

Here is the caller graph for this function:

get_simRecords()

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

inline

Accessor to the simulations parameter list.

{return _simRecords;}

lowercase()

string ParamManager::lowercase ( string &  input )

private

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

param_consistency_check()

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

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

References _allParams, and error().

Referenced by set_parameters().

Here is the caller graph for this function:

set_parameters()

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

{
  _inputParams = simparams;
  list<ParamSet*>::iterator current_paramset = _allParams.begin();
  map< string,string >::iterator IT = _inputParams.begin();
  bool set = false;
  bool found = false;
  
  vector< string > unset;
  vector< string > notfound;
 
  // we try and assign recorded parameters to a paramset
  while(IT != _inputParams.end()) {
    
    current_paramset = _allParams.begin();
    
    // go through the list of all paramsets to assign the param to at least one paramset
    // one parameter can be in multiple paramsets because of inheritance between components
    while(current_paramset != _allParams.end()){
 
      found |= ( (*current_paramset)->find_param((string&)IT->first) != NULL );
 
      if(found)
        set |= (*current_paramset)->set_param((string&)IT->first, IT->second);
 
      current_paramset++;
    }
    
    // if not found, add param to list for warnings
    if(!found){
 
      notfound.push_back(IT->first);
 
    }
 
    // if found but set failed, add param to list for warnings
    if(found && !set){
 
      unset.push_back(IT->first);
 
    }
 
    // reset the flags
    found = false;
    set = false;
 
    // move to next input parameter
    IT++;
  }
  
 
  if(!silent && _myenv->isMaster()) {
 
    if(notfound.size() > 0) {
 
      warning(" Orphan parameters!\n>>>> The following parameters do not belong to any simulation component:\n");
 
      for(unsigned i = 0; i < notfound.size(); ++i)
        message(">>>> \"%s\" \n",notfound[i].c_str());
 
      message("\n");
    }
 
    if(unset.size() > 0) {
 
      error(" Unset parameters!\n>>>> The following parameters could not be set (wrong value):\n");
 
      for(unsigned i = 0; i < unset.size(); ++i)
        message(">>>> \"%s\" \n",unset[i].c_str());
 
      fatal("Please check the input parameter file and correct the error.\n");
    }
 
  }
 
 
  return param_consistency_check();
}

References _allParams, _inputParams, _myenv, error(), fatal(), MPIenv::isMaster(), message(), param_consistency_check(), and warning().

Referenced by SimBuilder::build_currentParams().

Here is the caller graph for this function:

setArgString()

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

private

{
  unsigned int width, digits;
  double value;
  bool is_dotless = 0;
  string out, arg_str;
  size_t pos = 0;
  
  if(fmt.size() != 0) {
 
    if(fmt[0] == '[') {
      // comma-separated form: '[s1,s2,...]' -- no width, variable-length pieces
      size_t close = fmt.find(']');
      if(close == string::npos) {
        error("syntax error in format string for filename parameter:\n");
        fatal("enclosing ']' was not found\n");
      }
      string content = fmt.substr(1, close - 1);
 
      // [+] keeps its meaning (position number) but unpadded since no width is given
      if(content.compare("+") == 0) {
        ostringstream ostr;
        ostr << arg_pos + 1;
        return ostr.str();
      }
 
      vector<string> pieces;
      size_t start = 0, comma;
      while((comma = content.find(',', start)) != string::npos) {
        pieces.push_back(content.substr(start, comma - start));
        start = comma + 1;
      }
      pieces.push_back(content.substr(start));
 
      if(arg_pos >= pieces.size()) {
        fatal("not enough comma-separated substrings in substitution string \"[%s]\": "
              "got %u, need at least %u for sequential parameter values\n",
              content.c_str(), (unsigned)pieces.size(), arg_pos + 1);
      }
 
      return pieces[arg_pos];
    }
 
    if(fmt[0] == '.') {
      is_dotless = true;
      fmt = fmt.substr(1, string::npos);
    }
    
    if( !isdigit(fmt[0]) ) {
      error("syntax error in format string for parameter substitution:\n");
      fatal("first character within \' \' 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){
        error("syntax error in format string for parameter substitution:\n");
        fatal("enclosing ']' was not found\n");
      }
      
      arg_str = fmt.substr(1, pos-1);
 
      // reject mixing the two forms: width digit + comma-separated list
      if(arg_str.find(',') != string::npos) {
        error("syntax error in format string for parameter substitution:\n");
        fatal("comma-separated replacement list \"[%s]\" cannot be combined with a size specifier; "
              "drop the leading width digit and use \"[%s]\" alone for variable-length pieces.\n",
              arg_str.c_str(), arg_str.c_str());
      }
 
      if(arg_str[0] == '+') {
        
        ostringstream ostr;
        ostr.width(width);
        ostr.fill('0');
        ostr << arg_pos+1;
        
        out = ostr.str();
        
      } else {
        
        if (arg_str.size() < (arg_pos+1)*width) {
          error("syntax error in format string for parameter substitution:\n");
          fatal("the number of characters in \"[%s]\" is not sufficient.\n", arg_str.c_str());
        }
 
        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;
}

References error(), and fatal().

Referenced by setFilename().

Here is the caller graph for this function:

setFilename()

string ParamManager::setFilename ( string &  fstring, unsigned int  sim, vector< string > &  args, vector< unsigned int > &  arg_no, vector< bool > &  is_linked, vector< string > &  names, bool  check_arg_no  )

private

{
  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;
  static bool has_warned_linked_skip = false;
 
  while(pos != string::npos)
    nstr_args += ( (pos = fstring.find('%', pos+1)) != string::npos);
 
  if(check_arg_no && nstr_args < args.size()) {
 
    //pre-scan the filename to find which 1-based %N indices are referenced
    set<unsigned int> referenced;
    string::size_type scan_pos = fstring.find_first_of('%');
    while(scan_pos != string::npos) {
      string scan_tail = fstring.substr(scan_pos + 1, string::npos);
      unsigned int scan_index = 0;
      stripFormatString(scan_tail, scan_index);
      if(scan_index >= 1 && scan_index <= args.size())
        referenced.insert(scan_index);
      scan_pos = fstring.find('%', scan_pos + 1);
    }
 
    //count linked vs combinatorial slots, and how many of each are referenced
    unsigned int n_linked = 0, n_combin = 0;
    unsigned int referenced_linked = 0, referenced_combin = 0;
    for(unsigned int k = 0; k < is_linked.size(); ++k) {
      if(is_linked[k]) {
        n_linked++;
        if(referenced.count(k + 1)) referenced_linked++;
      } else {
        n_combin++;
        if(referenced.count(k + 1)) referenced_combin++;
      }
    }
 
    bool all_combin_covered = (referenced_combin == n_combin);
    bool any_linked_covered = (referenced_linked >= 1);
 
    if(n_linked > 0 && all_combin_covered && any_linked_covered) {
      //only linked-sequential params are missing from the filename; skip auto-numbering
      string omitted;
      for(unsigned int k = 0; k < is_linked.size(); ++k) {
        if(is_linked[k] && referenced.count(k + 1) == 0) {
          if(!omitted.empty()) omitted += ", ";
          omitted += names[k];
        }
      }
      if(!has_warned_linked_skip)
        warning("linked-sequential param(s) '%s' omitted in filename; filename will not be numbered.\n",
                omitted.c_str());
      has_warned_linked_skip = true;
    } else {
      if(!has_warned) warning("missing sequential arguments in filename parameter, adding simulation number to filename.\n");
      has_warned = true;
      add_sim_no = true;
    }
  }
  
  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;
}

References fatal(), setArgString(), stripFormatString(), and warning().

Referenced by build_records().

Here is the caller graph for this function:

stripFormatString()

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

private

{
  string fmt;
  unsigned int digits;
  size_t 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 {
    
    // check that the placement character '%' is directly followed by a digit (if not by ' )
    if( !isdigit(str[0]) ) {
      error("found a mal-formed format string \"%s\" for parameter substitutions in the input file.\n", str.c_str());
      fatal("Please check that the placement character \"%%\" is directly followed by the reference number of the sequential parameter, or by a format string starting with a \'.\n");
    }
    // no formating string provided
    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;
  
}

References error(), and fatal().

Referenced by setFilename().

Here is the caller graph for this function:

Member Data Documentation

_allParams

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.

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

_inputParams

map< string, string > ParamManager::_inputParams

protected

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

Referenced by set_parameters().

_paramSet

ParamSet ParamManager::_paramSet

protected

The ParamSet param set of the simulation.

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

_simRecords

list< map< string, string > > ParamManager::_simRecords

protected

Sets of parameters of all the simulations to perform.

Referenced by build_records(), and SimRunner::run().

_temporalParams

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

protected

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

---

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

• basicsimulation.h
• basicsimulation.cc