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 ()
param_t	getType ()
bool	isSet ()
bool	isBounded ()
bool	isRequired ()
bool	isTemporal ()
bool	hasMultipleArgs ()
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

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)
 
{
  _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)
{
  _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().

getArg()

string Param::getArg ( )

inline

{return _input_arg;}

Referenced by LCE_Cross::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), Metapop::loadPopFromBinarySource(), ParamSet::print(), TProtoQuanti::setAlleleModel(), LCE_Breed_base::setFecundity(), BinaryDataSaver::setParameters(), LCE_BreedAssortativeMating::setParameters(), LCE_Breed_Disperse::setParameters(), LCE_Cross::setParameters(), LCE_QuantiModifier::setParameters(), TProtoQuanti::setParameters(), and TProtoDispersal::setRandom().

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

getBound()

double Param::getBound ( unsigned int  i )

inline

{return _bounds[i];}

getExternalFiles()

vector< string > Param::getExternalFiles ( )

inline

{return _externalFile;}

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(), LCE_FileServicesNotifier::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(), 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_QuantiModifier::setParameters(), TProtoBDMI::setParameters(), LCE_Breed_Wolbachia::setParameters(), and TProtoDispersal::setRandom().

getMultiArgs()

vector< string > Param::getMultiArgs

(

)

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

References _arg, _hasMultipleArgs, and _multiArgs.

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

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

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

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

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(), LCE_FileServicesNotifier::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), LCE_PhenotypeExpression::set_g_value_matrix(), LCE_Patch_Extinction::set_matrix_param(), TProtoDispersal::setNonRandom(), and LCE_StatServiceNotifier::setOccurence().

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(), TTProtoWithMap::setGeneticMapParameters(), LCE_Disperse_EvolDisp::setParameters(), and LCE_Disperse_base::setReducedMatricesBySex().

hasExternalFile()

bool Param::hasExternalFile ( )

inline

{return _hasExternalFile;}

hasMultipleArgs()

bool Param::hasMultipleArgs ( )

inline

{return _hasMultipleArgs;}

Referenced by Metapop::setSourceParameters().

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(), LCE_FileServicesNotifier::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), LCE_PhenotypeExpression::set_g_value_matrix(), LCE_Patch_Extinction::set_matrix_param(), TProtoQuanti::setInitialValuesParams(), LCE_StatServiceNotifier::setOccurence(), LCE_QuantiModifier::setParameters(), and LCE_Selection_base::setSelectionMatrix().

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(), LCE_FileServicesNotifier::loadFileServices(), TProtoBDMI::loadFileServices(), TProtoDeletMutations_bitstring::loadFileServices(), TProtoNeutralGenes::loadFileServices(), TProtoQuanti::loadFileServices(), ParamSet::print(), TProtoNeutralGenes::resetParameterFromSource(), LCE_Selection_base::set_sel_model(), LCE_Disperse_base::setBaseParameters(), TProtoQuanti::setContinuousMutationModel_no_pleio(), TTProtoWithMap::setGeneticMapParameters(), TProtoQuanti::setHeritabilityParams(), TProtoQuanti::setInitialValuesParams(), LCE_Breed_base::setMatingSystem(), TProtoDispersal::setNonRandom(), BinaryDataSaver::setParameters(), LCE_Breed_Disperse::setParameters(), LCE_Cross::setParameters(), LCE_Breed_Quanti::setParameters(), LCE_FileServicesNotifier::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().

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

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 == ';') {
        //read a row element:
        IN>>elmnt;
        (*mat)[i].push_back(elmnt);
        
      } else if(c == '}')
        //go to next row
        break;
    }
  }
}

References _arg.

Referenced by getVariableMatrix().

parseAgeSpecArgument()

bool Param::parseAgeSpecArgument

(

const string &

arg

)

{
  return true;
}

Referenced by parseArgument().

parseArgument()

bool Param::parseArgument

(

string &

arg

)

Parse an argument string enclosed in '( )', might hold temporal or multiple values.

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

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

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

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

Referenced by LCE_Breed_Selection_Disperse::setParameters().

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";
 
  _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, _input_arg, _isBounded, _isSet, _type, BOOL, checkArgumentForExpansion(), DBL, INT, tstring::isanumber(), MAT, parseArgument(), tstring::str2dble(), and tstring::str2int().

Referenced by update().

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

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

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()) {
    if( !set( _temporalArgs[generation], error_msg ) ){
      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 _name, _temporalArgs, error(), and set().

Referenced by ParamSet::update_param().

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

_input_arg

string Param::_input_arg

private

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

Referenced by reset(), and set().

_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