Param Class Reference

This structure stores one parameter, its definition and its string argument. More...

#include <param.h>

Collaboration diagram for Param:

Public Member Functions
	Param (string &Name, param_t Type, bool mandatory, bool bounded, double low_bnd, double up_bnd, SimComponent *owner, ParamUpdaterBase *updater)
	Constructor. More...
	Param (const Param &P)
	Copy cstor, provides shallow copy of the parameter definition, do not copy arguments. More...
virtual	~Param ()
void	reset ()
	Clears the _isSet flag and the argument string. More...
void	setName (string value)
	Sets the parameter's name. More...
void	setArg (string value)
	Sets the parameter's argument. More...
void	setType (param_t value)
	Sets the parameter's type (see types.h) More...
void	setIsSet (bool value)
	Sets the _isSet flag. More...
void	setIsBounded (bool value)
	Sets the _isBounded flag. More...
void	setIsRequired (bool value)
	Sets the isRequired flag. More...
void	setBounds (double low_bnd, double up_bnd)
	Sets the bounds. More...
void	setOwner (SimComponent *owner)
	Sets the pointer to owner. More...
void	setUpdater (ParamUpdaterBase *updater)
	Sets the pointer to the updater object. More...
void	setAtGeneration (unsigned int generation)
string	getName ()
string	getArg ()
string	getInputArg ()
	Returns the original, untouched input argument string (for logging). More...
param_t	getType ()
bool	isSet ()
bool	isBounded ()
bool	isRequired ()
bool	isTemporal ()
bool	hasMultipleArgs ()
bool	hasPreservedMacro ()
void	clearPreservedMacro ()
bool	hasExternalFile ()
double	getBound (unsigned int i)
SimComponent *	getOwner ()
ParamUpdaterBase *	getUpdater ()
deque< unsigned int >	getUpdatingDates ()
deque< string >	getTemporalArgs ()
vector< string >	getMultiArgs ()
vector< string >	getExternalFiles ()
bool	set (string arg, string &errmsg)
	Sets the _isSet flag to true and _arg to arg if the arg is of the right type and whithin the bounds. More...
bool	update (unsigned int generation)
	Updates the parameter value at a given generation during the simulation. More...
double	getValue ()
	Returns the argument value according to its type. More...
bool	isMatrix ()
	Checks if the argument is of matrix type. More...
void	getMatrix (TMatrix *mat)
	Sets the matrix from the argument string if the parameter is set and of matrix type. More...
void	getVariableMatrix (vector< vector< double > > *mat)
void	parse_matrix (TMatrix *mat)
	Parses the matrix from the argument string. More...
void	parse_variable_matrix (vector< vector< double > > *mat)
bool	parseArgument (string &arg)
bool	parseTemporalArgument (const string &arg)
bool	parseAgeSpecArgument (const string &arg)
bool	parseSubParamArgument (const string &arg)
string	checkArgumentForExpansion (string arg)
string	getArgumentFromFile (string file)
void	show_up ()
	Print state to stdout. More...

Private Attributes
string	_name
	The name of the parameter as read in the init file. More...
string	_arg
	The argument string, set by the ParamsParser upon initialization. More...
string	_input_arg
	The input argument string, kept untouched as a backup for logging. More...
param_t	_type
	The type of the argument, must one of DBL, INT, BOOL, STR or MAT (see types.h). More...
bool	_isSet
	Flag set once the parameter has recieved the right argument. More...
bool	_isBounded
	Flag telling if the parameter has a bounded argument value. More...
bool	_isRequired
	Flag telling if this parameter is mandatory. More...
double	_bounds [2]
	The argument value boundaries. More...
unsigned int	_setAtGeneration
	Generation at which the parameter has been set/updated. More...
SimComponent *	_myOwner
	Pointer to the component that declared this parameter. More...
ParamUpdaterBase *	_myUpdater
	Pointer to an ParamUpdater object. More...
vector< string >	_externalFile
	External argument file. More...
bool	_hasExternalFile
map< unsigned int, string >	_temporalArgs
	The temporal arguments. More...
bool	_isTemporal
	Flag telling if this parameter has temporal arguments. More...
vector< string >	_multiArgs
	Multiple arguments. More...
bool	_hasMultipleArgs
bool	_hasPreservedMacro
	Flag telling if this parameter's argument holds a macro preserved by the P() macro, whose expansion is deferred until after the random seed has been set. More...

Detailed Description

This structure stores one parameter, its definition and its string argument.

Parameters are aggregated into a ParamSet.

Constructor & Destructor Documentation

Param() [1/2]

Param::Param	(	string &	Name,
		param_t	Type,
		bool	mandatory,
		bool	bounded,
		double	low_bnd,
		double	up_bnd,
		SimComponent *	owner,
		ParamUpdaterBase *	updater
	)

Constructor.

Parameters

Name	the name of the parameter as read in the init file
Type	the type of the parameter argument (see types.h), used to convert the argument string into a value
mandatory	specifies whether this parameter is mandatory for the ParamSet owning it
bounded	specifies whether the values this parameter can take are bounded
low_bnd	the lower bound of the parameter value
up_bnd	the upper bound
owner	pointer to the SimComponents that owns this parameter
updater	the param updater object used to update the parameter's state during a simulation

: _name(Name),_arg(""),_type(Type),_isSet(0),_isBounded(bounded),_isRequired(mandatory),
  _setAtGeneration(0),_myOwner(owner), _myUpdater(updater),_hasExternalFile(0),_isTemporal(0),
  _hasMultipleArgs(0),_hasPreservedMacro(0)
 
{
  _bounds[0] = low_bnd;
  _bounds[1] = up_bnd;
}

References _bounds.

Param() [2/2]

Param::Param

(

const Param &

P

)

Copy cstor, provides shallow copy of the parameter definition, do not copy arguments.

: _name(P._name),_arg(P._arg),_type(P._type),_isSet(P._isSet),_isBounded(P._isBounded),
_isRequired(P._isRequired),_setAtGeneration(P._setAtGeneration),_myOwner(P._myOwner),
_myUpdater(0),_hasExternalFile(P._hasExternalFile),_hasMultipleArgs(P._hasMultipleArgs),
_hasPreservedMacro(0)
{
  _bounds[0] = P._bounds[0];
  _bounds[1] = P._bounds[1];
}

References _bounds.

~Param()

Param::~Param ( )

virtual

{
  if(_myUpdater) delete _myUpdater;
}

References _myUpdater.

Member Function Documentation

checkArgumentForExpansion()

string Param::checkArgumentForExpansion

(

string

arg

)

{
  string expanded;
  
  if (arg[0] == '&') { //this is the char indicating an external argument file
    expanded = getArgumentFromFile(arg);
  } else
    expanded = arg;
  
  return expanded;
}

References getArgumentFromFile().

Referenced by parseArgument(), parseTemporalArgument(), and set().

Here is the caller graph for this function:

clearPreservedMacro()

void Param::clearPreservedMacro ( )

inline

{_hasPreservedMacro = false;}

getArg()

string Param::getArg ( )

inline

{return _arg;}

Referenced by LCE_Cross::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), LCE_Selection_base::set_sel_model(), TProtoQuanti::setAlleleModel(), LCE_Breed_base::setFecundity(), LCE_FileServicesNotifier::setGenotyperParameters(), BinaryDataSaver::setParameters(), LCE_BreedAssortativeMating::setParameters(), LCE_Breed_Disperse::setParameters(), LCE_Cross::setParameters(), LCE_QuantiModifier::setParameters(), TProtoQuanti::setParameters(), and TProtoDispersal::setRandom().

Here is the caller graph for this function:

getArgumentFromFile()

string Param::getArgumentFromFile

(

string

file

)

{
  StreamParser Parser(tstring::removeFirstCharOf(file, '&').c_str());
  int dummyCnt;
  string arg;
  
  ifstream EXT(tstring::removeFirstCharOf(file, '&').c_str());
  if(!EXT) fatal("External parameter file '%s' could not be found!\n", file.c_str());
  while(Parser.readArguments(EXT, dummyCnt, arg));
  EXT.close();
  
  //add the external file name to the list
  _externalFile.push_back(file);
  _hasExternalFile = true;
 
  return arg;
}

References _externalFile, _hasExternalFile, fatal(), StreamParser::readArguments(), and tstring::removeFirstCharOf().

Referenced by checkArgumentForExpansion().

Here is the caller graph for this function:

getBound()

double Param::getBound ( unsigned int  i )

inline

{return _bounds[i];}

getExternalFiles()

vector< string > Param::getExternalFiles ( )

inline

{return _externalFile;}

getInputArg()

string Param::getInputArg ( )

inline

Returns the original, untouched input argument string (for logging).

{return _input_arg;}

Referenced by Metapop::loadPopFromBinarySource(), and ParamSet::print().

Here is the caller graph for this function:

getMatrix()

void Param::getMatrix

(

TMatrix *

mat

)

Sets the matrix from the argument string if the parameter is set and of matrix type.

Passes the param 'mat' to function Param::parse_matrix.

Parameters

mat	a TMatrix ptr, mat dimensions and values will be reset to the values read in the init file.

{
  if( isMatrix() && _isSet ){
    
    parse_matrix(mat);
    
  } else
    warning("param \"%s\" is not a matrix!\n",_name.c_str());
}

References _isSet, _name, isMatrix(), parse_matrix(), and warning().

Referenced by LCE_Selection_base::loadFileServices(), Metapop::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), LCE_PhenotypeExpression::set_g_value_matrix(), LCE_Patch_Extinction::set_matrix_param(), LCE_Selection_base::set_param_rate_of_change(), LCE_Selection_base::set_sel_model(), LCE_Selection_base::set_std_rate_of_change(), TProtoQuanti::setContinuousMutationModel_full_pleio(), TProtoQuanti::setDiallelicMutationModel(), TProtoQuanti::setDominanceParameters(), TProtoDeletMutations_bitstring::setEffectsFromInput(), TProtoQuanti::setEpistasisParameters(), LCE_Breed_base::setFecundity(), TTProtoWithMap::setGeneticMapParameters(), LCE_FileServicesNotifier::setGenotyperParameters(), TProtoQuanti::setHeritabilityParams(), TProtoQuanti::setInitialValuesParams(), TProtoQuanti::setMutationCorrelation(), TProtoQuanti::setMutationModel_no_pleio(), TProtoQuanti::setMutationModel_var_pleio(), TProtoQuanti::setMutationSigmaFromQuantiMutationVariance(), TProtoQuanti::setMutationSigmaFromQuantiMutationVariance_no_pleio(), TTProtoWithMap::setNumLociPerChromosome(), LCE_StatServiceNotifier::setOccurence(), LCE_Breed_Disperse::setParameters(), LCE_QuantiModifier::setParameters(), TProtoBDMI::setParameters(), LCE_Breed_Wolbachia::setParameters(), TProtoDispersal::setRandom(), LCE_FileServicesNotifier::setSamplingParameters(), LCE_Selection_base::setSelectionOffset(), and LCE_Selection_base::setSelectTraitMapping().

getMultiArgs()

vector< string > Param::getMultiArgs

(

)

{
  if (!_hasMultipleArgs) {
    _multiArgs.clear();
    _multiArgs.push_back(_arg);
  }
  return _multiArgs;
}

References _arg, _hasMultipleArgs, and _multiArgs.

Referenced by LCE_Selection_base::set_sel_model(), LCE_FileServicesNotifier::setGenotyperParameters(), LCE_Selection_base::setParameters(), and Metapop::setSourceParameters().

Here is the caller graph for this function:

getName()

string Param::getName ( )

inline

{return _name;}

Referenced by ParamSet::add_param(), LCE_PhenotypeExpression::check_g_index_matrix(), ParamSet::print(), and LCE_PhenotypeExpression::set_g_value_matrix().

Here is the caller graph for this function:

getOwner()

SimComponent* Param::getOwner ( )

inline

{return _myOwner;}

getTemporalArgs()

deque< string > Param::getTemporalArgs

(

)

{
  deque< string > args;
  
  for(map< unsigned int, string >::iterator tmp_it = _temporalArgs.begin();
      tmp_it != _temporalArgs.end(); tmp_it++)
    args.push_back( tmp_it->second );
  
  return args;
}

References _temporalArgs.

Referenced by LCE_StatServiceNotifier::setOccurence().

Here is the caller graph for this function:

getType()

param_t Param::getType ( )

inline

{return _type;}

getUpdater()

ParamUpdaterBase* Param::getUpdater ( )

inline

{return _myUpdater;}

getUpdatingDates()

deque< unsigned int > Param::getUpdatingDates

(

)

{
  deque< unsigned int > dates;
  
  for(map< unsigned int, string >::iterator tmp_it = _temporalArgs.begin();
      tmp_it != _temporalArgs.end(); tmp_it++)
    dates.push_back( tmp_it->first );
  
  return dates;
}

References _temporalArgs.

Referenced by LCE_StatServiceNotifier::setOccurence().

Here is the caller graph for this function:

getValue()

double Param::getValue

(

)

Returns the argument value according to its type.

Returns

-1 if the parameter is not set or not of a the right type

{
  if( !(isMatrix() || _type == STR) && _isSet)
    return atof(_arg.c_str());
  else
    return -1.0;
}

References _arg, _isSet, _type, isMatrix(), and STR.

Referenced by LCE_Selection_base::loadFileServices(), Metapop::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), LCE_PhenotypeExpression::set_g_value_matrix(), LCE_Patch_Extinction::set_matrix_param(), LCE_FileServicesNotifier::setGenotyperParameters(), TProtoDispersal::setNonRandom(), and LCE_StatServiceNotifier::setOccurence().

Here is the caller graph for this function:

getVariableMatrix()

void Param::getVariableMatrix

(

vector< vector< double > > *

mat

)

{
  if( isMatrix() && _isSet ){
    
    parse_variable_matrix(mat);
    
  } else
    warning("param \"%s\" is not a (variable) matrix!\n",_name.c_str());
}

References _isSet, _name, isMatrix(), parse_variable_matrix(), and warning().

Referenced by TProtoQuanti::readMatrixFromQuantiMutationMatrix(), TProtoQuanti::setEpistasisParameters(), TTProtoWithMap::setGeneticMapParameters(), LCE_Disperse_EvolDisp::setParameters(), LCE_PhenotypeExpression::setParameters(), and LCE_Disperse_base::setReducedMatricesBySex().

Here is the caller graph for this function:

hasExternalFile()

bool Param::hasExternalFile ( )

inline

{return _hasExternalFile;}

hasMultipleArgs()

bool Param::hasMultipleArgs ( )

inline

{return _hasMultipleArgs;}

Referenced by Metapop::setSourceParameters().

Here is the caller graph for this function:

hasPreservedMacro()

bool Param::hasPreservedMacro ( )

inline

{return _hasPreservedMacro;}

isBounded()

bool Param::isBounded ( )

inline

{return _isBounded;}

isMatrix()

bool Param::isMatrix ( )

inline

Checks if the argument is of matrix type.

    {  return (_type == MAT || (_arg.size() != 0 ? _arg[0] == '{' : false) ); }

References MAT.

Referenced by getMatrix(), getValue(), getVariableMatrix(), LCE_Selection_base::loadFileServices(), Metapop::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), LCE_PhenotypeExpression::set_g_value_matrix(), LCE_Patch_Extinction::set_matrix_param(), LCE_FileServicesNotifier::setGenotyperParameters(), TProtoQuanti::setInitialValuesParams(), LCE_StatServiceNotifier::setOccurence(), and LCE_QuantiModifier::setParameters().

Here is the caller graph for this function:

isRequired()

bool Param::isRequired ( )

inline

{return _isRequired;}

isSet()

bool Param::isSet ( )

inline

{return _isSet;}

Referenced by LCE_Breed_base::isWrightFisher(), LCE_Selection_base::loadFileServices(), Metapop::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), ParamSet::print(), TProtoNeutralGenes::resetParameterFromSource(), LCE_Disperse_base::setBaseParameters(), TProtoQuanti::setContinuousMutationModel_no_pleio(), TTProtoWithMap::setGeneticMapParameters(), LCE_FileServicesNotifier::setGenotyperParameters(), TProtoQuanti::setHeritabilityParams(), TProtoQuanti::setInitialValuesParams(), LCE_Breed_base::setMatingSystem(), TProtoDispersal::setNonRandom(), BinaryDataSaver::setParameters(), LCE_Breed_Disperse::setParameters(), LCE_Cross::setParameters(), LCE_Breed_Quanti::setParameters(), LCE_Init_BDMI::setParameters(), TProtoDeletMutations_bitstring::setParameters(), TProtoNeutralGenes::setParameters(), TProtoDispersal::setRandom(), and LCE_Resize::updateParameters().

isTemporal()

bool Param::isTemporal ( )

inline

{return _isTemporal;}

Referenced by LCE_StatServiceNotifier::setOccurence().

Here is the caller graph for this function:

parse_matrix()

void Param::parse_matrix

(

TMatrix *

mat

)

Parses the matrix from the argument string.

Parameters

mat	a TMatrix ptr, mat dimensions and values will be reset to the values read in the init file.

{
  std::vector< std::vector<double> > tmpMat;
  std::istringstream IN;
  
  IN.str(_arg);
  
  unsigned int cols = 0;
  double elmnt;
  char c;
  
  
  int rows = -1, pos = -1;
  //we count the number of rows
  do {
    pos = _arg.find("{", pos + 1);
    //message("pos %i, arg %s\n",pos,_arg.c_str());
    rows++;
  }while(pos != (int)string::npos);
  //decrement by 1, the first doesn't count for a row
  rows--;
  
  for(int i = 0; i < rows; i++)
    tmpMat.push_back( vector<double>()  );
  
  //remove the first enclosing bracket
  IN>>c;
  //then read the rows
  for(unsigned int i = 0; i < tmpMat.size(); i++) {
    
    cols = 0;
    
    //read a row enclosed by {...}:
    while(IN) {
      
      //first character:
      IN>>c;
      
      if(c == '{' || c == ',' || c == ';') {
        //read a row element:
        IN>>elmnt;
        cols++;
        tmpMat[i].push_back(elmnt);
        
      } else if(c == '}')
        //go to next row
        break;
      else if(isdigit(c) || c == '.' || c == '-' || c == '+')
        fatal("param \"%s\": matrix values must be separated by commas, not spaces.\n", _name.c_str());
 
    }
  }
  //check for matrix coherence:
  for(unsigned int i = 0; i < tmpMat.size(); i++) {
    if(tmpMat[i].size() != cols)
      fatal("%s: not same number of elements in all rows of matrix! (%i, cols %i)\n",_name.c_str(),tmpMat[i].size(),cols);
    cols = tmpMat[i].size();
  }
  
  //copy to input TMatrix:
  mat->reset(rows, cols);
  for(int i = 0; i < rows; ++i)
    for(unsigned int j = 0; j < cols; ++j)
      mat->set(i,j,tmpMat[i][j]);
  
 
  tmpMat.clear();
}

References _arg, _name, fatal(), TMatrix::reset(), and TMatrix::set().

Referenced by getMatrix().

Here is the caller graph for this function:

parse_variable_matrix()

void Param::parse_variable_matrix

(

vector< vector< double > > *

mat

)

{
  //  std::vector< std::vector<double> > tmpMat;
  std::istringstream IN;
  
  IN.str(_arg);
  
  double elmnt;
  char c;
  
  //purge the input matrix:
  mat->clear();
  
  int rows = -1, pos = -1;
  //we count the number of rows
  do {
    pos = _arg.find("{", pos + 1);
    //message("pos %i, arg %s\n",pos,_arg.c_str());
    rows++;
  }while(pos != (int)string::npos);
  //decrement by 1, the first doesn't count for a row
  rows--;
  
  for(int i = 0; i < rows; i++)
    mat->push_back( vector<double>()  );
  
  //remove the first enclosing bracket
  IN>>c;
  //then read the rows
  for(unsigned int i = 0; i < mat->size(); i++) {
    
    //read a row enclosed by {...}:
    while(IN) {
      
      //first character:
      IN>>c;
      
      if(c == '{' || c == ',' || c == ';') {
        //peek ahead to handle empty rows, e.g. {} in {{}{1, 2}}
        char next;
        IN >> next;
        if(next == '}') {
          break; //empty row or end of row
        }
        IN.putback(next);
        //read a row element:
        IN>>elmnt;
        (*mat)[i].push_back(elmnt);
 
      } else if(c == '}')
        //go to next row
        break;
    }
  }
}

References _arg.

Referenced by getVariableMatrix().

Here is the caller graph for this function:

parseAgeSpecArgument()

bool Param::parseAgeSpecArgument

(

const string &

arg

)

{
  return true;
}

Referenced by parseArgument().

Here is the caller graph for this function:

parseArgument()

bool Param::parseArgument

(

string &

arg

)

Parse an argument string enclosed in '( )', might hold temporal or multiple values. Might also hold a macro to expand.

{
  // do some string clean-up:
  arg = tstring::replaceChar(arg, '\t', ' ');
  arg = tstring::replaceChar(arg, '\n', ' ');
  // remove the enclosing parentheses:
  arg = tstring::removeEnclosingChar(arg, '(', ')');
  
  vector< string > args = tstring::splitExcludeEnclosedDelimiters(arg); //split with default delimiter = ','
  
  _temporalArgs.clear();
  _multiArgs.clear();
  
//  cout<< "Param::parseArgument: " << endl;
//
//  cout<<"  argument string: "<<arg<<endl;
  
  for(unsigned int i = 0; i < args.size(); ++i) {
    
    // removing any leading white spaces (' ', '\t')
    args[i] = tstring::removeLeadingWhiteSpace(args[i]);
 
//    cout << args[i] << endl;
 
    // check for specifiers:
    if(args[i][0] == '@') {
 
      // temporal argument
      if(args[i][1] == 'g')
      {
        if(!parseTemporalArgument(args[i])) return false;
      }
 
      // age-specific argument
      else if(args[i][1] == 'a')
      {
        if(!parseAgeSpecArgument(args[i])) return false;
      }
 
      // error
      else
      {
        return error("parameter \"%s\" has unrecognized specifier in its argument string \"%s\".\n", _name.c_str(), args[i].c_str());
      }
 
  // multiple arguments?
    } else { // (arg1, arg2, arg3, ...)
      //values might still be in external files
      _multiArgs.push_back( checkArgumentForExpansion(args[i]) );
    }
  }
  
  if(_multiArgs.size() != 0)
    _hasMultipleArgs = true;
  else
    _hasMultipleArgs = false;
  
 
  // deal with temporal arguments:
  if(_temporalArgs.size() != 0) {
    
//    cout << "temporal arg values:\n";
//    for(map< unsigned int , string >::iterator iter = _temporalArgs.begin();
//        iter != _temporalArgs.end();
//        iter++)
//      cout << iter->first <<" "<< iter->second << endl;
    
    if(_myUpdater != 0) {
      
      if(_temporalArgs.find(0) != _temporalArgs.end()) {
        _isTemporal = true;
        //set the value for the first generation
        arg = _temporalArgs.find(0)->second;
      }
      else {
        return error("first generation argument value for temporal parameter \"%s\" is missing; no \"@g0\".\n", _name.c_str());
      }
      
    } else {
      warning("trying to pass a temporal argument to a non temporal parameter (\"%s\").\n", _name.c_str());
      _isTemporal = false;
      _temporalArgs.clear();
    }
    
  } else _isTemporal = false;
  
  
  return true;
}

References _hasMultipleArgs, _isTemporal, _multiArgs, _myUpdater, _name, _temporalArgs, checkArgumentForExpansion(), error(), parseAgeSpecArgument(), parseTemporalArgument(), tstring::removeEnclosingChar(), tstring::removeLeadingWhiteSpace(), tstring::replaceChar(), tstring::splitExcludeEnclosedDelimiters(), and warning().

Referenced by set().

Here is the caller graph for this function:

parseSubParamArgument()

bool Param::parseSubParamArgument

(

const string &

arg

)

{
  return true;
}

parseTemporalArgument()

bool Param::parseTemporalArgument

(

const string &

arg

)

{
  vector< string > args = tstring::split(arg, ' ', true);
  
  if(args.size() != 2) {
    error("Param::parseTemporalArgument:: missing argument value in \"%s %s\".\n", _name.c_str(), arg.c_str());
    return false;
  }
  
  unsigned int gen = tstring::str2uint(tstring::removeFirstCharOf(tstring::removeFirstCharOf(args[0], '@'), 'g'));
  
  // remove extra white space characters introduced between delimiter and argument value:
  args[1] = tstring::removeLeadingWhiteSpace(args[1]);
  args[1] = checkArgumentForExpansion(args[1]);
  
  _temporalArgs[gen] = args[1];
  
  return true;
}

References _name, _temporalArgs, checkArgumentForExpansion(), error(), tstring::removeFirstCharOf(), tstring::removeLeadingWhiteSpace(), tstring::split(), and tstring::str2uint().

Referenced by parseArgument().

Here is the caller graph for this function:

reset()

void Param::reset

(

)

Clears the _isSet flag and the argument string.

{
  _input_arg = "",
  _arg = "";
  _isSet = 0;
  _setAtGeneration = 0;
 
  _multiArgs.clear();
  _hasMultipleArgs = false;
 
  _externalFile.clear();
  _hasExternalFile = false;
 
  _temporalArgs.clear();
  _isTemporal = false;
 
  _hasPreservedMacro = false;
 
}

References _arg, _externalFile, _hasExternalFile, _hasMultipleArgs, _hasPreservedMacro, _input_arg, _isSet, _isTemporal, _multiArgs, _setAtGeneration, and _temporalArgs.

set()

bool Param::set	(	string	arg,
		string &	errmsg
	)

Sets the _isSet flag to true and _arg to arg if the arg is of the right type and whithin the bounds.

Called at simulation setup (i.e. generation 0). For parameter update during the simulation, check the Param::update member function.

!a matrix may also be specified!! in that case, we don't check values here

{
//  cout << "Param::set ("<<arg<<")\n";
 
  _hasPreservedMacro = false;
 
  // A leading MACRO_PRESERVE_TAG marks an argument whose macro(s) were preserved by the P()
  // macro (see ParamsParser::parseMacroFunctionBlock). Their expansion is deferred until the
  // random seed has been set, because stochastic macros (rexp, rnorm, ...) draw from the RNG.
  // Record the deferral, store the still-un-expanded argument, and skip parsing/validation now:
  // SimRunner::expandPreservedMacros will expand it and call set() again with the resolved value.
  if(arg[0] == MACRO_PRESERVE_TAG) {
    arg.erase(0, 1);          // strip the sentinel
    _input_arg = arg;         // keep the un-expanded macro string (e.g. "{{c(q(rexp(...)),0)}}")
    _arg = arg;
    _hasPreservedMacro = true;
    _isSet = true;            // the parameter is specified; it will be resolved after seeding
    return true;
  }
 
  _input_arg = arg; //backup the input parameter argument string
 
  //remove any remaining leading white-space character
  while(isspace(arg[0])) {
    arg.erase(0);
  }
 
  if(arg.size() == 0){
    errmsg = "argument is empty";
    return false;
  }
  _externalFile.clear(); //ext. file names will be pushed here
  //check if argument is in an external file, and read it from that file
  if (arg[0] == '&') {
      //read the argument from an external file, file name is stored within the call.
      string expanded = checkArgumentForExpansion(arg);
      arg = expanded;
    }
 
  if( arg[0] == '(' ) {
    if( !parseArgument( arg ) ) {
      errmsg = "could not parse the argument string";
      return false;
    }
  }
 
  //integer or decimal: 
  if(_type == INT || _type == DBL) {
    if(arg[0] != '{') {
      
      if(!tstring::isanumber(arg)) {
        errmsg = "argument is not a number";
        return false;
      }
      
      double val = tstring::str2dble(arg);
      
      if(_isBounded && (val < _bounds[0] || val > _bounds[1]) ){
        errmsg = "argument is out of bounds";
        return false;
      }
    }
    
    //boolean:
  } else if(_type == BOOL) {
    
    if( !tstring::isanumber(arg) ){
      errmsg = "argument is not a boolean";
      return false;
    }
    
  } else if(_type == MAT) {
    if(arg[0] != '{'){
      errmsg = "argument is not a matrix";
      return false;
    }
  }
  // else if(_type == P || _type == S): no conditions to check
  
  _isSet = (_type == BOOL && tstring::str2int(arg) == 0 ? false : true);
 
  //now we set the value of the parameter to the value of the argument read in the file
  _arg = arg;
 
  return true;
}

References _arg, _bounds, _externalFile, _hasPreservedMacro, _input_arg, _isBounded, _isSet, _type, BOOL, checkArgumentForExpansion(), DBL, INT, tstring::isanumber(), MACRO_PRESERVE_TAG, MAT, parseArgument(), tstring::str2dble(), and tstring::str2int().

Referenced by update().

Here is the caller graph for this function:

setArg()

void Param::setArg ( string  value )

inline

Sets the parameter's argument.

{_arg = value; _input_arg = value;}

Referenced by TTProtoWithMap::recordRandomMap(), TProtoDispersal::setParameters(), TTProtoWithMap::setRecombinationMapRandom(), and TProtoDeletMutations_bitstring::write_effects_to_parameter().

Here is the caller graph for this function:

setAtGeneration()

void Param::setAtGeneration ( unsigned int  generation )

inline

{_setAtGeneration = generation;}

setBounds()

void Param::setBounds ( double  low_bnd, double  up_bnd  )

inline

Sets the bounds.

{_bounds[0]=low_bnd; _bounds[1]=up_bnd;}

setIsBounded()

void Param::setIsBounded ( bool  value )

inline

Sets the _isBounded flag.

{_isBounded = value;}

setIsRequired()

void Param::setIsRequired ( bool  value )

inline

Sets the isRequired flag.

{_isRequired = value;}

setIsSet()

void Param::setIsSet ( bool  value )

inline

Sets the _isSet flag.

{_isSet = value;}

Referenced by TTProtoWithMap::recordRandomMap(), TProtoDispersal::setParameters(), TTProtoWithMap::setRecombinationMapRandom(), and TProtoDeletMutations_bitstring::write_effects_to_parameter().

Here is the caller graph for this function:

setName()

void Param::setName ( string  value )

inline

Sets the parameter's name.

{_name = value;}

setOwner()

void Param::setOwner ( SimComponent *  owner )

inline

Sets the pointer to owner.

{_myOwner = owner;}

setType()

void Param::setType ( param_t  value )

inline

Sets the parameter's type (see types.h)

{_type = value;}

setUpdater()

void Param::setUpdater ( ParamUpdaterBase *  updater )

inline

Sets the pointer to the updater object.

{_myUpdater = updater;}

show_up()

void Param::show_up

(

)

Print state to stdout.

{
  message("%s = %s",_name.c_str(),_arg.c_str());
  if(_isSet)
    message(" (set at gen %i)\n",_setAtGeneration);
  else
    message(" (not set)\n");
}

References _arg, _isSet, _name, _setAtGeneration, and message().

update()

bool Param::update

(

unsigned int

generation

)

Updates the parameter value at a given generation during the simulation.

{
  string error_msg;
  if(_temporalArgs.find( generation ) != _temporalArgs.end()) {
    //_input_arg must remain the original input string throughout the simulation
    //(it is the untouched backup used for logging); set() overwrites it, so we
    //save it before the update and restore it after — only _arg should change.
    string original_input = _input_arg;
    bool ok = set( _temporalArgs[generation], error_msg );
    _input_arg = original_input;
    if( !ok ){
      error("could not set \"%s\": %s", _name.c_str(), error_msg.c_str());
      return false;
    } else
      return true;
  } else
    error("parameter \"%s\" does not have an argument value for generation %i.\n", _name.c_str(), generation);
  return false;
}

References _input_arg, _name, _temporalArgs, error(), and set().

Referenced by ParamSet::update_param().

Here is the caller graph for this function:

Member Data Documentation

_arg

string Param::_arg

private

The argument string, set by the ParamsParser upon initialization.

Referenced by getMultiArgs(), getValue(), parse_matrix(), parse_variable_matrix(), reset(), set(), and show_up().

_bounds

double Param::_bounds[2]

private

The argument value boundaries.

Referenced by Param(), and set().

_externalFile

vector< string > Param::_externalFile

private

External argument file.

Referenced by getArgumentFromFile(), reset(), and set().

_hasExternalFile

bool Param::_hasExternalFile

private

Referenced by getArgumentFromFile(), and reset().

_hasMultipleArgs

bool Param::_hasMultipleArgs

private

Referenced by getMultiArgs(), parseArgument(), and reset().

_hasPreservedMacro

bool Param::_hasPreservedMacro

private

Flag telling if this parameter's argument holds a macro preserved by the P() macro, whose expansion is deferred until after the random seed has been set.

While set, the stored argument (_input_arg/_arg) is the un-expanded macro string; it is expanded and the parameter re-set by SimRunner::expandPreservedMacros.

Referenced by reset(), and set().

_input_arg

string Param::_input_arg

private

The input argument string, kept untouched as a backup for logging.

Referenced by reset(), set(), and update().

_isBounded

bool Param::_isBounded

private

Flag telling if the parameter has a bounded argument value.

Referenced by set().

_isRequired

bool Param::_isRequired

private

Flag telling if this parameter is mandatory.

A SimComponent with a mandatory parameter in the 'unset' state will not be selected to be part of a running simulation component.

_isSet

bool Param::_isSet

private

Flag set once the parameter has recieved the right argument.

Referenced by getMatrix(), getValue(), getVariableMatrix(), reset(), set(), and show_up().

_isTemporal

bool Param::_isTemporal

private

Flag telling if this parameter has temporal arguments.

Referenced by parseArgument(), and reset().

_multiArgs

vector< string > Param::_multiArgs

private

Multiple arguments.

Referenced by getMultiArgs(), parseArgument(), and reset().

_myOwner

SimComponent* Param::_myOwner

private

Pointer to the component that declared this parameter.

_myUpdater

ParamUpdaterBase* Param::_myUpdater

private

Pointer to an ParamUpdater object.

Referenced by parseArgument(), and ~Param().

_name

string Param::_name

private

The name of the parameter as read in the init file.

Referenced by getMatrix(), getVariableMatrix(), parse_matrix(), parseArgument(), parseTemporalArgument(), show_up(), and update().

_setAtGeneration

unsigned int Param::_setAtGeneration

private

Generation at which the parameter has been set/updated.

Referenced by reset(), and show_up().

_temporalArgs

map< unsigned int, string > Param::_temporalArgs

private

The temporal arguments.

Referenced by getTemporalArgs(), getUpdatingDates(), parseArgument(), parseTemporalArgument(), reset(), and update().

_type

param_t Param::_type

private

The type of the argument, must one of DBL, INT, BOOL, STR or MAT (see types.h).

Referenced by getValue(), and set().

---

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

• param.h
• param.cc