TTQuantiSH Class Reference

TTQuantiSH. More...

#include <ttquanti.h>

Inheritance diagram for TTQuantiSH:

Collaboration diagram for TTQuantiSH:

Public Member Functions
	TTQuantiSH (TProtoQuanti *TP)
virtual	~TTQuantiSH ()
void	resetPtrs ()
virtual void	init ()
virtual bool	setStatRecorders (std::string &token)
void	addQuanti (age_t AGE)
void	addEigen (age_t AGE)
void	addEigenValues (age_t AGE)
void	addEigenVect1 (age_t AGE)
void	addQuantiPerPatch (age_t AGE)
void	addAvgPerPatch (age_t AGE)
void	addGenotPerPatch (age_t AGE)
void	addVarPerPatch (age_t AGE)
void	addCovarPerPatch (age_t AGE)
void	addEigenPerPatch (age_t AGE)
void	addEigenValuesPerPatch (age_t AGE)
void	addEigenVect1PerPatch (age_t AGE)
void	addEigenStatsPerPatcg (age_t AGE)
void	addSkewPerPatch (age_t AGE)
void	addQuantiEpistasis (age_t AGE)
void	addEffectStats (age_t AGE)
void	setDataTables (age_t AGE)
void	setAdultStats ()
void	setOffsprgStats ()
void	setStats (age_t AGE)
double	getMeanGenot (unsigned int i)
double	getMeanPhenot (unsigned int i)
double	getVa (unsigned int i)
double	getVg (unsigned int i)
double	getVb (unsigned int i)
double	getVp (unsigned int i)
double	getQst (unsigned int i)
double	getCovar (unsigned int i)
double	getEigenValue (unsigned int i)
double	getEigenVectorElt (unsigned int t1, unsigned int t2)
double	getVaH ()
double	getNbAlleles (unsigned int i)
double	getMeanEffectSize (unsigned int i)
double	getMeanGenotPerPatch (unsigned int i, unsigned int p)
double	getMeanPhenotPerPatch (unsigned int i, unsigned int p)
double	getVaPerPatch (unsigned int i, unsigned int p)
double	getVpPerPatch (unsigned int i, unsigned int p)
double	getEigenValuePerPatch (unsigned int i, unsigned int p)
double	getCovarPerPatch (unsigned int p, unsigned int i)
double	getEigenVectorEltPerPatch (unsigned int p, unsigned int v)
double	getSkewPerPatch (unsigned int i, unsigned int p)
vector< double >	getSNPalleleFreqInPatch (Patch *patch, const age_idx AGE)
vector< double >	getVaWithDominance (Patch *curPop, const age_idx AGE)
	computation of the additive genetic variance from the average excess of each allele exact under random mating only More...
vector< double >	getVaNoDominance (Patch *curPop, const age_idx AGE)
Public Member Functions inherited from TraitStatHandler< TProtoQuanti, TTQuantiSH >
	TraitStatHandler (TProtoQuanti *trait_proto)
virtual	~TraitStatHandler ()
Public Member Functions inherited from StatHandler< SH >
	StatHandler ()
virtual	~StatHandler ()
virtual void	clear ()
	Empties the _recorders list, they are destroyed in StatHandlerBase::reset(). More...
virtual StatRecorder< SH > *	add (std::string Title, std::string Name, age_t AGE, unsigned int ARG1, unsigned int ARG2, double(SH::*getStatNoArg)(void), double(SH::*getStatOneArg)(unsigned int), double(SH::*getStatTwoArg)(unsigned int, unsigned int), void(SH::*setStat)(void))
	Adds a StatRecorder to the list, it is also added to the StatHandlerBase::_stats list. More...
Public Member Functions inherited from StatHandlerBase
	StatHandlerBase ()
virtual	~StatHandlerBase ()
virtual void	reset ()
	Empties the _stats list and calls clear() (defined in the derived class). More...
Metapop *	get_pop_ptr ()
void	set_service (StatServices *srv)
StatServices *	get_service ()
unsigned int	getOccurrence ()
unsigned int	getNumOccurrences ()
unsigned int	getCurrentOccurrence ()
unsigned int	getNbRecorders ()
std::list< StatRecBase * > &	getStats ()
virtual void	add (StatRecBase *rec)
virtual void	update ()
	This function is left empty as the StatServices calls StatRecorder::setVal directly. More...
Public Member Functions inherited from Handler
virtual	~Handler ()

Private Attributes
double	_VaH
double *	_meanP
double *	_meanG
double *	_Va
double *	_Vg
double *	_Vb
double *	_Vp
double *	_covar
double *	_eigval
double **	_eigvect
double *	_meanEffectSize
double **	_pmeanP
double **	_pmeanG
double **	_pVa
double **	_pVp
double **	_pcovar
double **	_peigval
double **	_peigvect
double **	_pmeanL
double **	_pVaL
double **	_pmeanEpiL
unsigned int	_num_locus
unsigned int	_num_trait
unsigned int	_patchNbr
bool	_eVar
bool	_epistats
bool	_alleleStats
set< long int > *	_uniqueEffectSizes
map< long int, int > *	_countUniqueEffects
gsl_matrix *	_G
gsl_matrix *	_evec
gsl_vector *	_eval
gsl_eigen_symmv_workspace *	_ws
DataTable< double >	_phenoTable
DataTable< double >	_genoTable
DataTable< double >	_lociTable
DataTable< double >	_lociRefTable
unsigned int	_table_set_gen
unsigned int	_table_set_age
unsigned int	_table_set_repl

Additional Inherited Members
Protected Types inherited from StatHandler< SH >
typedef std::list< StatRecorder< SH > * >::iterator	REC_IT
Protected Attributes inherited from TraitStatHandler< TProtoQuanti, TTQuantiSH >
TProtoQuanti *	_SHLinkedTrait
	Pointer to a TraitProtoype object. More...
int	_SHLinkedTraitIndex
	Index of the trait in the Individual::Traits table. More...
Protected Attributes inherited from StatHandler< SH >
std::list< StatRecorder< SH > * >	_recorders
	The list of stat recorders. More...
Protected Attributes inherited from StatHandlerBase
Metapop *	_pop
	Link to the current population, set through the link to the StatService. More...

Detailed Description

TTQuantiSH.

Constructor & Destructor Documentation

TTQuantiSH()

TTQuantiSH::TTQuantiSH ( TProtoQuanti *  TP )

inline

    : TraitStatHandler<TProtoQuanti, TTQuantiSH> (TP), 
    _VaH(0), _meanP(0), _meanG(0), _Va(0), _Vg(0), _Vb(0), _Vp(0), _covar(0), _eigval(0), _eigvect(0), _meanEffectSize(0),
    _pmeanP(0), _pmeanG(0), _pVa(0), _pVp(0), _pcovar(0), _peigval(0), _peigvect(0), _pmeanL(0), _pVaL(0), _pmeanEpiL(0),
    _num_locus(0), _num_trait(0),_patchNbr(0), _eVar(0), _epistats(0), _alleleStats(0),
    _uniqueEffectSizes(0), _countUniqueEffects(0),
    _G(0), _evec(0),_eval(0),_ws(0),
    _table_set_gen(999999), _table_set_age(999999), _table_set_repl(999999)
    {}

~TTQuantiSH()

virtual TTQuantiSH::~TTQuantiSH ( )

inlinevirtual

{resetPtrs();}

References resetPtrs().

Member Function Documentation

addAvgPerPatch()

void TTQuantiSH::addAvgPerPatch

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addAvgPerPatch(ADULTS);
    addAvgPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name;
  string patch;
  string t1;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("Mean phenotype of trait 1 in patch 1", suffix + "q1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getMeanPhenotPerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; p++) {
    for(unsigned int i = 0; i < _num_trait; i++) {
      if(p == 0 && i == 0) continue;
      name = "Mean phenotype of trait " + tstring::int2str(i+1) + " in patch " + tstring::int2str(p+1);
      t1 = "q" + tstring::int2str(i+1);
      patch = ".p" + tstring::int2str(p+1);
      add(name, suffix + t1 + patch, AGE, i, p, 0, 0, &TTQuantiSH::getMeanPhenotPerPatch, 0);
    }
  }
 
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), ADULTS, ALL, getMeanPhenotPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addQuantiPerPatch(), and setStatRecorders().

addCovarPerPatch()

void TTQuantiSH::addCovarPerPatch

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    //    warning("not recording traits covariance with only one \"quanti\" trait!");
    return;
  }
 
  if (AGE == ALL) {
    addCovarPerPatch(ADULTS);
    addCovarPerPatch(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string patch;
  string cov;
  unsigned int patchNbr = _pop->getPatchNbr();
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("Genetic covariance of trait 1 and trait 2 in patch 1", suffix + "cov.q12.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getCovarPerPatch, setter);
 
  unsigned int c;
  for(unsigned int p = 0; p < patchNbr; p++) {
    patch = ".p" + tstring::int2str(p+1);
    c = 0;
    for(unsigned int t = 0; t < _num_trait; ++t) {
      for(unsigned int v = t + 1; v < _num_trait; ++v){
        if(p==0 && t==0 && v==1) {c++; continue;} //this on is already recorder above
        cov = tstring::int2str((t+1)*10+v+1);
        add("", suffix + "cov.q" + cov + patch,  AGE, c++, p, 0, 0, &TTQuantiSH::getCovarPerPatch, 0);
      }
    }
  }
 
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), ADULTS, ALL, getCovarPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addQuantiPerPatch(), and setStatRecorders().

addEffectStats()

void TTQuantiSH::addEffectStats

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addEffectStats(ADULTS);
    addEffectStats(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name = suffix + "q";
  string t1, t2;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
                                        &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("",suffix + "q1.alleles",AGE,0,0,0,&TTQuantiSH::getNbAlleles,0,setter);
 
  //Alleles
  for(unsigned int i = 1; i < _num_trait; i++) {
    t1 = tstring::int2str(i+1);
    add("", name + t1 +".alleles",AGE,i,0,0,&TTQuantiSH::getNbAlleles,0,0);
  }
 
  //MeanEffect
  for(unsigned int i = 0; i < _num_trait; i++) {
    t1 = tstring::int2str(i+1);
    add("", name + t1 +".mean.effect",AGE,i,0,0,&TTQuantiSH::getMeanEffectSize,0,0);
  }
}

References _num_trait, StatHandler< SH >::add(), ADULTS, ALL, getMeanEffectSize(), getNbAlleles(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by setStatRecorders().

addEigen()

void TTQuantiSH::addEigen

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    warning("not recording G-matrix eigen stats with only one \"quanti\" trait!\n");
    return;
  }
 
  if (AGE == ALL) {
    addEigen(ADULTS);
    addEigen(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("", suffix + "q.eval1",AGE,0,0,0,&TTQuantiSH::getEigenValue, 0, setter); //this one calls the setter
 
  for(unsigned int t = 1; t < _num_trait; ++t)
    add("", suffix + "q.eval" + tstring::int2str(t+1),AGE,t,0,0,&TTQuantiSH::getEigenValue, 0, 0);
 
  for(unsigned int t = 0; t< _num_trait; ++t)
    for(unsigned int v = 0; v < _num_trait; ++v)
      add("", suffix + "q.evect" + tstring::int2str((t+1)*10+(v+1)),AGE,t,v,0,0,&TTQuantiSH::getEigenVectorElt,0);
 
}

References _num_trait, StatHandler< SH >::add(), ADULTS, ALL, getEigenValue(), getEigenVectorElt(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

Referenced by addEigenValues(), and addEigenVect1().

addEigenPerPatch()

void TTQuantiSH::addEigenPerPatch

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    warning("not recording G-matrix eigen stats with only one \"quanti\" trait!\n");
    return;
  }
 
  if (AGE == ALL) {
    addEigenPerPatch(ADULTS);
    addEigenPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string patch;
  unsigned int pv =0;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
 
  add("First G-matrix eigenvalue in patch 1", suffix + "qeval1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getEigenValuePerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; ++p) {
    patch = ".p" + tstring::int2str(p+1);
    for(unsigned int t = 0; t < _num_trait; ++t) {
      if(p==0 && t==0) continue;
      add("", suffix + "qeval" + tstring::int2str(t+1) + patch,  AGE, t, p, 0, 0, &TTQuantiSH::getEigenValuePerPatch,0);
    }
  }
  for(unsigned int p = 0; p < patchNbr; ++p) {
    patch = ".p" + tstring::int2str(p+1);
    pv = 0;
    for(unsigned int t = 0; t < _num_trait; ++t)
      for(unsigned int v = 0; v < _num_trait; ++v)
        add("", suffix + "qevect" + tstring::int2str((t+1)*10+v+1) + patch,  AGE, p, pv++, 0, 0, &TTQuantiSH::getEigenVectorEltPerPatch,0);
  }
 
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), ADULTS, ALL, getEigenValuePerPatch(), getEigenVectorEltPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

Referenced by addEigenValuesPerPatch(), addEigenVect1PerPatch(), and setStatRecorders().

addEigenStatsPerPatcg()

void TTQuantiSH::addEigenStatsPerPatcg

(

age_t

AGE

)

addEigenValues()

void TTQuantiSH::addEigenValues

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    warning("not recording G-matrix eigen stats with only one \"quanti\" trait!\n");
    return;
  }
 
  if (AGE == ALL) {
    addEigen(ADULTS);
    addEigen(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("", suffix + "q.eval1",AGE,0,0,0,&TTQuantiSH::getEigenValue, 0, setter);
 
  for(unsigned int t = 1; t < _num_trait; ++t)
    add("", suffix + "q.eval" + tstring::int2str(t+1),AGE,t,0,0,&TTQuantiSH::getEigenValue, 0, 0);
 
 
}

References _num_trait, StatHandler< SH >::add(), addEigen(), ADULTS, ALL, getEigenValue(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

addEigenValuesPerPatch()

void TTQuantiSH::addEigenValuesPerPatch

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    warning("not recording G-matrix eigen stats with only one \"quanti\" trait!\n");
    return;
  }
 
  if (AGE == ALL) {
    addEigenPerPatch(ADULTS);
    addEigenPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string patch;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("First G-matrix eigenvalue in patch 1", suffix + "qeval1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getEigenValuePerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; ++p) {
    patch = ".p" + tstring::int2str(p+1);
    for(unsigned int t = 0; t < _num_trait; ++t) {
      if(p==0 && t==0) continue;
      add("", suffix + "qeval" + tstring::int2str(t+1) + patch,  AGE, t, p, 0, 0, &TTQuantiSH::getEigenValuePerPatch,0);
    }
  }
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addEigenPerPatch(), ADULTS, ALL, getEigenValuePerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

Referenced by setStatRecorders().

addEigenVect1()

void TTQuantiSH::addEigenVect1

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    warning("not recording G-matrix eigen stats with only one \"quanti\" trait!\n");
    return;
  }
 
  if (AGE == ALL) {
    addEigen(ADULTS);
    addEigen(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("", suffix + "q.evect11",AGE,0,0,0,0,&TTQuantiSH::getEigenVectorElt,setter);
 
  for(unsigned int v = 1; v < _num_trait; ++v)
    add("", suffix + "q.evect1" + tstring::int2str(v+1),AGE,0,v,0,0,&TTQuantiSH::getEigenVectorElt,0);
 
}

References _num_trait, StatHandler< SH >::add(), addEigen(), ADULTS, ALL, getEigenVectorElt(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

addEigenVect1PerPatch()

void TTQuantiSH::addEigenVect1PerPatch

(

age_t

AGE

)

{
  if(_num_trait < 2) {
    warning("not recording G-matrix eigen stats with only one \"quanti\" trait!\n");
    return;
  }
 
  if (AGE == ALL) {
    addEigenPerPatch(ADULTS);
    addEigenPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string patch;
  unsigned int pv =0;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats :
      &TTQuantiSH::setOffsprgStats);
 
 
  add("First G-matrix eigenvector in patch 1", suffix + "qevect11.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getEigenVectorEltPerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; ++p) {
    patch = ".p" + tstring::int2str(p+1);
    pv = 0;
    //    for(unsigned int t = 0; t < _num_trait; ++t)
    for(unsigned int v = 0; v < _num_trait; ++v){
      if(p==0 && v==0) {pv++; continue;}
      add("", suffix + "qevect1" + tstring::int2str(v+1) + patch,  AGE, p, pv++, 0, 0, &TTQuantiSH::getEigenVectorEltPerPatch,0);
    }
  }
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addEigenPerPatch(), ADULTS, ALL, getEigenVectorEltPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

Referenced by setStatRecorders().

addGenotPerPatch()

void TTQuantiSH::addGenotPerPatch

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addGenotPerPatch(ADULTS);
    addGenotPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name;
  string patch;
  string t1;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("Mean genotype of trait 1 in patch 1", suffix + "g1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getMeanGenotPerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; p++) {
    for(unsigned int i = 0; i < _num_trait; i++) {
      if(p == 0 && i == 0) continue;
      name = "Mean genotype of trait " + tstring::int2str(i+1) + " in patch " + tstring::int2str(p+1);
      t1 = "g" + tstring::int2str(i+1);
      patch = ".p" + tstring::int2str(p+1);
      add(name, suffix + t1 + patch, AGE, i, p, 0, 0, &TTQuantiSH::getMeanGenotPerPatch, 0);
    }
  }
 
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), ADULTS, ALL, getMeanGenotPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by setStatRecorders().

addQuanti()

void TTQuantiSH::addQuanti

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addQuanti(ADULTS);
    addQuanti(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name = suffix + "q";
  string t1, t2;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("",suffix + "q1",AGE,0,0,0,&TTQuantiSH::getMeanPhenot,0,setter);
 
  for(unsigned int i = 1; i < _num_trait; i++) {
    t1 = tstring::int2str(i+1);
    add("", name + t1,AGE,i,0,0,&TTQuantiSH::getMeanPhenot,0,0);
  }
 
  //Va, no dominance, no epistasis
  if(_SHLinkedTrait->get_dominance_model() == 0 && !_SHLinkedTrait->do_epistasis()) {
    for(unsigned int i = 0; i < _num_trait; i++) {
      t1 = tstring::int2str(i+1);
      add("", name + t1 +".Va",AGE,i,0,0,&TTQuantiSH::getVa,0,0);
    }
  } else {
    //if dominance or epistasis, then what we record is Vg, not Va
    for(unsigned int i = 0; i < _num_trait; i++) {
          t1 = tstring::int2str(i+1);
          add("", name + t1 +".Vg",AGE,i,0,0,&TTQuantiSH::getVa,0,0);
        }
  }
 
  //Vp
  if(_eVar) {
    for(unsigned int i = 0; i < _num_trait; i++) {
      t1 = tstring::int2str(i+1);
      add("", name + t1 +".Vp",AGE,i,0,0,&TTQuantiSH::getVp,0,0);
    }
  }
  //Vb
  if(_pop->getPatchNbr() > 1){
    for(unsigned int i = 0; i < _num_trait; i++) {
      t1 = tstring::int2str(i+1);
      add("", name + t1 +".Vb",AGE,i,0,0,&TTQuantiSH::getVb,0,0);
    }
    //Qst
    for(unsigned int i = 0; i < _num_trait; i++) {
      t1 = tstring::int2str(i+1);
      add("", name + t1 +".Qst",AGE,i,0,0,&TTQuantiSH::getQst,0,0);
    }
  }
 
  if (_num_trait > 1) {
    unsigned int c = 0;
    for(unsigned int t = 0; t < _num_trait; ++t) {
      for(unsigned int v = t + 1; v < _num_trait; ++v) {
        t1 = tstring::int2str((t+1)*10+(v+1));
        add("", name + t1 +".cov", AGE, c++, 0,0,&TTQuantiSH::getCovar,0,0);
      }
    }
  }
}

References _eVar, _num_trait, StatHandlerBase::_pop, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, StatHandler< SH >::add(), ADULTS, ALL, TProtoQuanti::do_epistasis(), TProtoQuanti::get_dominance_model(), getCovar(), getMeanPhenot(), Metapop::getPatchNbr(), getQst(), getVa(), getVb(), getVp(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by setStatRecorders().

addQuantiEpistasis()

void TTQuantiSH::addQuantiEpistasis

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addQuantiEpistasis(ADULTS);
    addQuantiEpistasis(OFFSPRG);
    return;
  }
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name = suffix + "q";
  string t1, t2;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
                                        &TTQuantiSH::setAdultStats : &TTQuantiSH::setOffsprgStats);
 
  add("",suffix + "q1.VaH",AGE,0,0,&TTQuantiSH::getVaH,0,0,setter);
 
//  for(unsigned int i = 1; i < _num_trait; i++) {
//    t1 = tstring::int2str(i+1);
//    add("", name + t1 + ".std",AGE,i,0,0,&TTQuantiSH::getVaH,0,0);
//  }
}

References StatHandler< SH >::add(), ADULTS, ALL, getVaH(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by setStatRecorders().

addQuantiPerPatch()

void TTQuantiSH::addQuantiPerPatch

(

age_t

AGE

)

{
 
  if (AGE == ALL) {
    addQuantiPerPatch(ADULTS);
    addQuantiPerPatch(OFFSPRG);
    return;
  }
 
  addAvgPerPatch(AGE);
  addVarPerPatch(AGE);
  addCovarPerPatch(AGE);
  //  addEigenPerPatch(AGE);
 
}

References addAvgPerPatch(), addCovarPerPatch(), addVarPerPatch(), ADULTS, ALL, and OFFSPRG.

Referenced by setStatRecorders().

addSkewPerPatch()

void TTQuantiSH::addSkewPerPatch

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addSkewPerPatch(ADULTS);
    addSkewPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name;
  string patch;
  string t1;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats :
      &TTQuantiSH::setOffsprgStats);
 
  add("Genetic skew of trait 1 in patch 1", suffix + "Sk.q1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getSkewPerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; p++) {
    for(unsigned int i = 0; i < _num_trait; i++) {
      if(p == 0 && i == 0) continue;
      name = "Genetic skew of trait " + tstring::int2str(i+1) + " in patch " + tstring::int2str(p+1);
      t1 = "q" + tstring::int2str(i+1);
      patch = ".p" + tstring::int2str(p+1);
      add(name, suffix + "Sk." + t1 + patch, AGE, i, p, 0, 0, &TTQuantiSH::getSkewPerPatch, 0);
    }
  }
 
}

References _num_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), ADULTS, ALL, Metapop::getPatchNbr(), getSkewPerPatch(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by setStatRecorders().

addVarPerPatch()

void TTQuantiSH::addVarPerPatch

(

age_t

AGE

)

{
  if (AGE == ALL) {
    addVarPerPatch(ADULTS);
    addVarPerPatch(OFFSPRG);
    return;
  }
 
  unsigned int patchNbr = _pop->getPatchNbr();
 
  string suffix = (AGE == ADULTS ? "adlt.":"off.");
  string name;
  string patch;
  string t1;
  string Vtype;
 
 
  if(_SHLinkedTrait->get_dominance_model() == 0 || _SHLinkedTrait->do_epistasis())
    Vtype = "Vg.";
  else
    Vtype = "Va.";
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats :
      &TTQuantiSH::setOffsprgStats);
 
  add("Genetic variance of trait 1 in patch 1", suffix + Vtype + "q1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getVaPerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; p++) {
    for(unsigned int i = 0; i < _num_trait; i++) {
      if(p == 0 && i == 0) continue;
      name = "Genetic variance of trait " + tstring::int2str(i+1) + " in patch " + tstring::int2str(p+1);
      t1 = "q" + tstring::int2str(i+1);
      patch = ".p" + tstring::int2str(p+1);
      add(name, suffix + Vtype + t1 + patch, AGE, i, p, 0, 0, &TTQuantiSH::getVaPerPatch, 0);
    }
  }
 
  if(_eVar) {
    for(unsigned int p = 0; p < patchNbr; p++) {
      for(unsigned int i = 0; i < _num_trait; i++) {
        name = "Phenotypic variance of trait " + tstring::int2str(i+1) + " in patch " + tstring::int2str(p+1);
        t1 = "q" + tstring::int2str(i+1);
        patch = ".p" + tstring::int2str(p+1);
        add(name, suffix + "Vp." + t1 + patch, AGE, i, p, 0, 0, &TTQuantiSH::getVpPerPatch, 0);
      }
    }
  }
}

References _eVar, _num_trait, StatHandlerBase::_pop, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, StatHandler< SH >::add(), ADULTS, ALL, TProtoQuanti::do_epistasis(), TProtoQuanti::get_dominance_model(), Metapop::getPatchNbr(), getVaPerPatch(), getVpPerPatch(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addQuantiPerPatch(), and setStatRecorders().

getCovar()

double TTQuantiSH::getCovar ( unsigned int  i )

inline

{return _covar[i];}

References _covar.

Referenced by addQuanti().

getCovarPerPatch()

double TTQuantiSH::getCovarPerPatch ( unsigned int  p, unsigned int  i  )

inline

{return _pcovar[p][i];}

References _pcovar.

Referenced by addCovarPerPatch().

getEigenValue()

double TTQuantiSH::getEigenValue ( unsigned int  i )

inline

{return _eigval[i];}

References _eigval.

Referenced by addEigen(), and addEigenValues().

getEigenValuePerPatch()

double TTQuantiSH::getEigenValuePerPatch ( unsigned int  i, unsigned int  p  )

inline

{return _peigval[i][p];}

References _peigval.

Referenced by addEigenPerPatch(), and addEigenValuesPerPatch().

getEigenVectorElt()

double TTQuantiSH::getEigenVectorElt ( unsigned int  t1, unsigned int  t2  )

inline

{return _eigvect[t2][t1];}//eigenvectors arranged column-wise

References _eigvect.

Referenced by addEigen(), and addEigenVect1().

getEigenVectorEltPerPatch()

double TTQuantiSH::getEigenVectorEltPerPatch ( unsigned int  p, unsigned int  v  )

inline

{return _peigvect[p][v];}

References _peigvect.

Referenced by addEigenPerPatch(), and addEigenVect1PerPatch().

getMeanEffectSize()

double TTQuantiSH::getMeanEffectSize ( unsigned int  i )

inline

{return _meanEffectSize[i];}

References _meanEffectSize.

Referenced by addEffectStats().

getMeanGenot()

double TTQuantiSH::getMeanGenot ( unsigned int  i )

inline

{return _meanG[i];}

References _meanG.

getMeanGenotPerPatch()

double TTQuantiSH::getMeanGenotPerPatch ( unsigned int  i, unsigned int  p  )

inline

{return _pmeanG[i][p];}

References _pmeanG.

Referenced by addGenotPerPatch().

getMeanPhenot()

double TTQuantiSH::getMeanPhenot ( unsigned int  i )

inline

{return _meanP[i];}

References _meanP.

Referenced by addQuanti().

getMeanPhenotPerPatch()

double TTQuantiSH::getMeanPhenotPerPatch ( unsigned int  i, unsigned int  p  )

inline

{return _pmeanP[i][p];}

References _pmeanP.

Referenced by addAvgPerPatch().

getNbAlleles()

double TTQuantiSH::getNbAlleles ( unsigned int  i )

inline

{return double(_uniqueEffectSizes[i].size()/_num_locus);}

References _num_locus, and _uniqueEffectSizes.

Referenced by addEffectStats().

getQst()

double TTQuantiSH::getQst ( unsigned int  i )

inline

{return _Vb[i]/(_Vb[i]+2*_Va[i]);}

References _Va, and _Vb.

Referenced by addQuanti().

getSkewPerPatch()

double TTQuantiSH::getSkewPerPatch	(	unsigned int	i,
		unsigned int	p
	)

{
  double skew = 0;
 
  double *phenot = _phenoTable.getClassWithinGroup(i, p);
  unsigned int patch_size = _phenoTable.size(i, p);
 
  for(unsigned int k = 0; k < patch_size; ++k)
    skew += pow( phenot[k] - _pmeanP[i][p], 3);  //the mean has been set by setStats()
 
  return skew / patch_size;
}

References _phenoTable, _pmeanP, DataTable< T >::getClassWithinGroup(), and DataTable< T >::size().

Referenced by addSkewPerPatch().

getSNPalleleFreqInPatch()

vector< double > TTQuantiSH::getSNPalleleFreqInPatch	(	Patch *	patch,
		const age_idx	AGE
	)

{
  //ONLY IMPLEMENTED FOR DIALLELIC LOCI!
  if(_SHLinkedTrait->get_allele_model() > 1)
    fatal("TTQuantiSH::getSNPalleleFreqInPatch::SNP allele frequencies can only be computed for di-allelic loci, sorry!\n");
 
  Individual* ind;
  TTQuanti* Qtrait;
 
  if(!_SHLinkedTrait) fatal("TTQuantiSH::getSNPalleleFreqInPatch:: Pointer to trait prototype is not set!\n");
 
  unsigned int seqLength = _SHLinkedTrait->get_seq_length();
 
  //create a null vector of the total sequence size, including alleles affecting all traits (max 2 for di-allelic loci)
  vector<double> snp_tab(seqLength, 0.0);
 
  for(unsigned int s = 0; s < 2; ++s){
 
    for(unsigned int j = 0, size = patch->size(sex_t(s), AGE); j < size; ++j) {
 
      ind = patch->get(sex_t(s), AGE, j);
 
      Qtrait = dynamic_cast<TTQuanti*>(ind->getTrait(_SHLinkedTraitIndex));
 
      //compute allele freq at all positions, we count allele 0 (freq 'p' is for trait-increasing allele in diallelic model)
      for(unsigned int i = 0; i < seqLength; ++i) {
        snp_tab[i] +=  !Qtrait->get_allele_bit(i, 0) + !Qtrait->get_allele_bit(i, 1);
      }
 
    }
 
  }
 
  // pre-compute 1/2N :
  double inv_size = 1.0/(2.0*patch->size(AGE));
 
  std::transform(snp_tab.cbegin(), snp_tab.cend(), snp_tab.begin(), [inv_size](double i){return i*inv_size;});
 
  return snp_tab;
}

References TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, fatal(), Patch::get(), TTQuanti::get_allele_bit(), TProtoQuanti::get_allele_model(), TProtoQuanti::get_seq_length(), Individual::getTrait(), and Patch::size().

Referenced by getVaNoDominance(), and getVaWithDominance().

getVa()

double TTQuantiSH::getVa ( unsigned int  i )

inline

{return _Va[i];}

References _Va.

Referenced by addQuanti().

getVaH()

double TTQuantiSH::getVaH ( )

inline

{return _VaH;}

References _VaH.

Referenced by addQuantiEpistasis().

getVaNoDominance()

vector< double > TTQuantiSH::getVaNoDominance	(	Patch *	curPop,
		const age_idx	AGE
	)

CYCLE THROUGH ALL TRAITS

{
  // function called by LCE_QuantiModifier when setting fixed h^2
  unsigned int sizeF = patch->size(FEM, AGE),
      sizeM = patch->size(MAL, AGE);
  unsigned int size  = sizeF + sizeM;
 
  if(!size) {return vector<double>(_num_trait, -1.0);}
 
  TTQuanti* trait;
 
  double G, meanG;
 
  vector< double > varA(_num_trait, 0.0);
 
  double *genot = new double[size];
 
  for(unsigned int TRAIT = 0; TRAIT < _num_trait; ++TRAIT)
  {
 
    meanG = 0;
 
    // females
 
    Individual* curInd;
    unsigned int gpos = 0;
 
    for(unsigned int i = 0; i < sizeF && gpos < size; ++i )
    {
      curInd = patch->get(FEM, AGE, i);
 
      trait = dynamic_cast<TTQuanti*>(curInd->getTrait(_SHLinkedTraitIndex));
 
      G = trait->get_additive_genotype(TRAIT);          // genotype value
 
      genot[gpos++] = G;
 
      meanG += G;
 
    } // for each female
 
    // males
    for(unsigned int i = 0; i < sizeM && gpos < size; ++i )
    {
      curInd = patch->get(MAL, AGE, i);
 
      trait = dynamic_cast<TTQuanti*>(curInd->getTrait(_SHLinkedTraitIndex));
 
      G = trait->get_additive_genotype(TRAIT);          // genotype value
 
      genot[gpos++] = G;
 
      meanG += G;
 
    } // for each male
 
    assert(gpos == size);
 
    meanG /= size;
 
    varA[TRAIT] = my_variance_with_fixed_mean(genot, size, meanG); // not a sample variance
 
    // record the genotypic variance in the stater
    _Vg[TRAIT] = varA[TRAIT];
 
#ifdef _DEBUG_
    message("TTQuantiSH::getVaNoDominance:: Va = %d\n",varA[TRAIT]);
 
    const TMatrix& allele_value = _SHLinkedTrait->get_diallele_values(); // nlocus x 2
    double Vacheck = 0, a, d,avG;
    //compute the allele frequencies:
    vector< double > freqs = getSNPalleleFreqInPatch(patch, AGE); //it has num locus x num traits elements, in a 1D array
 
    for(unsigned int l = 0, pos; l < _num_locus; ++l)
    {
      pos = l * _num_trait + TRAIT;
      a = abs(allele_value.get(l,0) - allele_value.get(l,1))/2;
      d = allele_value.get(l,0)+allele_value.get(l,1);
      avG = a + d*(1-2*freqs[pos]);
      Vacheck += 2*freqs[pos]*(1 - freqs[pos])*avG*avG;
    }
 
    message("TTQuantiSH::getVaNoDominance:: Va check = %d\n",Vacheck);
#endif
 
  }
 
  delete [] genot;
 
  return varA;
}

References _num_locus, _num_trait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _Vg, FEM, Patch::get(), TMatrix::get(), TTQuanti::get_additive_genotype(), TProtoQuanti::get_diallele_values(), getSNPalleleFreqInPatch(), Individual::getTrait(), MAL, message(), my_variance_with_fixed_mean(), and Patch::size().

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

getVaPerPatch()

double TTQuantiSH::getVaPerPatch ( unsigned int  i, unsigned int  p  )

inline

{return _pVa[i][p];}

References _pVa.

Referenced by addVarPerPatch().

getVaWithDominance()

vector< double > TTQuantiSH::getVaWithDominance	(	Patch *	curPop,
		const age_idx	AGE
	)

computation of the additive genetic variance from the average excess of each allele exact under random mating only

CYCLE THROUGH ALL TRAITS

{
  // function called by LCE_QuantiModifier when setting fixed h^2
  if(_SHLinkedTrait->get_allele_model() > 2)
    fatal("Quanti Trait StatHandler::Va with dominance can only be estimated for di-allelic loci, sorry!\n");
 
  unsigned int size  = patch->size(AGE);
 
#ifdef _DEBUG_
  message("\nTTQuantiSH::getVaWithDominance in patch %i; size = %i\n", patch->getID(), size);
#endif
 
  if(!size)
    return vector<double>(_num_trait, -1.0);
 
 
  //compute the allele frequencies:
  vector< double > freqs = getSNPalleleFreqInPatch(patch, AGE); //it has num locus x num traits elements, in a 1D array
 
  unsigned int numLocus, pos, a1, a2;
  TTQuanti* trait;
  const TMatrix& allele_value = _SHLinkedTrait->get_diallele_values(); // nlocus x 2
 
  double G, meanG;
  vector< double > genotypeValues[3];
  vector< double > genotypeFreq[3];
 
  double *genot = new double[size];
 
  vector< double > varA(_num_trait, 0.0);
 
  for(unsigned int TRAIT = 0; TRAIT < _num_trait; ++TRAIT)
  {
 
    numLocus = _SHLinkedTrait->get_num_locus(TRAIT);
 
    meanG = 0;
 
    genotypeValues[0].assign(numLocus, 0.0);  //AA
    genotypeValues[1].assign(numLocus, 0.0);  //Aa/aA
    genotypeValues[2].assign(numLocus, 0.0);  //aa
 
    genotypeFreq[0].assign(numLocus, 0.0);  //AA
    genotypeFreq[1].assign(numLocus, 0.0);  //Aa/aA
    genotypeFreq[2].assign(numLocus, 0.0);  //aa
 
    for(unsigned int l = 0, locID; l < numLocus; ++l)
    {
      locID = _SHLinkedTrait->get_locus_ID(l, TRAIT);
      genotypeValues[0][l] = _SHLinkedTrait->get_genotype_with_dominance( allele_value.get(locID,0), allele_value.get(locID,0), locID, TRAIT);
      genotypeValues[1][l] = _SHLinkedTrait->get_genotype_with_dominance( allele_value.get(locID,0), allele_value.get(locID,1), locID, TRAIT);
      genotypeValues[2][l] = _SHLinkedTrait->get_genotype_with_dominance( allele_value.get(locID,1), allele_value.get(locID,1), locID, TRAIT);
    }
 
    // cycle trhough all individuals:
 
    Individual* curInd;
    unsigned int gpos = 0, fpos = 0;
 
    for(unsigned int s = 0; s < 2; ++s) {
      for(unsigned int i = 0; i < patch->size(sex_t(s), AGE) && gpos < size; ++i )
      {
        curInd = patch->get(sex_t(s), AGE, i);
 
        trait = dynamic_cast<TTQuanti*>(curInd->getTrait(_SHLinkedTraitIndex));
 
        G = trait->get_full_genotype(TRAIT);          // genotype value
 
        meanG += G;
 
        genot[gpos++] = G;
 
        for(unsigned int l = 0; l < numLocus; ++l)
        {
          pos = _SHLinkedTrait->get_locus_seq_pos(l, TRAIT); //l * _num_trait + TRAIT;
 
          a1 = trait->get_allele_bit(pos, 0);
          a2 = trait->get_allele_bit(pos, 1);
 
          fpos = a1 + a2;  //which genotype: 0 = AA, 1 = Aa/aA, 2 = aa
 
          genotypeFreq[fpos][l]++;
 
          //        if( genotypeValues[fpos][l] != _SHLinkedTrait->get_genotype_with_dominance( genes[0][pos], genes[1][pos], locID, TRAIT))
          //        {
          //          cout << "assert failure: genot table value: "<<genotypeValues[fpos][l]<<" at "<<fpos
          //              <<"; genot value: "<<_SHLinkedTrait->get_genotype_with_dominance( genes[0][pos], genes[1][pos], locID, TRAIT)
          //              <<" ("<< genes[0][pos]<<", "<< genes[1][pos] <<", "<<_SHLinkedTrait->get_dominance(locID, TRAIT)<<")\n";
          //        }
        }
 
 
      } // for each female
    }
 
    assert(gpos == size);
 
    meanG /= size;
 
    // record the genotypic variance in the stater, will be needed to comput Ve
    _Vg[TRAIT] = my_variance_with_fixed_mean(genot, size, meanG);
 
    for(unsigned int l = 0; l < numLocus; ++l)
    {
      genotypeFreq[0][l] /= size;
      genotypeFreq[1][l] /= size;
      genotypeFreq[2][l] /= size;
    }
 
 
    // compute the average excess (alphaStar) which is identical to the additive effects under random mating
 
    // !!! THIS DOESN'T WORK AT ALL !!!
 
//    vector< double > alphaStar[2];
//    alphaStar[0].assign(_num_locus, 0.0);
//    alphaStar[1].assign(_num_locus, 0.0);
//
//    double mean_alpha = 0;
//
//    for(unsigned int l = 0; l < _num_locus; ++l)
//    {
//
//      pos = l * _num_trait + TRAIT;
//
//      // average excess of each allele; the frequency table contains the frequency of the first allele only
//      // here, we condition on the genotype being present in the population, in case HW equilibrium is not reached
//      // eq 4.13b Lynch & Walsh 98
//      // allele frequency freq[pos] is that of the first allele at [0]
//      alphaStar[0][l] = genotypeValues[1][l] * (1.0 - freqs[pos]) + genotypeValues[0][l] * freqs[pos] - meanG;  // alpha*_1
//
//      alphaStar[1][l] = genotypeValues[1][l] * freqs[pos] + genotypeValues[2][l] * (1.0-freqs[pos]) - meanG;    // alpha*_2
//
//
//      mean_alpha += (alphaStar[0][l] + alphaStar[1][l])/2;
//
//      varA[TRAIT] += alphaStar[0][l]*alphaStar[0][l]*freqs[pos] + alphaStar[1][l]*alphaStar[1][l]*(1-freqs[pos]); // SUM(p_i*alpha_i^2)
//
//    }
//    varA[TRAIT] *= 2;    // for diploids
//
//    cout <<"TTQuantiSH::getVaWithDominance:: Va = "<<varA[TRAIT]<< " (mean alpha = "<<mean_alpha/_num_locus<<")"<<endl;
 
 
    // check form general formula Va = 2pq[a + d(q-p)]^2 !! q here is 1-freqs[pos], freq of smaller allele (reducing value) which has index [1]
    double Vacheck = 0, a, d,avG, VDcheck = 0, vd, p, q, pq;
    for(unsigned int l = 0; l < numLocus; ++l)
    {
      // the freq vector has same arrangement of loci as the quanti sequence in the genome
      pos = _SHLinkedTrait->get_locus_seq_pos(l, TRAIT);
      p = freqs[pos];
      q = 1 - freqs[pos];
      pq= p*q;
      a = abs(genotypeValues[0][l] - genotypeValues[2][l])/2.0;
      d = genotypeValues[1][l];
      avG = a + d*(1-2*p); //'freqs' stores 'p' not 'q', at same location in the array as loci in the sequences
      Vacheck += 2*pq*avG*avG;
      vd = 2*pq*d;
      VDcheck += vd*vd;
    }
 
    if(_SHLinkedTrait->get_h2_isBroad())
      varA [TRAIT] = _Vg[TRAIT];
    else
      varA[TRAIT] = Vacheck;
 
#ifdef _DEBUG_
    message("TTQuantiSH::getVaWithDominance:: mean genotype = %d\n", meanG);
    message("TTQuantiSH::getVaWithDominance:: var genotype Vg = %d\n",_Vg[TRAIT]);
    message("TTQuantiSH::getVaWithDominance:: estimates: Va = %d, Vd = %d, Vg = %d\n", Vacheck, VDcheck, Vacheck+VDcheck);
#endif
 
  } //for each trait
 
  delete [] genot;
 
  return varA;
}

References _num_trait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _Vg, fatal(), Patch::get(), TMatrix::get(), TTQuanti::get_allele_bit(), TProtoQuanti::get_allele_model(), TProtoQuanti::get_diallele_values(), TTQuanti::get_full_genotype(), TProtoQuanti::get_genotype_with_dominance(), TProtoQuanti::get_h2_isBroad(), TProtoQuanti::get_locus_ID(), TProtoQuanti::get_locus_seq_pos(), TProtoQuanti::get_num_locus(), Patch::getID(), getSNPalleleFreqInPatch(), Individual::getTrait(), message(), my_variance_with_fixed_mean(), and Patch::size().

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

getVb()

double TTQuantiSH::getVb ( unsigned int  i )

inline

{return _Vb[i];}

References _Vb.

Referenced by addQuanti().

getVg()

double TTQuantiSH::getVg ( unsigned int  i )

inline

{return _Vg[i];}

References _Vg.

Referenced by LCE_QuantiModifier::setVefromVa().

getVp()

double TTQuantiSH::getVp ( unsigned int  i )

inline

{return _Vp[i];}

References _Vp.

Referenced by addQuanti().

getVpPerPatch()

double TTQuantiSH::getVpPerPatch ( unsigned int  i, unsigned int  p  )

inline

{return _pVp[i][p];}

References _pVp.

Referenced by addVarPerPatch().

init()

void TTQuantiSH::init ( )

virtual

Reimplemented from StatHandlerBase.

{
  StatHandlerBase::init();
 
  _SHLinkedTraitIndex = _pop->getTraitIndex(_SHLinkedTrait->get_type());
 
  _eVar = (!_SHLinkedTrait->get_env_var().empty() || !_SHLinkedTrait->get_heritability().empty());
 
  resetPtrs(); //deallocate anything that was previously allocated
 
  if(_patchNbr != _pop->getPatchNbr())
    _patchNbr = _pop->getPatchNbr();
 
  if(_num_trait != _SHLinkedTrait->get_num_traits())
    _num_trait = _SHLinkedTrait->get_num_traits();
 
  if(_num_locus != _SHLinkedTrait->get_num_locus())
    _num_locus = _SHLinkedTrait->get_num_locus();
 
  _meanP = new double [_num_trait];
  _meanG = new double [_num_trait];
  _Va = new double [_num_trait];
  _Vg = new double [_num_trait];
  _Vb = new double [_num_trait];
  _Vp = new double [_num_trait];
//  _eigval = new double [_num_trait];  // this was used to store the among-patch D-matrix eigenvalues
  _uniqueEffectSizes = new set<long int> [_num_trait];
  _countUniqueEffects = new map<long int, int> [_num_trait];
  _meanEffectSize = new double [_num_trait];
 
 
  _pVa = new double* [_num_trait];
  _pVp = new double* [_num_trait];
  _pmeanP = new double* [_num_trait];
  _pmeanG = new double* [_num_trait];
 
  for(unsigned int i=0; i < _num_trait; ++i) {
 
    _pVa[i] = new double [_patchNbr];
    _pVp[i] = new double [_patchNbr];
    _pmeanP[i] = new double [_patchNbr];
    _pmeanG[i] = new double [_patchNbr];
 
  }
 
 
  _pVaL = new double* [_num_locus];
  _pmeanL = new double* [_num_locus];
  _pmeanEpiL = new double* [_num_locus];
  for(unsigned int i=0; i < _num_locus; ++i) {
    _pVaL[i] = new double [_patchNbr];
    _pmeanL[i] = new double [_patchNbr];
    _pmeanEpiL[i] = new double [_patchNbr];
  }
 
 
 
  if(_num_trait > 1) {
 
    _G = gsl_matrix_alloc(_num_trait,_num_trait);
    _eval = gsl_vector_alloc (_num_trait);
    _evec = gsl_matrix_alloc (_num_trait, _num_trait);
    _ws = gsl_eigen_symmv_alloc (_num_trait);
 
    _peigval = new double* [_num_trait];
//    _eigvect = new double* [_num_trait];
 
    for(unsigned int i=0; i < _num_trait; ++i) {
//       _eigvect[i]  = new double [_num_trait];
       _peigval[i] = new double [_patchNbr];
    }
 
    _peigvect = new double* [_patchNbr];
 
    for(unsigned int i = 0; i < _patchNbr; i++)
      _peigvect[i] = new double [_num_trait*_num_trait];
 
    _covar = new double [_num_trait*(_num_trait -1)/2];
 
    _pcovar = new double* [_num_trait*(_num_trait - 1)/2];
 
    for(unsigned int i = 0; i < _num_trait*(_num_trait - 1)/2; i++)
      _pcovar[i] = new double [_patchNbr];
 
  }
 
}

References _countUniqueEffects, _covar, _eval, _eVar, _evec, _G, _meanEffectSize, _meanG, _meanP, _num_locus, _num_trait, _patchNbr, _pcovar, _peigval, _peigvect, _pmeanEpiL, _pmeanG, _pmeanL, _pmeanP, StatHandlerBase::_pop, _pVa, _pVaL, _pVp, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _uniqueEffectSizes, _Va, _Vb, _Vg, _Vp, _ws, TProtoQuanti::get_env_var(), TProtoQuanti::get_heritability(), TProtoQuanti::get_num_locus(), TProtoQuanti::get_num_traits(), TProtoQuanti::get_type(), Metapop::getPatchNbr(), IndFactory::getTraitIndex(), StatHandlerBase::init(), and resetPtrs().

resetPtrs()

void TTQuantiSH::resetPtrs

(

)

{
 
  if(_G)    gsl_matrix_free(_G);
  if(_eval) gsl_vector_free(_eval);
  if(_evec) gsl_matrix_free(_evec);
  if(_ws)   gsl_eigen_symmv_free (_ws);
 
  if(_meanP) delete [] _meanP; _meanP = NULL;
  if(_meanG) delete [] _meanG; _meanG = NULL;
  if(_Va)    delete [] _Va;    _Va = NULL;
  if(_Vg)    delete [] _Vg;    _Vg = NULL;
  if(_Vb)    delete [] _Vb;    _Vb = NULL;
  if(_Vp)    delete [] _Vp;    _Vp = NULL;
 
 
  if(_pVa) {
    for(unsigned int i=0; i < _num_trait; ++i) delete [] _pVa[i];
    delete [] _pVa; _pVa = NULL;
  }
  if(_pVp) {
    for(unsigned int i=0; i < _num_trait; ++i) delete [] _pVp[i];
    delete [] _pVp; _pVp = NULL;
  }
  if(_pmeanP) {
    for(unsigned int i=0; i < _num_trait; ++i) delete [] _pmeanP[i];
    delete [] _pmeanP; _pmeanP = NULL;
  }
  if(_pmeanG) {
    for(unsigned int i=0; i < _num_trait; ++i) delete [] _pmeanG[i];
    delete [] _pmeanG; _pmeanG = NULL;
  }
 
  // tables whose allocation depends on trait options need to be set to NULL
 
//  if(_eigval) delete [] _eigval;
//  _eigval = NULL;
//
//  if(_eigvect) {
//    for(unsigned int i=0; i < _num_trait; ++i) delete [] _eigvect[i];
//    delete [] _eigvect;
//    _eigvect = NULL;
//  }
 
  if(_peigval) {
    for(unsigned int i=0; i < _num_trait; ++i) delete [] _peigval[i];
    delete [] _peigval;
    _peigval = NULL;
  }
 
  if(_covar) delete [] _covar;
  _covar = NULL;
 
  if(_pcovar) {
    for(unsigned int i = 0; i < (_num_trait*(_num_trait - 1)/2); i++) delete [] _pcovar[i];
    delete [] _pcovar;
    _pcovar = NULL;
  }
 
  if(_peigvect) {
    for(unsigned int i = 0; i < _patchNbr; i++) delete [] _peigvect[i];
    delete []  _peigvect;
    _peigvect = NULL;
  }
 
  if(_pVaL) {
    for(unsigned int i=0; i < _num_locus; ++i) delete [] _pVaL[i];
    delete [] _pVaL;
    _pVaL = NULL;
  }
  if(_pmeanL) {
    for(unsigned int i=0; i < _num_locus; ++i) delete [] _pmeanL[i];
    delete [] _pmeanL;
    _pmeanL = NULL;
  }
  if(_pmeanEpiL) {
    for(unsigned int i=0; i < _num_locus; ++i) delete [] _pmeanEpiL[i];
    delete [] _pmeanEpiL;
    _pmeanEpiL = NULL;
  }
 
  if(_meanEffectSize) delete [] _meanEffectSize;
  _meanEffectSize = NULL;
 
  if(_countUniqueEffects) delete [] _countUniqueEffects;
  _countUniqueEffects = NULL;
 
  if(_meanEffectSize) delete [] _meanEffectSize;
  _meanEffectSize = NULL;
}

References _countUniqueEffects, _covar, _eval, _evec, _G, _meanEffectSize, _meanG, _meanP, _num_locus, _num_trait, _patchNbr, _pcovar, _peigval, _peigvect, _pmeanEpiL, _pmeanG, _pmeanL, _pmeanP, _pVa, _pVaL, _pVp, _Va, _Vb, _Vg, _Vp, and _ws.

Referenced by init(), and ~TTQuantiSH().

setAdultStats()

void TTQuantiSH::setAdultStats ( )

inline

{setStats(ADULTS);}

References ADULTS, and setStats().

Referenced by addAvgPerPatch(), addCovarPerPatch(), addEffectStats(), addEigen(), addEigenPerPatch(), addEigenValues(), addEigenValuesPerPatch(), addEigenVect1(), addEigenVect1PerPatch(), addGenotPerPatch(), addQuanti(), addQuantiEpistasis(), addSkewPerPatch(), and addVarPerPatch().

setDataTables()

void TTQuantiSH::setDataTables

(

age_t

AGE

)

{
  unsigned int **sizes;
  unsigned int **lsizes;
  unsigned int nb_patch = _pop->getPatchNbr();
  const TMatrix& epiCoefs = _SHLinkedTrait->get_epi_coefs();
  const TMatrix& epiCoefsIdxs = _SHLinkedTrait->get_epi_coef_index();
 
  sizes = new unsigned int * [_num_trait];
 
  for(unsigned int i = 0; i < _num_trait; ++i) {
    sizes[i] = new unsigned int [nb_patch];
    for(unsigned int j = 0; j < nb_patch; ++j)
      sizes[i][j] = _pop->size(AGE, j);
  }
 
  _phenoTable.update(_num_trait, nb_patch, sizes);
  _genoTable.update(_num_trait, nb_patch, sizes);
 
  for(unsigned int i = 0; i < _num_trait; ++i)
    delete [] sizes[i];
  delete [] sizes;
 
  Patch* patch;
  age_idx age = (AGE == ADULTS ? ADLTx : OFFSx);
 
 
  if (_epistats) {
 
    lsizes = new unsigned int * [_num_locus];
 
    for(unsigned int i = 0; i < _num_locus; ++i) {
      lsizes[i] = new unsigned int [_patchNbr];
      for(unsigned int j = 0; j < _patchNbr; ++j)
        lsizes[i][j] = _pop->size(AGE, j);
    }
 
    _lociTable.update(_num_locus, _patchNbr, lsizes);
    _lociRefTable.update(_num_locus, _patchNbr, lsizes);
 
    for(unsigned int i = 0; i < _num_locus; ++i)
      delete [] lsizes[i];
    delete [] lsizes;
  }
 
  if (_alleleStats) {
    for(unsigned int k = 0; k < _num_trait; k++) {
      _uniqueEffectSizes[k].clear();
      _countUniqueEffects[k].clear();
    }
  }
 
  for(unsigned int i = 0, n, m; i < nb_patch; i++) {
 
    patch = _pop->getPatch(i);
 
    n = 0, m = 0;
 
    if ((patch->size(MAL, age)+patch->size(FEM, age)) != _phenoTable.size(0,i)) {
      fatal("problem while recording quanti trait values; table size doesn't match patch size.\n");
    }
    store_quanti_trait_values(patch, i, patch->size(MAL, age), &n, MAL, age, &_phenoTable, &_genoTable,
        _num_trait, _SHLinkedTraitIndex);
 
    store_quanti_trait_values(patch, i, patch->size(FEM, age), &n, FEM, age, &_phenoTable, &_genoTable,
        _num_trait, _SHLinkedTraitIndex);
 
    if (n != _phenoTable.size(0,i) || n != _genoTable.size(0,i)) {
      fatal("problem while recording quanti trait values; size counter doesn't match table size.\n");
    }
 
 
    unsigned int loc;
    TTQuanti_diallelic *trait;
 
    if (_epistats) {
 
      for(unsigned int s = 0; s < 2; ++s) {
 
        for(unsigned int j = 0; j < patch->size(sex_t(s), age); ++j) {
 
          trait = dynamic_cast<TTQuanti_diallelic*> (patch->get(sex_t(s), age, j)->getTrait(_SHLinkedTraitIndex));
 
          //  "Relative pairwise epistasis factor", cf. second term of Eq.2 from Carter et al. (2005, TPB)
          map< int, double > epiFacPerLocus;
 
          for(unsigned int l = 0; l < epiCoefs.length(); l++) {
 
            epiFacPerLocus[epiCoefsIdxs.get(l,0)] +=
                epiCoefs.get(0,l) * (trait->get_allele_value(epiCoefsIdxs.get(l,1), 0) + trait->get_allele_value(epiCoefsIdxs.get(l,1), 1));
 
            epiFacPerLocus[epiCoefsIdxs.get(l,1)] +=
                epiCoefs.get(0,l) * (trait->get_allele_value(epiCoefsIdxs.get(l,0), 0) + trait->get_allele_value(epiCoefsIdxs.get(l,0), 1));
          }
 
          for(unsigned int l = 0; l < _num_locus; l++) {
            _lociTable.set(l, i, m, trait->get_allele_value(l, 0) +   trait->get_allele_value(l, 1));
            _lociRefTable.set(l, i, m, 1 + epiFacPerLocus[l]);
          }
          m++;
        }
      }
    } // end epistasis
 
    if (_alleleStats) {
 
      for(unsigned int s = 0; s < 2; ++s) {
 
        for(unsigned int j = 0; j < patch->size(MAL, age); ++j) {
 
          trait = dynamic_cast<TTQuanti_diallelic*> (patch->get(MAL, age, j)->getTrait(_SHLinkedTraitIndex));
 
          for(unsigned int k = 0; k < _num_trait; k++) {
            for(unsigned int l = 0; l < _num_locus; l++) {
              loc = l * _num_trait + k;
              _uniqueEffectSizes[k].insert(trait->get_allele_value(loc, 0) * 1000000);
              _uniqueEffectSizes[k].insert(trait->get_allele_value(loc, 1) * 1000000);
              ++_countUniqueEffects[k][trait->get_allele_value(loc, 0) * 1000000];
              ++_countUniqueEffects[k][trait->get_allele_value(loc, 1) * 1000000];
            }
          }
        } // end for each individual
      } // end for each sex
    } //allele stats
 
  } // end for patches
}

References _alleleStats, _countUniqueEffects, _epistats, _genoTable, _lociRefTable, _lociTable, _num_locus, _num_trait, _patchNbr, _phenoTable, StatHandlerBase::_pop, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _uniqueEffectSizes, ADLTx, ADULTS, fatal(), FEM, Patch::get(), TMatrix::get(), TTQuanti_diallelic::get_allele_value(), TProtoQuanti::get_epi_coef_index(), TProtoQuanti::get_epi_coefs(), Metapop::getPatch(), Metapop::getPatchNbr(), Individual::getTrait(), TMatrix::length(), MAL, OFFSx, DataTable< T >::set(), Metapop::size(), Patch::size(), DataTable< T >::size(), store_quanti_trait_values(), and DataTable< T >::update().

Referenced by setStats().

setOffsprgStats()

void TTQuantiSH::setOffsprgStats ( )

inline

{setStats(OFFSPRG);}

References OFFSPRG, and setStats().

Referenced by addAvgPerPatch(), addCovarPerPatch(), addEffectStats(), addEigen(), addEigenPerPatch(), addEigenValues(), addEigenValuesPerPatch(), addEigenVect1(), addEigenVect1PerPatch(), addGenotPerPatch(), addQuanti(), addQuantiEpistasis(), addSkewPerPatch(), and addVarPerPatch().

setStatRecorders()

bool TTQuantiSH::setStatRecorders ( std::string &  token )

virtual

Implements StatHandlerBase.

{
#ifdef _DEBUG_
  message("-TTQuantiSH::setStatRecorders ");
#endif
  string age_tag = token.substr(0,token.find_first_of("."));
  string sub_token;
  age_t AGE = ALL;
 
  if (age_tag.size() != 0 && age_tag.size() != string::npos) {
 
    if (age_tag == "adlt") AGE = ADULTS;
 
    else if (age_tag == "off") AGE = OFFSPRG;
 
    else age_tag = "";
 
  } else {
    age_tag = "";
  }
 
  if (age_tag.size() != 0)
    sub_token = token.substr(token.find_first_of(".") + 1, string::npos);
  else
    sub_token = token;
 
  if(sub_token == "quanti") {
    addQuanti(AGE);
//  } else if(sub_token == "quanti.eigen") {  //based on Vb; among-patch (D) matrix
//    addEigen(AGE);
//  } else if(sub_token == "quanti.eigenvalues") {  //based on Vb; among-patch (D) matrix
//    addEigenValues(AGE);
//  } else if(sub_token == "quanti.eigenvect1") {  //based on Vb; among-patch (D) matrix
//    addEigenVect1(AGE);
  } else if(sub_token == "quanti.patch") {
    addQuantiPerPatch(AGE);
  } else if(sub_token == "quanti.mean.patch") {
    addAvgPerPatch(AGE);
  } else if(sub_token == "quanti.geno.patch") {
    addGenotPerPatch(AGE);
  } else if(sub_token == "quanti.var.patch") {
    addVarPerPatch(AGE);
  } else if(sub_token == "quanti.covar.patch") {
    addCovarPerPatch(AGE);
  } else if(sub_token == "quanti.eigen.patch") {
    addEigenPerPatch(AGE);
  } else if(sub_token == "quanti.eigenvalues.patch") {
    addEigenValuesPerPatch(AGE);
  } else if(sub_token == "quanti.eigenvect1.patch") {
    addEigenVect1PerPatch(AGE);
  } else if(sub_token == "quanti.skew.patch") {
    addSkewPerPatch(AGE);
  } else if((sub_token == "quanti.epistasis") && (_SHLinkedTrait->do_epistasis())) {
    addQuantiEpistasis(AGE);
    _epistats = true;
  } else if(sub_token == "quanti.effect.stats") {
    addEffectStats(AGE);
    _alleleStats = true;
  } else
    return false;
 
  return true;
}

References _alleleStats, _epistats, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, addAvgPerPatch(), addCovarPerPatch(), addEffectStats(), addEigenPerPatch(), addEigenValuesPerPatch(), addEigenVect1PerPatch(), addGenotPerPatch(), addQuanti(), addQuantiEpistasis(), addQuantiPerPatch(), addSkewPerPatch(), addVarPerPatch(), ADULTS, ALL, TProtoQuanti::do_epistasis(), message(), and OFFSPRG.

setStats()

void TTQuantiSH::setStats

(

age_t

AGE

)

{
  if(_table_set_age == AGE
      && _table_set_gen == _pop->getCurrentGeneration()
      && _table_set_repl == _pop->getCurrentReplicate())
    return;
 
  unsigned int pop_size = _pop->size(AGE);
  unsigned int patch_size;
  double *phenot1, *genot1, *genot2, *meanL, *meanEpiL;
 
  unsigned int nb_patch = _pop->getPatchNbr();
 
  if(nb_patch < _patchNbr) {
    warning("increase in patch number detected (in Quanti Stat Handler),");
    warning("stats for quanti trait will not be recorded in new patches, patch identity may have changed.\n");
    _patchNbr = nb_patch; // record stat only in remaining patches
  }
 
  if(nb_patch > _patchNbr)  nb_patch = _patchNbr;  //tables have been allocated for _patchNbr patches
 
  setDataTables(AGE);
 
#ifdef HAS_GSL
  unsigned int c = 0; //covariance position counter
  unsigned int pv = 0; //eigenvector position counter
 
  //within deme stats:
  for(unsigned int j = 0; j < nb_patch; j++) {
 
    patch_size = _pop->size(AGE, j);
 
    for(unsigned int t=0; t < _num_trait; t++) {
 
      phenot1 = _phenoTable.getClassWithinGroup(t,j);
      genot1  = _genoTable.getClassWithinGroup(t,j);
 
      _pmeanP[t][j] = my_mean (phenot1, patch_size );
      _pmeanG[t][j] = my_mean (genot1, patch_size );
      _pVp[t][j] = my_variance_with_fixed_mean (phenot1, patch_size, _pmeanP[t][j]);
      _pVa[t][j] = my_variance_with_fixed_mean (genot1,  patch_size, _pmeanG[t][j]);
 
    }
 
    if (_epistats) { // note: this works for one trait only
      for(unsigned int l=0; l < _num_locus; l++) {
        meanL = _lociTable.getClassWithinGroup(l,j);
        _pmeanL[l][j] = my_mean(meanL, patch_size);
        _pVaL[l][j] = my_variance_with_fixed_mean(meanL, patch_size, _pmeanL[l][j]);
        meanEpiL = _lociRefTable.getClassWithinGroup(l,j);
        _pmeanEpiL[l][j] = my_mean(meanEpiL, patch_size);
      }
    }
 
    if(_num_trait > 1) {
      c = 0;
      //    calculate the covariances and G, need to adjust dimensions in class declaration
      for(unsigned int t1 = 0; t1 < _num_trait; t1++) {
        //      set the diagonal elements of G here
 
        gsl_matrix_set(_G, t1, t1, _pVa[t1][j]);
 
        for(unsigned int t2 = t1 + 1; t2 < _num_trait; t2++) {
 
          genot1  = _genoTable.getClassWithinGroup(t1,j);
          genot2  = _genoTable.getClassWithinGroup(t2,j);
 
          _pcovar[c][j] = gsl_stats_covariance_m (genot1, 1, genot2, 1, patch_size,
              _pmeanG[t1][j], _pmeanG[t2][j]);
 
          gsl_matrix_set(_G, t1, t2, _pcovar[c][j]);
          gsl_matrix_set(_G, t2, t1, _pcovar[c++][j]);
        }
      }
 
      gsl_eigen_symmv (_G, _eval, _evec, _ws);
      gsl_eigen_symmv_sort (_eval, _evec, GSL_EIGEN_SORT_VAL_DESC);
 
      pv = 0;
 
      for(unsigned int t = 0; t < _num_trait; t++) {
        _peigval[t][j] = gsl_vector_get (_eval, t);
        for(unsigned int v = 0; v < _num_trait; v++)
          _peigvect[j][pv++] = gsl_matrix_get (_evec, v, t); //read eigenvectors column-wise
      }
    }
  } //_end_ for patch
 
  double meanGamong1;
  c = 0; //reset covariance positioner
 
  //among demes stats:
  for(unsigned int t1 = 0; t1 < _num_trait; t1++) {
 
    phenot1 = _phenoTable.getGroup(t1);
    genot1  = _genoTable.getGroup(t1);
 
    _meanP[t1] = my_mean (phenot1, pop_size ); //grand mean, pooling all individuals
    _meanG[t1] = my_mean (genot1, pop_size ); //grand mean, pooling all individuals
 
    _Vp[t1] = my_mean_no_nan (_pVp[t1], nb_patch); //mean within patch variance
    _Va[t1] = my_mean_no_nan (_pVa[t1], nb_patch); //mean within patch variance
 
    meanGamong1 = my_mean_no_nan (_pmeanG[t1], nb_patch); //mean of within patch mean genotypic values
 
    _Vb[t1] = my_variance_with_fixed_mean_no_nan (_pmeanG[t1], nb_patch,  meanGamong1); //variance of patch means
 
    //_G here becomes the D-matrix, the among-deme (Difference) covariance matrix
    // DEPRECATED
//    gsl_matrix_set(_G, t1, t1, _Vb[t1]);
 
    for(unsigned int t2 = t1 + 1; t2 < _num_trait; t2++) {
 
      _covar[c] = my_covariance_no_nan(_pmeanG[t1], _pmeanG[t2], nb_patch, nb_patch);
 
//      gsl_matrix_set(_G, t1, t2, _covar[c]);
//      gsl_matrix_set(_G, t2, t1, _covar[c]);
 
      //set covariance to the mean covariance within patch for recording
      _covar[c] = my_mean_no_nan (_pcovar[c], nb_patch);
 
      c++;
    }
 
    if (_alleleStats) {
      for (set<long int>::iterator it = _uniqueEffectSizes[t1].begin(); it != _uniqueEffectSizes[t1].end(); it++)
        _meanEffectSize[t1] += *it * _countUniqueEffects[t1][*it] / 1000000;
      _meanEffectSize[t1] /= (_num_locus * pop_size);
    }
 
 
  } //_end_ for trait
 
  if (_epistats) {
    _VaH = 0;
    for(unsigned int l=0; l < _num_locus; l++) {
      _VaH += pow(_pmeanEpiL[l][0], 2) * _pVaL[l][0];
    }
  }
 
  // This is for the D-matrix, among-patch divergence matrix
  // DEPRECATED
//  if(_num_trait > 1) {
//    gsl_eigen_symmv (_G, _eval, _evec, _ws);
//    gsl_eigen_symmv_sort (_eval, _evec, GSL_EIGEN_SORT_VAL_DESC);
//
//    for(unsigned int t1 = 0; t1 < _num_trait; t1++) {
//      _eigval[t1] = gsl_vector_get (_eval, t1);
//      for(unsigned int t2 = 0; t2 < _num_trait; t2++) {
//        _eigvect[t2][t1] = gsl_matrix_get (_evec, t2, t1);
//      }
//    }
//  }
 
#else
  fatal("install the GSL library to get the quanti stats!\n");
#endif
 
  _table_set_age = AGE;
  _table_set_gen = _pop->getCurrentGeneration();
  _table_set_repl = _pop->getCurrentReplicate();
 
}

References _alleleStats, _countUniqueEffects, _covar, _epistats, _eval, _evec, _G, _genoTable, _lociRefTable, _lociTable, _meanEffectSize, _meanG, _meanP, _num_locus, _num_trait, _patchNbr, _pcovar, _peigval, _peigvect, _phenoTable, _pmeanEpiL, _pmeanG, _pmeanL, _pmeanP, StatHandlerBase::_pop, _pVa, _pVaL, _pVp, _table_set_age, _table_set_gen, _table_set_repl, _uniqueEffectSizes, _Va, _VaH, _Vb, _Vp, _ws, fatal(), DataTable< T >::getClassWithinGroup(), Metapop::getCurrentGeneration(), Metapop::getCurrentReplicate(), DataTable< T >::getGroup(), Metapop::getPatchNbr(), my_covariance_no_nan(), my_mean(), my_mean_no_nan(), my_variance_with_fixed_mean(), my_variance_with_fixed_mean_no_nan(), setDataTables(), Metapop::size(), and warning().

Referenced by setAdultStats(), and setOffsprgStats().

Member Data Documentation

_alleleStats

bool TTQuantiSH::_alleleStats

private

Referenced by setDataTables(), setStatRecorders(), and setStats().

_countUniqueEffects

map<long int, int>* TTQuantiSH::_countUniqueEffects

private

Referenced by init(), resetPtrs(), setDataTables(), and setStats().

_covar

double * TTQuantiSH::_covar

private

Referenced by getCovar(), init(), resetPtrs(), and setStats().

_eigval

double * TTQuantiSH::_eigval

private

Referenced by getEigenValue().

_eigvect

double ** TTQuantiSH::_eigvect

private

Referenced by getEigenVectorElt().

_epistats

bool TTQuantiSH::_epistats

private

Referenced by setDataTables(), setStatRecorders(), and setStats().

_eval

gsl_vector* TTQuantiSH::_eval

private

Referenced by init(), resetPtrs(), and setStats().

_eVar

bool TTQuantiSH::_eVar

private

Referenced by addQuanti(), addVarPerPatch(), and init().

_evec

gsl_matrix * TTQuantiSH::_evec

private

Referenced by init(), resetPtrs(), and setStats().

_G

gsl_matrix* TTQuantiSH::_G

private

Referenced by init(), resetPtrs(), and setStats().

_genoTable

DataTable< double > TTQuantiSH::_genoTable

private

Referenced by setDataTables(), and setStats().

_lociRefTable

DataTable< double > TTQuantiSH::_lociRefTable

private

Referenced by setDataTables(), and setStats().

_lociTable

DataTable< double > TTQuantiSH::_lociTable

private

Referenced by setDataTables(), and setStats().

_meanEffectSize

double * TTQuantiSH::_meanEffectSize

private

Referenced by getMeanEffectSize(), init(), resetPtrs(), and setStats().

_meanG

double * TTQuantiSH::_meanG

private

Referenced by getMeanGenot(), init(), resetPtrs(), and setStats().

_meanP

double* TTQuantiSH::_meanP

private

Referenced by getMeanPhenot(), init(), resetPtrs(), and setStats().

_num_locus

unsigned int TTQuantiSH::_num_locus

private

Referenced by getNbAlleles(), getVaNoDominance(), init(), resetPtrs(), setDataTables(), and setStats().

_num_trait

unsigned int TTQuantiSH::_num_trait

private

Referenced by addAvgPerPatch(), addCovarPerPatch(), addEffectStats(), addEigen(), addEigenPerPatch(), addEigenValues(), addEigenValuesPerPatch(), addEigenVect1(), addEigenVect1PerPatch(), addGenotPerPatch(), addQuanti(), addSkewPerPatch(), addVarPerPatch(), getVaNoDominance(), getVaWithDominance(), init(), resetPtrs(), setDataTables(), and setStats().

_patchNbr

unsigned int TTQuantiSH::_patchNbr

private

Referenced by init(), resetPtrs(), setDataTables(), and setStats().

_pcovar

double ** TTQuantiSH::_pcovar

private

Referenced by getCovarPerPatch(), init(), resetPtrs(), and setStats().

_peigval

double ** TTQuantiSH::_peigval

private

Referenced by getEigenValuePerPatch(), init(), resetPtrs(), and setStats().

_peigvect

double ** TTQuantiSH::_peigvect

private

Referenced by getEigenVectorEltPerPatch(), init(), resetPtrs(), and setStats().

_phenoTable

DataTable< double > TTQuantiSH::_phenoTable

private

Referenced by getSkewPerPatch(), setDataTables(), and setStats().

_pmeanEpiL

double ** TTQuantiSH::_pmeanEpiL

private

Referenced by init(), resetPtrs(), and setStats().

_pmeanG

double ** TTQuantiSH::_pmeanG

private

Referenced by getMeanGenotPerPatch(), init(), resetPtrs(), and setStats().

_pmeanL

double** TTQuantiSH::_pmeanL

private

Referenced by init(), resetPtrs(), and setStats().

_pmeanP

double** TTQuantiSH::_pmeanP

private

Referenced by getMeanPhenotPerPatch(), getSkewPerPatch(), init(), resetPtrs(), and setStats().

_pVa

double ** TTQuantiSH::_pVa

private

Referenced by getVaPerPatch(), init(), resetPtrs(), and setStats().

_pVaL

double ** TTQuantiSH::_pVaL

private

Referenced by init(), resetPtrs(), and setStats().

_pVp

double ** TTQuantiSH::_pVp

private

Referenced by getVpPerPatch(), init(), resetPtrs(), and setStats().

_table_set_age

unsigned int TTQuantiSH::_table_set_age

private

Referenced by setStats().

_table_set_gen

unsigned int TTQuantiSH::_table_set_gen

private

Referenced by setStats().

_table_set_repl

unsigned int TTQuantiSH::_table_set_repl

private

Referenced by setStats().

_uniqueEffectSizes

set< long int >* TTQuantiSH::_uniqueEffectSizes

private

Referenced by getNbAlleles(), init(), setDataTables(), and setStats().

_Va

double * TTQuantiSH::_Va

private

Referenced by getQst(), getVa(), init(), resetPtrs(), and setStats().

_VaH

double TTQuantiSH::_VaH

private

Referenced by getVaH(), and setStats().

_Vb

double * TTQuantiSH::_Vb

private

Referenced by getQst(), getVb(), init(), resetPtrs(), and setStats().

_Vg

double * TTQuantiSH::_Vg

private

Referenced by getVaNoDominance(), getVaWithDominance(), getVg(), init(), and resetPtrs().

_Vp

double * TTQuantiSH::_Vp

private

Referenced by getVp(), init(), resetPtrs(), and setStats().

_ws

gsl_eigen_symmv_workspace* TTQuantiSH::_ws

private

Referenced by init(), resetPtrs(), and setStats().

---

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

• ttquanti.h
• ttquanti.cc