TTQuantiSH Class Reference

#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	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	setDataTables (age_t AGE)
void	setAdultStats ()
void	setOffsprgStats ()
void	setStats (age_t AGE)
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	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)
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 void	init ()=0
	Inits state. More...
virtual void	update ()=0
	Updates the handler state. More...
virtual	~Handler ()

Private Attributes
double *	_meanP
double *	_meanG
double *	_Va
double *	_Vg
double *	_Vb
double *	_Vp
double *	_covar
double *	_eigval
double **	_eigvect
double **	_pmeanP
double **	_pmeanG
double **	_pVa
double **	_pVp
double **	_pcovar
double **	_peigval
double **	_peigvect
unsigned int	_nb_locus
unsigned int	_nb_trait
unsigned int	_patchNbr
bool	_eVar
gsl_matrix *	_G
gsl_matrix *	_evec
gsl_vector *	_eval
gsl_eigen_symmv_workspace *	_ws
DataTable< double >	_phenoTable
DataTable< double >	_genoTable
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...

Constructor & Destructor Documentation

TTQuantiSH()

TTQuantiSH::TTQuantiSH ( TProtoQuanti *  TP )

inline

    : TraitStatHandler<TProtoQuanti, TTQuantiSH> (TP), 
    _meanP(0), _meanG(0), _Va(0), _Vg(0), _Vb(0), _Vp(0), _covar(0), _eigval(0), _eigvect(0),
    _pmeanP(0), _pmeanG(0), _pVa(0), _pVp(0), _pcovar(0), _peigval(0), _peigvect(0),
    _nb_locus(0), _nb_trait(0),_patchNbr(0), _eVar(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 < _nb_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 _nb_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addAvgPerPatch(), ADULTS, ALL, getMeanPhenotPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addAvgPerPatch(), addQuantiPerPatch(), and setStatRecorders().

Here is the caller graph for this function:

addCovarPerPatch()

void TTQuantiSH::addCovarPerPatch

(

age_t

AGE

)

{
  if(_nb_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 < _nb_trait; ++t) {
      for(unsigned int v = t + 1; v < _nb_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 _nb_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addCovarPerPatch(), ADULTS, ALL, getCovarPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addCovarPerPatch(), addQuantiPerPatch(), and setStatRecorders().

Here is the caller graph for this function:

addEigen()

void TTQuantiSH::addEigen

(

age_t

AGE

)

{
  if(_nb_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 < _nb_trait; ++t)
    add("", suffix + "q.eval" + tstring::int2str(t+1),AGE,t,0,0,&TTQuantiSH::getEigenValue, 0, 0);
 
  for(unsigned int t = 0; t< _nb_trait; ++t)
    for(unsigned int v = 0; v < _nb_trait; ++v)
      add("", suffix + "q.evect" + tstring::int2str((t+1)*10+(v+1)),AGE,t,v,0,0,&TTQuantiSH::getEigenVectorElt,0);
 
}

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

Referenced by addEigen(), addEigenValues(), addEigenVect1(), and setStatRecorders().

Here is the caller graph for this function:

addEigenPerPatch()

void TTQuantiSH::addEigenPerPatch

(

age_t

AGE

)

{
  if(_nb_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 < _nb_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 < _nb_trait; ++t)
      for(unsigned int v = 0; v < _nb_trait; ++v)
        add("", suffix + "qevect" + tstring::int2str((t+1)*10+v+1) + patch,  AGE, p, pv++, 0, 0, &TTQuantiSH::getEigenVectorEltPerPatch,0);
  }
 
}

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

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

Here is the caller graph for this function:

addEigenStatsPerPatcg()

void TTQuantiSH::addEigenStatsPerPatcg

(

age_t

AGE

)

addEigenValues()

void TTQuantiSH::addEigenValues

(

age_t

AGE

)

{
  if(_nb_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 < _nb_trait; ++t)
    add("", suffix + "q.eval" + tstring::int2str(t+1),AGE,t,0,0,&TTQuantiSH::getEigenValue, 0, 0);
 
 
}

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

Referenced by setStatRecorders().

Here is the caller graph for this function:

addEigenValuesPerPatch()

void TTQuantiSH::addEigenValuesPerPatch

(

age_t

AGE

)

{
  if(_nb_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 < _nb_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 _nb_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addEigenPerPatch(), ADULTS, ALL, getEigenValuePerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

Referenced by setStatRecorders().

Here is the caller graph for this function:

addEigenVect1()

void TTQuantiSH::addEigenVect1

(

age_t

AGE

)

{
  if(_nb_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 < _nb_trait; ++v)
    add("", suffix + "q.evect1" + tstring::int2str(v+1),AGE,0,v,0,0,&TTQuantiSH::getEigenVectorElt,0);
 
}

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

Referenced by setStatRecorders().

Here is the caller graph for this function:

addEigenVect1PerPatch()

void TTQuantiSH::addEigenVect1PerPatch

(

age_t

AGE

)

{
  if(_nb_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 < _nb_trait; ++t)
    for(unsigned int v = 0; v < _nb_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 _nb_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addEigenPerPatch(), ADULTS, ALL, getEigenVectorEltPerPatch(), Metapop::getPatchNbr(), tstring::int2str(), OFFSPRG, setAdultStats(), setOffsprgStats(), and warning().

Referenced by setStatRecorders().

Here is the caller graph for this function:

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 < _nb_trait; i++) {
    t1 = tstring::int2str(i+1);
    add("", name + t1,AGE,i,0,0,&TTQuantiSH::getMeanPhenot,0,0);
  } 
 
  //Va, no dominance
  if(_SHLinkedTrait->get_dominance_model() == 0) {
    for(unsigned int i = 0; i < _nb_trait; i++) {
      t1 = tstring::int2str(i+1);
      add("", name + t1 +".Va",AGE,i,0,0,&TTQuantiSH::getVa,0,0);
    }
  } else {
    //if dominance, then what we record is Vg, not Va
    for(unsigned int i = 0; i < _nb_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 < _nb_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 < _nb_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 < _nb_trait; i++) {
      t1 = tstring::int2str(i+1);
      add("", name + t1 +".Qst",AGE,i,0,0,&TTQuantiSH::getQst,0,0);
    }
  }
 
  if (_nb_trait > 1) {
    unsigned int c = 0;
    for(unsigned int t = 0; t < _nb_trait; ++t) {
      for(unsigned int v = t + 1; v < _nb_trait; ++v) {
        t1 = tstring::int2str((t+1)*10+(v+1));
        add("", name + t1 +".cov", AGE, c++, 0,0,&TTQuantiSH::getCovar,0,0);
      }
    }
  }
}

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

Referenced by addQuanti(), and setStatRecorders().

Here is the caller graph for this function:

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(), addQuantiPerPatch(), addVarPerPatch(), ADULTS, ALL, and OFFSPRG.

Referenced by addQuantiPerPatch(), and setStatRecorders().

Here is the caller graph for this function:

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 < _nb_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 _nb_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addSkewPerPatch(), ADULTS, ALL, Metapop::getPatchNbr(), getSkewPerPatch(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addSkewPerPatch(), and setStatRecorders().

Here is the caller graph for this function:

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;
 
  void (TTQuantiSH::* setter) (void) = (AGE == ADULTS ?
      &TTQuantiSH::setAdultStats :
      &TTQuantiSH::setOffsprgStats);
 
  add("Genetic variance of trait 1 in patch 1", suffix + "Va.q1.p1",  AGE, 0, 0, 0, 0,
      &TTQuantiSH::getVaPerPatch, setter);
 
  for(unsigned int p = 0; p < patchNbr; p++) {
    for(unsigned int i = 0; i < _nb_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 + "Va." + 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 < _nb_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, _nb_trait, StatHandlerBase::_pop, StatHandler< SH >::add(), addVarPerPatch(), ADULTS, ALL, Metapop::getPatchNbr(), getVaPerPatch(), getVpPerPatch(), tstring::int2str(), OFFSPRG, setAdultStats(), and setOffsprgStats().

Referenced by addQuantiPerPatch(), addVarPerPatch(), and setStatRecorders().

Here is the caller graph for this function:

getCovar()

double TTQuantiSH::getCovar ( unsigned int  i )

inline

{return _covar[i];}

References _covar.

Referenced by addQuanti().

Here is the caller graph for this function:

getCovarPerPatch()

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

inline

{return _pcovar[p][i];}

References _pcovar.

Referenced by addCovarPerPatch().

Here is the caller graph for this function:

getEigenValue()

double TTQuantiSH::getEigenValue ( unsigned int  i )

inline

{return _eigval[i];}

References _eigval.

Referenced by addEigen(), and addEigenValues().

Here is the caller graph for this function:

getEigenValuePerPatch()

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

inline

{return _peigval[i][p];}

References _peigval.

Referenced by addEigenPerPatch(), and addEigenValuesPerPatch().

Here is the caller graph for this function:

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

Here is the caller graph for this function:

getEigenVectorEltPerPatch()

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

inline

{return _peigvect[p][v];}

References _peigvect.

Referenced by addEigenPerPatch(), and addEigenVect1PerPatch().

Here is the caller graph for this function:

getMeanPhenot()

double TTQuantiSH::getMeanPhenot ( unsigned int  i )

inline

{return _meanP[i];}

References _meanP.

Referenced by addQuanti().

Here is the caller graph for this function:

getMeanPhenotPerPatch()

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

inline

{return _pmeanP[i][p];}

References _pmeanP.

Referenced by addAvgPerPatch().

Here is the caller graph for this function:

getQst()

double TTQuantiSH::getQst ( unsigned int  i )

inline

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

References _Va, and _Vb.

Referenced by addQuanti().

Here is the caller graph for this function:

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

Here is the caller graph for this function:

getSNPalleleFreqInPatch()

vector< double > TTQuantiSH::getSNPalleleFreqInPatch

(

Patch *

patch

)

{
  Individual* ind;
  double **genes;
  int total_size = 0;
 
  if(!_SHLinkedTrait) fatal("TTQuantiSH::getSNPalleleFreqInPatch:: Pointer to trait prototype is not set!\n");
 
  double **snp_allele = _SHLinkedTrait->get_allele_values();
 
 
  unsigned int loc;
  unsigned int nb_trait = _SHLinkedTrait->get_nb_traits();
  unsigned int nb_locus = _SHLinkedTrait->get_nb_locus();
 
 
 
  vector<double> snp_tab(nb_trait * nb_locus, 0.0);
 
  //ONLY IMPLEMENTED FOR DIALLELIC LOCI!
  for(unsigned int k = 0; k < nb_trait; k++) {
    for(unsigned int l = 0; l < nb_locus; l++) {
      loc = l * nb_trait + k;
      snp_tab [loc] = 0.0;
    }
  }
 
  total_size = patch->size(FEM, ADLTx) + patch->size(MAL, ADLTx);
 
 
  for(unsigned int j = 0, size = patch->size(FEM, ADLTx); j < size; j++) {
 
    ind = patch->get(FEM, ADLTx, j);
 
    genes = (double**)ind->getTrait(_SHLinkedTraitIndex)->get_sequence();
 
 
    for(unsigned int k = 0; k < nb_trait; k++) {
      for(unsigned int l = 0; l < nb_locus; l++) {
 
        loc = l * nb_trait + k;
 
        if (genes[0][loc] == snp_allele[l][0]){
          snp_tab [loc] += 1;
        }
 
        if (genes[1][loc] == snp_allele[l][0]){
          snp_tab [loc] += 1;
        }
      }
    }
  }
 
 
  for(unsigned int j = 0, size = patch->size(MAL, ADLTx); j < size; j++) {
 
    ind = patch->get(MAL, ADLTx, j);
 
    genes = (double**)ind->getTrait(_SHLinkedTraitIndex)->get_sequence();
 
    for(unsigned int k = 0; k < nb_trait; k++) {
      for(unsigned int l = 0; l < nb_locus; l++) {
 
        loc = l * nb_trait + k;
 
        if (genes[0][loc] == snp_allele[l][0]){
          snp_tab [loc] += 1;
        }
        if (genes[1][loc] == snp_allele[l][0]){
          snp_tab [loc] += 1;
        }
      }
    }
 
 
  }
 
  double inv_size = 1.0/(2.0*total_size);
 
  for(unsigned int k = 0; k < nb_trait; k++) {
    for(unsigned int l = 0; l < nb_locus; l++) {
      loc = l * nb_trait + k;
      snp_tab [loc] *= inv_size;
    }
  }
 
  return snp_tab;
}

References TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, ADLTx, fatal(), FEM, Patch::get(), TProtoQuanti::get_allele_values(), TProtoQuanti::get_nb_locus(), TProtoQuanti::get_nb_traits(), TTrait::get_sequence(), Individual::getTrait(), MAL, and Patch::size().

Referenced by getVaNoDominance(), and getVaWithDominance().

Here is the caller graph for this function:

getVa()

double TTQuantiSH::getVa ( unsigned int  i )

inline

{return _Va[i];}

References _Va.

Referenced by addQuanti().

Here is the caller graph for this function:

getVaNoDominance()

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

CYCLE THROUGH ALL TRAITS

{
  unsigned int sizeF = patch->size(FEM, AGE),
      sizeM = patch->size(MAL, AGE);
  unsigned int size  = sizeF + sizeM;
 
  if(!size) {return vector<double>(_nb_trait, -1.0);}
 
  TTQuanti* trait;
  double **allele_value = _SHLinkedTrait->get_allele_values(); // nlocus x 2
 
  double G, meanG;
 
  vector< double > varA(_nb_trait, 0.0);
 
  double *genot = new double[size];
 
  for(unsigned int TRAIT = 0; TRAIT < _nb_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]);
 
    double Vacheck = 0, a, d,avG;
    //compute the allele frequencies:
    vector< double > freqs = getSNPalleleFreqInPatch(patch); //it has num locus x num traits elements, in a 1D array
 
    for(unsigned int l = 0, pos; l < _nb_locus; ++l)
    {
      pos = l * _nb_trait + TRAIT;
      a = abs(allele_value[l][0] - allele_value[l][1])/2;
      d = allele_value[l][0]+allele_value[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 _nb_locus, _nb_trait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _Vg, FEM, Patch::get(), TTQuanti::get_additive_genotype(), TProtoQuanti::get_allele_values(), getSNPalleleFreqInPatch(), Individual::getTrait(), MAL, message(), my_variance_with_fixed_mean(), and Patch::size().

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

Here is the caller graph for this function:

getVaPerPatch()

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

inline

{return _pVa[i][p];}

References _pVa.

Referenced by addVarPerPatch().

Here is the caller graph for this function:

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

{
  unsigned int sizeF = patch->size(FEM, AGE),
      sizeM = patch->size(MAL, AGE);
  unsigned int size  = sizeF + sizeM;
 
#ifdef _DEBUG_
  message("\nTTQuantiSH::getVaWithDominance in patch %i; size = %i + %i\n", patch->getID(), sizeF, sizeM);
#endif
 
  if(!size)
    return vector<double>(_nb_trait, -1.0);
 
 
  //compute the allele frequencies:
  vector< double > freqs = getSNPalleleFreqInPatch(patch); //it has num locus x num traits elements, in a 1D array
 
  unsigned int l, pos, a1, a2;
  double** genes;
  TTQuanti* trait;
  double **allele_value = _SHLinkedTrait->get_allele_values(); // nlocus x 2
 
  double G, meanG,  varG;
  vector< double > genotypeValues[3];
  vector< double > genotypeFreq[3];
 
  double *genot = new double[size];
 
  vector< double > varA(_nb_trait, 0.0);
 
  for(unsigned int TRAIT = 0; TRAIT < _nb_trait; ++TRAIT)
  {
 
    meanG = 0;
 
    genotypeValues[0].assign(_nb_locus, 0.0);  //AA
    genotypeValues[1].assign(_nb_locus, 0.0);  //Aa/aA
    genotypeValues[2].assign(_nb_locus, 0.0);  //aa
 
    genotypeFreq[0].assign(_nb_locus, 0.0);  //AA
    genotypeFreq[1].assign(_nb_locus, 0.0);  //Aa/aA
    genotypeFreq[2].assign(_nb_locus, 0.0);  //aa
 
    for(unsigned int l = 0; l < _nb_locus; ++l)
    {
      genotypeValues[0][l] = _SHLinkedTrait->get_genotype( allele_value[l][0], allele_value[l][0], l, TRAIT);
      genotypeValues[1][l] = _SHLinkedTrait->get_genotype( allele_value[l][0], allele_value[l][1], l, TRAIT);
      genotypeValues[2][l] = _SHLinkedTrait->get_genotype( allele_value[l][1], allele_value[l][1], l, TRAIT);
    }
 
    // females
 
    Individual* curInd;
    unsigned int gpos = 0, fpos = 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_full_genotype(TRAIT);          // genotype value
 
      meanG += G;
 
      genot[gpos++] = G;
 
      genes = (double**)trait->get_sequence();
 
      for(unsigned int l = 0; l < _nb_locus; ++l)
      {
        pos = l * _nb_trait + TRAIT;
 
        a1 = (genes[0][pos] != allele_value[l][0]); //allele index 1.allele
        a2 = (genes[1][pos] != allele_value[l][0]);
 
        fpos = a1 + a2;  //which genotype: 0 = AA, 1 = Aa/aA, 2 = aa
 
        genotypeFreq[fpos][l]++;
 
        if( genotypeValues[fpos][l] != _SHLinkedTrait->get_genotype( genes[0][pos], genes[1][pos], l, TRAIT))
        {
          cout << "assert failure: genot table value: "<<genotypeValues[fpos][l]<<" at "<<fpos
              <<"; genot value: "<<_SHLinkedTrait->get_genotype( genes[0][pos], genes[1][pos], l, TRAIT)
              <<" ("<< genes[0][pos]<<", "<< genes[1][pos] <<", "<<_SHLinkedTrait->get_dominance(l, TRAIT)<<")\n";
        }
      }
 
 
    } // 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_full_genotype(TRAIT);          // genotype value
 
      meanG += G;
 
      genot[gpos++] = G;
 
      genes = (double**)trait->get_sequence();
 
      for(unsigned int l = 0; l < _nb_locus; ++l)
      {
        pos = l * _nb_trait + TRAIT;
 
        a1 = (genes[0][pos] != allele_value[l][0]); //allele index 1.allele
        a2 = (genes[1][pos] != allele_value[l][0]);
 
        fpos = a1 + a2;  //which genotype: 0 = AA, 1 = Aa/aA, 2 = aa
 
        genotypeFreq[fpos][l]++;
      }
 
    } // for each male
 
    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 < _nb_locus; ++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(_nb_locus, 0.0);
//    alphaStar[1].assign(_nb_locus, 0.0);
//
//    double mean_alpha = 0;
//
//    for(unsigned int l = 0; l < _nb_locus; ++l)
//    {
//
//      pos = l * _nb_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/_nb_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;
    for(unsigned int l = 0; l < _nb_locus; ++l)
    {
      pos = l * _nb_trait + TRAIT;
      a = abs(genotypeValues[0][l] - genotypeValues[2][l])/2.0;
      d = genotypeValues[1][l];
      avG = a + d*(1-2*freqs[pos]);
      Vacheck += 2*freqs[pos]*(1 - freqs[pos])*avG*avG;
      vd = 2*freqs[pos]*(1 - freqs[pos])*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 _nb_locus, _nb_trait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _Vg, FEM, Patch::get(), TProtoQuanti::get_allele_values(), TProtoQuanti::get_dominance(), TTQuanti::get_full_genotype(), TProtoQuanti::get_genotype(), TProtoQuanti::get_h2_isBroad(), TTQuanti::get_sequence(), Patch::getID(), getSNPalleleFreqInPatch(), Individual::getTrait(), MAL, message(), my_variance_with_fixed_mean(), and Patch::size().

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

Here is the caller graph for this function:

getVb()

double TTQuantiSH::getVb ( unsigned int  i )

inline

{return _Vb[i];}

References _Vb.

Referenced by addQuanti().

Here is the caller graph for this function:

getVg()

double TTQuantiSH::getVg ( unsigned int  i )

inline

{return _Vg[i];}

References _Vg.

Referenced by LCE_QuantiModifier::setVefromVa().

Here is the caller graph for this function:

getVp()

double TTQuantiSH::getVp ( unsigned int  i )

inline

{return _Vp[i];}

References _Vp.

Referenced by addQuanti().

Here is the caller graph for this function:

getVpPerPatch()

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

inline

{return _pVp[i][p];}

References _pVp.

Referenced by addVarPerPatch().

Here is the caller graph for this function:

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(_nb_trait != _SHLinkedTrait->get_nb_traits())
    _nb_trait = _SHLinkedTrait->get_nb_traits();
 
  if(_nb_locus != _SHLinkedTrait->get_nb_locus())
    _nb_locus = _SHLinkedTrait->get_nb_locus();
 
  _G = gsl_matrix_alloc(_nb_trait,_nb_trait);
  _eval = gsl_vector_alloc (_nb_trait);
  _evec = gsl_matrix_alloc (_nb_trait, _nb_trait);
  _ws = gsl_eigen_symmv_alloc (_nb_trait);
 
  _meanP = new double [_nb_trait];
  _meanG = new double [_nb_trait];
  _Va = new double [_nb_trait];
  _Vg = new double [_nb_trait];
  _Vb = new double [_nb_trait];
  _Vp = new double [_nb_trait];
  _eigval = new double [_nb_trait];
 
  _eigvect = new double* [_nb_trait];
  _pVa = new double* [_nb_trait];
  _pVp = new double* [_nb_trait];
  _pmeanP = new double* [_nb_trait];
  _pmeanG = new double* [_nb_trait];
  _peigval = new double* [_nb_trait];
 
  for(unsigned int i=0; i < _nb_trait; ++i) {
 
    _eigvect[i]  = new double [_nb_trait];
 
    _pVa[i] = new double [_patchNbr];
    _pVp[i] = new double [_patchNbr];
    _pmeanP[i] = new double [_patchNbr];
    _pmeanG[i] = new double [_patchNbr];
    _peigval[i] = new double [_patchNbr];
 
  }
 
  _peigvect = new double* [_patchNbr];
  for(unsigned int i = 0; i < _patchNbr; i++)     
    _peigvect[i] = new double [_nb_trait*_nb_trait]; 
 
 
  if(_nb_trait > 1) {
 
    _covar = new double [_nb_trait*(_nb_trait -1)/2];
 
    _pcovar = new double* [_nb_trait*(_nb_trait - 1)/2];
 
    for(unsigned int i = 0; i < _nb_trait*(_nb_trait - 1)/2; i++)
      _pcovar[i] = new double [_patchNbr];
 
  }
 
}

References _covar, _eigval, _eigvect, _eval, _eVar, _evec, _G, _meanG, _meanP, _nb_locus, _nb_trait, _patchNbr, _pcovar, _peigval, _peigvect, _pmeanG, _pmeanP, StatHandlerBase::_pop, _pVa, _pVp, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTrait, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, _Va, _Vb, _Vg, _Vp, _ws, TProtoQuanti::get_env_var(), TProtoQuanti::get_heritability(), TProtoQuanti::get_nb_locus(), TProtoQuanti::get_nb_traits(), TProtoQuanti::get_type(), Metapop::getPatchNbr(), IndFactory::getTraitIndex(), StatHandlerBase::init(), and resetPtrs().

resetPtrs()

void TTQuantiSH::resetPtrs

(

)

{  
 
  if(_G != NULL) gsl_matrix_free(_G);
  if(_eval != NULL) gsl_vector_free(_eval);
  if(_evec != NULL) gsl_matrix_free(_evec);
  if(_ws != NULL)  gsl_eigen_symmv_free (_ws);
 
  if(_meanP != NULL) delete [] _meanP;
  if(_meanG != NULL) delete [] _meanG;
  if(_Va != NULL) delete [] _Va;
  if(_Vg != NULL) delete [] _Vg;
  if(_Vb != NULL) delete [] _Vb;
  if(_Vp != NULL) delete [] _Vp;
  if(_covar != NULL) delete [] _covar;
  _covar = 0;
  if(_eigval != NULL) delete [] _eigval;
 
 
  if(_eigvect) {
    for(unsigned int i=0; i < _nb_trait; ++i) delete [] _eigvect[i];
    delete [] _eigvect;
  }
  if(_pVa) {
    for(unsigned int i=0; i < _nb_trait; ++i) delete [] _pVa[i];
    delete [] _pVa;
  }
  if(_pVp) {
    for(unsigned int i=0; i < _nb_trait; ++i) delete [] _pVp[i];
    delete [] _pVp;
  }
  if(_pmeanP) {
    for(unsigned int i=0; i < _nb_trait; ++i) delete [] _pmeanP[i];
    delete [] _pmeanP;
  }
  if(_pmeanG) {
    for(unsigned int i=0; i < _nb_trait; ++i) delete [] _pmeanG[i];
    delete [] _pmeanG;
  }
  if(_peigval) {
    for(unsigned int i=0; i < _nb_trait; ++i) delete [] _peigval[i];
    delete [] _peigval;
  }
 
  if(_pcovar != NULL) {  
    for(unsigned int i = 0; i < (_nb_trait*(_nb_trait - 1)/2); i++) delete [] _pcovar[i];
    delete [] _pcovar;
    _pcovar = 0;
  }
 
  if(_peigvect != NULL) {
    for(unsigned int i = 0; i < _patchNbr; i++) delete [] _peigvect[i];
    delete []  _peigvect;
    _peigvect = 0;
  }
 
}

References _covar, _eigval, _eigvect, _eval, _evec, _G, _meanG, _meanP, _nb_trait, _patchNbr, _pcovar, _peigval, _peigvect, _pmeanG, _pmeanP, _pVa, _pVp, _Va, _Vb, _Vg, _Vp, and _ws.

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

Here is the caller graph for this function:

setAdultStats()

void TTQuantiSH::setAdultStats ( )

inline

{setStats(ADULTS);}

References ADULTS, and setStats().

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

Here is the caller graph for this function:

setDataTables()

void TTQuantiSH::setDataTables

(

age_t

AGE

)

{
  unsigned int **sizes;
  unsigned int nb_patch = _pop->getPatchNbr();
 
  sizes = new unsigned int * [_nb_trait];
 
  for(unsigned int i = 0; i < _nb_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(_nb_trait, nb_patch, sizes);
  _genoTable.update(_nb_trait, nb_patch, sizes);
 
  for(unsigned int i = 0; i < _nb_trait; ++i)
    delete [] sizes[i];
  delete [] sizes;
 
  Patch* patch;
  age_idx age = (AGE == ADULTS ? ADLTx : OFFSx);
 
  for(unsigned int i = 0, n; i < nb_patch; i++) {
 
    patch = _pop->getPatch(i);
 
    n=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,
        _nb_trait, _SHLinkedTraitIndex);
 
    store_quanti_trait_values(patch, i, patch->size(FEM, age), &n, FEM, age, &_phenoTable, &_genoTable,
        _nb_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");
    }
  }
}

References _genoTable, _nb_trait, _phenoTable, StatHandlerBase::_pop, TraitStatHandler< TProtoQuanti, TTQuantiSH >::_SHLinkedTraitIndex, ADLTx, ADULTS, fatal(), FEM, Metapop::getPatch(), Metapop::getPatchNbr(), MAL, OFFSx, Metapop::size(), Patch::size(), DataTable< T >::size(), store_quanti_trait_values(), and DataTable< T >::update().

Referenced by setStats().

Here is the caller graph for this function:

setOffsprgStats()

void TTQuantiSH::setOffsprgStats ( )

inline

{setStats(OFFSPRG);}

References OFFSPRG, and setStats().

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

Here is the caller graph for this function:

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.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
    return false;
 
  return true;
}

References addAvgPerPatch(), addCovarPerPatch(), addEigen(), addEigenPerPatch(), addEigenValues(), addEigenValuesPerPatch(), addEigenVect1(), addEigenVect1PerPatch(), addQuanti(), addQuantiPerPatch(), addSkewPerPatch(), addVarPerPatch(), ADULTS, ALL, 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;
 
  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 < _nb_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(_nb_trait > 1) { 
      c = 0;
      //    calculate the covariances and G, need to adjust dimensions in class declaration
      for(unsigned int t1 = 0; t1 < _nb_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 < _nb_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 < _nb_trait; t++) {
        _peigval[t][j] = gsl_vector_get (_eval, t);
        for(unsigned int v = 0; v < _nb_trait; v++)
          _peigvect[j][pv++] = gsl_matrix_get (_evec, v, t); //read eigenvectors column-wise
      }
    }
  }
 
  double meanGamong1, meanGamong2;
  c = 0; //reset covariance positioner
  //among demes stats:
  for(unsigned int t1 = 0; t1 < _nb_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
 
    gsl_matrix_set(_G, t1, t1, _Vb[t1]); //_G here becomes the D-matrix, the among-deme (Difference) covariance matrix 
 
    for(unsigned int t2 = t1 + 1; t2 < _nb_trait; t2++) {
 
      meanGamong2 = my_mean (_pmeanG[t2], nb_patch);
 
      _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(_nb_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 < _nb_trait; t1++) {
      _eigval[t1] = gsl_vector_get (_eval, t1);
      for(unsigned int t2 = 0; t2 < _nb_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 _covar, _eigval, _eigvect, _eval, _evec, _G, _genoTable, _meanG, _meanP, _nb_trait, _patchNbr, _pcovar, _peigval, _peigvect, _phenoTable, _pmeanG, _pmeanP, StatHandlerBase::_pop, _pVa, _pVp, _table_set_age, _table_set_gen, _table_set_repl, _Va, _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().

Here is the caller graph for this function:

Member Data Documentation

_covar

double * TTQuantiSH::_covar

private

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

_eigval

double * TTQuantiSH::_eigval

private

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

_eigvect

double ** TTQuantiSH::_eigvect

private

Referenced by getEigenVectorElt(), init(), resetPtrs(), 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().

_meanG

double * TTQuantiSH::_meanG

private

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

_meanP

double* TTQuantiSH::_meanP

private

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

_nb_locus

unsigned int TTQuantiSH::_nb_locus

private

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

_nb_trait

unsigned int TTQuantiSH::_nb_trait

private

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

_patchNbr

unsigned int TTQuantiSH::_patchNbr

private

Referenced by init(), resetPtrs(), 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().

_pmeanG

double ** TTQuantiSH::_pmeanG

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

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

_Va

double * TTQuantiSH::_Va

private

Referenced by getQst(), getVa(), init(), resetPtrs(), 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