#include <ttquanti.h>

Inheritance diagram for TProtoQuanti:

Collaboration diagram for TProtoQuanti:

Public Member Functions
	TProtoQuanti ()

	TProtoQuanti (const TProtoQuanti &T)

virtual	~TProtoQuanti ()

unsigned int	get_nb_traits ()

unsigned int	get_nb_locus ()

unsigned int	get_seq_length ()

vector< double >	get_env_var ()

vector< double >	get_heritability ()

unsigned int	get_h2_setTime ()

bool	get_h2_isBroad ()

double	get_trait_var (unsigned int trait)

double	get_mutation_correlation ()

unsigned int	get_allele_model ()

double **	get_allele_values () const

double	get_init_value (unsigned int i)

TTQuantiSH *	get_stater ()

void	set_eVarianceSD (unsigned int trait, double SD)

void	set_init_values (const double *values, unsigned int nval)

void	set_trait_value_func_ptr (bool withVe)

double	set_trait_value_VE (const TTQuanti *ind, const unsigned int trait)

double	set_trait_value_noVE (const TTQuanti *ind, const unsigned int trait)

double	set_genotype_value_additive (const double **sequ, const unsigned int trait)

double	set_genotype_value_dominance (const double **sequ, const unsigned int trait)

double	get_genotype (const double a1, const double a2, const unsigned int locus, const unsigned int trait)

double	get_genotype_dominance_h (double a1, double a2, double h)

double	get_genotype_dominance_k (double a1, double a2, double k)

unsigned int	get_dominance_model ()

double	get_dominance (unsigned int locus, unsigned int trait)

TMatrix	get_dominance_effects ()

bool	setMutationParameters ()

bool	setDominanceParameters ()

void	reset_mutation_pointers ()

bool	setDiallelicMutationModel ()

bool	setContinuousMutationModel ()

void	set_mutation_matrix_decomposition ()

double *	getMutationEffectMultivariateGaussian (unsigned int loc)

double *	getMutationEffectBivariateGaussian (unsigned int loc)

double *	getMutationEffectUnivariateGaussian (unsigned int loc)

double *	getMutationEffectUnivariateDiallelic (unsigned int loc)

double *	getMutationEffectBivariateDiallelic (unsigned int loc)

void	inherit (sex_t SEX, double seq, const double *parent)

void	inherit_free (sex_t SEX, double seq, const double *parent)

void	inherit_low (sex_t SEX, double seq, const double *parent)

void	mutate (TTQuanti *ind)

void	mutate_nill (TTQuanti *ind)

void	mutate_noHC (TTQuanti *ind)

void	mutate_HC (TTQuanti *ind)

void	mutate_diallelic_HC (TTQuanti *ind)

virtual void	reset ()

virtual TTQuanti *	hatch ()

virtual TProtoQuanti *	clone ()

virtual trait_t	get_type () const

virtual bool	setParameters ()

virtual void	loadFileServices (FileServices *loader)

virtual void	loadStatServices (StatServices *loader)

virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)

virtual void	store_data (BinaryStorageBuffer *saver)

virtual bool	retrieve_data (BinaryStorageBuffer *reader)

Public Member Functions inherited from TTProtoWithMap
	TTProtoWithMap ()

	TTProtoWithMap (const TTProtoWithMap &TP)

virtual	~TTProtoWithMap ()

void	setMapIndex (unsigned int idx)

unsigned int	getMapIndex ()

bool	setGeneticMapParameters (string prefix)

void	addGeneticMapParameters (string prefix)

bool	setRecombinationMapRandom ()

bool	setRecombinationMapNonRandom (vector< vector< double > > *lociPositions)

bool	setRecombinationMapFixed ()

bool	setNumLociPerChromosome (string param_name)

void	reset_recombination_pointers ()

void	registerGeneticMap ()

void	unregisterFromGeneticMap ()

bool	areGeneticMapParamSet (string prefix)

bool	isRecombinationFree (string prefix)

void	recordRandomMap ()

virtual void	reset ()

Public Member Functions inherited from TraitPrototype
virtual void	reset ()=0
	Called at the end of a simulation to reset the Traits' prototypes (e.g. More...

virtual TTrait *	hatch ()=0
	Creates the trait of which it is the prototype, called by `IndFactory::makePrototype()`. More...

virtual TraitPrototype *	clone ()=0
	Returns a copy of itself. More...

virtual trait_t	get_type () const =0
	Type accessor. More...

virtual void	set_index (int idx)
	Sets the traits index. More...

virtual int	get_index ()
	Index getter. More...

Public Member Functions inherited from StorableComponent
virtual void	store_data (BinaryStorageBuffer *saver)=0
	Interface to store the component data (e.g. gene values) into a binary buffer. More...

virtual bool	retrieve_data (BinaryStorageBuffer *reader)=0
	Interface to retrieve the same data from the binary buffer. More...

virtual	~StorableComponent ()

Public Member Functions inherited from SimComponent
	SimComponent ()

virtual	~SimComponent ()

virtual void	loadUpdaters (UpdaterServices *loader)
	Loads the parameters and component updater onto the updater manager. More...

virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...

virtual void	set_paramset (std::string name, bool required, SimComponent *owner)
	Sets a new ParamSet and name it. More...

virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...

virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...

virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...

virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...

virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...

virtual Param *	get_parameter (std::string name)
	Param getter. More...

virtual double	get_parameter_value (std::string name)
	Param value getter. More...

virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...

virtual bool	has_parameter (std::string name)
	Param getter. More...

Private Attributes
unsigned int	_nb_locus
	Total number of loci, for all traits. More...

unsigned int	_nb_traits
	Number of traits. More...

unsigned int	_seq_length
	Total number of loci, same as _nb_locus. More...

unsigned int	_allele_model

double **	_allele_value

double *	_init_value

double *	_phenotypes

TMatrix *	_mutation_matrix

gsl_matrix *	_gsl_mutation_matrix

gsl_matrix *	_evect

gsl_vector *	_eval

gsl_vector *	_effects_multivar

gsl_vector *	_ws

double	_genomic_mutation_rate

double	_mutation_correlation

double *	_mutation_sigma

double	_effects_bivar [2]

unsigned int	_doInitMutation

unsigned int	_dominance_model

TMatrix	_dominance_sd

TMatrix	_dominance_effects

bool	_dominance_is_constant

bool *	_all_chooser

size_t	_locusByteSize

size_t	_sizeofLocusType

vector< double >	_eVariance

vector< double >	_h2

unsigned int	_h2_setTime

bool	_h2_isBroad

void(TProtoQuanti::*	_inherit_fun_ptr )(sex_t, double , const double *)

void(TProtoQuanti::*	_mutation_func_ptr )(TTQuanti *)

double (TProtoQuanti::	_getMutationValues )(unsigned int)

double(TProtoQuanti::*	_getGenotypeWithDominance )(double, double, double)

double(TProtoQuanti::*	_set_trait_value_func_ptr )(const TTQuanti *, const unsigned int)

double(TProtoQuanti::*	_set_genotype_func_ptr )(const double **, const unsigned int)

TTQuantiSH *	_stats

TTQuantiFH *	_writer

TTQuantiFH *	_reader

TTQFreqExtractor *	_freqExtractor

Friends
class	TTQuanti

Additional Inherited Members
Static Public Member Functions inherited from TTProtoWithMap
static void	recombine (unsigned long indID)

Static Public Attributes inherited from TTProtoWithMap
static GeneticMap	_map

Protected Attributes inherited from TTProtoWithMap
unsigned int	_mapIndex

double	_totRecombEventsMean

double	_recombRate

double	_mapResolution

unsigned int	_numChromosome

unsigned int	_numLoci

double *	_recombRatePerChrmsm

unsigned int *	_numLociPerChrmsm

unsigned int *	_chrsmLength

unsigned int *	_lociMapPositions

Protected Attributes inherited from TraitPrototype
int	_index
	The trait index in the Individual traits table. More...

Protected Attributes inherited from SimComponent
ParamSet *	_paramSet
	The parameters container. More...

Detailed Description

TProtoQuanti.

Constructor & Destructor Documentation

◆ TProtoQuanti() [1/2]

TProtoQuanti::TProtoQuanti ( )

                           :
        _nb_locus(0),
        _nb_traits(0),
        _seq_length(0),
        _allele_model(0),
        _allele_value(0),
        _mutation_matrix(0),
        _gsl_mutation_matrix(0),
        _evect(0),
        _eval(0),
        _effects_multivar(0),
        _ws(0),
        _genomic_mutation_rate(0),
        _mutation_correlation(0),
        _mutation_sigma(0),
        _init_value(0),
        _phenotypes(0),
        _doInitMutation(0),
        _h2_setTime(0),
        _h2_isBroad(0),
        _dominance_model(0),
        _dominance_sd(),
        _dominance_is_constant(0),
        _all_chooser(0),
        _locusByteSize(0),
        _sizeofLocusType(sizeof(double)),
        _eVariance(0),
        _inherit_fun_ptr(0),
        _mutation_func_ptr(0),
        _getMutationValues(0),
        _getGenotypeWithDominance(0),
        _set_trait_value_func_ptr(0),
        _set_genotype_func_ptr(0),
        _stats(0),
        _writer(0),
        _reader(0),
        _freqExtractor(0)
{
  set_paramset("quantitative_trait", false, this);
 
  add_parameter("quanti_traits",INT,true,false,0,0);
  add_parameter("quanti_loci",INT,true,false,0,0);
  add_parameter("quanti_allele_model",STR,false,false,0,0);
  add_parameter("quanti_allele_value",DBL,false,false,0,0);
  add_parameter("quanti_init_value",MAT,false,false,0,0);
  add_parameter("quanti_init_model",INT,false,true,0,4);
 
  add_parameter("quanti_environmental_variance",DBL,false,false,0,0);
  add_parameter("quanti_heritability", DBL, false, false, 0, 0);
  add_parameter("quanti_heritability_setTime",INT, false, false, 0,0);
  add_parameter("quanti_heritability_isBroad",BOOL, false, false, 0,0);
 
  add_parameter("quanti_mutation_rate",DBL,true,true,0,1, 0);
  add_parameter("quanti_mutation_variance",DBL,false,false,0,0, 0);
  add_parameter("quanti_mutation_correlation",DBL,false,false,0,0, 0);
  add_parameter("quanti_mutation_matrix",MAT,false,false,0,0, 0);
 
  add_parameter("quanti_dominance_model", INT, false, true, 0, 1, 0);
  add_parameter("quanti_dominance_mean", DBL, false, false, 0, 0, 0);
  add_parameter("quanti_dominance_sd", DBL, false, false, 0, 0, 0);
  add_parameter("quanti_dominance_effects", DBL, false, false, 0, 0, 0);
 
  //genetic map parameters:
  TTProtoWithMap::addGeneticMapParameters("quanti");
 
  add_parameter("quanti_output",STR,false,false,0,0);
  add_parameter("quanti_logtime",INT,false,false,0,0);
  add_parameter("quanti_dir",STR,false,false,0,0);
 
  add_parameter("quanti_freq_output",BOOL,false,false,0,0);
  add_parameter("quanti_freq_logtime",INT,false,false,0,0);
}

References SimComponent::add_parameter(), TTProtoWithMap::addGeneticMapParameters(), BOOL, DBL, INT, MAT, SimComponent::set_paramset(), and STR.

Referenced by clone().

Here is the caller graph for this function:

◆ TProtoQuanti() [2/2]

TProtoQuanti::TProtoQuanti ( const TProtoQuanti & T )

                                                : 
        _nb_locus(T._nb_locus),
        _nb_traits(T._nb_traits),
        _seq_length(T._seq_length),
        _allele_model(T._allele_model),
        _mutation_matrix(0),
        _gsl_mutation_matrix(0),
        _evect(0),
        _eval(0),
        _effects_multivar(0),
        _ws(0),
        _genomic_mutation_rate(T._genomic_mutation_rate),
        _mutation_correlation(T._mutation_correlation),
        _mutation_sigma(0),
        _init_value(0),
        _phenotypes(0),
        _h2_setTime(0),
        _h2_isBroad(0),
        _doInitMutation(0),
        _dominance_model(0),
        _dominance_sd(),
        _dominance_is_constant(0),
        _allele_value(0),
        _all_chooser(0),
        _locusByteSize(0),
        _sizeofLocusType(sizeof(double)),
        _eVariance(0),
        _inherit_fun_ptr(0),
        _mutation_func_ptr(0),
        _getMutationValues(0),
        _getGenotypeWithDominance(0),
        _set_trait_value_func_ptr(0),
        _set_genotype_func_ptr(0),
        _stats(0),
        _writer(0),
        _reader(0),
        _freqExtractor(0)
{ 
  _locusByteSize = T._nb_traits * sizeof(double);
  _paramSet = new ParamSet( *(T._paramSet) ) ;
}

References _locusByteSize, _nb_traits, and SimComponent::_paramSet.

◆ ~TProtoQuanti()

TProtoQuanti::~TProtoQuanti ( )

virtual

{
  reset_mutation_pointers();
 
  if(_stats != NULL){delete _stats; _stats = NULL;}
  if(_writer != NULL){delete _writer; _writer = NULL;}
  if(_reader) delete _reader;
  if(_freqExtractor != NULL){delete _freqExtractor; _freqExtractor = NULL;}
  if(_all_chooser) {delete [] _all_chooser; _all_chooser = NULL;}
  if(_init_value) {delete[] _init_value;_init_value = NULL;}
}

References _all_chooser, _freqExtractor, _init_value, _reader, _stats, _writer, and reset_mutation_pointers().

Member Function Documentation

◆ clone()

virtual TProtoQuanti * TProtoQuanti::clone ( )

inlinevirtual

Implements TraitPrototype.

178{return new TProtoQuanti(*this);}

TProtoQuanti::TProtoQuanti

TProtoQuanti()

Definition: ttquanti.cc:60

References TProtoQuanti().

◆ get_allele_model()

unsigned int TProtoQuanti::get_allele_model ( )

inline

130{return _allele_model;}

References _allele_model.

Referenced by LCE_QuantiInit::setParameters(), and TTQuantiFH::write_PLINK().

Here is the caller graph for this function:

◆ get_allele_values()

double ** TProtoQuanti::get_allele_values ( ) const

inline

131{return _allele_value;}

References _allele_value.

Referenced by TTQFreqExtractor::FHwrite(), TTQuantiSH::getSNPalleleFreqInPatch(), TTQuantiSH::getVaNoDominance(), TTQuantiSH::getVaWithDominance(), TTQuantiFH::print(), and TTQuantiFH::print_PLINK_PED().

Here is the caller graph for this function:

◆ get_dominance()

double TProtoQuanti::get_dominance	(	unsigned int	locus,
		unsigned int	trait
	)

inline

148 {return _dominance_effects.get(trait, locus); }

TMatrix::get

double get(unsigned int i, unsigned int j)

Accessor to element at row i and column j.

Definition: tmatrix.h:147

TProtoQuanti::_dominance_effects

TMatrix _dominance_effects

Definition: ttquanti.h:222

References _dominance_effects, and TMatrix::get().

Referenced by get_genotype(), TTQuantiSH::getVaWithDominance(), set_genotype_value_dominance(), and TTQuantiFH::write_TABLE().

Here is the caller graph for this function:

◆ get_dominance_effects()

TMatrix TProtoQuanti::get_dominance_effects ( )

inline

149{return _dominance_effects;}

References _dominance_effects.

◆ get_dominance_model()

unsigned int TProtoQuanti::get_dominance_model ( )

inline

146{return _dominance_model;}

References _dominance_model.

Referenced by TTQuantiSH::addQuanti(), LCE_QuantiModifier::setParameters(), LCE_Breed_Quanti::setParameters(), and TTQuantiFH::write_TABLE().

Here is the caller graph for this function:

◆ get_env_var()

vector< double > TProtoQuanti::get_env_var ( )

inline

124{return _eVariance;}

References _eVariance.

Referenced by TTQuantiFH::FHread(), TTQuantiSH::init(), and TTQuantiFH::write_TABLE().

Here is the caller graph for this function:

◆ get_genotype()

double TProtoQuanti::get_genotype	(	const double	a1,
		const double	a2,
		const unsigned int	locus,
		const unsigned int	trait
	)

{
  return (this->*_getGenotypeWithDominance)( a1 , a2, get_dominance(locus, trait));
}

References _getGenotypeWithDominance, and get_dominance().

Referenced by TTQuantiSH::getVaWithDominance().

Here is the caller graph for this function:

◆ get_genotype_dominance_h()

double TProtoQuanti::get_genotype_dominance_h	(	double	a1,
		double	a2,
		double	h
	)

inline

{
  if(a1<a2) return 2*((1-h)*a1 + h*a2);
  return 2*((1-h)*a2 + h*a1);
}

Referenced by setParameters().

Here is the caller graph for this function:

◆ get_genotype_dominance_k()

double TProtoQuanti::get_genotype_dominance_k	(	double	a1,
		double	a2,
		double	k
	)

inline

{
  return a1 + a2 + k*abs(a2-a1);
}

Referenced by setParameters().

Here is the caller graph for this function:

◆ get_h2_isBroad()

bool TProtoQuanti::get_h2_isBroad ( )

inline

127{return _h2_isBroad;}

References _h2_isBroad.

Referenced by TTQuantiSH::getVaWithDominance().

Here is the caller graph for this function:

◆ get_h2_setTime()

unsigned int TProtoQuanti::get_h2_setTime ( )

inline

126{return _h2_setTime;}

References _h2_setTime.

Referenced by LCE_Breed_Quanti::setVefromVa().

Here is the caller graph for this function:

◆ get_heritability()

vector< double > TProtoQuanti::get_heritability ( )

inline

125{return _h2;}

TProtoQuanti::_h2

vector< double > _h2

Definition: ttquanti.h:231

References _h2.

Referenced by LCE_QuantiModifier::execute(), TTQuantiSH::init(), LCE_Breed_Quanti::NonWrightFisherPopulation(), and LCE_Breed_Quanti::WrightFisherPopulation().

Here is the caller graph for this function:

◆ get_init_value()

double TProtoQuanti::get_init_value ( unsigned int i )

inline

132{return _init_value[i]; }

References _init_value.

◆ get_mutation_correlation()

double TProtoQuanti::get_mutation_correlation ( )

inline

129{return _mutation_correlation;}

References _mutation_correlation.

◆ get_nb_locus()

unsigned int TProtoQuanti::get_nb_locus ( )

inline

122{return _nb_locus;}

References _nb_locus.

Referenced by TTQuantiFH::FHread(), TTQFreqExtractor::FHwrite(), TTQuantiSH::getSNPalleleFreqInPatch(), TTQuantiSH::init(), TTQuantiFH::print(), TTQuantiFH::print_PLINK_PED(), LCE_QuantiInit::setParameters(), TTQuantiFH::write_PLINK(), and TTQuantiFH::write_TABLE().

Here is the caller graph for this function:

◆ get_nb_traits()

unsigned int TProtoQuanti::get_nb_traits ( )

inline

121{return _nb_traits;}

References _nb_traits.

Referenced by TTQuantiFH::FHread(), TTQFreqExtractor::FHwrite(), TTQuantiSH::getSNPalleleFreqInPatch(), TTQuantiSH::init(), TTQuantiFH::print(), TTQuantiFH::print_PLINK_FAM(), TTQuantiFH::print_PLINK_PED(), LCE_QuantiModifier::setVefromVa(), LCE_Breed_Quanti::setVefromVa(), TTQuantiFH::write_PLINK(), and TTQuantiFH::write_TABLE().

Here is the caller graph for this function:

◆ get_seq_length()

unsigned int TProtoQuanti::get_seq_length ( )

inline

123{return _seq_length;}

References _seq_length.

◆ get_stater()

TTQuantiSH * TProtoQuanti::get_stater ( )

inline

133{return _stats;}

References _stats.

Referenced by LCE_QuantiModifier::setVefromVa(), and LCE_Breed_Quanti::setVefromVa().

Here is the caller graph for this function:

◆ get_trait_var()

double TProtoQuanti::get_trait_var ( unsigned int trait )

inline

128{return _mutation_matrix->get(trait, trait);}

References _mutation_matrix, and TMatrix::get().

◆ get_type()

virtual trait_t TProtoQuanti::get_type ( ) const

inlinevirtual

Implements TraitPrototype.

179{return QUANT;}

QUANT

#define QUANT

Definition: types.h:72

References QUANT.

Referenced by TTQuantiSH::init(), and TTQuantiFH::write_PLINK().

Here is the caller graph for this function:

◆ getMutationEffectBivariateDiallelic()

double * TProtoQuanti::getMutationEffectBivariateDiallelic ( unsigned int loc )

{
  bool pos = RAND::RandBool();
  _effects_bivar[0] = _allele_value[loc][pos];
  _effects_bivar[1] = _allele_value[loc][ (RAND::Uniform() < _mutation_correlation ? 
      pos : RAND::RandBool()) ];
  return &_effects_bivar[0];
}

References _allele_value, _effects_bivar, _mutation_correlation, RAND::RandBool(), and RAND::Uniform().

Referenced by setParameters().

Here is the caller graph for this function:

◆ getMutationEffectBivariateGaussian()

double * TProtoQuanti::getMutationEffectBivariateGaussian ( unsigned int loc )

{
  RAND::BivariateGaussian(_mutation_sigma[0], _mutation_sigma[1], _mutation_correlation,
      &_effects_bivar[0], &_effects_bivar[1]);
  return &_effects_bivar[0];
}

References _effects_bivar, _mutation_correlation, _mutation_sigma, and RAND::BivariateGaussian().

Referenced by setParameters().

Here is the caller graph for this function:

◆ getMutationEffectMultivariateGaussian()

double * TProtoQuanti::getMutationEffectMultivariateGaussian ( unsigned int loc )

{
  RAND::MultivariateGaussian(_eval, _evect, _ws, _effects_multivar);
  return _effects_multivar->data;
}

References _effects_multivar, _eval, _evect, and _ws.

Referenced by setParameters().

Here is the caller graph for this function:

◆ getMutationEffectUnivariateDiallelic()

double * TProtoQuanti::getMutationEffectUnivariateDiallelic ( unsigned int loc )

{
  _effects_bivar[0] = _allele_value[loc][ RAND::RandBool() ];
  return &_effects_bivar[0];
}

References _allele_value, _effects_bivar, and RAND::RandBool().

Referenced by setParameters().

Here is the caller graph for this function:

◆ getMutationEffectUnivariateGaussian()

double * TProtoQuanti::getMutationEffectUnivariateGaussian ( unsigned int loc )

{
  _effects_bivar[0] = RAND::Gaussian(_mutation_sigma[0]);
  return &_effects_bivar[0];
}

References _effects_bivar, _mutation_sigma, and RAND::Gaussian().

Referenced by setParameters().

Here is the caller graph for this function:

◆ hatch()

TTQuanti * TProtoQuanti::hatch ( )

virtual

Implements TraitPrototype.

{
  TTQuanti* kid = new TTQuanti();
 
  kid->set_proto(this);
 
  return kid;
}

References TTQuanti::set_proto(), and TTQuanti.

◆ inherit()

void TProtoQuanti::inherit	(	sex_t	SEX,
		double *	seq,
		const double **	parent
	)

inline

{
  (this->*_inherit_fun_ptr)(SEX, seq, parent);
}

References _inherit_fun_ptr.

Referenced by TTQuanti::inherit().

Here is the caller graph for this function:

◆ inherit_free()

void TProtoQuanti::inherit_free	(	sex_t	SEX,
		double *	seq,
		const double **	parent
	)

inline

{
  register unsigned int bloc;
 
  assert(_all_chooser);
 
  for(unsigned int i = 0; i < _nb_locus; ++i)
    _all_chooser[i] = RAND::RandBool();
 
  for(unsigned int i = 0; i < _nb_locus; ++i) {
 
    bloc = i*_nb_traits;
 
    memcpy(&seq[bloc], &parent[ _all_chooser[i] ][bloc], _locusByteSize);
 
  }
}

References _all_chooser, _locusByteSize, _nb_locus, _nb_traits, and RAND::RandBool().

Referenced by setParameters().

Here is the caller graph for this function:

◆ inherit_low()

void TProtoQuanti::inherit_low	(	sex_t	SEX,
		double *	seq,
		const double **	parent
	)

inline

{
  register unsigned int prevLoc = 0, chrm_bloc = 0, prev_bloc, cpy_bloc;
  register bool flipper;
 
  //the table containing the loci at which x-overs happen
  vector< unsigned int >& recTable = _map.getRecLoci(SEX, _mapIndex);
 
  //the table containing which homologous chromosome copy we start with, for each chromosome
  vector< bool > & firstRecPos = _map.getFirstRecPosition(SEX);
 
  //number of x-overs
  unsigned int nbRec = recTable.size();
 
  //  cout << "TProtoQuanti::inherit; sex="<<SEX<<"; nb Rec = "<<nbRec;//<<endl;
 
  // c is the chromosome number
  // stride is the number of loci considered so-far, sum of chromosome loci
  // rec is the number of x-over done so-far
  for(unsigned int c = 0, stride = 0, rec = 0; c < _numChromosome; ++c) {
 
    //the copy of the chromosome with which with start
    flipper = firstRecPos[c];
 
    //number of loci to consider, including previous chromosomes
    chrm_bloc = stride + _numLociPerChrmsm[c];
 
    //last locus at which a x-over happened, will be first position on current chromosome
    prevLoc = stride;
 
    //    cout<<"chrm "<<c<<" side="<<firstRecPos[c]<<endl;
 
    // copy blocs of loci between x-over points on current chromosome
    // skip it if locus is not on this chromosome but a latter one
    for(; recTable[rec] < chrm_bloc && rec < nbRec; rec++) {
 
      // start position of the bloc of values to copy (_nb_traits values per locus)
      prev_bloc = prevLoc * _nb_traits;
 
      // size of the bloc to copy
      cpy_bloc = (recTable[rec] - prevLoc) * _nb_traits;
 
      //      cout<<"copy seq from "<<prevLoc<<"("<<prev_bloc<<") to "<<recTable[rec]
      //      <<"("<<(recTable[rec] - prevLoc)<<" loc) ("<<cpy_bloc*_locusByteSize<<"B) side "<<flipper<<endl;
 
      memcpy(&seq[prev_bloc], &parent[flipper][prev_bloc], cpy_bloc * _sizeofLocusType);
 
      //update the starting locus to the next recombination point
      prevLoc = recTable[rec];
 
      //switch side for next bloc to copy on this chromosome
      flipper = !flipper;
    }
 
    prev_bloc = prevLoc * _nb_traits;
 
    cpy_bloc = (chrm_bloc - prevLoc) * _nb_traits;
 
    //    cout << "copy end of chrmsm from "<<prevLoc<<" to "<<chrm_bloc
    //         <<"("<<(chrm_bloc - prevLoc)<<" loc) on side "<<flipper<<endl;
 
    //copy what's left between the last x-over point and the end of the chrmsme
    memcpy(&seq[prev_bloc], &parent[flipper][prev_bloc], cpy_bloc * _sizeofLocusType);
 
    stride += _numLociPerChrmsm[c];
  }
  //  cout<<" done"<<endl;
}

References TTProtoWithMap::_map, TTProtoWithMap::_mapIndex, _nb_traits, TTProtoWithMap::_numChromosome, TTProtoWithMap::_numLociPerChrmsm, _sizeofLocusType, GeneticMap::getFirstRecPosition(), and GeneticMap::getRecLoci().

Referenced by setParameters().

Here is the caller graph for this function:

◆ loadFileServices()

void TProtoQuanti::loadFileServices ( FileServices * loader )

virtual

Implements SimComponent.

{ 
  int logtime = 0;
  //writer
  if(get_parameter("quanti_output")->isSet()) {
 
    if(_writer == NULL) _writer = new TTQuantiFH(this);
 
    _writer->setOutputOption(get_parameter("quanti_output")->getArg());
 
    if(!get_parameter("quanti_logtime")->isSet())
      fatal("parameter \"quanti_logtime\" is missing!\n");
 
    Param* param = get_parameter("quanti_logtime");
 
    logtime = (param->isSet() ? (int)param->getValue() : 0);
 
    if(param->isMatrix()) {
 
      TMatrix temp;
      param->getMatrix(&temp);
      _writer->set_multi(true, true, 1, &temp, get_parameter("quanti_dir")->getArg());
 
    } else   //  rpl_per, gen_per, rpl_occ, gen_occ, rank (0), path, self-ref      
      _writer->set(true, true, 1, logtime, 0, get_parameter("quanti_dir")->getArg(),this);
 
    loader->attach(_writer);
 
  } else if(_writer != NULL) {
    delete _writer;
    _writer = NULL;
  }
 
  //freq extractor
  if(get_parameter("quanti_freq_output")->isSet()) {
 
    string model = get_parameter("quanti_allele_model")->getArg();
 
    if(model != "diallelic" && model != "diallelic_HC") {
 
      error("option \"quanti_freq_output\" only works with di-allelic quantitative loci, ignoring option.\n");
 
    }else {
 
      if(_freqExtractor == NULL) _freqExtractor = new TTQFreqExtractor(this);
 
      _freqExtractor->resetTable();
 
      Param* param = get_parameter("quanti_freq_logtime");
 
      logtime = (param->isSet() ? (int)param->getValue() : 0);
 
      //save multiple generations in a single file:
      _freqExtractor->set(true, true, 1, logtime, 0, get_parameter("quanti_dir")->getArg(),this);
 
      loader->attach(_freqExtractor);
    }
 
  } else if(_freqExtractor != NULL) {
    delete _freqExtractor;
    _freqExtractor = NULL;
  }
 
  //load the reader:
  if(_reader) delete _reader;
  _reader = new TTQuantiFH(this);
  _reader->set_isInputHandler(true);
  loader->attach_reader(_reader);
}

References _freqExtractor, _reader, _writer, FileServices::attach(), FileServices::attach_reader(), error(), fatal(), SimComponent::get_parameter(), Param::getArg(), Param::getMatrix(), Param::getValue(), Param::isMatrix(), Param::isSet(), TTQFreqExtractor::resetTable(), TraitFileHandler< TP >::set(), FileHandler::set_isInputHandler(), FileHandler::set_multi(), and TTQuantiFH::setOutputOption().

◆ loadStatServices()

void TProtoQuanti::loadStatServices ( StatServices * loader )

virtual

Implements SimComponent.

{
  //allocate the stat handler
  if(_stats)
    delete _stats; // this will reset internal state for the new simulation, safest solution
 
  _stats = new TTQuantiSH(this);
 
  loader->attach(_stats);
}

References _stats, and StatServices::attach().

◆ mutate()

void TProtoQuanti::mutate ( TTQuanti * ind )

inline

{
  (this->*_mutation_func_ptr)(ind);
}

References _mutation_func_ptr.

Referenced by TTQuanti::mutate().

Here is the caller graph for this function:

◆ mutate_diallelic_HC()

void TProtoQuanti::mutate_diallelic_HC ( TTQuanti * ind )

inline

{
  unsigned int NbMut = (unsigned int)RAND::Poisson(_genomic_mutation_rate);
  unsigned int mut_locus, mut_all, block, pos;
 
  while(NbMut != 0) {
 
    mut_locus = RAND::Uniform(_nb_locus);
    mut_all = RAND::RandBool();
 
    block = mut_locus*_nb_traits;
 
    for(unsigned int i = 0; i < _nb_traits; i++) {
      pos = block + i;
      ind->set_allele( pos, mut_all, -1.0 * ind->get_allele_value(pos, mut_all));
    }
 
    NbMut--;
  }
 
}

References _genomic_mutation_rate, _nb_locus, _nb_traits, TTQuanti::get_allele_value(), RAND::Poisson(), RAND::RandBool(), TTQuanti::set_allele(), and RAND::Uniform().

Referenced by setParameters().

Here is the caller graph for this function:

◆ mutate_HC()

void TProtoQuanti::mutate_HC ( TTQuanti * ind )

inline

{
  unsigned int NbMut = (unsigned int)RAND::Poisson(_genomic_mutation_rate);
  unsigned int mut_locus, mut_all, pos;
  double *effects;
 
  while(NbMut != 0) {
    mut_locus = RAND::Uniform(_nb_locus);
    effects = (this->*_getMutationValues)(mut_locus);
    mut_all = RAND::RandBool();
    pos = mut_locus*_nb_traits;
 
    for(unsigned int i = 0; i < _nb_traits; i++)
      ind->set_allele( pos + i, mut_all, effects[i]);
 
    NbMut--;
  }
}

References _genomic_mutation_rate, _getMutationValues, _nb_locus, _nb_traits, RAND::Poisson(), RAND::RandBool(), TTQuanti::set_allele(), and RAND::Uniform().

Referenced by setParameters().

Here is the caller graph for this function:

◆ mutate_nill()

void TProtoQuanti::mutate_nill ( TTQuanti * ind )

inline

{
  //nill
}

Referenced by setParameters().

Here is the caller graph for this function:

◆ mutate_noHC()

void TProtoQuanti::mutate_noHC ( TTQuanti * ind )

inline

{
  unsigned int NbMut = (unsigned int)RAND::Poisson(_genomic_mutation_rate);
  unsigned int mut_locus, mut_all, pos;
  double *effects;
 
  while(NbMut != 0) {
    mut_locus = RAND::Uniform(_nb_locus);
    effects = (this->*_getMutationValues)(mut_locus);
    mut_all = RAND::RandBool();
    pos = mut_locus*_nb_traits;
 
    for(unsigned int i = 0; i < _nb_traits; i++) {
      ind->set_allele( pos + i, mut_all, ind->get_allele_value(pos + i, mut_all) + effects[i]);
    }
 
    NbMut--;
  }
 
}

References _genomic_mutation_rate, _getMutationValues, _nb_locus, _nb_traits, TTQuanti::get_allele_value(), RAND::Poisson(), RAND::RandBool(), TTQuanti::set_allele(), and RAND::Uniform().

Referenced by setParameters().

Here is the caller graph for this function:

◆ reset()

virtual void TProtoQuanti::reset ( )

inlinevirtual

Reimplemented from TTProtoWithMap.

176{TTProtoWithMap::reset();}

TTProtoWithMap::reset

virtual void reset()

Definition: ttrait_with_map.cc:611

References TTProtoWithMap::reset().

◆ reset_mutation_pointers()

void TProtoQuanti::reset_mutation_pointers ( )

{
  if(_allele_value) {
    for(unsigned int i = 0; i < _nb_locus; ++i)
      delete [] _allele_value[i];
    delete [] _allele_value;
    _allele_value = NULL;
  }
 
  if(_mutation_matrix != NULL) {
    delete _mutation_matrix;
    _mutation_matrix = NULL;
  }
 
  if(_gsl_mutation_matrix != NULL) {
    gsl_matrix_free(_gsl_mutation_matrix);
    _gsl_mutation_matrix = NULL;
  }
 
  if(_mutation_sigma != NULL){
    delete [] _mutation_sigma;
    _mutation_sigma = NULL;
  }
 
  if(_evect != NULL) {
    gsl_matrix_free(_evect);
    _evect = NULL;
  }
 
  if(_eval != NULL) {
    gsl_vector_free(_eval);
    _eval = NULL;
  }
 
  if(_effects_multivar != NULL) {
    gsl_vector_free(_effects_multivar);
    _effects_multivar = NULL;
  }
 
  if(_ws) {
    gsl_vector_free(_ws);
    _ws = 0;
  }
 
}

References _allele_value, _effects_multivar, _eval, _evect, _gsl_mutation_matrix, _mutation_matrix, _mutation_sigma, _nb_locus, and _ws.

Referenced by setMutationParameters(), and ~TProtoQuanti().

Here is the caller graph for this function:

◆ resetParameterFromSource()

virtual bool TProtoQuanti::resetParameterFromSource	(	std::string	param,
		SimComponent *	cmpt
	)

inlinevirtual

Implements SimComponent.

185{return false;}

◆ retrieve_data()

virtual bool TProtoQuanti::retrieve_data ( BinaryStorageBuffer * reader )

inlinevirtual

Implements StorableComponent.

193 {reader->read(&_seq_length,sizeof(int));return true;}

BinaryStorageBuffer::read

void read(void *out, unsigned int nb_bytes)

Definition: binarystoragebuffer.h:162

References _seq_length, and BinaryStorageBuffer::read().

◆ set_eVarianceSD()

void TProtoQuanti::set_eVarianceSD	(	unsigned int	trait,
		double	SD
	)

{
  if(_eVariance.size() < trait + 1) //trait is expected as the element index
    _eVariance.push_back(SD);
  else
    _eVariance[trait] = SD;
}

References _eVariance.

Referenced by LCE_QuantiModifier::setVefromVa(), and LCE_Breed_Quanti::setVefromVa().

Here is the caller graph for this function:

◆ set_genotype_value_additive()

double TProtoQuanti::set_genotype_value_additive	(	const double **	sequ,
		const unsigned int	trait
	)

{
  unsigned int loc;
  double genotype = 0;
 
  for(unsigned int j = 0; j < _nb_locus; ++j) {
    // alleles are ordered locus-trait: seq[0]:l0t0,l0t1,l0t2, ..., l1t0,l1t1,l1t2, ...
    loc = j * _nb_traits + trait;
    genotype +=  sequ[0][loc] + sequ[1][loc];
  }
 
  return genotype;
}

References _nb_locus, and _nb_traits.

Referenced by TTQuanti::get_additive_genotype(), and setParameters().

Here is the caller graph for this function:

◆ set_genotype_value_dominance()

double TProtoQuanti::set_genotype_value_dominance	(	const double **	sequ,
		const unsigned int	trait
	)

{
  unsigned int loc;
  double genotype = 0;
 
  for(unsigned int j = 0; j < _nb_locus; ++j) {
    loc = j * _nb_traits + trait;
    genotype += (this->*_getGenotypeWithDominance)( sequ[0][loc] , sequ[1][loc], get_dominance(j, trait));
  }
 
  return genotype;
}

References _getGenotypeWithDominance, _nb_locus, _nb_traits, and get_dominance().

Referenced by setParameters().

Here is the caller graph for this function:

◆ set_init_values()

void TProtoQuanti::set_init_values	(	const double *	values,
		unsigned int	nval
	)

{
  assert(nval == _nb_traits);
 
  if(!_init_value) _init_value = new double[_nb_traits];
 
  for(unsigned int i = 0; i < nval; ++i)
    _init_value[i] = values[i];
}

References _init_value, and _nb_traits.

Referenced by LCE_QuantiInit::execute().

Here is the caller graph for this function:

◆ set_mutation_matrix_decomposition()

void TProtoQuanti::set_mutation_matrix_decomposition ( )

{
  gsl_matrix *E = gsl_matrix_alloc(_nb_traits,_nb_traits);
  gsl_matrix_memcpy(E,_gsl_mutation_matrix);
  gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (_nb_traits);
  gsl_eigen_symmv (E, _eval, _evect, w);
  gsl_eigen_symmv_free (w);
  gsl_matrix_free(E);
 
#ifdef _DEBUG_
  message("-- Mutation matrix eigenvalues:\n");
  for(unsigned int i = 0; i < _nb_traits; i++)
    cout<<gsl_vector_get(_eval,i)<<" ";
  cout<<endl;
#endif
 
  double eval;
  //take square root of eigenvalues, will be used in Gaussian as stdev
  for(unsigned int i = 0; i < _nb_traits; i++) {
    eval = gsl_vector_get(_eval,i);
    eval = (eval < 0.000001 ? 0 : eval);
    gsl_vector_set( _eval, i, sqrt(eval) );
  }
}// ----------------------------------------------------------------------------------------

References _eval, _evect, _gsl_mutation_matrix, _nb_traits, and message().

Referenced by setContinuousMutationModel().

Here is the caller graph for this function:

◆ set_trait_value_func_ptr()

void TProtoQuanti::set_trait_value_func_ptr ( bool withVe )

{
  if(withVe)
    _set_trait_value_func_ptr = &TProtoQuanti::set_trait_value_VE;
  else
    _set_trait_value_func_ptr = &TProtoQuanti::set_trait_value_noVE;
}

References _set_trait_value_func_ptr, set_trait_value_noVE(), and set_trait_value_VE().

Referenced by LCE_QuantiModifier::execute(), and LCE_Breed_Quanti::setVefromVa().

Here is the caller graph for this function:

◆ set_trait_value_noVE()

double TProtoQuanti::set_trait_value_noVE	(	const TTQuanti *	ind,
		const unsigned int	trait
	)

{
  return (this->*_set_genotype_func_ptr)((const double**)ind->get_sequence(), trait);
}

References _set_genotype_func_ptr, and TTQuanti::get_sequence().

Referenced by set_trait_value_func_ptr(), set_trait_value_VE(), and setParameters().

Here is the caller graph for this function:

◆ set_trait_value_VE()

double TProtoQuanti::set_trait_value_VE	(	const TTQuanti *	ind,
		const unsigned int	trait
	)

{
  return set_trait_value_noVE(ind, trait) + RAND::Gaussian( _eVariance[trait] );
}

References _eVariance, RAND::Gaussian(), and set_trait_value_noVE().

Referenced by set_trait_value_func_ptr(), and setParameters().

Here is the caller graph for this function:

◆ setContinuousMutationModel()

bool TProtoQuanti::setContinuousMutationModel ( )

{
  unsigned int dims[2];
 
  // the pointer has been freed previously in TProtoQuanti::setMutationParameters
  // we double-check with assert
  assert(_mutation_matrix == NULL);
  assert(_gsl_mutation_matrix == NULL);
  assert(_mutation_sigma == NULL);
 
  //setting the mutation variance-covariance matrix  
  if(get_parameter("quanti_mutation_variance")->isSet()) {
 
    if(get_parameter("quanti_mutation_matrix")->isSet()) {
 
      warning("both \"quanti_mutation_variance\" and \"quanti_mutation_matrix\" are set, using the matrix only!\n");
 
    } else {
 
      // the variance, and covariance are passed as single values,
      // we set the mutation-matrix from those values, copied to all traits
 
      _mutation_sigma = new double [_nb_traits];
 
      double sigma = sqrt( get_parameter_value("quanti_mutation_variance") );
 
      for(unsigned int i = 0; i < _nb_traits; i++)  _mutation_sigma[i] = sigma;
 
      // pleiotropic loci for more than 1 trait, we need the full mutation matrix:
      if(_nb_traits > 1) {
 
        //setting the mutation matrix
 
        _mutation_matrix = new TMatrix();
 
        _gsl_mutation_matrix = gsl_matrix_alloc(_nb_traits, _nb_traits);
 
        double covar, var = get_parameter_value("quanti_mutation_variance");
 
        covar = _mutation_correlation * var;
 
        // copy the trait mutational variance into the GSL matrix (diogonal)
        for(unsigned int i = 0; i < _nb_traits; i++)
          gsl_matrix_set(_gsl_mutation_matrix, i, i, var);
 
        // copy the trait mutational co-variance into the GSL matrix (off-diogonal & symmetric)
        for(unsigned int i = 0; i < _nb_traits - 1; i++)  
          for(unsigned int j = i + 1 ; j < _nb_traits; j++) {
            gsl_matrix_set(_gsl_mutation_matrix, i, j, covar);
            gsl_matrix_set(_gsl_mutation_matrix, j, i, covar);
          }
 
        // copy the GSL matrix into the TMatrix:
        _mutation_matrix->set_from_gsl_matrix(_gsl_mutation_matrix);
      }
    }
  }
 
  if(get_parameter("quanti_mutation_matrix")->isSet()) {
 
    // full mutation matrix given in input:
 
    _mutation_matrix = new TMatrix();
 
    get_parameter("quanti_mutation_matrix")->getMatrix(_mutation_matrix);
 
    _mutation_matrix->get_dims(&dims[0]);
 
    if( dims[0] != _nb_traits || dims[1] != _nb_traits) {
 
      return error("\"quanti_mutation_matrix\" must be a square matrix of size = \"quanti_traits\" x \"quanti_traits\"\n");
 
    }
 
    _gsl_mutation_matrix = gsl_matrix_alloc(dims[0], dims[1]);
 
    _mutation_matrix->get_gsl_matrix(_gsl_mutation_matrix);
 
    _mutation_sigma = new double [_nb_traits];
 
    for(unsigned int i = 0; i < _nb_traits; i++) 
      _mutation_sigma[i] = sqrt(_mutation_matrix->get(i, i));
 
  }
  else if(!get_parameter("quanti_mutation_variance")->isSet()) {
 
    return error("\"quanti_mutation_matrix\" or \"quanti_mutation_variance\" must be specified!\n");
  }
 
  //some more initializations for multi-variate case, important to draw mutation from multi-variate Gaussian
  if(_mutation_matrix) {
 
    _evect = gsl_matrix_alloc(_nb_traits, _nb_traits);
    _eval = gsl_vector_alloc(_nb_traits);
 
    // M-matrix eigen-decomposition:
    set_mutation_matrix_decomposition();
 
    if(_nb_traits == 2) {
 
      _mutation_correlation = _mutation_matrix->get(0,1) / sqrt(_mutation_matrix->get(0,0)*_mutation_matrix->get(1,1));
 
    } else if(_nb_traits > 2) {
 
      _effects_multivar = gsl_vector_alloc(_nb_traits);
      _ws = gsl_vector_alloc(_nb_traits);
 
    }
 
#ifdef _DEBUG_
    message("-- Mutation matrix:\n");
    _mutation_matrix->show_up();
    message("-- MMatrix decomposition:\n");
    for(unsigned int i = 0; i < _nb_traits; i++)
      cout<<gsl_vector_get(_eval,i)<<" ";
    cout<<endl;
    if(_nb_traits == 2) message("-- mutation correlation: %f\n",_mutation_correlation);
#endif
  }
 
  return true;
}

References _effects_multivar, _eval, _evect, _gsl_mutation_matrix, _mutation_correlation, _mutation_matrix, _mutation_sigma, _nb_traits, _ws, error(), TMatrix::get(), TMatrix::get_dims(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), message(), set_mutation_matrix_decomposition(), TMatrix::show_up(), and warning().

Referenced by setMutationParameters().

Here is the caller graph for this function:

◆ setDiallelicMutationModel()

bool TProtoQuanti::setDiallelicMutationModel ( )

{
  if (!get_parameter("quanti_allele_value")->isSet()) {
 
    return error("in \"quanti\" trait, \"quanti_allele_value\" is not set for the diallelic model.\n");
 
  } else {
 
    assert(_allele_value == NULL); 
    //should be the case as reset_mutation_pointers has been called in setMutationParameters
 
 
    // allele_value is a matrix nb_locus x 2 values
 
    // IMPORTANT:: This interface doesn't allow for trait-specific allelic values!!
 
    _allele_value = new double* [_nb_locus];
 
    for (unsigned i = 0; i < _nb_locus; ++i) _allele_value[i] = new double [2];
 
    if (get_parameter("quanti_allele_value")->isMatrix()) { //locus-specific allelic values
 
      TMatrix tmp;
 
      get_parameter("quanti_allele_value")->getMatrix(&tmp);
 
      if (tmp.ncols() != _nb_locus) {
        warning("\"quanti_allele_value\" has less values than the number of loci, allelic values will be recycled among loci.\n");
      }
 
      unsigned int nval = tmp.ncols();
 
      // we need to order the allele in decreasing order for later calculations of allele frequencies
      // such that p = freq of trai-increasing allele, q = freq of trait-decreasing allele
 
      double a1, a2;
 
      if (tmp.nrows() == 1) { // store + and - allelic values
 
        if(nval < _nb_locus) { // recycle allelic values among loci
 
          for (unsigned i = 0; i < _nb_locus; ++i) {
 
            a1 = tmp.get(0, i % nval);
            if(a1 < 0) a1 = -1.0*a1;
            a2 = -1.0*a1;
 
            _allele_value[i][0] = a1;
            _allele_value[i][1] = a2;
          }
        } else {
          for (unsigned i = 0; i < _nb_locus; ++i) {
 
            a1 = tmp.get(0, i);
            if(a1 < 0) a1 = -1.0*a1;
            a2 = -1.0*a1;
 
            _allele_value[i][0] = a1;
            _allele_value[i][1] = a2;
          }
 
        }
 
      } else if (tmp.nrows() == 2) { // store A and a allelic values
 
        if(nval < _nb_locus) { // recycle allelic values among loci
 
          for (unsigned i = 0; i < _nb_locus; ++i) {
 
            a1 = tmp.get(0, i % nval);
            a2 = tmp.get(1, i % nval);
            if(a1 < a2) {
              a1 = a2;
              a2 = tmp.get(0, i % nval);
            }
            _allele_value[i][0] = a1;
            _allele_value[i][1] = a2;
          }
 
        } else {
 
          for (unsigned i = 0; i < _nb_locus; ++i) {
 
            a1 = tmp.get(0, i % nval);
            a2 = tmp.get(1, i % nval);
            if(a1 < a2) {
              a1 = a2;
              a2 = tmp.get(0, i % nval);
            }
            _allele_value[i][0] = tmp.get(0, i);
            _allele_value[i][1] = tmp.get(1, i);
          }
 
        }
 
      } else {
 
        return error("\"quanti_allele_value\" must get a matrix with a max. of 2 rows (and num. columns = num. loci).\n");
 
      }
 
 
    } else { //not a matrix, therefore no locus-specific allelic values
 
      double a1 = get_parameter_value("quanti_allele_value"), a2;
 
      if(a1 < 0) a1 = -1.0*a1;
      a2 = -1.0*a1;
 
      for (unsigned i = 0; i < _nb_locus; ++i) {
        _allele_value[i][0] = a1;
        _allele_value[i][1] = a2;
      }
 
    }
 
  }
 
  return true;
}

References _allele_value, _nb_locus, error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), TMatrix::ncols(), TMatrix::nrows(), and warning().

Referenced by setMutationParameters().

Here is the caller graph for this function:

◆ setDominanceParameters()

bool TProtoQuanti::setDominanceParameters ( )

{
  TMatrix tmp_mat;
 
   if(get_parameter("quanti_dominance_model")->isSet())
   {
 
     _dominance_model = get_parameter_value("quanti_dominance_model") + 1; // internally, model 0 = no dominance
     // note that the bounds for the model values are set and checked by construction of the parameters
 
     // check and set the dominance effects, either explicitly from input or from the mean and sd provided above
     if( !get_parameter("quanti_dominance_mean")->isSet() )
     {
 
       return error("the dominance at QTLs needs to be set with \"quanti_dominance_mean\"\n");
 
     } else {
 
       // one row per trait, one column per locus; trait x locus matrix
       _dominance_effects.reset(_nb_traits, _nb_locus);
 
       if(get_parameter("quanti_dominance_mean")->isMatrix())
       {
 
         get_parameter("quanti_dominance_mean")->getMatrix(&tmp_mat);
 
         _dominance_effects.copy_recycle(tmp_mat);
 
       }
       else {
         _dominance_effects.assign( get_parameter_value("quanti_dominance_mean") );
       }
 
       // variance of the dominance effect across QTLs
       if( !get_parameter("quanti_dominance_sd")->isSet() )
       {
 
         _dominance_sd.reset(1, 1, 0.0); //set to 0 by default.
 
         _dominance_is_constant = true;
 
       } else { // sd parameter is set
 
         // one row per trait, one column per locus; trait x locus matrix
         _dominance_sd.reset(_nb_traits, _nb_locus);
 
         _dominance_is_constant = false;
 
         if(get_parameter("quanti_dominance_sd")->isMatrix())
         {
           get_parameter("quanti_dominance_sd")->getMatrix(&tmp_mat);
 
           _dominance_sd.copy_recycle(tmp_mat);
 
         }
         else {
 
           double sd = get_parameter_value("quanti_dominance_sd");
 
           if(sd == 0.0) _dominance_is_constant = true;
 
           _dominance_sd.assign( sd );
         }
       }
 
       if( !_dominance_is_constant) { // add a gaussian deviate
         for(unsigned int i = 0; i < _nb_traits; ++i)
           for(unsigned int j = 0; j < _nb_locus; ++j)
             _dominance_effects.plus(i, j, RAND::Gaussian(_dominance_sd.get(i, j)));
       }
 
     } // end random dominance setting
   }
   else { //no model specified in input
 
     _dominance_model = 0;
     _dominance_sd.reset();
     _dominance_effects.reset(); //empty it when no dominance required
 
     if(get_parameter("quanti_dominance_mean")->isSet())
       return error("the mean dominance effect at QTLs is set but the dominance model is missing (\"quanti_dominance_model\")\n");
 
     if(get_parameter("quanti_dominance_sd")->isSet())
       return error("the stdev of dominance effects across QTLs is set but the dominance model is missing (\"quanti_dominance_model\")\n");
 
   }
 
  return true;
}

References _dominance_effects, _dominance_is_constant, _dominance_model, _dominance_sd, _nb_locus, _nb_traits, TMatrix::assign(), TMatrix::copy_recycle(), error(), RAND::Gaussian(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), TMatrix::plus(), and TMatrix::reset().

Referenced by setParameters().

Here is the caller graph for this function:

◆ setMutationParameters()

bool TProtoQuanti::setMutationParameters ( )

{  
  // set the genomic mutation rate
  _genomic_mutation_rate = get_parameter_value("quanti_mutation_rate") * 2 * _nb_locus;  
 
  // set the mutational correlation, for pleiotropic loci:
  if(get_parameter("quanti_mutation_correlation")->isSet())
 
    _mutation_correlation = get_parameter_value("quanti_mutation_correlation");
 
  else
 
    _mutation_correlation = 0;
 
  // reset all allelic effect tables and pointer to mutation parameters etc.:
  reset_mutation_pointers();
 
  //checking allelic model
 
  if (get_parameter("quanti_allele_model")->isSet()) {
 
    string model = get_parameter("quanti_allele_model")->getArg();
 
    //---------------------------------------------------------------------------------------
    // DIALLELIC MODELS
 
    if (model == "diallelic") {
 
      if(get_parameter("quanti_init_value")->isSet()){
 
        error("\"quanti_allele_model diallelic\" needs to be initialized with \"quanti_init_freq\" instead of \"quanti_init_value\". \n");
 
      }
 
      _allele_model = 1;
 
      return setDiallelicMutationModel ();
 
    } else if (model == "diallelic_HC") {
 
      if(get_parameter("quanti_init_value")->isSet()){
 
        error("\"quanti_allele_model diallelic_HC\" needs to be initialized with \"quanti_init_freq\" instead of \"quanti_init_value\". \n");
 
      }
 
      _allele_model = 2;
 
      return setDiallelicMutationModel ();
 
      //---------------------------------------------------------------------------------------
      // CONTIUUM OF ALLELE MODELS
 
    } else if (model == "continuous") {
 
      _allele_model = 3;
 
      return setContinuousMutationModel ();
 
    } else if (model == "continuous_HC") {
 
      _allele_model = 4;
 
      return setContinuousMutationModel ();
 
    } else {
      return error("\"quanti_allele_model\" has options \"diallelic[_HC]\" or \"continuous[_HC]\" only. \n");
    }
 
  } 
  else { //default model: 'continuous"
    _allele_model = 3;
    return setContinuousMutationModel ();
  }
 
  return true;
}

References _allele_model, _genomic_mutation_rate, _mutation_correlation, _nb_locus, error(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getArg(), reset_mutation_pointers(), setContinuousMutationModel(), and setDiallelicMutationModel().

Referenced by setParameters().

Here is the caller graph for this function:

◆ setParameters()

bool TProtoQuanti::setParameters ( )

virtual

Implements SimComponent.

{  
  // Mandatory parameters:
 
  // number of quantitative traits
  _nb_traits = (unsigned int)get_parameter_value("quanti_traits");
 
  // number of loci
  _nb_locus = (unsigned int)get_parameter_value("quanti_loci");
 
  // store a few important numbers
  //total nbre of values for both traits in a haploid genome
  _seq_length = _nb_traits * _nb_locus; //mutations are pleiotropic!!!
 
  // size of data used to store pleiotropic allelic values at a locus
  _locusByteSize = _nb_traits * sizeof(double);
 
  // memory size of a single allele value
  _sizeofLocusType = sizeof(double);
 
 
  //  temporary TMatrix for parameters read-in
  TMatrix tmp_mat;
 
  //---------------------------------------------------------------------------------------------
  // ENVIRONMENTAL VARIANCE and HERITABILITY
 
  _eVariance.clear(); //it is empty by default, signaling that we do not add Ve to trait genotype
 
  if(get_parameter("quanti_environmental_variance")->isSet()){
 
    if(get_parameter("quanti_environmental_variance")->isMatrix())
    {
      get_parameter("quanti_environmental_variance")->getMatrix(&tmp_mat);
 
      double var;
 
      for(unsigned int i = 0; i < _nb_traits; i++) {
 
        var = tmp_mat.get(0,i);
 
        if( var < 0 )
          return error("\"quanti_environmental_variance\" received a negative value for trait %i!\n", i+1 );
        else
          _eVariance.push_back( sqrt(var) ); // store the SD to save time later
      }
 
    } else {
 
      double var = get_parameter_value("quanti_environmental_variance");
 
      if( var < 0 )
        return error("\"quanti_environmental_variance\" received a negative value!\n");
 
      for(unsigned int i = 0; i < _nb_traits; ++i) {
        _eVariance.push_back( sqrt(var) ); // store the SD to save time later
      }
 
    }
 
    _set_trait_value_func_ptr = &TProtoQuanti::set_trait_value_VE;
 
  } else {
 
    _set_trait_value_func_ptr = &TProtoQuanti::set_trait_value_noVE;
 
  }
 
  _h2.clear();
 
  if(get_parameter("quanti_heritability")->isSet()){
 
    if(get_parameter("quanti_heritability")->isMatrix())
    {
      get_parameter("quanti_heritability")->getMatrix(&tmp_mat);
 
      double h2;
 
      for(unsigned int i = 0; i < _nb_traits; i++) {
 
        h2 = tmp_mat.get(0,i);
 
        if( h2< 0 )
          return error("\"quanti_heritability\" received a negative value for trait %i!\n", i+1 );
        else
          _h2.push_back( h2 ); // store the SD to save time later
      }
 
    } else {
 
      double h2 = get_parameter_value("quanti_heritability");
 
      if( h2 < 0 )
        return error("\"quanti_heritability\" received a negative value!\n");
 
      for(unsigned int i = 0; i < _nb_traits; ++i) {
        _h2.push_back( h2 ); // store the SD to save time later
      }
 
    }
  }
 
  _h2_setTime = 0;
  if(get_parameter("quanti_heritability_setTime")->isSet()){
    _h2_setTime = (unsigned int)get_parameter_value("quanti_heritability_setTime");
  }
 
  _h2_isBroad = false;
  if(get_parameter("quanti_heritability_isBroad")->isSet())
    _h2_isBroad = (bool)get_parameter_value("quanti_heritability_isBroad");
 
  //---------------------------------------------------------------------------------------------
  // INITIAL VALUES:
 
  if(_init_value != NULL) {
    delete [] _init_value;
    _init_value = NULL;
  }  
 
  if(get_parameter("quanti_init_value")->isSet()) {
 
    get_parameter("quanti_init_value")->getMatrix(&tmp_mat);
 
    if(tmp_mat.getNbRows() != 1 || tmp_mat.getNbCols() != _nb_traits) {
      return error("\"quanti_init_value\" must be a vector of length equal to the number of traits!\n");
    }
 
    _init_value = new double [_nb_traits];
 
    for(unsigned int i = 0; i < _nb_traits; i++)
      _init_value[i] = tmp_mat.get(0,i);
 
  }
  else {
 
    _init_value = new double [_nb_traits];
 
    for(unsigned int i = 0; i < _nb_traits; i++)
      _init_value[i] = 0.0;
  }
 
  if(get_parameter("quanti_init_model")->isSet()) {
 
    _doInitMutation = (unsigned int)get_parameter_value("quanti_init_model");
 
  } else {
    _doInitMutation = 1;
  }
 
 
  //---------------------------------------------------------------------------------------
  // ALLELE MODELS AND MUTATIONS
 
  if( !setMutationParameters() ) return false;
 
  // SET POINTER TO MUTATE FUNCTION
 
  if(_genomic_mutation_rate == 0) {
 
    _mutation_func_ptr = &TProtoQuanti::mutate_nill;
 
  } else if(_allele_model == 1 || _allele_model == 3) {// no "house-of-cards" models
 
    _mutation_func_ptr = &TProtoQuanti::mutate_noHC;
 
  } else if(_allele_model == 2) {
 
    _mutation_func_ptr = &TProtoQuanti::mutate_diallelic_HC;
 
  } else
    _mutation_func_ptr = &TProtoQuanti::mutate_HC;
 
  // SET POINTERS TO MUTATION EFFECTS FUNCTIONS
 
  if(_nb_traits == 1) { // univariate models
 
    if (_allele_model == 1 || _allele_model == 2) {
 
      _getMutationValues = &TProtoQuanti::getMutationEffectUnivariateDiallelic;
 
    } else {
 
      _getMutationValues = &TProtoQuanti::getMutationEffectUnivariateGaussian;
 
    }
 
  } else if (_nb_traits == 2) { // bivariate models
 
    if (_allele_model == 1 || _allele_model == 2) {
 
      _getMutationValues = &TProtoQuanti::getMutationEffectBivariateDiallelic;
 
    } else {
 
      _getMutationValues = &TProtoQuanti::getMutationEffectBivariateGaussian;
 
    }
 
  } else if (_nb_traits > 2) { // multivariate models, only for non-diallelic loci
 
    if (_allele_model > 2) {
 
      _getMutationValues = &TProtoQuanti::getMutationEffectMultivariateGaussian;
 
    } else {
      fatal("in \"quanti\" trait, the di-allelic model is only allowed for max. 2 quantitative traits.");
    }
 
  }
  //---------------------------------------------------------------------------------------
  // COMPUTING GENOTYPE VALUES: ADDITVITY or DOMINANCE
 
  if( !setDominanceParameters() ) return false;
 
  switch( _dominance_model) {
 
  case 0:
    _set_genotype_func_ptr = &TProtoQuanti::set_genotype_value_additive;
    _getGenotypeWithDominance = 0;
    break;
 
  case 1:
    _set_genotype_func_ptr = &TProtoQuanti::set_genotype_value_dominance;
    _getGenotypeWithDominance = &TProtoQuanti::get_genotype_dominance_h;
    break;
 
  case 2:
    _set_genotype_func_ptr = &TProtoQuanti::set_genotype_value_dominance;
    _getGenotypeWithDominance = &TProtoQuanti::get_genotype_dominance_k;
    break;
  }
 
  //---------------------------------------------------------------------------------------
  // RECOMBINATION
 
  //bypass the genetic map for free recombination to save significant time:
  //this is done whenever the recombination rate is set to 0.5
 
  if( TTProtoWithMap::isRecombinationFree("quanti")) { //test all possible options to set recomb rate = 0.5
 
    TTProtoWithMap::_recombRate = 0.5;
 
    _inherit_fun_ptr = &TProtoQuanti::inherit_free;
 
    //necessary for the inherit_free function:
    if(_all_chooser) delete [] _all_chooser;
    _all_chooser = new bool[_nb_locus];
 
  } else {
 
    // the loci positions will be registered in the genetic map
    if( !setGeneticMapParameters("quanti") ) return false;
 
    _inherit_fun_ptr = &TProtoQuanti::inherit_low;
 
  }
 
  //---------------------------------------------------------------------------------------
  return true; 
}