#include <ttquanti.h>

Inheritance diagram for TProtoQuanti:

Collaboration diagram for TProtoQuanti:

Public Member Functions
	TProtoQuanti ()

	TProtoQuanti (const TProtoQuanti &T)

virtual	~TProtoQuanti ()

unsigned int	get_num_traits ()

unsigned int	get_num_locus ()

unsigned int	get_num_locus (unsigned int trait)

unsigned int	get_pleiotropy_type ()

unsigned int	get_seq_length ()

size_t	get_size_locus_type ()

size_t	get_locus_byte_size ()

vector< double >	get_env_var ()

vector< double >	get_heritability ()

unsigned int	get_h2_setTime ()

bool	get_h2_isBroad ()

unsigned int	get_allele_model ()

const TMatrix &	get_diallele_values ()

double	get_diallele_value (unsigned int locus, unsigned int allele)

double	get_seq_diallele_value (unsigned int position, unsigned int allele)

bool	has_equal_domCoeff ()

bool	has_equal_effects ()

double	get_equal_val_0 ()

double	get_equal_val_1 ()

double	get_equal_val_diff ()

const bitstring &	get_trait_mask (unsigned int trait) const

double	get_init_value (unsigned int i)

double	get_init_variance (unsigned int i)

unsigned int	get_doInitMutation ()

TTQuantiSH *	get_stater ()

const TMatrix &	get_pleio_matrix ()

unsigned int	get_locus_seq_pos (unsigned int loc, unsigned int trait)

unsigned int	get_locus_ID (unsigned int locus, unsigned int trait)

unsigned int	get_locus_PD (unsigned int locus)

unsigned int	get_locus_start_pos (unsigned int locus)

unsigned int	get_sequence_block_size (unsigned int from, unsigned int to)

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 TTQuanti *ind, const unsigned int trait)

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

int	get_allele_position (const unsigned int locus, const unsigned int trait)

double	get_allele_value (const TTQuanti *ind, const unsigned int allele, const unsigned int locus, const unsigned int trait)

double	get_genotype_with_dominance (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)

const TMatrix &	get_dominance_effects ()

double	get_trait_mutation_variance (unsigned int trait)

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

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

bool	setHeritabilityParams ()

bool	setInitialValuesParams ()

bool	setGeneticMapParams ()

unsigned int	setAlleleModel ()

bool	setMutationModel_no_pleio ()

bool	setMutationModel_full_pleio ()

bool	setMutationModel_var_pleio ()

void	setTraitAndLocusTables_full_pleio ()

void	setTraitAndLocusTables_no_pleio (TMatrix &mat)

bool	setMutationCorrelation ()

bool	setDominanceParameters ()

bool	setDiallelicMutationModel ()

bool	setMutationSigmaFromQuantiMutationVariance ()

bool	setMutationSigmaFromQuantiMutationVariance_no_pleio ()

bool	readMatrixFromQuantiMutationMatrix (vector< vector< double >> &varmat)

bool	setContinuousMutationModel_no_pleio ()

bool	setContinuousMutationModel_full_pleio ()

bool	setContinuousMutationModel_var_pleio ()

void	allocate_gsl_mutation_matrix_space (unsigned int num_locus)

void	deallocate_gsl_mutation_matrix_space ()

gsl_matrix *	set_gsl_mutation_matrix_from_sigma (unsigned int loc, unsigned int pleio_deg)

gsl_matrix *	set_gsl_mutation_matrix (unsigned int pleio_deg, const vector< double > &varcov)

void	set_mutation_matrix_decomposition (unsigned int loc, unsigned int pleio_deg)

double *	getMutationEffectMultivariateGaussian (unsigned int loc)

double *	getMutationEffectBivariateGaussian (unsigned int loc)

double *	getMutationEffectUnivariateGaussian (unsigned int loc)

double *	getMutationEffectMultivariateGaussianLocSpec (unsigned int loc)

double *	getMutationEffectBivariateGaussianLocSpec (unsigned int loc)

double *	getMutationEffectUnivariateGaussianLocSpec (unsigned int loc)

double *	getMutationEffectBivariateDiallelic (unsigned int loc)

double *	getMutationEffects (unsigned int loc)

double *	getMutationEffectsVarPleio (unsigned int loc)

void	inherit (sex_t SEX, TTQuanti ind, const TTQuanti parent)

void	inherit_free (sex_t SEX, TTQuanti ind, const TTQuanti parent)

void	inherit_low (sex_t SEX, TTQuanti ind, const TTQuanti parent)

unsigned int	get_num_mutations ()

void	mutate (TTQuanti *ind)

void	mutate_nill (TTQuanti *ind)

void	mutate_full_pleio (TTQuanti *ind)

void	mutate_var_pleio (TTQuanti *ind)

void	mutate_no_pleio (TTQuanti *ind)

void	mutate_inplace_full_pleio (TTQuanti *ind)

void	mutate_inplace_var_pleio (TTQuanti *ind)

void	mutate_inplace_no_pleio (TTQuanti *ind)

void	mutate_diallelic_pleio (TTQuanti *ind)

void	mutate_diallelic_var_pleio (TTQuanti *ind)

void	mutate_diallelic_no_pleio (TTQuanti *ind)

bool	setEpistasisParameters ()

unsigned int	get_num_epi_coefs ()

bool	do_epistasis ()

const TMatrix &	get_epi_coefs () const

const TMatrix &	get_epi_coef_index () const

TraitPrototype implementations
virtual void	reset ()

virtual TTQuanti *	hatch ()

virtual TProtoQuanti *	clone ()

virtual trait_t	get_type () const

virtual int	get_phenotype_dimension ()
	Returns the dimension of the phenotype of the trait (size of the array accessed with TTrait::getValue() More...

virtual int	get_allele_number ()
	Returns the number of allele per locus. More...

virtual int	get_locus_number ()
	Returns the number of locus. More...

StorableComponent implementation
virtual void	store_data (BinaryStorageBuffer *saver)

virtual bool	retrieve_data (BinaryStorageBuffer *reader)

SimComponent implementation
virtual bool	setParameters ()

virtual void	loadFileServices (FileServices *loader)

virtual void	loadStatServices (StatServices *loader)

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

Public Member Functions inherited from TTProtoWithMap
	TTProtoWithMap ()

	TTProtoWithMap (const TTProtoWithMap &TP)

virtual	~TTProtoWithMap ()

void	setMapIndex (unsigned int idx)

unsigned int	getMapIndex ()

double	getRecombRate () const

bool	setGeneticMapParameters (string prefix, unsigned int numLoci=0)

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 bool	is_mappable ()
	Checks if the trait is mappable, i.e., if the loci can be placed on a genetic map. More...

virtual bool	is_mapped ()
	Checks if the trait's loci are placed on a genetic map. More...

virtual vector< unsigned int >	get_locus_map_positions ()
	Returns the map positions of the loci in vector. More...

Public Member Functions inherited from TraitPrototype
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	~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...

Protected Attributes
unsigned int	_num_locus
	Total number of loci, for all traits. More...

unsigned int	_2L
	Diploid locus size, to save on useless operations during mutation. More...

unsigned int	_num_traits
	Number of traits. More...

unsigned int	_seq_length
	Total number of allelic values stored in individual sequences, no trait x no locus. More...

unsigned int	_allele_model

string	_diallele_datatype

double	_mutation_rate

double	_genomic_mutation_rate

unsigned int	_pleio_type

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

Private Attributes
TMatrix	_allele_value

double *	_sequence_diallele_values [2]

bool	_equal_effects

double	_equal_val_0

double	_equal_val_1

double	_equal_val_diff

vector< bitstring >	_trait_masks

TMatrix	_init_value

TMatrix	_init_variance

TMatrix	_mutation_correlation

TMatrix	_mutation_sigma

gsl_matrix **	_gsl_mutation_matrix

gsl_matrix **	_evect

gsl_vector **	_eval

gsl_vector **	_effects_multivar

gsl_vector **	_ws

double	_effects_bivar [2]

unsigned int	_doInitMutation

bool	_mutationVarianceIsLocusSpecific

bool	_mutationEffectIsFixedDiAllele

unsigned int	_dominance_model

TMatrix	_dominance_effects

bool	_equal_dom_coeff

bool *	_all_chooser

size_t	_locusByteSize

size_t	_sizeofLocusType

vector< double >	_eVariance

vector< double >	_h2

unsigned int	_h2_setTime

bool	_h2_isBroad

TMatrix	_pleio_matx
	Pleiotropy matrix provided in input (num locu X num trait). More...

vector< vector< unsigned int > >	_trait_table
	Trait table, (num trait X (variable length/trait)), holds, for each trait, the array position of causative alleles in the sequence. More...

vector< vector< unsigned int > >	_trait_locus_table
	Table storing the locus id of each locus affecting each trait (num trait X (variable length/trait)). More...

vector< vector< unsigned int > >	_locus_table
	Locus table, num_locus x 2, first column holds the start position of the alleles of each locus in the sequence, second column counts the number of alleles = pleiotropic degree. More...

bool	_epistasis

unsigned int	_num_epi_coefs

TMatrix	_epistatic_coefs_matrix

TMatrix	_epistatic_coefs_indices

void(TProtoQuanti::*	_inherit_fun_ptr )(sex_t, TTQuanti , const TTQuanti )
	Pointer to inheritance functions: either inherit_free() (r=0.5), or inherit_low() (r<0.5). More...

void(TProtoQuanti::*	_mutation_func_ptr )(TTQuanti *)
	Pointer to mutation function, which depends on allele on model (HC, noHC, diallelic) More...

double (TProtoQuanti::	_getMutationValues )(unsigned int)
	Pointer to mutation allele value function, which depends on allele model and number of traits affected. More...

vector< double (TProtoQuanti::)(unsigned int) >	_getMutationValuesVarPleio
	Collection of pointers to mutation functions, which generate allele values in dependence of pleiotropic degree. More...

double(TProtoQuanti::*	_getGenotypeWithDominance )(double, double, double)
	Pointer to either dominance_h() or dominance_k() function computing the genotypic value with dominance. More...

double(TProtoQuanti::*	_set_trait_value_func_ptr )(const TTQuanti *, const unsigned int)
	Pointer to either set_trait_value_VE() or set_trait_value_noVE() to compute phenotypic values. More...

double(TProtoQuanti::*	_set_genotype_func_ptr )(const TTQuanti *, const unsigned int)
	Pointer to functions get_genotype_value_additive() or get_genotype_value_dominance() computing the genotypic value of a trait as function of allele effect. More...

TTQuantiSH *	_stats

TTQuantiFH *	_writer

TTQuantiFH *	_reader

TTQFreqExtractor *	_freqExtractor

TTQOhtaStats *	_ohtaStats

Friends
class	TTQuanti

class	TTQuanti_continuous

class	TTQuanti_continuous_full_pleio

class	TTQuanti_continuous_var_pleio

class	TTQuanti_continuous_no_pleio

class	TTQuanti_continuous_single

Additional Inherited Members
Static Public Member Functions inherited from TTProtoWithMap
static GeneticMap &	getGeneticMapRef ()

static void	recombine (unsigned long indID)

Static Public Attributes inherited from TTProtoWithMap
static GeneticMap	_map

Detailed Description

TProtoQuanti.

Constructor & Destructor Documentation

◆ TProtoQuanti() [1/2]

TProtoQuanti::TProtoQuanti ( )

                            :
         _num_locus(0),
         _2L(0),
         _num_traits(0),
         _seq_length(0),
         _allele_model(0),
         _gsl_mutation_matrix(0),
         _evect(0),
         _eval(0),
         _effects_multivar(0),
         _ws(0),
         _mutation_rate(0),
         _genomic_mutation_rate(0),
         _doInitMutation(0),
         _mutationVarianceIsLocusSpecific(0),
         _mutationEffectIsFixedDiAllele(0),
         _h2_setTime(0),
         _h2_isBroad(0),
         _pleio_type(0),
         _dominance_model(0),
         _all_chooser(0),
         _locusByteSize(0),
         _sizeofLocusType(0),
         _eVariance(0),
         _epistasis(false),
         _num_epi_coefs(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),
         _ohtaStats(0)
 {
   set_paramset("quantitative_trait", false, this);
  
   add_parameter("quanti_traits",INT,true,false,0,0);  // MANDATORY
   add_parameter("quanti_loci",INT,true,false,0,0);     // MANDATORY
   add_parameter("quanti_loci_per_trait", MAT, false, false,0,0);
   add_parameter("quanti_allele_model",STR,true,false,0,0); // MANDATORY
   add_parameter("quanti_allele_value",DBL,false,false,0,0);
   add_parameter("quanti_diallele_datatype", STR, false, false, 0, 0);
   add_parameter("quanti_init_value",MAT,false,false,0,0);
   add_parameter("quanti_init_variance",DBL,false,false,0,0,0);
   add_parameter("quanti_init_model",INT,false,true,0,3);
  
   // heritability
   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);
  
   // mutations
   add_parameter("quanti_mutation_rate",DBL,true,true,0,1, 0); // MANDATORY
   add_parameter("quanti_mutation_variance",DBL,false,false,0,0, 0); // accept locus-specific values
  
   // pleiotropy
   add_parameter("quanti_pleiotropy", STR, false, false, 0,0, 0); // optional
   add_parameter("quanti_mutation_correlation",DBL,false,false,0,0, 0);  // accept locus-specific values
   add_parameter("quanti_mutation_matrix",MAT,false,false,0,0, 0);
   add_parameter("quanti_pleio_matrix",INT,false,true,0,1); // allows user to set pleiotropic degree of loci
  
   //dominance
 //  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);
  
   //epsistasis
   add_parameter("quanti_epistatic_effects", MAT, false, false, 0, 0, 0);
   add_parameter("quanti_epistatic_network", MAT, false, false, 0, 0, 0);
  
   //genetic map parameters:
   TTProtoWithMap::addGeneticMapParameters("quanti");
  
   // output
   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);
  
   add_parameter("quanti_ohta_output",BOOL,false,false,0,0);
   add_parameter("quanti_ohta_logtime",INT,false,false,0,0);
  
  
 // some pointer initialization:
   _sequence_diallele_values[0] = NULL;
   _sequence_diallele_values[1] = NULL;
   _equal_effects  = false;
   _equal_val_0    = 0.0;
   _equal_val_1    = 0.0;
   _equal_val_diff = 0.0;
  
 }

References _equal_effects, _equal_val_0, _equal_val_1, _equal_val_diff, _sequence_diallele_values, SimComponent::add_parameter(), TTProtoWithMap::addGeneticMapParameters(), BOOL, DBL, INT, MAT, SimComponent::set_paramset(), and STR.

Referenced by clone().

◆ TProtoQuanti() [2/2]

TProtoQuanti::TProtoQuanti ( const TProtoQuanti & T )

                                                 :
         _num_locus(T._num_locus),
         _2L(_2L),
         _num_traits(T._num_traits),
         _seq_length(T._seq_length),
         _allele_model(T._allele_model),
         _gsl_mutation_matrix(0),
         _evect(0),
         _eval(0),
         _effects_multivar(0),
         _ws(0),
         _mutation_rate(T._mutation_rate),
         _genomic_mutation_rate(T._genomic_mutation_rate),
         _h2_setTime(0),
         _h2_isBroad(0),
         _pleio_type(0),
         _doInitMutation(0),
         _mutationVarianceIsLocusSpecific(0),
         _mutationEffectIsFixedDiAllele(0),
         _dominance_model(0),
         _all_chooser(0),
         _locusByteSize(0),
         _sizeofLocusType(T._sizeofLocusType),
         _eVariance(0),
         _epistasis(T._epistasis),
         _num_epi_coefs(T._num_epi_coefs),
         _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),
         _ohtaStats(0)
 {
   _locusByteSize = T._num_traits * sizeof(double);
   _paramSet = new ParamSet( *(T._paramSet) ) ;
  
   _pleio_matx.copy(T._pleio_matx);
  
   _sequence_diallele_values[0] = NULL;
   _sequence_diallele_values[1] = NULL;
   _equal_effects  = T._equal_effects;
   _equal_val_0    = T._equal_val_0;
   _equal_val_1    = T._equal_val_1;
   _equal_val_diff = T._equal_val_diff;
  
   _epistatic_coefs_indices.copy(T._epistatic_coefs_indices);
   _epistatic_coefs_matrix.copy(T._epistatic_coefs_matrix);
  
 }

References _epistatic_coefs_indices, _epistatic_coefs_matrix, _equal_effects, _equal_val_0, _equal_val_1, _equal_val_diff, _locusByteSize, _num_traits, SimComponent::_paramSet, _pleio_matx, _sequence_diallele_values, and TMatrix::copy().

◆ ~TProtoQuanti()

TProtoQuanti::~TProtoQuanti ( )

virtual

 {
   deallocate_gsl_mutation_matrix_space();
  
   if(_stats){delete _stats; _stats = NULL;}
   if(_writer){delete _writer; _writer = NULL;}
   if(_reader) delete _reader;
   if(_freqExtractor){delete _freqExtractor; _freqExtractor = NULL;}
   if(_ohtaStats) {delete _ohtaStats; _ohtaStats = NULL;}
   if(_all_chooser) {delete [] _all_chooser; _all_chooser = NULL;}
  
   if(_sequence_diallele_values[0]) {
     delete [] _sequence_diallele_values[0];
     _sequence_diallele_values[0] = NULL;
   }
  
   if(_sequence_diallele_values[1]) {
     delete [] _sequence_diallele_values[1];
     _sequence_diallele_values[1] = NULL;
   }
  
 }

References _all_chooser, _freqExtractor, _ohtaStats, _reader, _sequence_diallele_values, _stats, _writer, and deallocate_gsl_mutation_matrix_space().

Member Function Documentation

◆ allocate_gsl_mutation_matrix_space()

void TProtoQuanti::allocate_gsl_mutation_matrix_space ( unsigned int num_locus )

 {
   _eval = new gsl_vector* [num_loc];
   _evect = new gsl_matrix* [num_loc];
   _effects_multivar = new gsl_vector* [num_loc];;
   _ws = new gsl_vector* [num_loc];
   _gsl_mutation_matrix = new gsl_matrix* [num_loc];
  
   // initializing pointers
   for(unsigned int i = 0; i < num_loc; ++i) {
     _eval[i] = NULL;
     _evect[i] = NULL;
     _effects_multivar[i] = NULL;
     _ws[i] = NULL;
     _gsl_mutation_matrix[i] = NULL;
   }
 }

References _effects_multivar, _eval, _evect, _gsl_mutation_matrix, and _ws.

Referenced by setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ clone()

virtual TProtoQuanti* TProtoQuanti::clone ( )

inlinevirtual

Implements TraitPrototype.

575 {return new TProtoQuanti(*this);}

TProtoQuanti::TProtoQuanti

TProtoQuanti()

Definition: ttquanti.cc:64

References TProtoQuanti().

◆ deallocate_gsl_mutation_matrix_space()

void TProtoQuanti::deallocate_gsl_mutation_matrix_space ( )

 {
  
   unsigned int SIZE = 1;
  
   if(_mutationVarianceIsLocusSpecific) // this should represent the state of the simulation which did the allocation
     SIZE = _num_locus;
  
   if(_gsl_mutation_matrix){
  
     for(unsigned int i = 0; i < SIZE; ++i)
       if(_gsl_mutation_matrix[i]) gsl_matrix_free(_gsl_mutation_matrix[i]);
  
     delete [] _gsl_mutation_matrix;
     _gsl_mutation_matrix = NULL;
   }
  
   if(_evect) {
     for(unsigned int i = 0; i < SIZE; ++i)
       if(_evect[i]) gsl_matrix_free(_evect[i]);
     delete [] _evect;
     _evect = NULL;
   }
  
   if(_eval){
     for(unsigned int i = 0; i < SIZE; ++i)
       if(_eval[i]) gsl_vector_free(_eval[i]);
     delete [] _eval;
     _eval = NULL;
   }
  
   if(_effects_multivar) {
     for(unsigned int i = 0; i < SIZE; ++i)
       if(_effects_multivar[i]) gsl_vector_free(_effects_multivar[i]);
     delete [] _effects_multivar;
     _effects_multivar = NULL;
   }
  
   if(_ws) {
     for(unsigned int i = 0; i < SIZE; ++i)
       if(_ws[i]) gsl_vector_free(_ws[i]);
     delete [] _ws;
     _ws = NULL;
   }
  
 }

References _effects_multivar, _eval, _evect, _gsl_mutation_matrix, _mutationVarianceIsLocusSpecific, _num_locus, and _ws.

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

◆ do_epistasis()

bool TProtoQuanti::do_epistasis ( )

inline

567 {return _epistasis;}

References _epistasis.

Referenced by TTQuantiSH::addQuanti(), and TTQuantiSH::addVarPerPatch().

◆ get_allele_model()

unsigned int TProtoQuanti::get_allele_model ( )

inline

434 {return _allele_model;}

References _allele_model.

Referenced by TTQuantiFH::FHread(), TTQFreqExtractor::FHwrite(), TTQOhtaStats::FHwrite(), TTQuantiSH::getSNPalleleFreqInPatch(), TTQuantiSH::getVaWithDominance(), loadFileServices(), LCE_QuantiInit::setParameters(), TTQuantiFH::write_PLINK(), and TTQuantiFH::write_TABLE().

◆ get_allele_number()

virtual int TProtoQuanti::get_allele_number ( )

inlinevirtual

Returns the number of allele per locus.

Implements TraitPrototype.

580 {return (_allele_model > 2 ? 3: 2);} //3 just means more than di-allelic

References _allele_model.

◆ get_allele_position()

int TProtoQuanti::get_allele_position	(	const unsigned int	locus,
		const unsigned int	trait
	)

 {
   // not assured that the locus is affecting that trait, first check
   if(std::any_of(_trait_locus_table[trait].cbegin(), _trait_locus_table[trait].cend(),
       [locus](unsigned int i){return (i == locus);})) {
  
     // we have to find where the locus sits in the table
     vector<unsigned int>::const_iterator I = find(_trait_locus_table[trait].cbegin(), _trait_locus_table[trait].cend(),
         locus);
     // find index of pointer
     unsigned int pos = I - _trait_locus_table[trait].cbegin();
  
     return _trait_table[trait][pos];
   }
   return -1;
 }

References _trait_locus_table, and _trait_table.

Referenced by get_allele_value().

◆ get_allele_value()

double TProtoQuanti::get_allele_value	(	const TTQuanti *	ind,
		const unsigned int	allele,
		const unsigned int	locus,
		const unsigned int	trait
	)

 {
   assert(allele < 2); // can be 0 or 1 only
  
   int pos = get_allele_position(locus, trait);
  
   if(pos > -1)
     return ind->get_allele_value(pos, allele);
   else
     return error("TProtoQuanti::get_allele_value::wrong allele position at locus %i for trait %i\n", locus, trait);
 }

References error(), get_allele_position(), and TTrait::get_allele_value().

◆ get_diallele_value()

double TProtoQuanti::get_diallele_value	(	unsigned int	locus,
		unsigned int	allele
	)

inline

437 {return _allele_value.get(locus, allele);}

TMatrix::get

double get(unsigned int i, unsigned int j) const

Accessor to element at row i and column j.

Definition: tmatrix.h:193

TProtoQuanti::_allele_value

TMatrix _allele_value

Definition: ttquanti.h:622

References _allele_value, and TMatrix::get().

◆ get_diallele_values()

const TMatrix& TProtoQuanti::get_diallele_values ( )

inline

435 {return _allele_value;}

References _allele_value.

Referenced by TTQFreqExtractor::FHwrite(), TTQuantiSH::getVaNoDominance(), and TTQuantiSH::getVaWithDominance().

◆ get_doInitMutation()

unsigned int TProtoQuanti::get_doInitMutation ( )

inline

449 {return _doInitMutation;}

References _doInitMutation.

◆ get_dominance()

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

inline

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

TProtoQuanti::_dominance_effects

TMatrix _dominance_effects

Definition: ttquanti.h:648

References _dominance_effects, and TMatrix::get().

Referenced by TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_var_pleio::get_dominant_genotype(), and get_genotype_with_dominance().

◆ get_dominance_effects()

const TMatrix& TProtoQuanti::get_dominance_effects ( )

inline

481 {return _dominance_effects;}

References _dominance_effects.

Referenced by TTQuanti_continuous_no_pleio::get_dominant_genotype().

◆ get_dominance_model()

unsigned int TProtoQuanti::get_dominance_model ( )

inline

478 {return _dominance_model;}

References _dominance_model.

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

◆ get_env_var()

vector<double> TProtoQuanti::get_env_var ( )

inline

430 {return _eVariance;}

References _eVariance.

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

◆ get_epi_coef_index()

const TMatrix& TProtoQuanti::get_epi_coef_index ( ) const

inline

569 {return _epistatic_coefs_indices;}

References _epistatic_coefs_indices.

Referenced by TTQuanti_continuous_full_pleio_epistasis::get_epistatic_genotype(), TTQuanti_diallelic_full_pleio_epistasis::get_epistatic_genotype(), TTQuanti_continuous_no_pleio_epistasis::get_epistatic_genotype(), TTQuanti_diallelic_no_pleio_epistasis::get_epistatic_genotype(), TTQuanti_diallelic_bitstring_no_pleio_epistasis::get_epistatic_genotype(), and TTQuanti_diallelic_bitstring_full_pleio_epistasis::get_epistatic_genotype().

◆ get_epi_coefs()

const TMatrix& TProtoQuanti::get_epi_coefs ( ) const

inline

568 {return _epistatic_coefs_matrix;}

References _epistatic_coefs_matrix.

Referenced by TTQuanti_continuous_full_pleio_epistasis::get_epistatic_genotype(), TTQuanti_diallelic_full_pleio_epistasis::get_epistatic_genotype(), TTQuanti_continuous_no_pleio_epistasis::get_epistatic_genotype(), TTQuanti_diallelic_no_pleio_epistasis::get_epistatic_genotype(), TTQuanti_diallelic_bitstring_no_pleio_epistasis::get_epistatic_genotype(), and TTQuanti_diallelic_bitstring_full_pleio_epistasis::get_epistatic_genotype().

◆ get_equal_val_0()

double TProtoQuanti::get_equal_val_0 ( )

inline

442 {return _equal_val_0;}

References _equal_val_0.

Referenced by TTQuanti_diallelic_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_var_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype_equal_effects(), TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_dominant_genotype(), and TTQuanti_diallelic_bitstring_var_pleio::get_dominant_genotype().

◆ get_equal_val_1()

double TProtoQuanti::get_equal_val_1 ( )

inline

443 {return _equal_val_1;}

References _equal_val_1.

Referenced by TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_dominant_genotype(), and TTQuanti_diallelic_bitstring_var_pleio::get_dominant_genotype().

◆ get_equal_val_diff()

double TProtoQuanti::get_equal_val_diff ( )

inline

444 {return _equal_val_diff;}

References _equal_val_diff.

Referenced by TTQuanti_diallelic_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_var_pleio::get_additive_genotype(), and TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype_equal_effects().

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

◆ get_genotype_dominance_k()

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

inline

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

Referenced by get_genotype_with_dominance(), and setParameters().

◆ get_genotype_with_dominance()

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

 {
   // let's use the "k" model by default, it's the fastest:
   return get_genotype_dominance_k( a1 , a2, get_dominance(locus, trait));
 //  return (this->*_getGenotypeWithDominance)( a1 , a2, get_dominance(locus, trait));
 }

References get_dominance(), and get_genotype_dominance_k().

◆ get_genotypic_value()

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

inline

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

References _set_genotype_func_ptr.

Referenced by TTQuanti_continuous::get_full_genotype(), TTQuanti_diallelic::get_full_genotype(), and TTQuanti_diallelic_bitstring::get_full_genotype().

◆ get_h2_isBroad()

bool TProtoQuanti::get_h2_isBroad ( )

inline

433 {return _h2_isBroad;}

References _h2_isBroad.

Referenced by TTQuantiSH::getVaWithDominance().

◆ get_h2_setTime()

unsigned int TProtoQuanti::get_h2_setTime ( )

inline

432 {return _h2_setTime;}

References _h2_setTime.

Referenced by LCE_Breed_Quanti::setVefromVa().

◆ get_heritability()

vector<double> TProtoQuanti::get_heritability ( )

inline

431 {return _h2;}

TProtoQuanti::_h2

vector< double > _h2

Definition: ttquanti.h:658

References _h2.

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

◆ get_init_value()

double TProtoQuanti::get_init_value ( unsigned int i )

inline

447 {return _init_value.get(0,i); }

TProtoQuanti::_init_value

TMatrix _init_value

Definition: ttquanti.h:629

References _init_value, and TMatrix::get().

Referenced by TTQuanti_continuous_full_pleio::init_sequence(), TTQuanti_continuous_var_pleio::init_sequence(), TTQuanti_continuous_no_pleio::init_sequence(), TTQuanti_continuous_full_pleio_epistasis::init_sequence(), and TTQuanti_continuous_no_pleio_epistasis::init_sequence().

◆ get_init_variance()

double TProtoQuanti::get_init_variance ( unsigned int i )

inline

448 {return _init_variance.get(0,i);}

TProtoQuanti::_init_variance

TMatrix _init_variance

Definition: ttquanti.h:630

References _init_variance, and TMatrix::get().

Referenced by TTQuanti_continuous_full_pleio::init_sequence(), TTQuanti_continuous_var_pleio::init_sequence(), TTQuanti_continuous_no_pleio::init_sequence(), TTQuanti_continuous_full_pleio_epistasis::init_sequence(), and TTQuanti_continuous_no_pleio_epistasis::init_sequence().

◆ get_locus_byte_size()

size_t TProtoQuanti::get_locus_byte_size ( )

inline

429 {return _locusByteSize;}

References _locusByteSize.

◆ get_locus_ID()

unsigned int TProtoQuanti::get_locus_ID	(	unsigned int	locus,
		unsigned int	trait
	)

inline

456 {return _trait_locus_table[trait][locus];}

References _trait_locus_table.

◆ get_locus_number()

virtual int TProtoQuanti::get_locus_number ( )

inlinevirtual

Returns the number of locus.

Implements TraitPrototype.

582 {return _num_locus;}

References _num_locus.

◆ get_locus_PD()

unsigned int TProtoQuanti::get_locus_PD ( unsigned int locus )

inline

457 {return _locus_table[locus][1];}

TProtoQuanti::_locus_table

vector< vector< unsigned int > > _locus_table

Locus table, num_locus x 2, first column holds the start position of the alleles of each locus in the...

Definition: ttquanti.h:676

References _locus_table.

Referenced by TTQuanti_diallelic_bitstring_var_pleio::copy_sequence_1locus(), TTQuanti_continuous_var_pleio::copy_sequence_1locus(), TTQuanti_diallelic_var_pleio::copy_sequence_1locus(), getMutationEffectMultivariateGaussian(), getMutationEffectMultivariateGaussianLocSpec(), and TTQuanti_continuous_var_pleio::init_sequence().

◆ get_locus_seq_pos()

unsigned int TProtoQuanti::get_locus_seq_pos	(	unsigned int	loc,
		unsigned int	trait
	)

inline

454 {return _trait_table[trait][loc];}

References _trait_table.

◆ get_locus_start_pos()

unsigned int TProtoQuanti::get_locus_start_pos ( unsigned int locus )

inline

458 {return _locus_table[locus][0];}

References _locus_table.

Referenced by TTQuanti_diallelic_bitstring_full_pleio::copy_sequence_1locus(), TTQuanti_diallelic_bitstring_var_pleio::copy_sequence_1locus(), TTQuanti_diallelic_bitstring_full_pleio_epistasis::copy_sequence_1locus(), TTQuanti_continuous_var_pleio::copy_sequence_1locus(), TTQuanti_diallelic_var_pleio::copy_sequence_1locus(), TTQuanti_diallelic_bitstring_full_pleio::copy_sequence_block(), TTQuanti_diallelic_bitstring_var_pleio::copy_sequence_block(), TTQuanti_diallelic_bitstring_full_pleio_epistasis::copy_sequence_block(), TTQuanti_continuous_var_pleio::copy_sequence_block(), TTQuanti_diallelic_var_pleio::copy_sequence_block(), and TTQuanti_continuous_var_pleio::init_sequence().

◆ get_num_epi_coefs()

unsigned int TProtoQuanti::get_num_epi_coefs ( )

inline

566 {return _num_epi_coefs;}

References _num_epi_coefs.

◆ get_num_locus() [1/2]

unsigned int TProtoQuanti::get_num_locus ( )

inline

424 {return _num_locus;}

References _num_locus.

◆ get_num_locus() [2/2]

unsigned int TProtoQuanti::get_num_locus ( unsigned int trait )

inline

425 {return _trait_table[trait].size();}

References _trait_table.

◆ get_num_mutations()

unsigned int TProtoQuanti::get_num_mutations ( )

inline

                                                                      {
     return (unsigned int)RAND::Binomial(_mutation_rate, _2L);
   }

References _2L, _mutation_rate, and RAND::Binomial().

Referenced by mutate_diallelic_no_pleio(), mutate_diallelic_pleio(), mutate_diallelic_var_pleio(), mutate_full_pleio(), mutate_inplace_full_pleio(), mutate_inplace_no_pleio(), mutate_inplace_var_pleio(), mutate_no_pleio(), and mutate_var_pleio().

◆ get_num_traits()

unsigned int TProtoQuanti::get_num_traits ( )

inline

423 {return _num_traits;}

References _num_traits.

◆ get_phenotype_dimension()

virtual int TProtoQuanti::get_phenotype_dimension ( )

inlinevirtual

Returns the dimension of the phenotype of the trait (size of the array accessed with TTrait::getValue()

Implements TraitPrototype.

578 {return _num_traits;}

References _num_traits.

◆ get_phenotypic_value()

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

inline

                                                                                                                  {
      return (this->*_set_trait_value_func_ptr)(ind, trait);
   }

References _set_trait_value_func_ptr.

Referenced by TTQuanti::set_value().

◆ get_pleio_matrix()

const TMatrix& TProtoQuanti::get_pleio_matrix ( )

inline

452 {return _pleio_matx;}

References _pleio_matx.

◆ get_pleiotropy_type()

unsigned int TProtoQuanti::get_pleiotropy_type ( )

inline

426 {return _pleio_type;}

References _pleio_type.

Referenced by TTQuanti_continuous::operator==(), TTQuanti_diallelic::operator==(), and TTQuanti_diallelic_bitstring::operator==().

◆ get_seq_diallele_value()

double TProtoQuanti::get_seq_diallele_value	(	unsigned int	position,
		unsigned int	allele
	)

inline

439 {return _sequence_diallele_values[allele][position];}

References _sequence_diallele_values.

◆ get_seq_length()

unsigned int TProtoQuanti::get_seq_length ( )

inline

427 {return _seq_length;}

References _seq_length.

◆ get_sequence_block_size()

unsigned int TProtoQuanti::get_sequence_block_size	(	unsigned int	from,
		unsigned int	to
	)

inline

                                                                                          {
                               return (to < _num_locus ? _locus_table[to][0] : _seq_length)
                                      - _locus_table[from][0];
                             }

References _locus_table, _num_locus, and _seq_length.

Referenced by TTQuanti_diallelic_bitstring_var_pleio::copy_sequence_block(), TTQuanti_continuous_var_pleio::copy_sequence_block(), TTQuanti_diallelic_var_pleio::copy_sequence_block(), TTQuanti_continuous_var_pleio::get_sequence_block_size(), TTQuanti_diallelic_var_pleio::get_sequence_block_size(), and TTQuanti_diallelic_bitstring_var_pleio::get_sequence_block_size().

◆ get_size_locus_type()

size_t TProtoQuanti::get_size_locus_type ( )

inline

428 {return _sizeofLocusType;}

References _sizeofLocusType.

Referenced by TTQuanti_continuous_var_pleio::copy_sequence_1locus(), TTQuanti_diallelic_var_pleio::copy_sequence_1locus(), TTQuanti_continuous_var_pleio::copy_sequence_block(), TTQuanti_diallelic_var_pleio::copy_sequence_block(), TTQuanti_continuous_var_pleio::get_sequence_block_size(), and TTQuanti_diallelic_var_pleio::get_sequence_block_size().

◆ get_stater()

TTQuantiSH* TProtoQuanti::get_stater ( )

inline

450 {return _stats;}

References _stats.

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

◆ get_trait_mask()

const bitstring& TProtoQuanti::get_trait_mask ( unsigned int trait ) const

inline

446 {return _trait_masks[trait];}

TProtoQuanti::_trait_masks

vector< bitstring > _trait_masks

Definition: ttquanti.h:628

References _trait_masks.

Referenced by TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_var_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_dominant_genotype(), and TTQuanti_diallelic_bitstring_var_pleio::get_dominant_genotype().

◆ get_trait_mutation_variance()

double TProtoQuanti::get_trait_mutation_variance ( unsigned int trait )

 {
   double Vm;
  
   if(_mutation_sigma.nrows() == 1) // same value for all loci
     Vm = 2 * _genomic_mutation_rate * _mutation_sigma.get(0, trait);
   else
     Vm = _mutation_sigma.colSum(trait) * _mutation_rate * 2;
  
   return Vm;
 }

References _genomic_mutation_rate, _mutation_rate, _mutation_sigma, TMatrix::colSum(), TMatrix::get(), and TMatrix::nrows().

◆ get_type()

virtual trait_t TProtoQuanti::get_type ( ) const

inlinevirtual

Implements TraitPrototype.

576 {return QUANT;}

QUANT

#define QUANT

Definition: types.h:72

References QUANT.

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

◆ getMutationEffectBivariateDiallelic()

double * TProtoQuanti::getMutationEffectBivariateDiallelic ( unsigned int loc )

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

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

Referenced by setMutationModel_full_pleio().

◆ getMutationEffectBivariateGaussian()

double * TProtoQuanti::getMutationEffectBivariateGaussian ( unsigned int loc )

 {
   //no need to assert() as we are using a different set of containers and read from mutation_sigma directly
   RAND::BivariateGaussian(_mutation_sigma.get(0,0), _mutation_sigma.get(0,1), _mutation_correlation.get(0,0),
       &_effects_bivar[0], &_effects_bivar[1]);
   return &_effects_bivar[0];
 }

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

Referenced by setMutationModel_full_pleio(), and setMutationModel_var_pleio().

◆ getMutationEffectBivariateGaussianLocSpec()

double * TProtoQuanti::getMutationEffectBivariateGaussianLocSpec ( unsigned int loc )

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

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

Referenced by setMutationModel_full_pleio(), and setMutationModel_var_pleio().

◆ getMutationEffectMultivariateGaussian()

double * TProtoQuanti::getMutationEffectMultivariateGaussian ( unsigned int loc )

 {
   // assert we are using the correct mutation environment
   assert(get_locus_PD(loc) == _effects_multivar[0]->size);
  
   RAND::MultivariateGaussian(_eval[0], _evect[0], _ws[0], _effects_multivar[0]);
  
   return _effects_multivar[0]->data;
 }

References _effects_multivar, _eval, _evect, _ws, and get_locus_PD().

Referenced by setMutationModel_full_pleio().

◆ getMutationEffectMultivariateGaussianLocSpec()

double * TProtoQuanti::getMutationEffectMultivariateGaussianLocSpec ( unsigned int loc )

 {
   // assert we are using the correct mutation environment
   assert(get_locus_PD(loc) == _effects_multivar[loc]->size);
  
   RAND::MultivariateGaussian(_eval[loc], _evect[loc], _ws[loc], _effects_multivar[loc]);
  
   return _effects_multivar[loc]->data;
 }

References _effects_multivar, _eval, _evect, _ws, and get_locus_PD().

Referenced by setMutationModel_full_pleio(), and setMutationModel_var_pleio().

◆ getMutationEffects()

double* TProtoQuanti::getMutationEffects ( unsigned int loc )

inline

                                                                                      {
     return (this->* _getMutationValues)(loc);
   }

References _getMutationValues.

Referenced by TTQuanti_continuous_no_pleio::init_sequence(), TTQuanti_continuous_full_pleio_epistasis::init_sequence(), and TTQuanti_continuous_no_pleio_epistasis::init_sequence().

◆ getMutationEffectsVarPleio()

double* TProtoQuanti::getMutationEffectsVarPleio ( unsigned int loc )

inline

                                                                                      {
     return (this->* _getMutationValuesVarPleio[loc]) (loc);
   }

References _getMutationValuesVarPleio.

Referenced by TTQuanti_continuous_var_pleio::init_sequence().

◆ getMutationEffectUnivariateGaussian()

double * TProtoQuanti::getMutationEffectUnivariateGaussian ( unsigned int loc )

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

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

Referenced by setMutationModel_no_pleio(), and setMutationModel_var_pleio().

◆ getMutationEffectUnivariateGaussianLocSpec()

double * TProtoQuanti::getMutationEffectUnivariateGaussianLocSpec ( unsigned int loc )

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

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

Referenced by setMutationModel_no_pleio(), and setMutationModel_var_pleio().

◆ has_equal_domCoeff()

bool TProtoQuanti::has_equal_domCoeff ( )

inline

440 {return _equal_dom_coeff;}

TProtoQuanti::_equal_dom_coeff

bool _equal_dom_coeff

Definition: ttquanti.h:649

References _equal_dom_coeff.

Referenced by TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_dominant_genotype(), and TTQuanti_diallelic_bitstring_var_pleio::get_dominant_genotype().

◆ has_equal_effects()

bool TProtoQuanti::has_equal_effects ( )

inline

441 {return _equal_effects;}

References _equal_effects.

Referenced by TTQuanti_diallelic_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_var_pleio::get_additive_genotype(), TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype(), TTQuanti_diallelic_bitstring_full_pleio::get_dominant_genotype(), and TTQuanti_diallelic_bitstring_var_pleio::get_dominant_genotype().

◆ hatch()

TTQuanti * TProtoQuanti::hatch ( )

virtual

Implements TraitPrototype.

 {
   TTQuanti* kid;
  
   if(_epistasis && _pleio_type == 2)
     fatal("quantitative trait loci with variable pleiotropy are not implemented for the epistatic case.\n");
  
   if(_pleio_type == 0) { //non-pleiotropic cases
  
     if(_allele_model <= 2) { // diallelic
  
       if(_epistasis) {
         if(_diallele_datatype == "byte")
           kid = new TTQuanti_diallelic_no_pleio_epistasis();
         else
           kid = new TTQuanti_diallelic_bitstring_no_pleio_epistasis();
       }
       else if(_diallele_datatype == "byte") {
         kid = new TTQuanti_diallelic_no_pleio();
       } else {
         kid = new TTQuanti_diallelic_bitstring_no_pleio();
       }
  
     } else { // continuous
  
       if(_epistasis)
         kid = new TTQuanti_continuous_no_pleio_epistasis();
       else
         kid = new TTQuanti_continuous_no_pleio();
     }
  
   } else if (_pleio_type == 1) { //full-pleiotropic cases
  
     if(_allele_model <= 2) {
  
       if(_epistasis) {
         if(_diallele_datatype == "byte")
           kid = new TTQuanti_diallelic_full_pleio_epistasis();
         else
           kid = new TTQuanti_diallelic_bitstring_full_pleio_epistasis();
       }
       else if(_diallele_datatype == "byte") {
         kid = new TTQuanti_diallelic_full_pleio();
       } else {
         kid = new TTQuanti_diallelic_bitstring_full_pleio();
       }
  
     } else {
  
       if(_epistasis)
         kid = new TTQuanti_continuous_full_pleio_epistasis();
       else
         kid = new TTQuanti_continuous_full_pleio();
     }
  
   } else {  // variable pleiotropy cases
  
     if(_allele_model <= 2) {
  
       if(_diallele_datatype == "byte")
         kid = new TTQuanti_diallelic_var_pleio();
       else
         kid = new TTQuanti_diallelic_bitstring_var_pleio();
  
     } else {
       kid = new TTQuanti_continuous_var_pleio();
     }
   }
  
   kid->set_proto(this);
  
   // set specific optimisations:
  
  
   return kid;
 }

References _allele_model, _diallele_datatype, _epistasis, _pleio_type, fatal(), TTQuanti::set_proto(), TTQuanti_continuous_full_pleio, TTQuanti_continuous_no_pleio, and TTQuanti_continuous_var_pleio.

Referenced by setParameters().

◆ inherit()

void TProtoQuanti::inherit	(	sex_t	SEX,
		TTQuanti *	ind,
		const TTQuanti *	parent
	)

inline

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

References _inherit_fun_ptr.

Referenced by TTQuanti::inherit().

◆ inherit_free()

void TProtoQuanti::inherit_free	(	sex_t	SEX,
		TTQuanti *	ind,
		const TTQuanti *	parent
	)

inline

 {
 //  assert(_all_chooser);
  
 //  for(unsigned int i = 0; i < _num_locus; ++i)
 //    _all_chooser[i] = RAND::RandBool();
  
   // copy the information for one locus at a time
   for(unsigned int i = 0; i < _num_locus; ++i)
 //    ind->copy_sequence_block(SEX, _all_chooser[i], i, i+1, parent);
     ind->copy_sequence_1locus(SEX, RAND::RandBool(), i, parent);
  
   // note that more than one value may be copied at a time because of pleiotropy
 }

References _num_locus, TTQuanti::copy_sequence_1locus(), and RAND::RandBool().

Referenced by setGeneticMapParams().

◆ inherit_low()

void TProtoQuanti::inherit_low	(	sex_t	SEX,
		TTQuanti *	ind,
		const TTQuanti *	parent
	)

inline

 {
   unsigned int prevLoc = 0;
  
   //the table containing the loci at which x-overs happen
   vector< pair<unsigned int, unsigned int> > recTable = _map.reduceJunctions(SEX, _mapIndex);
  
  
 #ifdef _REC_DEBUG_
   //number of x-overs
   unsigned int nbRec = recTable.size();
   cout << "TProtoQuanti::inherit_low; nb Rec = "<<nbRec - 1<<endl;
   cout << "   --sex = "<<SEX<<"\n";
 #endif
  
 //  unsigned int num_copied = 0;
  
   vector< pair<unsigned int, unsigned int> >::const_iterator xover = recTable.begin();
  
   while(xover != recTable.end()) {
  
 #ifdef _REC_DEBUG_
       cout<< "   copy seq from "<<prevLoc<<" to "<<xover->first
           <<" ("<<(xover->first - prevLoc)<<" loc) ("
           <<(xover->first - prevLoc)*_sizeofLocusType
           <<"B) on side "<<xover->second<<std::endl;
 #endif
  
     ind->copy_sequence_block(SEX, xover->second, prevLoc, xover->first, parent);
  
     prevLoc = xover->first;
  
     xover++;
   }
 }

References TTProtoWithMap::_map, TTProtoWithMap::_mapIndex, _sizeofLocusType, TTQuanti::copy_sequence_block(), and GeneticMap::reduceJunctions().

Referenced by setGeneticMapParams().

◆ loadFileServices()

void TProtoQuanti::loadFileServices ( FileServices * loader )

virtual

Implements SimComponent.

 {
   int logtime = 0;
  
   //writer
   // purge previous settings:
   if(_writer) delete _writer;
   _writer = NULL;
  
   if(get_parameter("quanti_output")->isSet()) {
  
     _writer = new TTQuantiFH(this);
  
     if(get_parameter("quanti_output")->getArg().find("snp_") != string::npos && get_allele_model() > 2) {
       fatal("parameter \"quanti_output\" option \"%s\" can only be selected for di-allelic quantitative loci\n",
           get_parameter("quanti_output")->getArg().c_str());
     }
  
     _writer->setOutputOption(get_parameter("quanti_output")->getArg());
  
     if(!get_parameter("quanti_logtime")->isSet())
       fatal("quant trait::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(), this);
  
     } 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);
  
   }
  
   //freq extractor
   if(_freqExtractor) delete _freqExtractor;
   _freqExtractor = NULL;
  
   if(get_parameter("quanti_freq_output")->isSet()) {
  
     if(get_allele_model() > 2) {
  
       error("option \"quanti_freq_output\" only works with di-allelic quantitative loci. This option will be ignored.\n");
  
     }else {
  
       _freqExtractor = new TTQFreqExtractor(this);
  
       _freqExtractor->resetTable();
  
       Param* param = get_parameter("quanti_freq_logtime");
  
       if(!param->isSet())
          fatal("quant trait::parameter \"quanti_freq_logtime\" is missing!\n");
  
       if(param->isMatrix())
         fatal("parameter \"quanti_freq_logtime\" only accepts a single log-time value and not an array of values.\n\
             A single '.qfreq' output file contains the allele frequencies computed every log-time generation.\n");
  
       logtime = (int)param->getValue();
  
       //save multiple generations in a single file:
       _freqExtractor->set(true, true, 1, logtime, 0, get_parameter("quanti_dir")->getArg(),this);
  
       loader->attach(_freqExtractor);
     }
  
   }
  
   // Ohta's (1982) D statistics
   if(_ohtaStats) delete _ohtaStats;
   _ohtaStats = NULL;
  
   if(get_parameter("quanti_ohta_output")->isSet()) {
  
     if ((_allele_model > 2) || (_num_traits > 1) || (SIMenv::MainSim->get_pop()->getPatchNbr() < 2)) {
       fatal("output option \"quanti_ohta_output\" is only valid for diallelic QTL affecting one trait in multiple patches!\n");
     }
  
     _ohtaStats = new TTQOhtaStats(this);
  
     Param* param = get_parameter("quanti_ohta_logtime");
  
     if(!param->isSet())
        fatal("quant trait::parameter \"quanti_ohta_logtime\" is missing!\n");
  
     if(param->isMatrix()) {
  
       TMatrix temp;
       param->getMatrix(&temp);
       _ohtaStats->set_multi(true, true, 1, &temp, get_parameter("quanti_dir")->getArg(), this);
  
     } else   //  rpl_per, gen_per, rpl_occ, gen_occ, rank (0), path, self-ref
       _ohtaStats->set(true, true, 1, (param->isSet() ? (int)param->getValue() : 0),
                    0, get_parameter("quanti_dir")->getArg(),this);
  
     loader->attach(_ohtaStats);
   }
  
   //load the reader:
   if(_reader) delete _reader;
   _reader = new TTQuantiFH(this);
   _reader->set_isInputHandler(true);
   loader->attach_reader(_reader);
 }

References _allele_model, _freqExtractor, _num_traits, _ohtaStats, _reader, _writer, FileServices::attach(), FileServices::attach_reader(), error(), fatal(), get_allele_model(), SimComponent::get_parameter(), Param::getArg(), Param::getMatrix(), Param::getValue(), Param::isMatrix(), Param::isSet(), SIMenv::MainSim, TTQFreqExtractor::resetTable(), TraitFileHandler< TP >::set(), FileHandler::set_isInputHandler(), TraitFileHandler< TP >::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().

◆ mutate_diallelic_no_pleio()

void TProtoQuanti::mutate_diallelic_no_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations(); //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all;
  
   while(NbMut != 0) {
  
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     // here just flips the bit at the mutating allele, value argument is ignored
     ind->mutate_inplace( mut_locus, mut_all, 1);
  
     NbMut--;
   }
  
 }

References _num_locus, get_num_mutations(), TTQuanti::mutate_inplace(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_no_pleio().

◆ mutate_diallelic_pleio()

void TProtoQuanti::mutate_diallelic_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all, pos;
   bool allele;
  
   while(NbMut != 0) {
  
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool(); // which of the two copies is mutated
  
     pos = mut_locus*_num_traits; //where it stands in the sequence (full pleio)
  
     allele = !(ind->get_allele_bit(pos, mut_all));
  
     // flip the bit, mutate to the alt. allele
     ind->mutate_inplace( pos, mut_all, allele);
  
     // There cannot be more than two traits in this case, as set during startup
     // set second value:
     pos++;
     // The allele affecting the second trait may receive the same mutation depending on the
     // mutational correlation
     if(RAND::Uniform() < _mutation_correlation.get(0,0))
       ind->set_allele_bit(pos, mut_all, allele); // calling ind->mutate_add(pos,...) would be equivalent
     else
       ind->set_allele_bit(pos, mut_all, RAND::RandBool()); // may or may not flip the bit, avoids spurious correlation
  
     NbMut--;
   }
  
 }

References _mutation_correlation, _num_locus, _num_traits, TMatrix::get(), TTQuanti::get_allele_bit(), get_num_mutations(), TTQuanti::mutate_inplace(), RAND::RandBool(), TTQuanti::set_allele_bit(), and RAND::Uniform().

Referenced by setMutationModel_full_pleio().

◆ mutate_diallelic_var_pleio()

void TProtoQuanti::mutate_diallelic_var_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all, pos;
  
   while(NbMut != 0) {
  
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     pos = _locus_table[mut_locus][0];
  
     ind->mutate_inplace(pos, mut_all, 1); // value argument is ignored, flips the bit
  
     if(_locus_table[mut_locus][1] == 2) { // only degree of pleiotropy allowed
  
       pos++;
  
       if(RAND::Uniform() < _mutation_correlation.get(0,0))
         ind->set_allele_bit(pos, mut_all, ind->get_allele_bit(pos-1, mut_all));
       else
         ind->set_allele_bit(pos, mut_all, RAND::RandBool()); //avoids spurious correlations
     }
  
     NbMut--;
   }
  
 }

References _locus_table, _mutation_correlation, _num_locus, TMatrix::get(), TTQuanti::get_allele_bit(), get_num_mutations(), TTQuanti::mutate_inplace(), RAND::RandBool(), TTQuanti::set_allele_bit(), and RAND::Uniform().

Referenced by setMutationModel_var_pleio().

◆ mutate_full_pleio()

void TProtoQuanti::mutate_full_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all, pos;
   double *effects;
  
   while(NbMut != 0) {
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     effects = (this->*_getMutationValues)(mut_locus);
  
     pos = mut_locus*_num_traits;
  
     //cycle through all alleles at the mutated locus, depending on the PD of the locus
     for(unsigned int i = 0; i < _num_traits; ++i, ++pos) {
       ind->mutate_add( pos, mut_all, effects[i]);
     }
  
     NbMut--;
   }
  
 }

References _getMutationValues, _num_locus, _num_traits, get_num_mutations(), TTQuanti::mutate_add(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_full_pleio().

◆ mutate_inplace_full_pleio()

void TProtoQuanti::mutate_inplace_full_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all, pos;
   double *effects;
  
   while(NbMut != 0) {
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     effects = (this->*_getMutationValues)(mut_locus);
  
     pos = mut_locus*_num_traits; //start location of the locus in the sequence
  
     //cycle through all alleles at the mutated locus, depending on the PD of the locus
     for(unsigned int i = 0; i < _num_traits; ++i, ++pos) {
       ind->mutate_inplace( pos, mut_all, effects[i]);
     }
  
     NbMut--;
   }
 }

References _getMutationValues, _num_locus, _num_traits, get_num_mutations(), TTQuanti::mutate_inplace(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_full_pleio().

◆ mutate_inplace_no_pleio()

void TProtoQuanti::mutate_inplace_no_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all;
   double *effects;
  
   while(NbMut != 0) {
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     effects = (this->*_getMutationValues)(mut_locus);
  
     ind->mutate_inplace( mut_locus, mut_all, effects[0]);
  
     NbMut--;
   }
 }

References _getMutationValues, _num_locus, get_num_mutations(), TTQuanti::mutate_inplace(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_no_pleio().

◆ mutate_inplace_var_pleio()

void TProtoQuanti::mutate_inplace_var_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all, pos;
   double *effects;
  
   while(NbMut != 0) {
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     effects = (this->*_getMutationValuesVarPleio[mut_locus])(mut_locus);
  
     pos = _locus_table[mut_locus][0];
  
     for(unsigned int i = 0; i < _locus_table[mut_locus][1]; ++i, ++pos){
       ind->mutate_inplace( pos, mut_all, effects[i]);
     }
  
     NbMut--;
   }
 }

References _getMutationValuesVarPleio, _locus_table, _num_locus, get_num_mutations(), TTQuanti::mutate_inplace(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_var_pleio().

◆ mutate_nill()

void TProtoQuanti::mutate_nill ( TTQuanti * ind )

inline

 {
   //nill
 }

Referenced by setMutationModel_full_pleio(), setMutationModel_no_pleio(), and setMutationModel_var_pleio().

◆ mutate_no_pleio()

void TProtoQuanti::mutate_no_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations(); //(unsigned int)RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all;
   double *effects;
  
   while(NbMut != 0) {
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     effects = (this->*_getMutationValues)(mut_locus);
  
     ind->mutate_add( mut_locus, mut_all, effects[0]);
  
     NbMut--;
   }
  
 }

References _getMutationValues, _num_locus, get_num_mutations(), TTQuanti::mutate_add(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_no_pleio().

◆ mutate_var_pleio()

void TProtoQuanti::mutate_var_pleio ( TTQuanti * ind )

inline

 {
   unsigned int NbMut = get_num_mutations();  //RAND::Poisson(_genomic_mutation_rate);
   unsigned int mut_locus, mut_all, pos;
   double *effects;
  
   while(NbMut != 0) {
  
     mut_locus = RAND::Uniform(_num_locus);
     mut_all = RAND::RandBool();
  
     effects = (this->* _getMutationValuesVarPleio[mut_locus])(mut_locus);
  
     pos = _locus_table[mut_locus][0];
  
     //cycle through all alleles at the mutated locus, depending on the PD of the locus
     for(unsigned int i = 0; i < _locus_table[mut_locus][1]; ++i, ++pos) {
       ind->mutate_add( pos, mut_all, effects[i]);
     }
  
     NbMut--;
   }
 }

References _getMutationValuesVarPleio, _locus_table, _num_locus, get_num_mutations(), TTQuanti::mutate_add(), RAND::RandBool(), and RAND::Uniform().

Referenced by setMutationModel_var_pleio().

◆ readMatrixFromQuantiMutationMatrix()

bool TProtoQuanti::readMatrixFromQuantiMutationMatrix ( vector< vector< double >> & varmat )

 {
 //  message("quant::found \"quanti_mutation_matrix\" in input, analyzing the matrix for pleiotropic loci\n");
  
   get_parameter("quanti_mutation_matrix")->getVariableMatrix(&varmat);
  
   // check dimensionality of the matrix: ------------------------------------------------
   size_t numRows = varmat.size();
   size_t numEl;
   size_t maxNumEl = varmat[0].size(); //number of elements in the first row, as a start
   bool rowsAreDifferent = false;
  
   int numCovariance = (_num_traits - 1)*_num_traits/2; // number of off-diagonal elements
  
   for(size_t i = 0; i < numRows; ++i) {
  
     numEl = varmat[i].size();
  
     if(_pleio_type == 1) {  //full pleio
       if( numEl != _num_traits && numEl != numCovariance + _num_traits) {
         return error("number of values in \"quanti_mutation_matrix\" at row %i \
 does not match with the pleiotropic degree of %i. Rows must contain either %i or %i variance-covariance values.\n",
 i+1, _num_traits, _num_traits, _num_traits + numCovariance);
       }
     }
  
     if(maxNumEl != numEl) rowsAreDifferent = true;
  
     maxNumEl = max(numEl, maxNumEl);
  
   }
  
   // assess if locus-specific matrices have been provided:
   if(numRows == _num_traits && maxNumEl == _num_traits && !rowsAreDifferent) {
  
 //    if(_pleio_type == 1)
 //      message("quant::\"quanti_mutation_matrix\" is a single square, num. traits x num. traits matrix. It will be used for all loci equally.\n");
  
     if(_pleio_type == 2)
       warning("\"quanti_mutation_matrix\" is a single square, num. traits x num. traits matrix but loci have variable pleiotropy. \
 The matrix will be interpreted as a set of locus-specific mutation matrices.");
  
     _mutationVarianceIsLocusSpecific = false;
  
   } else {
  
 //    message("quant::\"quanti_mutation_matrix\" is not a square, num. traits x num. traits matrix. Rows will be treated as locus-specific mutation matrices.");
  
     if( numRows > _num_locus )
       return error("\"quanti_mutation_matrix\" has too many rows, it must be a matrix with max num. rows = \"quanti_loci\" or \"quanti_traits\" \n");
  
     _mutationVarianceIsLocusSpecific = true;
   }
  
   return true;
 }

References _mutationVarianceIsLocusSpecific, _num_locus, _num_traits, _pleio_type, error(), SimComponent::get_parameter(), Param::getVariableMatrix(), and warning().

Referenced by setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ reset()

virtual void TProtoQuanti::reset ( )

inlinevirtual

Reimplemented from TTProtoWithMap.

573 {TTProtoWithMap::reset();}

TTProtoWithMap::reset

virtual void reset()

Definition: ttrait_with_map.cc:638

References TTProtoWithMap::reset().

◆ resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

597 {return false;}

◆ retrieve_data()

virtual bool TProtoQuanti::retrieve_data ( BinaryStorageBuffer * reader )

inlinevirtual

Implements StorableComponent.

590 {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 to be the element's index
     _eVariance.push_back(SD);
   else
     _eVariance[trait] = SD;
 }

References _eVariance.

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

◆ set_genotype_value_additive()

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

 {
   return ind->get_additive_genotype(trait);
 }

References TTQuanti::get_additive_genotype().

Referenced by setParameters().

◆ set_genotype_value_dominance()

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

 {
   return ind->get_dominant_genotype(trait);
 }

References TTQuanti::get_dominant_genotype().

Referenced by setParameters().

◆ set_gsl_mutation_matrix()

gsl_matrix * TProtoQuanti::set_gsl_mutation_matrix	(	unsigned int	pleio_deg,
		const vector< double > &	varcov
	)

 {
   // varcov must be a one-line matrix
   unsigned int numCovariance = (pleio_deg - 1)*pleio_deg/2; // number of off-diagonal elements
   unsigned int cov_pos = pleio_deg; //first covariance term in the array
   size_t numEl = varcov.size(); //dimension check has been done already
  
   gsl_matrix* mat = gsl_matrix_alloc(pleio_deg, pleio_deg);
  
   for(unsigned int i = 0; i < pleio_deg; ++i){
  
     //set the diagonal = variances, we know they are the first pleio_deg elements in the matrix
     gsl_matrix_set(mat,i,i,varcov[i]);
  
     if (numEl == numCovariance + pleio_deg ) { // covariance values also provided, set the off-diagonal
  
       //setting covariance given in input as: e.g. {{v1,v2,v3,cov12,cov13,cov23}} with pleio_deg = 3
       for(unsigned long int j = i+1; j < pleio_deg && cov_pos < numEl; ++j){
         gsl_matrix_set(mat,i,j,varcov[cov_pos]);
         gsl_matrix_set(mat,j,i,varcov[cov_pos++]); // the matrix is symmetrical
       }
  
     } else {
       // no covariance provided in input, set off-diagonal to zero
       for(unsigned long int j = i+1; j < pleio_deg ; ++j){
         gsl_matrix_set(mat,i,j,0);
         gsl_matrix_set(mat,j,i,0); // the matrix is symmetrical
       }
  
     }
   }
  
   return mat;
 }

Referenced by set_gsl_mutation_matrix_from_sigma(), setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ set_gsl_mutation_matrix_from_sigma()

gsl_matrix * TProtoQuanti::set_gsl_mutation_matrix_from_sigma	(	unsigned int	loc,
		unsigned int	pleio_deg
	)

 {
   // variance are identical across traits (in a row of _mutation_sigma) at this stage (mutation_matrix not set in input)
  
   unsigned int numCov = (pleio_deg-1)*pleio_deg / 2;
  
   vector<double> varcov(pleio_deg + numCov);
  
   // fill in the varcov array as a one-line matrix {{var1, var2, ..., covar12, covar13, ...}}
  
   // must be carefull as the mutation_sigma matrix may have only one row if variances are not locus specific
   // check for locus specificity:
   unsigned int pos = (_mutationVarianceIsLocusSpecific ? loc : 0);
  
   unsigned int cov_pos = pleio_deg; //starting place where covariance are recorded, after the variances
  
   for(unsigned int i = 0; i < pleio_deg; ++i) {
     varcov[i] = _mutation_sigma.get(pos, i)*_mutation_sigma.get(pos, i);
  
     for(unsigned int j = i; j < pleio_deg - 1 && cov_pos < (pleio_deg + numCov); ++j)
       varcov[cov_pos++] = _mutation_correlation.get(0, loc) * _mutation_sigma.get(pos, i)*_mutation_sigma.get(pos, j+1);
   }
  
 #ifdef _DEBUG_
   message("quanti:: Locus %i\n--setting mutation matrix from mutation variance and correlation\n", loc+1);
   message("-- one-line reduced matrix:\n");
   for(unsigned int i = 0; i < varcov.size(); ++i)
     message("%.3f ",varcov[i]);
   message("\n");
 #endif
  
   return set_gsl_mutation_matrix(pleio_deg, varcov);
 }

References _mutation_correlation, _mutation_sigma, _mutationVarianceIsLocusSpecific, TMatrix::get(), message(), and set_gsl_mutation_matrix().

Referenced by setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ set_init_values()

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

 {
   assert(nval == _num_traits);
  
   _init_value.reset(1, _num_traits, values);
  
 }

References _init_value, _num_traits, and TMatrix::reset().

Referenced by LCE_QuantiInit::execute().

◆ set_mutation_matrix_decomposition()

void TProtoQuanti::set_mutation_matrix_decomposition	(	unsigned int	loc,
		unsigned int	pleio_deg
	)

 {
   _evect[loc] = gsl_matrix_alloc(pleio_deg, pleio_deg);
   _eval[loc] = gsl_vector_alloc(pleio_deg);
   _effects_multivar[loc] = gsl_vector_alloc(pleio_deg);
   _ws[loc] = gsl_vector_alloc(pleio_deg);
  
   gsl_matrix *E = gsl_matrix_alloc(pleio_deg, pleio_deg);
   gsl_matrix_memcpy(E,_gsl_mutation_matrix[loc]);
   gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (pleio_deg);
   gsl_eigen_symmv (E, _eval[loc], _evect[loc], w);
   gsl_eigen_symmv_free (w);
   gsl_matrix_free(E);
  
  #ifdef _DEBUG_
    message("-- Mutation matrix eigenvalues:\n");
    for(unsigned int i = 0; i < pleio_deg; i++)
      cout<<gsl_vector_get(_eval[loc],i)<<" ";
    cout<<endl;
  #endif
  
    double eval;
    //take square root of eigenvalues, will be used in Gaussian as stdev
    for(unsigned int i = 0; i < pleio_deg; i++) {
  
      // check for positive matrix
      if(gsl_vector_get(_eval[loc],i) < 0)
        fatal("quanti::the mutation matrix is not a positive matrix (at least one eigenvalue is negative)\n\
             Please correct the values inside the matrix provided in input.\n");
  
      eval = gsl_vector_get(_eval[loc],i);
      eval = (eval < 0.000001 ? 0 : eval);
      gsl_vector_set( _eval[loc], i, sqrt(eval) );
    }
  
  #ifdef _DEBUG_
    // DEBUG OUTPUT ------------------------------------------------------
    cout << "_gsl_mutation_matrix eigen values (sqrt-ed): ";
    for(unsigned int i = 0; i < pleio_deg; i++)
      cout<<gsl_vector_get(_eval[loc],i)<<" ";
    cout << "\n_gsl_mutation_matrix eigen vectors: \n";
    for(unsigned int i = 0; i < pleio_deg; i++){
      for(unsigned int j = 0; j < pleio_deg; j++){
        cout<<gsl_matrix_get(_evect[loc],i,j)<<" | ";
      }
      cout<<endl;
    }
  #endif
  
 }// ----------------------------------------------------------------------------------------

References _effects_multivar, _eval, _evect, _gsl_mutation_matrix, _ws, fatal(), and message().

Referenced by setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

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

◆ set_trait_value_noVE()

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

inline

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

References _set_genotype_func_ptr.

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

◆ set_trait_value_VE()

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

inline

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

◆ setAlleleModel()

unsigned int TProtoQuanti::setAlleleModel ( )

 {
   string model("continuous");
  
   unsigned int ret_val;
  
   //checking allelic model
   if (get_parameter("quanti_allele_model")->isSet()) {
  
     model = get_parameter("quanti_allele_model")->getArg();
  
     //---------------------------------------------------------------------------------------
     // DIALLELIC MODELS
  
     if (model == "diallelic" || model == "diallelic_HC") {  //for backward-compatibility with v <2.4.0
  
       // symmetrical allelic values are centered on zero with -a/+a values
  
       if(get_parameter("quanti_init_value")->isSet()){
         error("\"quanti_allele_model diallelic\" needs to be initialized with \"quanti_init_freq\" provided by LCE \"quanti_init\" instead of \"quanti_init_value\". \n");
       }
  
       ret_val = 1;
  
     } else if (model == "diallelic_asymmetrical") {
  
       // asymmetrical model allows for two arbitrary allelic values a/b at a locus
  
       if(get_parameter("quanti_init_value")->isSet()){
         error("\"quanti_allele_model diallelic_HC\" needs to be initialized with \"quanti_init_freq\" provided by LCE \"quanti_init\" instead of \"quanti_init_value\". \n");
       }
  
       ret_val = 2;
  
       //---------------------------------------------------------------------------------------
       // CONTIUUM OF ALLELE MODELS
  
     } else if (model == "continuous") {
  
       ret_val = 3;
  
     } else if (model == "continuous_in_place" || model == "continuous_HC") { //for backward-compatibility with v <2.4.0
  
       ret_val = 4;
  
  
     } else {
       return error("\"quanti_allele_model\" has options \"diallelic\", \"diallelic_asymmetrical\", \"continuous\" or \"continuous_in_place\". \n");
     }
  
   }
   else { //default model: 'continuous"
     ret_val = 3;
   }
  
  
 #ifdef _DEBUG_
   message("quant::allele model is \"%s\"\n",model.c_str());
 #endif
   return ret_val;
 }

References error(), SimComponent::get_parameter(), Param::getArg(), and message().

Referenced by setParameters().

◆ setContinuousMutationModel_full_pleio()

bool TProtoQuanti::setContinuousMutationModel_full_pleio ( )

 {
   //setting the mutation variance-covariance matrix
  
   // the pointer has been freed previously by a call to TProtoQuanti::deallocate_gsl_mutation_matrix_space in TProtoQuanti::setMutationParameters
   // we double-check with assert
   assert(_gsl_mutation_matrix == NULL);
   assert(_eval == NULL);
   assert(_evect == NULL);
   assert(_effects_multivar == NULL);
   assert(_ws == NULL);
  
   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 are passed as single values because they apply to all traits equally
       // the sqrt-variance(s) are stored in _mutation_sigma, can be locus-specific
  
       if(!setMutationSigmaFromQuantiMutationVariance()) return false;
  
       //check if variance are locus-specific
       _mutationVarianceIsLocusSpecific = (_mutation_sigma.nrows() > 1);
  
       // pleiotropic loci for more than 2 traits, we need the full mutation matrix:
       if(_num_traits > 2) {
  
         //setting the mutation matrix
  
         if(_mutationVarianceIsLocusSpecific) {
  
           // allocate memory for one m-matrix per locus
           allocate_gsl_mutation_matrix_space(_num_locus);
  
           for(unsigned int l = 0; l < _num_locus; ++l) {
             _gsl_mutation_matrix[l] = set_gsl_mutation_matrix_from_sigma(l, _num_traits);
  
             set_mutation_matrix_decomposition(l, _num_traits);
           }
  
         } else { // !_mutationVarianceIsLocusSpecific
  
           // allocate memory for a single mutation matrix used for all loci
           allocate_gsl_mutation_matrix_space(1);
  
           _gsl_mutation_matrix[0] = set_gsl_mutation_matrix_from_sigma(0, _num_traits);
  
           set_mutation_matrix_decomposition(0, _num_traits);
         }
       }
     }
   } //_end_ if quanti_mutation_variance is set
  
   if(get_parameter("quanti_mutation_matrix")->isSet()) {
  
     // full mutation matrix given in input, we need to check what kind of matrix is passed (if locus-specific or not)
     vector< vector<double> > _mut_matrix;
  
     // check the structure of the matrix passed in input, and set the locus-specific flag
     if(!readMatrixFromQuantiMutationMatrix(_mut_matrix)) return false;
  
     // fill and create mutation matrices --------------------------------------------------
     int loc_pos;
     size_t numRows = _mut_matrix.size();
  
     if(_mutationVarianceIsLocusSpecific) {
       // set a new mutation matrix for each locus separately
       //each row of the input matrix will be used as a locus-specific m-matrix
       allocate_gsl_mutation_matrix_space(_num_locus);
  
       _mutation_sigma.reset(_num_locus, _num_traits); // this is used when PD = 2 or 1
  
       // checking that _mutation_correlation has been set:
       if(_mutation_correlation.ncols() != _num_locus) _mutation_correlation.reset(1,_num_locus);
  
       for(unsigned int loc = 0; loc < _num_locus; loc++){
  
         loc_pos = loc % numRows; //user may pass only a few rows that will be repeated across loci
  
         for(unsigned int i = 0; i < _num_traits; i++)  // first _num_traits elements are the per-trait mut variance
           _mutation_sigma.set(loc, i, sqrt(_mut_matrix[loc_pos][i]));
  
         //set the locus-specific mutation matrix:
         _gsl_mutation_matrix[loc] = set_gsl_mutation_matrix(_num_traits, _mut_matrix[loc_pos]);
  
         if(_num_traits == 2) {  // special case for bivariate Gaussian models
  
           _mutation_correlation.set(0, loc, gsl_matrix_get(_gsl_mutation_matrix[loc],0,1) / _mutation_sigma.get(loc,0) / _mutation_sigma.get(loc,1));
  
         } else {
  
           set_mutation_matrix_decomposition(loc, _num_traits);
         }
  
 #ifdef _DEBUG_
         cout << "\n-- _gsl_mutation_matrix for locus " << loc+1 << " \n";
         for(unsigned int i=0; i<_num_traits; ++i){
           for(unsigned int j=0; j<_num_traits; ++j){
             cout << gsl_matrix_get(_gsl_mutation_matrix[loc],i,j) << " | ";
           }
           cout << endl;
         }
  
         message("-- M-matrix decomposition:\n");
         for(unsigned int i = 0; i < _num_traits; i++)
           cout<<gsl_vector_get(_eval[loc],i)<<" ";
         cout<<endl;
         if(_num_traits == 2) message("-- mutation correlation: %f\n",_mutation_correlation.get(0,loc));
 #endif
       } //END for locus
  
     } else { //mutation is not locus-specific
       //create a single mutation matrix
       allocate_gsl_mutation_matrix_space(1);
  
       _mutation_sigma.reset(1, _num_traits); // this is used when PD = 2 or 1
  
       for(unsigned int i = 0; i < _num_traits; i++)  // the diagonal of the input matrix elements are the per-trait mut variance
         _mutation_sigma.set(0, i, sqrt(_mut_matrix[i][i]));
  
       //set the mutation matrix: we have to read the input matrix as a full square matrix, not as an array-matrix
       _gsl_mutation_matrix[0] = gsl_matrix_alloc(_num_traits, _num_traits);
  
       //easiest is to read the input matrix into a TMatrix object (we know it isn't a variable matrix by now)
       TMatrix mat;
       get_parameter("quanti_mutation_matrix")->getMatrix(&mat);
  
       //convert it into a gsl_matrix
       mat.get_gsl_matrix(_gsl_mutation_matrix[0]);
  
       if(_num_traits == 2) {  // special case for bivariate Gaussian models
  
         // reset the _mutation_correlation matrix for non-locus specific case:
         _mutation_correlation.reset(1,1);
  
         _mutation_correlation.set(0, 0, gsl_matrix_get(_gsl_mutation_matrix[0],0,1) / _mutation_sigma.get(0,0) / _mutation_sigma.get(0,1));
  
       } else { // more traits
  
         set_mutation_matrix_decomposition(0, _num_traits);
       }
  
  
 #ifdef _DEBUG_
     message("-- Mutation matrix:\n");
     mat.show_up();
     message("-- M-matrix decomposition:\n");
     for(unsigned int i = 0; i < _num_traits; i++)
       cout<<gsl_vector_get(_eval[0],i)<<" ";
     cout<<endl;
     if(_num_traits == 2) message("-- mutation correlation: %f\n",_mutation_correlation.get(0,1));
 #endif
  
     }
   } // END if(get_parameter("quanti_mutation_matrix")->isSet())
   else if(!get_parameter("quanti_mutation_variance")->isSet()) {
     return error("\"quanti_mutation_matrix\" or \"quanti_mutation_variance\" must be specified!\n");
   }
  
   return true;
 }

References _effects_multivar, _eval, _evect, _gsl_mutation_matrix, _mutation_correlation, _mutation_sigma, _mutationVarianceIsLocusSpecific, _num_locus, _num_traits, _ws, allocate_gsl_mutation_matrix_space(), error(), TMatrix::get(), SimComponent::get_parameter(), Param::getMatrix(), message(), TMatrix::ncols(), TMatrix::nrows(), readMatrixFromQuantiMutationMatrix(), TMatrix::reset(), TMatrix::set(), set_gsl_mutation_matrix(), set_gsl_mutation_matrix_from_sigma(), set_mutation_matrix_decomposition(), setMutationSigmaFromQuantiMutationVariance(), TMatrix::show_up(), and warning().

Referenced by setMutationModel_full_pleio().

◆ setContinuousMutationModel_no_pleio()

bool TProtoQuanti::setContinuousMutationModel_no_pleio ( )

 {
   //setting the mutation variance 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, not using the matrix in the non-pleiotropic case!\n");
  
     }
       // the variance are passed as single values because they apply to all traits equally
       // the sqrt-variance(s) are stored in _mutation_sigma, can be locus-specific
 #ifdef _DEBUG_
     message("quant::setting mutation variance (param is set).\n");
 #endif
  
       if(!setMutationSigmaFromQuantiMutationVariance_no_pleio()) return false;
  
       //check if variance are locus-specific
       _mutationVarianceIsLocusSpecific = (_mutation_sigma.nrows() > 1);
  
   } //_end_ if quanti_mutation_variance is set
  
   else if(get_parameter("quanti_mutation_matrix")->isSet()) {
  
     return error("quant::parameter \"quanti_mutation_matrix\" is not used under non-pleiotropic model, use \"quanti_mutation_variance\" instead.\n");
  
   } // END if(get_parameter("quanti_mutation_matrix")->isSet())
   else if(!get_parameter("quanti_mutation_variance")->isSet()) {
     return error("\"quanti_mutation_variance\" must be specified for the non-pleiotropic model of quantitative loci!\n");
   }
  
   return true;
 }

References _mutation_sigma, _mutationVarianceIsLocusSpecific, error(), SimComponent::get_parameter(), Param::isSet(), message(), TMatrix::nrows(), setMutationSigmaFromQuantiMutationVariance_no_pleio(), and warning().

Referenced by setMutationModel_no_pleio().

◆ setContinuousMutationModel_var_pleio()

bool TProtoQuanti::setContinuousMutationModel_var_pleio ( )

 {
 //  cout << "TProtoQuanti::setContinuousMutationModel_var_pleio\n";
  
   // the pointer has been freed previously in TProtoQuanti_var_pleio::setMutationParameters
   // we double-check with assert
   assert(_gsl_mutation_matrix == NULL);
   assert(_eval == NULL);
   assert(_evect == NULL);
   assert(_effects_multivar == NULL);
   assert(_ws == NULL);
  
   // allocate memory
   allocate_gsl_mutation_matrix_space(_num_locus);
  
   unsigned int pleio_deg;
  
   //setting the mutation variance
   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 are passed as single values because they apply to all traits equally
       // the sqrt-variance(s) are stored in _mutation_sigma, can be locus-specific
  
       if(!setMutationSigmaFromQuantiMutationVariance()) return false;
  
       //check if variance are locus-specific
       _mutationVarianceIsLocusSpecific = (_mutation_sigma.nrows() > 1);
  
       // we need one m-matrix per locus if locus is pleiotropic
       // even if all have same variance and _mutationVarianceIsLocusSpecific = false bcse PD varies among loci
       for(unsigned int loc = 0; loc < _num_locus; loc++){
  
         pleio_deg = _locus_table[loc][1];
  
         if(pleio_deg > 1) {
           //set the M-matrix for all pleiotropic loci, even though it is not used when PD == 2
           //setting the mutation matrix
           _gsl_mutation_matrix[loc] = set_gsl_mutation_matrix_from_sigma(loc , pleio_deg);
  
           set_mutation_matrix_decomposition(loc, pleio_deg);
  
  
 #ifdef _DEBUG_
           cout << "_gsl_mutation_matrix for locus " << loc+1 << " \n";
           for(unsigned int i=0; i<pleio_deg; ++i){
             for(unsigned int j=0; j<pleio_deg; ++j){
               cout << gsl_matrix_get(_gsl_mutation_matrix[loc],i,j) << " | ";
             }
             cout << endl;
           }
 #endif
  
         } // END if PD > 1
       } // END for locus
     } // END if get_parameter("quanti_mutation_matrix")->isSet()
   } // END if(get_parameter("quanti_mutation_variance")->isSet())
  
  
  
   if(get_parameter("quanti_mutation_matrix")->isSet()) {
  
     vector< vector<double> > _mut_matrix;
  
     if(!readMatrixFromQuantiMutationMatrix(_mut_matrix)) return false;
  
     // we will store sigma in case some loci have PD = 1 or PD = 2
     _mutation_sigma.reset(_num_locus, _num_traits);
  
     // checking that _mutation_correlation has been set:
     if(_mutation_correlation.ncols() != _num_locus) _mutation_correlation.reset(1,_num_locus);
  
     int numVarInRow;
     int numRows = _mut_matrix.size();
     int numCovariance;
     int loc_pos;
  
     // set the mutation matrix for each locus separately
     for(unsigned int loc = 0; loc < _num_locus; loc++){
  
       pleio_deg = _locus_table[loc][1];
  
       loc_pos = loc % numRows; //user may pass only one row that will be repeated for all loci
  
       numVarInRow = _mut_matrix[loc_pos].size();       // number of diagonal elements
       numCovariance = (pleio_deg - 1)*pleio_deg/2; // number of off-diagonal elements
  
       // we accept 1 value (same var on all traits, no covar), pleio_deg values, or pleio_deg +numCovariance values:
       if( numVarInRow > 1 && numVarInRow != (int)pleio_deg && numVarInRow != (numCovariance + (int)pleio_deg) ){
         return error("number of values (%i) for locus %i in \"quanti_mutation_matrix\" at row %i \
 does not match with its pleiotropic degree of %i \n", numVarInRow, loc+1, loc_pos+1, pleio_deg);
       }
  
 #ifdef _DEBUG_
       //    Print out mut_matrix for debugging purposes
       message("\nquant::input M-matrix for locus %i\n", loc_pos+1);
       for(unsigned int j=0; j<_mut_matrix[loc_pos].size(); ++j){
         message("%.3f | ",_mut_matrix[loc_pos][j]);
       }
       message("\n");
 #endif
  
       // we build the varcov vector in case only a single variance was passed:
       vector<double> varcov(pleio_deg);
  
       for(unsigned int i = 0; i < pleio_deg; i++) { // first pleio_deg elements are the per-trait mut variance
         _mutation_sigma.set(loc, i, sqrt(_mut_matrix[loc_pos][ i%numVarInRow]) ); //recycle if single value passed
         varcov[i] = _mut_matrix[loc_pos][ i%numVarInRow];
       }
       //set the mutation matrix: we either pass a pleio_deg copied set of a single variance or the original M-matrix
       _gsl_mutation_matrix[loc] = set_gsl_mutation_matrix(pleio_deg, (numVarInRow == 1 ? varcov : _mut_matrix[loc_pos] ) );
  
       set_mutation_matrix_decomposition(loc, pleio_deg);
  
       if(pleio_deg == 2) {  // special case for bivariate Gaussian models
         _mutation_correlation.set(0, loc, gsl_matrix_get(_gsl_mutation_matrix[loc],0,1) / _mutation_sigma.get(loc,0) / _mutation_sigma.get(loc,1));
       }
  
 #ifdef _DEBUG_
       message("quant::GSL M-matrix for locus %i\n", loc+1);
       for(unsigned int i=0; i<pleio_deg; ++i){
         for(unsigned int j=0; j<pleio_deg; ++j){
           message("%.3f | ",gsl_matrix_get(_gsl_mutation_matrix[loc],i,j));
         }
         message("\n");
       }
 #endif
  
  
 #ifdef _DEBUG_
       message("-- Mutation matrix for locus %i with PD=%i:\n", loc+1, pleio_deg);
       //  _mutation_matrix[loc].show_up();
       message("-- MMatrix decomposition:\n");
       for(unsigned int i = 0; i < pleio_deg; i++)
         message("%.3f ", gsl_vector_get(_eval[loc],i));
       cout<<endl;
       if(_num_traits == 2)
         message("-- mutation correlation: %f\n", _mutation_correlation.get(0,loc) ) ;
 #endif
  
     } //END for locus
  
   } // END if(get_parameter("quanti_mutation_matrix")->isSet())
   else if(!get_parameter("quanti_mutation_variance")->isSet()) {
     return error("\"quanti_mutation_matrix\" or \"quanti_mutation_variance\" must be specified!\n");
   }
  
 //  cout << "TProtoQuanti::setContinuousMutationModel_var_pleio::end\n";
   return true;
 }

References _effects_multivar, _eval, _evect, _gsl_mutation_matrix, _locus_table, _mutation_correlation, _mutation_sigma, _mutationVarianceIsLocusSpecific, _num_locus, _num_traits, _ws, allocate_gsl_mutation_matrix_space(), error(), TMatrix::get(), SimComponent::get_parameter(), message(), TMatrix::ncols(), TMatrix::nrows(), readMatrixFromQuantiMutationMatrix(), TMatrix::reset(), TMatrix::set(), set_gsl_mutation_matrix(), set_gsl_mutation_matrix_from_sigma(), set_mutation_matrix_decomposition(), setMutationSigmaFromQuantiMutationVariance(), and warning().

Referenced by setMutationModel_var_pleio().

◆ setDiallelicMutationModel()

bool TProtoQuanti::setDiallelicMutationModel ( )

 {
   static bool warn_allele_once = false;
  
   if (!get_parameter("quanti_allele_value")->isSet()) {
  
     return error("in \"quanti\" trait, \"quanti_allele_value\" is not set for the diallelic model.\n");
  
   } else {
  
     // allele_value is a matrix nb_locus x 2 values
  
     // IMPORTANT:: This interface doesn't allow for trait-specific allelic values!!
  
     _allele_value.reset(_num_locus, 2);
  
     if (get_parameter("quanti_allele_value")->isMatrix()) { //locus-specific allelic values
  
       TMatrix tmp;
  
       get_parameter("quanti_allele_value")->getMatrix(&tmp);
  
       if (tmp.ncols() != _num_locus) {
         if(tmp.ncols() < _num_locus && !warn_allele_once) {
           warning("\"quanti_allele_value\" has less values than the number of loci, allelic values will be recycled among loci.\n");
           warn_allele_once = true;
         }
  
         if(tmp.ncols() > _num_locus && !warn_allele_once) {
           warning("\"quanti_allele_value\" has more values than the number of loci, only the first %i values will be used.\n", _num_locus);
           warn_allele_once = true;
         }
       }
  
       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 trait-increasing allele, q = freq of trait-decreasing allele
  
       double a1, a2;
  
       if (tmp.nrows() == 1) { // only 'a' is provided
  
  
         if(_allele_model == 1) { // store +a and -a allelic values, with +a at position 0
           for (unsigned i = 0; i < _num_locus; ++i) {
  
             a1 = tmp.get(0, i % nval); // recycle allelic values among loci, if necessary
  
             if(a1 < 0) a1 = -1.0*a1;  // we need the positive value in the first position
  
             a2 = -1.0*a1;
  
             _allele_value.set(i, 0, a1);
             _allele_value.set(i, 1, a2);
           }
         }
         else if (_allele_model == 2)  // "asymmetrical case, create allele values {0, a}
         {
           for (unsigned i = 0; i < _num_locus; ++i) {
  
                a1 = tmp.get(0, i % nval); // recycle allelic values among loci, if necessary
                _allele_value.set(i, 0, 0.0); // first allele is the ancestral allele with value 0
                _allele_value.set(i, 1, a1);  // second allele is the derived allele with a != 0
              }
         } else
           return error("parameter \"quanti_allele_value\" should only be used with the \"diallelic\" allele models.\n ");
  
       } else if (tmp.nrows() == 2) { // store A and a allelic values, a != -A
  
  
         for (unsigned i = 0; i < _num_locus; ++i) {
  
           a1 = tmp.get(0, i % nval); // recycle allelic values among loci
           a2 = tmp.get(1, i % nval);
  
           //smallest first; but we keep the "ancestral" allele (value 0, if provided) at position 0 in all cases
           if(a1 != 0.0 && a1 > a2) {
             a1 = a2;
             a2 = tmp.get(0, i % nval);
           }
           _allele_value.set(i, 0, a1);
           _allele_value.set(i, 1, a2);
         }
  
       } else {
         return error("\"quanti_allele_value\" must get a matrix with a max. of 2 rows (and max. 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;
  
       _allele_value.set_col(0, a1);
       _allele_value.set_col(1, a2);
  
     }
   }
  
   // we need a mapping of sequence position to allele value to read the allele value from the sequence
   if(_sequence_diallele_values[0]) {
     delete [] _sequence_diallele_values[0];
     _sequence_diallele_values[0] = NULL;
   }
  
   if(_sequence_diallele_values[1]) {
     delete [] _sequence_diallele_values[1];
     _sequence_diallele_values[1] = NULL;
   }
  
   _sequence_diallele_values[0] = new double [_seq_length];
   _sequence_diallele_values[1] = new double [_seq_length];
  
   unsigned int pos, locID;
   for(unsigned int i = 0; i < _num_traits; ++i) {
     for(unsigned int j = 0; j < get_num_locus(i); ++j) {
       pos = get_locus_seq_pos(j, i);
       locID = get_locus_ID(j, i);
       _sequence_diallele_values[0][pos] = _allele_value.get(locID, 0);
       _sequence_diallele_values[1][pos] = _allele_value.get(locID, 1);
     }
   }
  
   // detect equal-effects case for bulk bitstring genotype computation
   _equal_val_0 = _allele_value.get(0, 0);
   _equal_val_1 = _allele_value.get(0, 1);
   _equal_effects = true;
   for (unsigned int i = 1; i < _num_locus; ++i) {
     if (_allele_value.get(i, 0) != _equal_val_0 ||
         _allele_value.get(i, 1) != _equal_val_1) {
       _equal_effects = false;
       break;
     }
   }
   _equal_val_diff = _equal_val_1 - _equal_val_0;
  
   // build trait masks for bulk bitstring genotype computation
   // one bitstring per trait, with 1s at sequence positions belonging to that trait
   // works for all pleiotropy types (no_pleio, full_pleio, var_pleio)
   _trait_masks.clear();
   for (unsigned int t = 0; t < _num_traits; ++t) {
     _trait_masks.push_back(bitstring(_seq_length));
     for (unsigned int l = 0; l < get_num_locus(t); ++l)
       _trait_masks[t].set(_trait_table[t][l], true);
   }
  
   return true;
 }

References _allele_model, _allele_value, _equal_effects, _equal_val_0, _equal_val_1, _equal_val_diff, _num_locus, _num_traits, _seq_length, _sequence_diallele_values, _trait_masks, _trait_table, error(), TMatrix::get(), get_locus_ID(), get_locus_seq_pos(), get_num_locus(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), TMatrix::set(), TMatrix::set_col(), and warning().

Referenced by setMutationModel_full_pleio(), setMutationModel_no_pleio(), and setMutationModel_var_pleio().

◆ setDominanceParameters()

bool TProtoQuanti::setDominanceParameters ( )

 {
   TMatrix tmp_mat;
  
 #ifdef _DEBUG_
   message("quant::setting dominance parameters\n");
 #endif
  
   _dominance_model = 0; // no dominance by default
   _dominance_effects.reset();
  
   if(get_parameter("quanti_dominance_effects")->isSet())
   {
  
     _dominance_effects.reset(_num_traits, _num_locus);
  
     if(get_parameter("quanti_dominance_effects")->isMatrix())
     {
  
       get_parameter("quanti_dominance_effects")->getMatrix(&tmp_mat);
  
       if(tmp_mat.nrows() > _num_traits)
         return error("the dominance effect matrix must hold at most as many rows as the number of quantitative trait.\n");
  
       if(tmp_mat.ncols() > _num_locus)
         return error("the dominance effect matrix must hold at most as many columns as the number of quantitative loci.\n");
  
       _dominance_effects.copy_recycle(tmp_mat);
  
       _equal_dom_coeff = true;
       double k = _dominance_effects.get(0,0);
       for(unsigned int i=0; i < _dominance_effects.nrows(); ++i) {
         for(unsigned int j=0; j < _dominance_effects.ncols(); ++j) {
           if(k != _dominance_effects.get(i,j)) {
             _equal_dom_coeff = false;
             break;
           }
         }
       }
     }
     else {
       _dominance_effects.assign( get_parameter_value("quanti_dominance_effects") );
       _equal_dom_coeff = true;
     }
  
     // set dominance flag active
     _dominance_model = 1; // internally, model 0 = no dominance
   }
  
  
 #ifdef _DEBUG_
   message("quant::dominance is set ? \"%s\"\n", (_dominance_model == 0 ? " no" : "yes"));
   if(_dominance_model) {
  
     message("quant::dominance coefficients (trait x locus table, 20 first loci):\n");
     for(unsigned int i = 0; i < _dominance_effects.nrows(); ++i)
       for(unsigned int j = 0; j < _dominance_effects.ncols() && j < 20; ++j)
         message("%.3f ", _dominance_effects.get(i,j));
   }
   message("\n");
 #endif
  
   return true;
 }

References _dominance_effects, _dominance_model, _equal_dom_coeff, _num_locus, _num_traits, TMatrix::assign(), TMatrix::copy_recycle(), error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), message(), TMatrix::ncols(), TMatrix::nrows(), and TMatrix::reset().

Referenced by setParameters().

◆ setEpistasisParameters()

bool TProtoQuanti::setEpistasisParameters ( )

 {
  
   _epistasis = false;
  
   // set epistatic coefficients:
  
   if(get_parameter("quanti_epistatic_effects")->isSet()) {
  
     if(get_parameter("quanti_epistatic_network")->isSet()) {
  
       // --- sparse/network mode ---
  
       vector< vector<double> > net_mat, efx_mat;
  
       get_parameter("quanti_epistatic_network")->getVariableMatrix(&net_mat);
       get_parameter("quanti_epistatic_effects")->getVariableMatrix(&efx_mat);
  
       if(net_mat.size() != efx_mat.size())
         return error("\"quanti_epistatic_network\" and \"quanti_epistatic_effects\" must have the same number of rows (%i vs %i).\n",
                      (int)net_mat.size(), (int)efx_mat.size());
  
       // validate and count total interactions
       _num_epi_coefs = 0;
  
       for(size_t r = 0; r < net_mat.size(); ++r) {
  
         unsigned int M = net_mat[r].size();
  
         if(M < 2)
           return error("\"quanti_epistatic_network\" row %i must contain at least 2 loci (got %i).\n", (int)(r+1), M);
  
         unsigned int n_pairs = M * (M - 1) / 2;
  
         if(efx_mat[r].size() != n_pairs)
           return error("\"quanti_epistatic_effects\" row %i must have %i values for %i loci (%i*(%i-1)/2), got %i.\n",
                        (int)(r+1), n_pairs, M, M, M, (int)efx_mat[r].size());
  
         for(unsigned int i = 0; i < M; ++i) {
           int loc = (int)net_mat[r][i];
           if(loc < 1 || loc > (int)_num_locus)
             return error("\"quanti_epistatic_network\" row %i: locus index %i is out of range [1, %i].\n",
                          (int)(r+1), loc, _num_locus);
         }
  
         _num_epi_coefs += n_pairs;
       }
  
       _epistatic_coefs_indices.reset(_num_epi_coefs, 2, 0.0);
       _epistatic_coefs_matrix.reset(1, _num_epi_coefs, 0.0);
  
       unsigned int idx = 0;
  
       for(size_t r = 0; r < net_mat.size(); ++r) {
  
         unsigned int M = net_mat[r].size();
         unsigned int efx_idx = 0;
  
         for(unsigned int i = 0; i < M - 1; ++i) {
           for(unsigned int j = i + 1; j < M; ++j) {
             unsigned int loc_i = (unsigned int)net_mat[r][i] - 1;  // 1-based to 0-based
             unsigned int loc_j = (unsigned int)net_mat[r][j] - 1;
             _epistatic_coefs_indices.set(idx, 0, min(loc_i, loc_j));
             _epistatic_coefs_indices.set(idx, 1, max(loc_i, loc_j));
             _epistatic_coefs_matrix.set(0, idx, efx_mat[r][efx_idx]);
             efx_idx++;
             idx++;
           }
         }
       }
  
     } else {
  
       // --- dense mode (existing behavior) ---
  
       _num_epi_coefs = nChooseK(_num_locus, 2);
  
       unsigned int num_interact = _num_locus*(_num_locus-1)/2.0; //num of pairwise interactions
  
       assert(num_interact == _num_epi_coefs);
  
       _epistatic_coefs_matrix.reset(1, _num_epi_coefs, 0.0);
  
       TMatrix readEpiCoefs;
  
       get_parameter("quanti_epistatic_effects")->getMatrix(&readEpiCoefs);
  
       if(readEpiCoefs.nrows() > 1)
         return error("\"quanti_epistatic_effects\" must be an array, i.e., have one row only\n");
  
       if(readEpiCoefs.ncols() > _num_epi_coefs){
  
         return error("The number of epistatic coefficients provided with \"quanti_epistatic_effects\"\
  must be at most equal to the total number of pairwise locus interactions (%i for %i loci).\n", _num_epi_coefs, _num_locus);
  
       }
  
       _epistatic_coefs_matrix.copy_recycle(readEpiCoefs);
  
       assert(_epistatic_coefs_matrix.length() == _num_epi_coefs);
  
       //  Here _epistatic_coefs_indices covers only pairwise epistatic interactions
       //  and has dimensions nbCoefs x 2
       _epistatic_coefs_indices.copy(nChooseKVec(_num_locus, 2));
  
     }
  
     _epistasis = true;
   }
  
  
   return true;
 }

References _epistasis, _epistatic_coefs_indices, _epistatic_coefs_matrix, _num_epi_coefs, _num_locus, TMatrix::copy(), TMatrix::copy_recycle(), error(), SimComponent::get_parameter(), Param::getMatrix(), Param::getVariableMatrix(), TMatrix::length(), nChooseK(), nChooseKVec(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), and TMatrix::set().

Referenced by setParameters().

◆ setGeneticMapParams()

bool TProtoQuanti::setGeneticMapParams ( )

                                         {
  
   //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[_num_locus];
  
   } else {
     // loci are not independent, ie recomb rate < 0.5
  
     // the loci positions will be registered in the genetic map
     if( !setGeneticMapParameters("quanti", _num_locus) ) return false;
  
     _inherit_fun_ptr = &TProtoQuanti::inherit_low;
  
   }
  
   return true;
 }

References _all_chooser, _inherit_fun_ptr, _num_locus, TTProtoWithMap::_recombRate, inherit_free(), inherit_low(), TTProtoWithMap::isRecombinationFree(), and TTProtoWithMap::setGeneticMapParameters().

Referenced by setParameters().

◆ setHeritabilityParams()

bool TProtoQuanti::setHeritabilityParams ( )

                                          {
  
   //  temporary TMatrix for parameters read-in
   TMatrix tmp_mat;
  
 #ifdef _DEBUG_
   message("quant::setting heritability parameters\n");
 #endif
   //---------------------------------------------------------------------------------------------
   // 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())
     {
       // environmental effects can be trait-specific
       get_parameter("quanti_environmental_variance")->getMatrix(&tmp_mat);
  
       if(tmp_mat.nrows() > 1)
         return error("\"quanti_environmental_variance\" accepts only an array with one row. \
 The matrix has %i rows.\n", tmp_mat.nrows());
  
       if(tmp_mat.ncols() > _num_traits)
         return error("\"quanti_environmental_variance\" accepts an array with as many values as the number of traits. \
 The matrix has %i columns.\n", tmp_mat.ncols());
  
       if(tmp_mat.ncols() < _num_traits)
         warning("\"quanti_environmental_variance\" received an array with less values (%i) than the number of traits (%i). \
 The values will be recycled among traits.", tmp_mat.ncols(), _num_traits);
  
       double var;
  
       for(unsigned int i = 0; i < _num_traits; i++) {
  
         var = tmp_mat.get(0, i%tmp_mat.ncols()); // recycle values if less values provided than number of traits
  
         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 { // single value provided, copied for all traits
  
       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 < _num_traits; ++i) {
         _eVariance.push_back( sqrt(var) ); // store the SD to save time later
       }
  
     }
  
   } // END if env variance
  
 #ifdef _DEBUG_
   if(_eVariance.size() > 0) {
  
     message("quant::environmental variance is set to: ");
  
     for(unsigned int i = 0; i < _eVariance.size(); ++i)
       message("%.3f, ", _eVariance[i]);
  
     message("\n");
  
   } else {
  
     message("quant::no environmental variance is set\n");
   }
  
 #endif
  
   _h2.clear();
  
   if(get_parameter("quanti_heritability")->isSet()){
  
     if(get_parameter("quanti_heritability")->isMatrix()) // can be trait-specific
     {
       get_parameter("quanti_heritability")->getMatrix(&tmp_mat);
  
       if(tmp_mat.nrows() > 1)
         return error("\"quanti_heritability\" accepts only an array with one row. \
 The matrix has %i rows.\n", tmp_mat.nrows());
  
       if(tmp_mat.ncols() > _num_traits)
         return error("\"quanti_heritability\" accepts an array with as many values as the number of traits. \
 The matrix has %i columns.\n", tmp_mat.ncols());
  
       if(tmp_mat.ncols() < _num_traits)
         warning("\"quanti_heritability\" received an array with less values (%i) than the number of traits (%i). \
 The values will be recycled among traits.", tmp_mat.ncols(), _num_traits);
  
  
       double h2;
  
       for(unsigned int i = 0; i < _num_traits; i++) {
  
         h2 = tmp_mat.get(0, i%_num_traits); // value recycling
  
         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 < _num_traits; ++i) {
         _h2.push_back( h2 ); // store the SD to save time later
       }
  
     }
   } //END IF isSet heritability
  
   _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");
  
 #ifdef _DEBUG_
   if(_h2.size() > 0) {
  
     message("quant::heritability is set to: ");
  
     for(unsigned int i = 0; i < _eVariance.size(); ++i)
       message("%.3f, ", _h2[i]);
  
     message("\n");
  
   } else {
  
     message("quant::no heritability is set, it will bepend on Ve (see above)\n");
   }
  
   if(_h2_isBroad)
     message("quant::heritability is set to \"broad sense\"\n");
 #endif
  
   return true;
 }

References _eVariance, _h2, _h2_isBroad, _h2_setTime, _num_traits, error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), Param::isSet(), message(), TMatrix::ncols(), TMatrix::nrows(), and warning().

Referenced by setParameters().

◆ setInitialValuesParams()

bool TProtoQuanti::setInitialValuesParams ( )

                                            {
  
   //---------------------------------------------------------------------------------------------
   // INITIAL VALUES:
  
   if(get_parameter("quanti_init_value")->isSet()) {
  
     get_parameter("quanti_init_value")->getMatrix(&_init_value);
  
     if(_init_value.nrows() != 1 || _init_value.ncols() != _num_traits) {
       return error("\"quanti_init_value\" must be an array of length equal to the number of traits!\n");
     }
  
   }
   else {
     _init_value.reset(1,_num_traits, 0.0);
   }
  
   if(get_parameter("quanti_init_model")->isSet()) {
  
     _doInitMutation = (unsigned int)get_parameter_value("quanti_init_model");
  
   } else {
     _doInitMutation = 0;
   }
  
   if(get_parameter("quanti_init_variance")->isSet()) {
  
     if(get_parameter("quanti_init_variance")->isMatrix()) {
  
       get_parameter("quanti_init_variance")->getMatrix(&_init_variance);
  
       if(_init_variance.nrows() != 1 || _init_variance.ncols() != _num_traits) {
         return error("\"quanti_init_variance\" must be an array of length equal to the number of traits!\n");
       }
  
     } else {
     _init_variance.reset(1, _num_traits, get_parameter_value("quanti_init_variance"));
     }
  
   }
   else { // initial variance is not set
  
     // verify that the initial variance is set when needed
     if(_doInitMutation == 2 && _allele_model > 2)
       return error("the initial trait variance must be set with \"quanti_init_variance\" for init model 2 and continuous allelic model.\n");
  
     _init_variance.reset(1, _num_traits, 0.0);
   }
  
   return true;
 }

References _allele_model, _doInitMutation, _init_value, _init_variance, _num_traits, error(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), Param::isMatrix(), Param::isSet(), TMatrix::ncols(), TMatrix::nrows(), and TMatrix::reset().

Referenced by setParameters().

◆ setMutationCorrelation()

bool TProtoQuanti::setMutationCorrelation ( )

 {
   //---------------------------------------------------------------------------------------
   // MUTATIONAL CORRELATION
  
   //  temporary TMatrix for parameters read-in
   TMatrix tmp_mat;
  
   _mutation_correlation.reset(1, _num_locus); // sets all elements to 0
  
   if(get_parameter("quanti_mutation_correlation")->isSet()) {
  
     if( get_parameter("quanti_mutation_matrix")->isSet() ){
  
       warning("\"quanti_mutation_correlation\" and \"quanti_mutation_matrix\" are set, we only use the mutation matrix. \"quanti_mutation_correlation\" is ignored.");
  
     } else if (_num_traits == 1) {
  
       warning("\"quanti_mutation_correlation\" is set but only one trait is modeled. Parameter is ignored.");
  
     } else {
  
       if(get_parameter("quanti_mutation_correlation")->isMatrix()) {
  
         get_parameter("quanti_mutation_correlation")->getMatrix(&tmp_mat);
  
         if(tmp_mat.nrows() > 1)
           return error("\"quanti_mutation_correlation\" must be an array with one row. The matrix has %i rows.\n", tmp_mat.nrows());
  
         if(tmp_mat.ncols() > _num_locus)
           return error("\"quanti_mutation_correlation\" accepts an array with as many values as the number of loci. \
 The array has %i values.\n", tmp_mat.ncols());
  
         if(tmp_mat.ncols() < _num_locus)
           warning("\"quanti_mutation_correlation\" received an array with less values (%i) than the number of loci (%i). \
 The values will be recycled among loci.", tmp_mat.ncols(), _num_locus);
  
         _mutation_correlation.copy_recycle(tmp_mat);
  
       } else { // not a matrix but a single value
  
         double val = get_parameter_value("quanti_mutation_correlation");
  
         if(val < -1.0 || val > 1.0)
           return error("quant::value assigned to \"quanti_mutation_correlation\" must be within [-1, 1].\n");
  
         _mutation_correlation.assign( val );
  
       }
  
     }
   } // _end_ if param->isSet()
  
   return true;
 }

References _mutation_correlation, _num_locus, _num_traits, TMatrix::assign(), TMatrix::copy_recycle(), error(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), and warning().

Referenced by setMutationModel_full_pleio(), and setMutationModel_var_pleio().

◆ setMutationModel_full_pleio()

bool TProtoQuanti::setMutationModel_full_pleio ( )

 {
  
   //store a few important numbers
   _seq_length = _num_traits * _num_locus;
  
   // memory size of a single allele value
 //  _sizeofLocusType = sizeof(double); --> this is set in setParameters() depending on the allele type
  
   // size of data used to store pleiotropic allelic values at a locus
   _locusByteSize = _num_traits * _sizeofLocusType;
  
   // mutation correlation set from "quanti_mutation_correlation"
   if(!setMutationCorrelation()) return false;
  
   // set the set trait/locus_table, will be used by stat and file handlers to access data
   setTraitAndLocusTables_full_pleio ();
  
   if( _allele_model == 1 || _allele_model ==2 ) {
     //---------------------------------------------------------------------------------------
     // DIALLELIC LOCI
  
     if (_num_traits > 2) { // multivariate models, only for non-diallelic loci
  
       return error("quant::the di-allelic model with pleiotropy is only allowed for max. 2 quantitative traits.\n");
  
     } else { // there are 2 traits, otherwise the "no_pleio" version of the function is called
  
       if(!setDiallelicMutationModel()) return false;
  
       _getMutationValues = &TProtoQuanti::getMutationEffectBivariateDiallelic;
  
     }
  
   } else {
     //---------------------------------------------------------------------------------------
     // CONTIUUM OF ALLELE MODEL
  
     if(!setContinuousMutationModel_full_pleio()) return false;
  
     if (_num_traits == 2) { // bivariate models, only for non-diallelic loci
  
       if(_mutationVarianceIsLocusSpecific)
         _getMutationValues = &TProtoQuanti::getMutationEffectBivariateGaussianLocSpec;
       else
         _getMutationValues = &TProtoQuanti::getMutationEffectBivariateGaussian;
  
  
     } else if (_num_traits > 2) { // multivariate models, only for non-diallelic loci
  
       if(_mutationVarianceIsLocusSpecific)
         _getMutationValues = &TProtoQuanti::getMutationEffectMultivariateGaussianLocSpec;
       else
         _getMutationValues = &TProtoQuanti::getMutationEffectMultivariateGaussian;
  
     }
   }
  
   // SET POINTER TO MUTATE FUNCTION
  
   if(_genomic_mutation_rate == 0) {
  
     _mutation_func_ptr = &TProtoQuanti::mutate_nill;
  
   } else if(_allele_model <= 2) { // diallelic models
  
     _mutation_func_ptr = &TProtoQuanti::mutate_diallelic_pleio;
  
   } else if(_allele_model == 3) { // continuous
     _mutation_func_ptr = &TProtoQuanti::mutate_full_pleio;
   } else                         // continuous in-place
     _mutation_func_ptr = &TProtoQuanti::mutate_inplace_full_pleio;
  
  
   return true;
 }

References _allele_model, _genomic_mutation_rate, _getMutationValues, _locusByteSize, _mutation_func_ptr, _mutationVarianceIsLocusSpecific, _num_locus, _num_traits, _seq_length, _sizeofLocusType, error(), getMutationEffectBivariateDiallelic(), getMutationEffectBivariateGaussian(), getMutationEffectBivariateGaussianLocSpec(), getMutationEffectMultivariateGaussian(), getMutationEffectMultivariateGaussianLocSpec(), mutate_diallelic_pleio(), mutate_full_pleio(), mutate_inplace_full_pleio(), mutate_nill(), setContinuousMutationModel_full_pleio(), setDiallelicMutationModel(), setMutationCorrelation(), and setTraitAndLocusTables_full_pleio().

Referenced by setParameters().

◆ setMutationModel_no_pleio()

bool TProtoQuanti::setMutationModel_no_pleio ( )

 {
  
   //---------------------------------------------------------------------------------------------
   // NON-PLEIOTROPIC TRAITS
  
   // size of data used to store allelic values at a locus -- here non-pleiotropic
   _locusByteSize = _sizeofLocusType;
  
     TMatrix tmp;
  
   if(_num_traits > 1) {
 #ifdef _DEBUG_
     message("quant::setting num loci per trait without pleiotropy.\n");
 #endif
  
  
     if(get_parameter("quanti_loci_per_trait")->isSet()) {
  
       get_parameter("quanti_loci_per_trait")->getMatrix(&tmp);
  
       if( tmp.nrows() > 1)
         return error("\"quanti_loci_per_trait\" must be an array with one row.\n");
  
       if( !(tmp.ncols() == _num_traits) )
         return error("\"quanti_loci_per_trait\" must hold a number of loci for each trait. Use \"quanti_loci\" if loci are equally distributed among traits.\n");
  
       if(tmp.rowSum(0) != _num_locus)
         return error("\"quanti_loci_per_trait\" must specify a total number of loci equal to \"quanti_loci\"\n");
  
 #ifdef _DEBUG_
     message("quant::found trait-specific number of loci.\n");
 #endif
  
     } else {
       // divide the tot num of loci into num of traits
       tmp.reset(1, _num_traits);
  
       unsigned int loc_per_trait = _num_locus / _num_traits;
  
       tmp.assign(loc_per_trait);
  
       if( _num_locus % _num_traits != 0) {
         warning("quant::number of loci is not a multiple of the number of trait, setting the number of loci per trait to %i.\n", _num_locus / _num_traits);
         warning("quant::resetting the total number of quantitative loci to %i\n", loc_per_trait*_num_traits);
       }
  
       _num_locus = loc_per_trait*_num_traits;
  
 #ifdef _DEBUG_
     message("quant::set equal number of loci per trait (%i).\n", (unsigned int)tmp.get(0,0));
 #endif
  
     }
  
 #ifdef _DEBUG_
     message("quant::setting trait and locus table for no-pleiotropy case.\n");
 #endif
  
     setTraitAndLocusTables_no_pleio(tmp);
   }
   else {
  
     tmp.reset(1, 1, _num_locus);
  
     setTraitAndLocusTables_no_pleio(tmp);
   }
  
   // _seq_length is equal to _num_locus
   _seq_length = _num_locus;
  
   //-----------------------------------------------------------------------------------------
   // SET MUTATION MODEL
  
  
   if( _allele_model <= 2 ) {
     //---------------------------------------------------------------------------------------
     // DIALLELIC LOCI
  
     if(!setDiallelicMutationModel()) return false;
  
   } else {
     //---------------------------------------------------------------------------------------
     // CONTIUUM OF ALLELE MODEL
 #ifdef _DEBUG_
     message("quant::setting continuous allele model for no-pleiotropy case.\n");
 #endif
  
     if(!setContinuousMutationModel_no_pleio()) return false;
  
     if(_mutationVarianceIsLocusSpecific)
       _getMutationValues = &TProtoQuanti::getMutationEffectUnivariateGaussianLocSpec;
     else
       _getMutationValues = &TProtoQuanti::getMutationEffectUnivariateGaussian;
   }
  
   //-----------------------------------------------------------------------------------------
   // SET POINTER TO MUTATE FUNCTION
  
   if(_genomic_mutation_rate == 0) {
  
     _mutation_func_ptr = &TProtoQuanti::mutate_nill;
  
   } else if(_allele_model <= 2) {// di-allelic models
  
     _mutation_func_ptr = &TProtoQuanti::mutate_diallelic_no_pleio;
  
   } else if(_allele_model == 3) {
  
     _mutation_func_ptr = &TProtoQuanti::mutate_no_pleio;
  
   } else
     _mutation_func_ptr = &TProtoQuanti::mutate_inplace_no_pleio;
  
 //-----------------------------------------------------------------------------------------
 // ADDITIONAL CHECKS
  
   if(_paramSet->isSet("quanti_mutation_correlation"))
     warning("quant trait::\"quanti_mutation_correlation\" has no effect on non-pleiotropic loci, it can be removed.\n");
  
   if(_paramSet->isSet("quanti_pleio_matrix"))
     warning("quant trait::\"quanti_pleio_matrix\" has no effect on non-pleiotropic loci, it can be removed.\n");
  
  
   return true;
 }

References _allele_model, _genomic_mutation_rate, _getMutationValues, _locusByteSize, _mutation_func_ptr, _mutationVarianceIsLocusSpecific, _num_locus, _num_traits, SimComponent::_paramSet, _seq_length, _sizeofLocusType, TMatrix::assign(), error(), TMatrix::get(), SimComponent::get_parameter(), Param::getMatrix(), getMutationEffectUnivariateGaussian(), getMutationEffectUnivariateGaussianLocSpec(), ParamSet::isSet(), message(), mutate_diallelic_no_pleio(), mutate_inplace_no_pleio(), mutate_nill(), mutate_no_pleio(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), TMatrix::rowSum(), setContinuousMutationModel_no_pleio(), setDiallelicMutationModel(), setTraitAndLocusTables_no_pleio(), and warning().

Referenced by setParameters().

◆ setMutationModel_var_pleio()

bool TProtoQuanti::setMutationModel_var_pleio ( )

 {
  
   //---------------------------------------------------------------------------------------------
   // VARIABLE PLEIOTROPY: Jobran Chebib
  
   // size of data used to store pleiotropic allelic values at a locus,
   //here set same as sizeof a single allele as PD varies per locus
   _locusByteSize = _sizeofLocusType;
  
   // initializes pleiotropic connectivity matrix -- "quanti_pleio_matx" in init file
   // the connectivity matrix holds 0's in absence of a locus effect on a trait, and 1's otherwise
   // loci are fully pleiotropic by default (1's everywhere)
  
   // a matrix is provided in input
  
   get_parameter("quanti_pleio_matrix")->getMatrix(&_pleio_matx); //this resets/builds the TMatrix
  
   if(_pleio_matx.nrows() != _num_locus || _pleio_matx.ncols() != _num_traits) {
     return error("quant::\"quanti_pleio-matrix\" must be an m by n matrix of length m equal to the number of loci and n equal to the number of traits!\n");
   }
  
  // end reading pleiot matrix
  
  
 #ifdef _DEBUG_
   // print _pleio_matrix
   message("\nquant::pleiotropy matrix dimensions: rows(loci) = %i, columns(traits) = %i, (first 25 loci)\n",_pleio_matx.getNbRows(),_pleio_matx.getNbCols());
   for(unsigned int i = 0; i < _pleio_matx.getNbRows() && i < 25; i++) {
     for(unsigned int j = 0; j < _pleio_matx.getNbCols(); j++){
       message("%.0f ",_pleio_matx.get(i,j));
       message(" | ");
     }
     message("\n");
   }
 #endif
  
   // create temp_table from _pleio_matx to build _trait_table and _locus_table
   // records the locus-specific allele position affecting each trait, which depends on the PD of each locus
  
   vector< vector<unsigned int> > temp_table(_pleio_matx.ncols(),vector<unsigned int>(_pleio_matx.nrows()));
  
   if(_trait_locus_table.size() != 0)  _trait_locus_table.clear();
   // build table:
   _trait_locus_table.assign(_pleio_matx.ncols(),vector<unsigned int>()); //trait X locus table, size of each row unknown yet
  
   unsigned int PD = 0, pos = 1;  //pos = 1 because '0' is for no-effect of locus i on trait j
  
   for(unsigned int i = 0; i < _pleio_matx.nrows(); ++i){
     // check that at least one trait is affected for each locus (row)
     PD = 0;
     for(unsigned int j = 0; j < _pleio_matx.ncols(); ++j){
  
       if(_pleio_matx.get(i,j) == 1){
         temp_table[j][i] = pos;      // pos is the array index in the sequence where the allelic value will be located
         pos++;
         PD++;
         _trait_locus_table[j].push_back(i);  //add locus ID if that locus affects trait j
       }
       else if(_pleio_matx.get(i,j) == 0){
         temp_table[j][i] = 0;
       }
       else return error("quant::\"quanti_pleio_matrix\" must only contain 0s and 1s \n");
     }
  
     if(PD == 0)
       return error("quanti_pleio_matrix has only 0's for locus %i. Loci must affect at least one trait.\n", i+1);
   }
  
 #ifdef _DEBUG_
   // print temp_table (for debugging purposes only)
   message("quant::pleiotropic locus sequence position per trait (temp_table) (first 25 loci/trait): \n");
   for(unsigned int i=0; i<temp_table.size(); ++i){
     for(unsigned int j=0; j<temp_table[i].size()  && j < 25; ++j){
       cout << temp_table[i][j] << " | ";
     }
     message("\n");
   }
 #endif
  
   // build _trait_table from temp_table (trait x locus)
   // it sets the array index of each allele affecting each trait in the QTL sequence
   // the sequence is organized as locus-trait: alleles affecting a given trait are NOT contiguous in the sequence
   if(_trait_table.size() != 0)  _trait_table.clear();
  
   for(size_t i = 0; i < temp_table.size(); ++i){ //trait-wise
  
     _trait_table.push_back(vector<unsigned int>());
  
     for(size_t j = 0; j < temp_table[i].size(); ++j){ //locus-wise, size is the number of loci affecting trait i
  
       if(temp_table[i][j] != 0){
         _trait_table[i].push_back(temp_table[i][j]-1); //position in sequence where causative alleles are located
       }
     }
   }
  
   // build _locus_table from _pleio_matx
   // table holding { start locus index in sequence , pleiotropic degree } on each row
   if(_locus_table.size() != 0)  _locus_table.clear();
  
   unsigned int pos4 = 0;  //counts position in sequence
   unsigned int tsize = 0; //counts n traits affected = PD
  
   for(unsigned int i=0; i<_pleio_matx.getNbRows(); ++i){ //locus-wise
  
     _locus_table.push_back(vector<unsigned int> (2));
  
     _locus_table[i][0] = pos4;
  
     for(unsigned int j=0; j<_pleio_matx.getNbCols(); ++j){ //trait-wise, sum the row
  
       if(_pleio_matx.get(i,j) == 1)
         tsize++;
     }
  
     _locus_table[i][1] = tsize;
  
     pos4 += tsize;
  
     tsize = 0;
   }
  
   // calculate _seq_length from _trait_table
   _seq_length = 0;
   for(unsigned int i=0; i<_trait_table.size(); ++i){
     _seq_length += _trait_table[i].size();
   }
  
   //-----------------------------------------------------------------------------------------
   // SET MUTATION MODEL
  
   // mutation correlation set from "quanti_mutation_correlation"
   if(!setMutationCorrelation()) return false;
  
   if(_allele_model < 3 && !setDiallelicMutationModel()) return false;
  
   if(_allele_model > 2 && ! setContinuousMutationModel_var_pleio()) return false;
  
   _getMutationValuesVarPleio.clear();  // dimensionality of mutations depends on pleiotropic degree
  
   for(unsigned int i=0; i < _num_locus; ++i){
  
     if (_locus_table[i][1] == 1) { // PD = 1, no pleiotropy at this locus
  
       if(_mutationVarianceIsLocusSpecific)
         _getMutationValuesVarPleio.push_back(&TProtoQuanti::getMutationEffectUnivariateGaussianLocSpec);
       else
         _getMutationValuesVarPleio.push_back(&TProtoQuanti::getMutationEffectUnivariateGaussian);
  
     } else if (_locus_table[i][1] == 2) { // PD = 2
  
       if(_mutationVarianceIsLocusSpecific)
         _getMutationValuesVarPleio.push_back(&TProtoQuanti::getMutationEffectBivariateGaussianLocSpec);
       else
         _getMutationValuesVarPleio.push_back(&TProtoQuanti::getMutationEffectBivariateGaussian);
  
     } else if (_locus_table[i][1] > 2) { // PD > 2
  
       if (_allele_model > 2) {
  
 //        if(_mutationVarianceIsLocusSpecific)
           _getMutationValuesVarPleio.push_back(&TProtoQuanti::getMutationEffectMultivariateGaussianLocSpec);
 //        else
 //          _getMutationValuesVarPleio.push_back(&TProtoQuanti::getMutationEffectMultivariateGaussian);
  
       } else {
         return error("quant::the di-allelic model with pleiotropy is only allowed for max. 2 quantitative traits (locus %i has PD = %i)\n.", i+1, _locus_table[i][1]);
       }
  
     }
   }
  
   //-----------------------------------------------------------------------------------------
   // SET POINTER TO MUTATE FUNCTION
  
   if(_genomic_mutation_rate == 0) {
  
     _mutation_func_ptr = &TProtoQuanti::mutate_nill;
  
   } else if(_allele_model <= 2) {// di-allelic models
  
     _mutation_func_ptr = &TProtoQuanti::mutate_diallelic_var_pleio;
  
   } else if(_allele_model == 3) {// continuous model
  
     _mutation_func_ptr = &TProtoQuanti::mutate_var_pleio;
  
   } else                         //model 4,  in-place continuous model
     _mutation_func_ptr = &TProtoQuanti::mutate_inplace_var_pleio;
  
   return true;
 }

References _allele_model, _genomic_mutation_rate, _getMutationValuesVarPleio, _locus_table, _locusByteSize, _mutation_func_ptr, _mutationVarianceIsLocusSpecific, _num_locus, _num_traits, _pleio_matx, _seq_length, _sizeofLocusType, _trait_locus_table, _trait_table, error(), TMatrix::get(), SimComponent::get_parameter(), Param::getMatrix(), getMutationEffectBivariateGaussian(), getMutationEffectBivariateGaussianLocSpec(), getMutationEffectMultivariateGaussianLocSpec(), getMutationEffectUnivariateGaussian(), getMutationEffectUnivariateGaussianLocSpec(), TMatrix::getNbCols(), TMatrix::getNbRows(), message(), mutate_diallelic_var_pleio(), mutate_inplace_var_pleio(), mutate_nill(), mutate_var_pleio(), TMatrix::ncols(), TMatrix::nrows(), setContinuousMutationModel_var_pleio(), setDiallelicMutationModel(), and setMutationCorrelation().

Referenced by setParameters().

◆ setMutationSigmaFromQuantiMutationVariance()

bool TProtoQuanti::setMutationSigmaFromQuantiMutationVariance ( )

 {
  
 //  message("quant::found \"quanti_mutation_variance\" in input, checking dimensionality: ");
  
   if(get_parameter("quanti_mutation_variance")->isMatrix()) {
  
 #ifdef _DEBUG_
     message("\nquant::found locus-specific mutation variance (param is matrix).\n");
 #endif
  
     TMatrix tmp;
  
     get_parameter("quanti_mutation_variance")->getMatrix(&tmp);
  
 //    message("%i x %i\n",tmp.nrows(), tmp.ncols());
  
     if(tmp.nrows() > 1) {
       error("\"quanti_mutation_variance\" must be an array with a single row and as many columns as the number of loci.\
 The matrix passed has %i rows.\n", tmp.nrows());
  
       error("Note: use \"quanti_mutation_matrix\" to specify different variance-covariance parameters for different traits\n");
       return false;
     }
  
     if(tmp.ncols() > _num_locus)
       return error("\"quanti_mutation_variance\" accepts an array with max. as many values as the number of loci. \
 The array has %i columns.\n", tmp.ncols());
  
     if(tmp.ncols() < _num_locus)
       warning("\"quanti_mutation_variance\" received an array with less values (%i) than the number of loci (%i). \
 The values will be recycled among loci.\n", tmp.ncols(), _num_locus);
  
     // using an array means that the mutation effect size is different among loci
     // we do not look at locus-specific pleiotropy here, but set the matrix to the maximum pleiotropic degree = num traits
  
     _mutation_sigma.reset(_num_locus, _num_traits);
  
 //    message("quant::setting locus-specific mutation variance\n");
  
     // copy the values for each locus to all traits equally
     for(unsigned int i = 0; i < _num_locus; ++i) {
  
       if(tmp.get(0, i % tmp.ncols()) < 0)
         return error("quant::values assigned to \"quanti_mutation_variance\" must by > 0.\n");
  
       _mutation_sigma.set_row(i, sqrt( tmp.get(0, i % tmp.ncols()) ) );
     }
  
   } else { // not a matrix but a single value, the matrix has a single row
  
 //    message("1 x 1\nquant::setting equal mutation variance on all traits and for all loci\n");
  
     if(get_parameter_value("quanti_mutation_variance") < 0)
       return error("quant::value assigned to \"quanti_mutation_variance\" must by > 0.\n");
  
     _mutation_sigma.reset(1, _num_traits, sqrt( get_parameter_value("quanti_mutation_variance") ));
  
   }
  
 #ifdef _DEBUG_
   message("quant::mutation sigma matrix:\n");
   _mutation_sigma.show_up();
 #endif
  
   return true;
 }

References _mutation_sigma, _num_locus, _num_traits, error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), message(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), TMatrix::set_row(), TMatrix::show_up(), and warning().

Referenced by setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ setMutationSigmaFromQuantiMutationVariance_no_pleio()

bool TProtoQuanti::setMutationSigmaFromQuantiMutationVariance_no_pleio ( )

 {
 //  message("quant::found \"quanti_mutation_variance\" in input, checking dimensionality for non-pleiotropic loci: ");
  
   if(get_parameter("quanti_mutation_variance")->isMatrix()) {
  
     TMatrix tmp;
  
     get_parameter("quanti_mutation_variance")->getMatrix(&tmp);
  
 //    message("%i x %i\n",tmp.nrows(), tmp.ncols());
  
     if(tmp.nrows() > _num_traits)
       return error("\"quanti_mutation_variance\" has more rows than the number of traits for non-pleiotropic loci. Ignoring extra rows.\n", tmp.nrows());
  
     if(tmp.ncols() > _num_locus)
       return error("\"quanti_mutation_variance\" has more columns than the number of loci. The matrix has %i columns.\n", tmp.ncols());
  
     if(tmp.ncols() < _num_locus || tmp.nrows() < _num_traits)
       warning("quant::\"quanti_mutation_variance\" received less values than expected from the number of loci or traits. \
 The values will be recycled among loci and traits.\n");
  
     // using an array means the mutation effect size is different among loci
     // we do not look at locus-specific pleiotropy here, but set the matrix to the maximum pleiotropic degree = num traits
  
 //    message("quant::setting locus-specific mutation variance for non-pleiotropic loci\n");
  
     _mutation_sigma.reset(_num_locus, 1); //each locus is affecting one trait only
  
     TMatrix expanded_mat(_num_traits, _num_locus);
  
     // copy elements at the right place when provided as trait-specific variance per block of loci, for instance.
     expanded_mat.copy_recycle(tmp);
  
     // copy trait-specific variances into the mutation sigma matrix first column
     for(unsigned int i = 0; i < _num_traits; ++i) {
       for(unsigned int j = 0, pos =  _trait_table[i][0]; j < _trait_table[i].size(); ++j, ++pos){
  
         if(expanded_mat.get(i,pos) < 0)
           return error("quant::values assigned to \"quanti_mutation_variance\" must by > 0.\n");
  
         _mutation_sigma.set(pos, 0, sqrt(expanded_mat.get(i,pos)));
       }
     }
  
   } else { // not a matrix but a single value, the matrix has a single row
  
 //    message("1 x 1\nquant::setting equal mutation variance across all quantitative loci\n");
  
     if(get_parameter_value("quanti_mutation_variance") < 0)
       return error("quant::value assigned to \"quanti_mutation_variance\" must by > 0.\n");
  
     _mutation_sigma.reset(1, 1, sqrt( get_parameter_value("quanti_mutation_variance") ));
  
   }
  
 #ifdef _DEBUG_
   message("quant::mutation sigma matrix:\n");
   _mutation_sigma.show_up();
 #endif
  
   return true;
 }

References _mutation_sigma, _num_locus, _num_traits, _trait_table, TMatrix::copy_recycle(), error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), message(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), TMatrix::set(), TMatrix::show_up(), and warning().

Referenced by setContinuousMutationModel_no_pleio().

◆ setParameters()

bool TProtoQuanti::setParameters ( )

virtual

Implements SimComponent.

 {
 #ifdef _DEBUG_
   message("Trait quant::setting parameters\n");
 #endif
  
   // reset all pointers to GSL matrices and vectors etc.
   // do it here, before changing num trait and num loci for a new simulation
   deallocate_gsl_mutation_matrix_space();
  
   //---------------------------------------------------------------------------------------
   // Mandatory parameters:
  
   // number of quantitative traits
   _num_traits = (unsigned int)get_parameter_value("quanti_traits");
  
   // number of loci
   _num_locus = (unsigned int)get_parameter_value("quanti_loci");
  
   _2L = 2*_num_locus;
  
   // set the genomic mutation rate
   _mutation_rate = get_parameter_value("quanti_mutation_rate");
  
   _genomic_mutation_rate =  _mutation_rate * 2 * _num_locus;
  
   // set the allelic model
   if( !(_allele_model = setAlleleModel()) ) return false;
  
   // check and set the datatype of the alleles, and size thereof
   if(get_parameter("quanti_diallele_datatype")->isSet()) {
  
     _diallele_datatype = get_parameter("quanti_diallele_datatype")->getArg();
  
     if(_diallele_datatype != "byte" && _diallele_datatype != "bit")
       return error("\"quanti_diallele_datatype\" received \"%s\", valid options are \"byte\" or \"bit\"\n",
                    _diallele_datatype.c_str());
   }
   else
     _diallele_datatype = "bit";
  
   if(_allele_model <= 2)
     _sizeofLocusType = sizeof(unsigned char); // only used for "byte" datatype; i.e. di-allelic loci
   else
     _sizeofLocusType = sizeof(double);
  
   //---------------------------------------------------------------------------------------
   // type of pleiotropy and pleiotropy-dpdt parameters:
  
   string pleio = get_parameter("quanti_pleiotropy")->getArg();
  
   if(_num_traits == 1 || pleio == "no" || pleio == "n" || pleio == "") {
  
     _pleio_type = 0;
  
 #ifdef _DEBUG_
   message("quant::%s pleiotropy, %i trait(s), %i loci\n",  "no", _num_traits, _num_locus);
 #endif
  
     if(!setMutationModel_no_pleio()) return false;
  
   } else if (pleio == "full" || pleio == "f") {
  
     if(get_parameter("quanti_pleio_matrix")->isSet())
       warning("\"quanti_pleio_matrix\" is ignored when pleiotropy type is \"full\".\n");
  
     _pleio_type = 1;
  
 #ifdef _DEBUG_
   message("quant::%s pleiotropy, %i trait(s), %i loci\n",  "full", _num_traits, _num_locus);
 #endif
  
     if (!setMutationModel_full_pleio()) return false;
  
   } else if (pleio == "var" || pleio == "variable" || pleio == "v") {
  
     if(!get_parameter("quanti_pleio_matrix")->isSet())
       return error("\"quanti_pleio_matrix\" must be provided when pleiotropy type is \"variable\".\n");
  
     _pleio_type = 2;
  
 #ifdef _DEBUG_
   message("quant::%s pleiotropy, %i trait(s), %i loci\n",  "variable", _num_traits, _num_locus);
 #endif
  
     if(!setMutationModel_var_pleio()) return false;
  
   } else {
     return error("\"quanti_pleiotropy\" takes options: full (f), var(iable) (v), or no (n)\n");
   }
  
 #ifdef _DEBUG_
   // print _trait_table (for debugging purposes only
   message("quant::pleiotropic locus sequence position per trait (_trait_table) (ID:pos of first 10 loci/trait): \n");
   for(unsigned int i=0; i<_trait_table.size(); ++i){
     message("trait %i:\n", i);
     for(unsigned int j=0; j <_trait_table[i].size() && j < 10; ++j){
       message("%i:%i | ", _trait_locus_table[i][j], _trait_table[i][j]);
     }
     message("\n");
   }
   message("\n_trait_size: %i\n", _trait_table.size());
  
   // print _locus_table (for debugging purposes only)
   message("quant::pleiotropic degree per locus (_locus_table) (first position in sequence of a locus : PD; for the first 25 loci): \n");
   for(unsigned int i = 0; i <_locus_table.size() && i < 25; ++i){
     message("  %i: %i \n", _locus_table[i][0], _locus_table[i][1]);
   }
  
   message("quant::total sequence length: %i\n", _seq_length);
 #endif
  
   //---------------------------------------------------------------------------------------
   // ENVIRONMENTAL VARIANCE AND HERITABILITY
  
   // check and set environmental variance and heritability parameters:
   if( !setHeritabilityParams()) return false;
  
   // setting the pointer to the phenotype setter function
   // called in TProtoQuanti::get_phenotypic_value, itself called by TTQuanti::set_value()
   if(_eVariance.size() != 0 ) {
  
     _set_trait_value_func_ptr = &TProtoQuanti::set_trait_value_VE;
  
   } else { // no environmental effect
  
     _set_trait_value_func_ptr = &TProtoQuanti::set_trait_value_noVE;
  
   }
  
   //---------------------------------------------------------------------------------------
   // INITIAL TRAIT VALUES
   if( !setInitialValuesParams()) return false;
  
   //---------------------------------------------------------------------------------------
   // COMPUTING GENOTYPE VALUES: ADDITVITY and DOMINANCE
  
   if( !setDominanceParameters() ) return false;
  
   //---------------------------------------------------------------------------------------
   // EPISTASIS
   if( !setEpistasisParameters() ) return false;
  
  
   //---------------------------------------------------------------------------------------
   // set pointers to genotype value setter
  
   // epistasis is hidden in the additive and dominance value setter of the "epistatic" classes
   // epistasis is thus allowed on top of dominance
  
  
   // set function pointers to default k-dominance model if dominance is added
   if(_dominance_model) {
  
     _set_genotype_func_ptr = &TProtoQuanti::set_genotype_value_dominance;
     _getGenotypeWithDominance = &TProtoQuanti::get_genotype_dominance_k;
  
   } else {
  
     _set_genotype_func_ptr = &TProtoQuanti::set_genotype_value_additive;
     _getGenotypeWithDominance = 0;
  
   }
  
  
  
   //---------------------------------------------------------------------------------------
   // GENETIC MAP AND INHERIT FUNCTION POINTER
  
   if( !setGeneticMapParams()) return false;
  
 #ifdef _DEBUG_
  
   TTQuanti* trait = hatch();
  
   trait->init();
   trait->init_sequence();
   message("quant::parameters are set; display individual trait info:\n");
   trait->show_up();
  
   delete trait;
  
 #endif
  
   return true;
 }

References _2L, _allele_model, _diallele_datatype, _dominance_model, _eVariance, _genomic_mutation_rate, _getGenotypeWithDominance, _locus_table, _mutation_rate, _num_locus, _num_traits, _pleio_type, _seq_length, _set_genotype_func_ptr, _set_trait_value_func_ptr, _sizeofLocusType, _trait_locus_table, _trait_table, deallocate_gsl_mutation_matrix_space(), error(), get_genotype_dominance_k(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getArg(), hatch(), TTrait::init(), TTrait::init_sequence(), message(), set_genotype_value_additive(), set_genotype_value_dominance(), set_trait_value_noVE(), set_trait_value_VE(), setAlleleModel(), setDominanceParameters(), setEpistasisParameters(), setGeneticMapParams(), setHeritabilityParams(), setInitialValuesParams(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), TTrait::show_up(), and warning().

◆ setTraitAndLocusTables_full_pleio()

void TProtoQuanti::setTraitAndLocusTables_full_pleio ( )

 {
   // set the number of loci per trait in the _trait_table
   _trait_table.clear();
   _trait_table.assign(_num_traits, vector<unsigned int>(_num_locus));
  
   for(unsigned int i = 0; i < _num_traits; ++i) {
     for(unsigned int j = 0; j < _num_locus; ++j)
     _trait_table[i][j] = j*_num_traits + i;
   }
  
   // set the ID of loci affecting each trait in the _trait_locus_table
   _trait_locus_table.clear();
   _trait_locus_table.assign(_num_traits, vector<unsigned int>(_num_locus));
  
   for(unsigned int i = 0; i < _num_traits; ++i)
     for(unsigned int j = 0; j < _num_locus; ++j)
       _trait_locus_table[i][j] = j;
  
   // build _locus_table from _pleio_matx
   // table holding { start locus index in sequence , pleiotropic degree } on each row
   _locus_table.clear();
   _locus_table.assign(_num_locus, vector<unsigned int>(2));
  
   for(unsigned int i = 0; i < _num_locus; ++i) {
     _locus_table[i][0] = i*_num_traits;
     _locus_table[i][1] = _num_traits;
   }
 }

References _locus_table, _num_locus, _num_traits, _trait_locus_table, and _trait_table.

Referenced by setMutationModel_full_pleio().

◆ setTraitAndLocusTables_no_pleio()

void TProtoQuanti::setTraitAndLocusTables_no_pleio ( TMatrix & mat )

 {
   // loci are contiguous, separated in chunks each affecting different traits
  
   // set the number of loci array position in the _trait_table
   // starting position in the sequence array of each locus set is the first value of each row
   _trait_table.clear();
  
   unsigned int loc = 0;
  
   for(unsigned int i = 0; i < _num_traits; ++i) {
  
     _trait_table.push_back(vector<unsigned int>(numLoc.get(0,i)));
  
     for(unsigned int j = 0; j < numLoc.get(0,i); ++j)
  
       _trait_table[i][j] = loc++;
   }
  
   assert(loc == _num_locus);
  
   // set the ID of loci affecting each trait in the _trait_locus_table,
   _trait_locus_table.clear();
   _trait_locus_table.assign(_num_traits, vector<unsigned int>());
  
   // here we just copy the _trait_table
   for(unsigned int i = 0; i < _num_traits; ++i) {
     _trait_locus_table[i].assign(_trait_table[i].begin(), _trait_table[i].end());
   }
  
   // build _locus_table from _pleio_matx
   // table holding { start locus index in sequence , pleiotropic degree } on each row
   _locus_table.clear();
   _locus_table.assign(_num_locus, vector<unsigned int>(2));
  
   for(unsigned int i = 0; i < _num_locus; ++i) {
     _locus_table[i][0] = i;
     _locus_table[i][1] = 1;
   }
 }

References _locus_table, _num_locus, _num_traits, _trait_locus_table, _trait_table, and TMatrix::get().

Referenced by setMutationModel_no_pleio().

◆ store_data()

virtual void TProtoQuanti::store_data ( BinaryStorageBuffer * saver )

inlinevirtual

Implements StorableComponent.

587 {saver->store(&_seq_length,sizeof(int));}

BinaryStorageBuffer::store

void store(void *stream, unsigned int nb_bytes)

Definition: binarystoragebuffer.cc:16

References _seq_length, and BinaryStorageBuffer::store().

Friends And Related Function Documentation

◆ TTQuanti

friend class TTQuanti

friend

◆ TTQuanti_continuous

friend class TTQuanti_continuous

friend

◆ TTQuanti_continuous_full_pleio

friend class TTQuanti_continuous_full_pleio

friend

Referenced by hatch().

◆ TTQuanti_continuous_no_pleio

friend class TTQuanti_continuous_no_pleio

friend

Referenced by hatch().

◆ TTQuanti_continuous_single

friend class TTQuanti_continuous_single

friend

◆ TTQuanti_continuous_var_pleio

friend class TTQuanti_continuous_var_pleio

friend

Referenced by hatch().

Member Data Documentation

◆ _2L

unsigned int TProtoQuanti::_2L

protected

Diploid locus size, to save on useless operations during mutation.

Referenced by get_num_mutations(), and setParameters().

◆ _all_chooser

bool* TProtoQuanti::_all_chooser

private

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

◆ _allele_model

unsigned int TProtoQuanti::_allele_model

protected

Referenced by get_allele_model(), get_allele_number(), hatch(), loadFileServices(), setDiallelicMutationModel(), setInitialValuesParams(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), and setParameters().

◆ _allele_value

TMatrix TProtoQuanti::_allele_value

private

Referenced by get_diallele_value(), get_diallele_values(), getMutationEffectBivariateDiallelic(), and setDiallelicMutationModel().

◆ _diallele_datatype

string TProtoQuanti::_diallele_datatype

protected

Referenced by hatch(), and setParameters().

◆ _doInitMutation

unsigned int TProtoQuanti::_doInitMutation

private

Referenced by get_doInitMutation(), and setInitialValuesParams().

◆ _dominance_effects

TMatrix TProtoQuanti::_dominance_effects

private

Referenced by get_dominance(), get_dominance_effects(), and setDominanceParameters().

◆ _dominance_model

unsigned int TProtoQuanti::_dominance_model

private

Referenced by get_dominance_model(), setDominanceParameters(), and setParameters().

◆ _effects_bivar

double TProtoQuanti::_effects_bivar[2]

private

Referenced by getMutationEffectBivariateDiallelic(), getMutationEffectBivariateGaussian(), getMutationEffectBivariateGaussianLocSpec(), getMutationEffectUnivariateGaussian(), and getMutationEffectUnivariateGaussianLocSpec().

◆ _effects_multivar

gsl_vector** TProtoQuanti::_effects_multivar

private

Referenced by allocate_gsl_mutation_matrix_space(), deallocate_gsl_mutation_matrix_space(), getMutationEffectMultivariateGaussian(), getMutationEffectMultivariateGaussianLocSpec(), set_mutation_matrix_decomposition(), setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ _epistasis

bool TProtoQuanti::_epistasis

private

Referenced by do_epistasis(), hatch(), and setEpistasisParameters().

◆ _epistatic_coefs_indices

TMatrix TProtoQuanti::_epistatic_coefs_indices

private

Referenced by get_epi_coef_index(), setEpistasisParameters(), and TProtoQuanti().

◆ _epistatic_coefs_matrix

TMatrix TProtoQuanti::_epistatic_coefs_matrix

private

Referenced by get_epi_coefs(), setEpistasisParameters(), and TProtoQuanti().

◆ _equal_dom_coeff

bool TProtoQuanti::_equal_dom_coeff

private

Referenced by has_equal_domCoeff(), and setDominanceParameters().

◆ _equal_effects

bool TProtoQuanti::_equal_effects

private

Referenced by has_equal_effects(), setDiallelicMutationModel(), and TProtoQuanti().

◆ _equal_val_0

double TProtoQuanti::_equal_val_0

private

Referenced by get_equal_val_0(), setDiallelicMutationModel(), and TProtoQuanti().

◆ _equal_val_1

double TProtoQuanti::_equal_val_1

private

Referenced by get_equal_val_1(), setDiallelicMutationModel(), and TProtoQuanti().

◆ _equal_val_diff

double TProtoQuanti::_equal_val_diff

private

Referenced by get_equal_val_diff(), setDiallelicMutationModel(), and TProtoQuanti().

◆ _eval

gsl_vector** TProtoQuanti::_eval

private

Referenced by allocate_gsl_mutation_matrix_space(), deallocate_gsl_mutation_matrix_space(), getMutationEffectMultivariateGaussian(), getMutationEffectMultivariateGaussianLocSpec(), set_mutation_matrix_decomposition(), setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ _eVariance

vector<double> TProtoQuanti::_eVariance

private

Referenced by get_env_var(), set_eVarianceSD(), set_trait_value_VE(), setHeritabilityParams(), and setParameters().

◆ _evect

gsl_matrix** TProtoQuanti::_evect

private

Referenced by allocate_gsl_mutation_matrix_space(), deallocate_gsl_mutation_matrix_space(), getMutationEffectMultivariateGaussian(), getMutationEffectMultivariateGaussianLocSpec(), set_mutation_matrix_decomposition(), setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ _freqExtractor

TTQFreqExtractor* TProtoQuanti::_freqExtractor

private

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

◆ _genomic_mutation_rate

double TProtoQuanti::_genomic_mutation_rate

protected

Referenced by get_trait_mutation_variance(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), and setParameters().

◆ _getGenotypeWithDominance

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

private

Pointer to either dominance_h() or dominance_k() function computing the genotypic value with dominance.

Referenced by setParameters().

◆ _getMutationValues

double*(TProtoQuanti::* TProtoQuanti::_getMutationValues) (unsigned int)

private

Pointer to mutation allele value function, which depends on allele model and number of traits affected.

Referenced by getMutationEffects(), TTQuanti_continuous_full_pleio::init_sequence(), mutate_full_pleio(), mutate_inplace_full_pleio(), mutate_inplace_no_pleio(), mutate_no_pleio(), setMutationModel_full_pleio(), and setMutationModel_no_pleio().

◆ _getMutationValuesVarPleio

vector< double* (TProtoQuanti::* ) (unsigned int) > TProtoQuanti::_getMutationValuesVarPleio

private

Collection of pointers to mutation functions, which generate allele values in dependence of pleiotropic degree.

Referenced by getMutationEffectsVarPleio(), mutate_inplace_var_pleio(), mutate_var_pleio(), and setMutationModel_var_pleio().

◆ _gsl_mutation_matrix

gsl_matrix** TProtoQuanti::_gsl_mutation_matrix

private

Referenced by allocate_gsl_mutation_matrix_space(), deallocate_gsl_mutation_matrix_space(), set_mutation_matrix_decomposition(), setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

◆ _h2

vector<double> TProtoQuanti::_h2

private

Referenced by get_heritability(), and setHeritabilityParams().

◆ _h2_isBroad

bool TProtoQuanti::_h2_isBroad

private

Referenced by get_h2_isBroad(), and setHeritabilityParams().

◆ _h2_setTime

unsigned int TProtoQuanti::_h2_setTime

private

Referenced by get_h2_setTime(), and setHeritabilityParams().

◆ _inherit_fun_ptr

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

private

Pointer to inheritance functions: either inherit_free() (r=0.5), or inherit_low() (r<0.5).

Referenced by inherit(), and setGeneticMapParams().

◆ _init_value

TMatrix TProtoQuanti::_init_value

private

Referenced by get_init_value(), set_init_values(), and setInitialValuesParams().

◆ _init_variance

TMatrix TProtoQuanti::_init_variance

private

Referenced by get_init_variance(), and setInitialValuesParams().

◆ _locus_table

vector< vector<unsigned int> > TProtoQuanti::_locus_table

private

Locus table, num_locus x 2, first column holds the start position of the alleles of each locus in the sequence, second column counts the number of alleles = pleiotropic degree.

Allelic values at a locus are contiguous in the sequence.

Referenced by get_locus_PD(), get_locus_start_pos(), get_sequence_block_size(), mutate_diallelic_var_pleio(), mutate_inplace_var_pleio(), mutate_var_pleio(), setContinuousMutationModel_var_pleio(), setMutationModel_var_pleio(), setParameters(), setTraitAndLocusTables_full_pleio(), and setTraitAndLocusTables_no_pleio().

◆ _locusByteSize

size_t TProtoQuanti::_locusByteSize

private

Referenced by get_locus_byte_size(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), and TProtoQuanti().

◆ _mutation_correlation

TMatrix TProtoQuanti::_mutation_correlation

private

Referenced by getMutationEffectBivariateDiallelic(), getMutationEffectBivariateGaussian(), getMutationEffectBivariateGaussianLocSpec(), mutate_diallelic_pleio(), mutate_diallelic_var_pleio(), set_gsl_mutation_matrix_from_sigma(), setContinuousMutationModel_full_pleio(), setContinuousMutationModel_var_pleio(), and setMutationCorrelation().

◆ _mutation_func_ptr

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

private

Pointer to mutation function, which depends on allele on model (HC, noHC, diallelic)

Referenced by mutate(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), and setMutationModel_var_pleio().

◆ _mutation_rate

double TProtoQuanti::_mutation_rate

protected

Referenced by get_num_mutations(), get_trait_mutation_variance(), and setParameters().

◆ _mutation_sigma

TMatrix TProtoQuanti::_mutation_sigma

private

Referenced by get_trait_mutation_variance(), getMutationEffectBivariateGaussian(), getMutationEffectBivariateGaussianLocSpec(), getMutationEffectUnivariateGaussian(), getMutationEffectUnivariateGaussianLocSpec(), set_gsl_mutation_matrix_from_sigma(), setContinuousMutationModel_full_pleio(), setContinuousMutationModel_no_pleio(), setContinuousMutationModel_var_pleio(), setMutationSigmaFromQuantiMutationVariance(), and setMutationSigmaFromQuantiMutationVariance_no_pleio().

◆ _mutationEffectIsFixedDiAllele

bool TProtoQuanti::_mutationEffectIsFixedDiAllele

private

◆ _mutationVarianceIsLocusSpecific

bool TProtoQuanti::_mutationVarianceIsLocusSpecific

private

Referenced by deallocate_gsl_mutation_matrix_space(), readMatrixFromQuantiMutationMatrix(), set_gsl_mutation_matrix_from_sigma(), setContinuousMutationModel_full_pleio(), setContinuousMutationModel_no_pleio(), setContinuousMutationModel_var_pleio(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), and setMutationModel_var_pleio().

◆ _num_epi_coefs

unsigned int TProtoQuanti::_num_epi_coefs

private

Referenced by get_num_epi_coefs(), and setEpistasisParameters().

◆ _num_locus

unsigned int TProtoQuanti::_num_locus

protected

Total number of loci, for all traits.

Referenced by deallocate_gsl_mutation_matrix_space(), get_locus_number(), get_num_locus(), get_sequence_block_size(), inherit_free(), mutate_diallelic_no_pleio(), mutate_diallelic_pleio(), mutate_diallelic_var_pleio(), mutate_full_pleio(), mutate_inplace_full_pleio(), mutate_inplace_no_pleio(), mutate_inplace_var_pleio(), mutate_no_pleio(), mutate_var_pleio(), readMatrixFromQuantiMutationMatrix(), setContinuousMutationModel_full_pleio(), setContinuousMutationModel_var_pleio(), setDiallelicMutationModel(), setDominanceParameters(), setEpistasisParameters(), setGeneticMapParams(), setMutationCorrelation(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), setMutationSigmaFromQuantiMutationVariance(), setMutationSigmaFromQuantiMutationVariance_no_pleio(), setParameters(), setTraitAndLocusTables_full_pleio(), and setTraitAndLocusTables_no_pleio().

◆ _num_traits

unsigned int TProtoQuanti::_num_traits

protected

◆ _ohtaStats

TTQOhtaStats* TProtoQuanti::_ohtaStats

private

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

◆ _pleio_matx

TMatrix TProtoQuanti::_pleio_matx

private

Pleiotropy matrix provided in input (num locu X num trait).

Gene (row)-trait (column) connectivity matrix.

Referenced by get_pleio_matrix(), setMutationModel_var_pleio(), and TProtoQuanti().

◆ _pleio_type

unsigned int TProtoQuanti::_pleio_type

protected

Referenced by get_pleiotropy_type(), hatch(), readMatrixFromQuantiMutationMatrix(), and setParameters().

◆ _reader

TTQuantiFH* TProtoQuanti::_reader

private

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

◆ _seq_length

unsigned int TProtoQuanti::_seq_length

protected

Total number of allelic values stored in individual sequences, no trait x no locus.

Referenced by get_seq_length(), get_sequence_block_size(), retrieve_data(), setDiallelicMutationModel(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), setParameters(), and store_data().

◆ _sequence_diallele_values

double* TProtoQuanti::_sequence_diallele_values[2]

private

Referenced by get_seq_diallele_value(), setDiallelicMutationModel(), TProtoQuanti(), and ~TProtoQuanti().

◆ _set_genotype_func_ptr

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

private

Pointer to functions get_genotype_value_additive() or get_genotype_value_dominance() computing the genotypic value of a trait as function of allele effect.

Referenced by get_genotypic_value(), set_trait_value_noVE(), and setParameters().

◆ _set_trait_value_func_ptr

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

private

Pointer to either set_trait_value_VE() or set_trait_value_noVE() to compute phenotypic values.

Will call function to compute genotype values stored in _set_genotype_func_ptr.

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

◆ _sizeofLocusType

size_t TProtoQuanti::_sizeofLocusType

private

Referenced by get_size_locus_type(), inherit_low(), setMutationModel_full_pleio(), setMutationModel_no_pleio(), setMutationModel_var_pleio(), and setParameters().

◆ _stats

TTQuantiSH* TProtoQuanti::_stats

private

Referenced by get_stater(), loadStatServices(), and ~TProtoQuanti().

◆ _trait_locus_table

vector< vector<unsigned int> > TProtoQuanti::_trait_locus_table

private

Table storing the locus id of each locus affecting each trait (num trait X (variable length/trait)).

Referenced by get_allele_position(), get_locus_ID(), setMutationModel_var_pleio(), setParameters(), setTraitAndLocusTables_full_pleio(), and setTraitAndLocusTables_no_pleio().

◆ _trait_masks

vector<bitstring> TProtoQuanti::_trait_masks

private

Referenced by get_trait_mask(), and setDiallelicMutationModel().

◆ _trait_table

vector< vector<unsigned int> > TProtoQuanti::_trait_table

private

Trait table, (num trait X (variable length/trait)), holds, for each trait, the array position of causative alleles in the sequence.

Referenced by get_allele_position(), get_locus_seq_pos(), get_num_locus(), setDiallelicMutationModel(), setMutationModel_var_pleio(), setMutationSigmaFromQuantiMutationVariance_no_pleio(), setParameters(), setTraitAndLocusTables_full_pleio(), and setTraitAndLocusTables_no_pleio().

◆ _writer

TTQuantiFH* TProtoQuanti::_writer

private

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

◆ _ws

gsl_vector** TProtoQuanti::_ws

private

Referenced by allocate_gsl_mutation_matrix_space(), deallocate_gsl_mutation_matrix_space(), getMutationEffectMultivariateGaussian(), getMutationEffectMultivariateGaussianLocSpec(), set_mutation_matrix_decomposition(), setContinuousMutationModel_full_pleio(), and setContinuousMutationModel_var_pleio().

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

Public Member Functions

Protected Attributes

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TProtoQuanti() [1/2]

◆ TProtoQuanti() [2/2]

◆ ~TProtoQuanti()

Member Function Documentation

◆ allocate_gsl_mutation_matrix_space()

◆ clone()

◆ deallocate_gsl_mutation_matrix_space()

◆ do_epistasis()

◆ get_allele_model()

◆ get_allele_number()

◆ get_allele_position()

◆ get_allele_value()

◆ get_diallele_value()

◆ get_diallele_values()

◆ get_doInitMutation()

◆ get_dominance()

◆ get_dominance_effects()

◆ get_dominance_model()

◆ get_env_var()

◆ get_epi_coef_index()

◆ get_epi_coefs()

◆ get_equal_val_0()

◆ get_equal_val_1()

◆ get_equal_val_diff()

◆ get_genotype_dominance_h()

◆ get_genotype_dominance_k()

◆ get_genotype_with_dominance()

◆ get_genotypic_value()

◆ get_h2_isBroad()

◆ get_h2_setTime()

◆ get_heritability()

◆ get_init_value()

◆ get_init_variance()

◆ get_locus_byte_size()

◆ get_locus_ID()

◆ get_locus_number()

◆ get_locus_PD()

◆ get_locus_seq_pos()

◆ get_locus_start_pos()

◆ get_num_epi_coefs()

◆ get_num_locus() [1/2]

◆ get_num_locus() [2/2]

◆ get_num_mutations()

◆ get_num_traits()

◆ get_phenotype_dimension()

◆ get_phenotypic_value()

◆ get_pleio_matrix()

◆ get_pleiotropy_type()

◆ get_seq_diallele_value()

◆ get_seq_length()

◆ get_sequence_block_size()

◆ get_size_locus_type()

◆ get_stater()

◆ get_trait_mask()

◆ get_trait_mutation_variance()

◆ get_type()

◆ getMutationEffectBivariateDiallelic()

◆ getMutationEffectBivariateGaussian()

◆ getMutationEffectBivariateGaussianLocSpec()

◆ getMutationEffectMultivariateGaussian()

◆ getMutationEffectMultivariateGaussianLocSpec()

◆ getMutationEffects()

◆ getMutationEffectsVarPleio()

◆ getMutationEffectUnivariateGaussian()

◆ getMutationEffectUnivariateGaussianLocSpec()

◆ has_equal_domCoeff()

◆ has_equal_effects()

◆ hatch()

◆ inherit()

◆ inherit_free()

◆ inherit_low()

◆ loadFileServices()

◆ loadStatServices()