TTQuanti Class Reference

TTQuanti. More...

#include <ttquanti.h>

Inheritance diagram for TTQuanti:

Collaboration diagram for TTQuanti:

Public Member Functions
	TTQuanti ()
	TTQuanti (const TTQuanti &T)
virtual	~TTQuanti ()
virtual void	init ()
virtual void	init_sequence ()
virtual void	reset ()
virtual void	inherit (TTrait *mother, TTrait *father)
virtual void	mutate ()
virtual void *	set_trait (void *value)
virtual void	set_sequence (void **seq)
virtual void	set_value ()
virtual void *	getValue () const
virtual trait_t	get_type () const
virtual void **	get_sequence () const
virtual double	get_allele_value (int loc, int all)
virtual void	set_allele_value (unsigned int locus, unsigned int allele, double value)
virtual void	show_up ()
virtual TTQuanti *	clone ()
virtual TTQuanti &	operator= (const TTrait &T)
virtual bool	operator== (const TTrait &T)
virtual bool	operator!= (const TTrait &T)
virtual void	store_data (BinaryStorageBuffer *saver)
virtual bool	retrieve_data (BinaryStorageBuffer *reader)
void	set_proto (TProtoQuanti *proto)
double	get_additive_genotype (unsigned int trait)
double	get_full_genotype (unsigned int trait)
void	set_allele (int locus, int allele, double value)
void	set_phenotype (unsigned int trait, double value)
Public Member Functions inherited from TTrait
virtual void	init ()=0
	Called to allocate the trait's genotypic sequences. More...
virtual void	init_sequence ()=0
	Called at the start of each replicate, sets the initial genotypes. More...
virtual void	reset ()=0
	Called at the end of each simulation/replicate, deallocates sequence memory. More...
virtual void	inherit (TTrait *mother, TTrait *father)=0
	Inheritance procedure, creates a new trait from mother's and father's traits. More...
virtual void	mutate ()=0
	Mutation procedure, perform mutations on the genes sequence. More...
virtual void *	set_trait (void *value)=0
	Called to set the phenotypic to a particular value or to give context-dependant value(s) to the trait. More...
virtual void	set_sequence (void **seq)=0
	Called to set the sequence pointer to an existing trait. More...
virtual double	get_allele_value (int loc, int all)=0
	Called to read one allele value at a particular locus. More...
virtual void	set_allele_value (unsigned int locus, unsigned int allele, double value)=0
	Called to change the allelic value at a particular locus. More...
virtual void	set_value ()=0
	Tells the trait to set its phenotype from genotype, should be used instead of getValue(). More...
virtual void *	getValue () const =0
	Genotype to phenotype mapper. More...
virtual trait_t	get_type () const =0
	type accessor. More...
virtual void **	get_sequence () const =0
	sequence accessor. More...
virtual void	show_up ()=0
	Writes some info to stdout. More...
virtual TTrait *	clone ()=0
	Returns a copy of itself. More...
virtual	~TTrait ()
Public Member Functions inherited from StorableComponent
virtual void	store_data (BinaryStorageBuffer *saver)=0
	Interface to store the component data (e.g. gene values) into a binary buffer. More...
virtual bool	retrieve_data (BinaryStorageBuffer *reader)=0
	Interface to retrieve the same data from the binary buffer. More...
virtual	~StorableComponent ()

Private Attributes
double **	_sequence
double *	_phenotypes
TProtoQuanti *	_myProto

Detailed Description

TTQuanti.

Constructor & Destructor Documentation

TTQuanti() [1/2]

TTQuanti::TTQuanti ( )

inline

              : _sequence(0),_phenotypes(0),_myProto(0)
  { }

Referenced by clone().

Here is the caller graph for this function:

TTQuanti() [2/2]

TTQuanti::TTQuanti ( const TTQuanti &  T )

inline

                               : _sequence(0), _phenotypes(0), _myProto(T._myProto)
  { }

~TTQuanti()

virtual TTQuanti::~TTQuanti ( )

inlinevirtual

{reset();}

References reset().

Member Function Documentation

clone()

virtual TTQuanti * TTQuanti::clone ( )

inlinevirtual

Implements TTrait.

{return new TTQuanti(*this);}

References TTQuanti().

get_additive_genotype()

double TTQuanti::get_additive_genotype

(

unsigned int

trait

)

{
  return _myProto->set_genotype_value_additive((const double**)_sequence, trait);
}

References _myProto, _sequence, and TProtoQuanti::set_genotype_value_additive().

Referenced by TTQuantiSH::getVaNoDominance(), and TTQuantiFH::print().

Here is the caller graph for this function:

get_allele_value()

double TTQuanti::get_allele_value ( int  loc, int  all  )

inlinevirtual

Implements TTrait.

{
  return (loc < (int)_myProto->_seq_length && all < 2 ? _sequence[all][loc] : 0);
}

References _myProto, TProtoQuanti::_seq_length, and _sequence.

Referenced by TProtoQuanti::mutate_diallelic_HC(), and TProtoQuanti::mutate_noHC().

Here is the caller graph for this function:

get_full_genotype()

double TTQuanti::get_full_genotype

(

unsigned int

trait

)

{ //returns genotypic value that includes dominance effects if any
  return (_myProto->*_myProto->_set_genotype_func_ptr)((const double**)_sequence, trait);
}

References _myProto, _sequence, and TProtoQuanti::_set_genotype_func_ptr.

Referenced by TTQuantiSH::getVaWithDominance(), TTQuantiFH::print(), and store_quanti_trait_values().

Here is the caller graph for this function:

get_sequence()

virtual void ** TTQuanti::get_sequence ( ) const

inlinevirtual

Implements TTrait.

{return (void**)_sequence;}

References _sequence.

Referenced by TTQuantiSH::getVaWithDominance(), TTQuantiFH::print(), and TProtoQuanti::set_trait_value_noVE().

Here is the caller graph for this function:

get_type()

virtual trait_t TTQuanti::get_type ( ) const

inlinevirtual

Implements TTrait.

{return QUANT;}

References QUANT.

Referenced by operator==().

Here is the caller graph for this function:

getValue()

virtual void * TTQuanti::getValue ( ) const

inlinevirtual

Implements TTrait.

{return _phenotypes;}

References _phenotypes.

Referenced by TTQuantiFH::print(), and store_quanti_trait_values().

Here is the caller graph for this function:

inherit()

void TTQuanti::inherit ( TTrait *  mother, TTrait *  father  )

inlinevirtual

Implements TTrait.

{
  const double** mother_seq = (const double**)mother->get_sequence();
  const double** father_seq = (const double**)father->get_sequence();
 
  _myProto->inherit(FEM, _sequence[FEM], mother_seq);
 
  _myProto->inherit(MAL, _sequence[MAL], father_seq);
}

References _myProto, _sequence, FEM, TTrait::get_sequence(), TProtoQuanti::inherit(), and MAL.

init()

void TTQuanti::init ( )

inlinevirtual

Implements TTrait.

{  
  reset();
  _sequence = new double*[2];
  _sequence[0] = new double [ _myProto->_seq_length];
  _sequence[1] = new double [ _myProto->_seq_length];
 
  _phenotypes = new double [_myProto->_nb_traits];
 
}

References _myProto, TProtoQuanti::_nb_traits, _phenotypes, TProtoQuanti::_seq_length, _sequence, and reset().

Referenced by operator=(), and set_sequence().

Here is the caller graph for this function:

init_sequence()

void TTQuanti::init_sequence ( )

inlinevirtual

Implements TTrait.

{
  unsigned int pos;
  //options:
  //0: no variation, init value = (trait value)/(2*_nb_locus)
  //1: init value = (trait value)/(2*_nb_locus) + 1 mutation/locus
  //2: init value = (trait value)/(2*_nb_locus) + 1 mutation/locus+make parts ==> mean trait value doesn't change
  //3: init value = (trait value + random deviate N(0,sdVm))/(2*_nb_locus) + 1 mutation/locus+make parts
  //4: no variation and initialize with opposite effect alleles at alternating loci.
 
  //decide what initial value to use
 
  //Note: the initial values may have been set individually by LCE_quanti
  //      it wouldn't make sense then to store the init values in the prototype 
  //      because init values are set patch-specific by LCE_quanti
  //      Problem: without LCE_quanti, the original init values must not change from one replicate
  //      to the other, so we use a local variable
 
  double my_init[_myProto->_nb_traits];
 
  if(_myProto->_doInitMutation == 3) {
 
    double sdVm;
 
    for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
      //      sdVm = sqrt(4*_nb_locus*_mut_rate*_myProto->get_trait_var(j)); //trait variance = 2Vm
      sdVm = 0.25;
      my_init[j] = (_myProto->_init_value[j] + RAND::Gaussian(sdVm)) / (2*_myProto->_nb_locus);
    }
 
  } else {
 
    for(unsigned int j = 0; j < _myProto->_nb_traits; j++) my_init[j] = _myProto->_init_value[j] / (2*_myProto->_nb_locus);
 
  }
 
  if(_myProto->_allele_model < 3) { //for the di-allelic models
 
    if (_myProto->_doInitMutation != 4){
      for(unsigned int i = 0; i < _myProto->_nb_locus; i++) {
        pos = i * _myProto->_nb_traits;
        for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
          _sequence[0][pos] = _myProto->_allele_value[i][0]; //set with the positive allele value
          _sequence[1][pos] = _myProto->_allele_value[i][0];
          pos++;
        }
      }
 
    } else {
      //this is intended for a diallelic model with no initial variance
 
      for(unsigned int i = 0; i < _myProto->_nb_locus; i++) {
        pos = i * _myProto->_nb_traits;
        for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
          if (i % 2 == 0){
            _sequence[0][pos] = _myProto->_allele_value[i][0]; //set with the positive allele value
            _sequence[1][pos] = _myProto->_allele_value[i][0];
            pos++;
          } else {
            _sequence[0][pos] = _myProto->_allele_value[i][0]*-1; //set with the negative allele value
            _sequence[1][pos] = _myProto->_allele_value[i][0]*-1;
            pos++;
          }
        }
      }
 
    }
  } else {
 
    //set the allele values from the trait value
    for(unsigned int i = 0; i < _myProto->_nb_locus; i++) {
      pos = i * _myProto->_nb_traits;
      for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
        _sequence[0][pos] = my_init[j];
        _sequence[1][pos] = my_init[j];
        pos++;
      }
    }
  }
 
 
  //add random effects to allele values if needed
  if(_myProto->_doInitMutation != 0 && _myProto->_doInitMutation != 4) {
 
    double *mut1, *mut2;
    unsigned int L;
 
    for(unsigned int i = 0; i < _myProto->_nb_locus; i++) {
 
      pos = i * _myProto->_nb_traits;
 
      mut1 = (_myProto->*_myProto->_getMutationValues)(i);
      mut2 = (_myProto->*_myProto->_getMutationValues)(i);
 
      if(_myProto->_allele_model < 3) { //diallelic models
 
        for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
          _sequence[0][pos] = mut1[j]; 
          _sequence[1][pos] = mut2[j]; 
          pos++;
        }
 
      } else {
 
        for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
          _sequence[0][pos] += mut1[j]; 
          _sequence[1][pos] += mut2[j]; 
          pos++;
        }
 
        if(_myProto->_doInitMutation > 1) { // the make-parts algorithm
 
          //select a random locus
          do{
            L = RAND::Uniform(_myProto->_nb_locus);
          }while(L == i);
 
          pos = L * _myProto->_nb_traits;
          //subtract the previous random deviates from that locus
          for(unsigned int j = 0; j < _myProto->_nb_traits; j++) {
            _sequence[0][pos] -= mut1[j]; 
            _sequence[1][pos] -= mut2[j]; 
            pos++;
          }
        }
      }
    }
  } 
 
}

References TProtoQuanti::_allele_model, TProtoQuanti::_allele_value, TProtoQuanti::_doInitMutation, TProtoQuanti::_getMutationValues, TProtoQuanti::_init_value, _myProto, TProtoQuanti::_nb_locus, TProtoQuanti::_nb_traits, _sequence, RAND::Gaussian(), and RAND::Uniform().

Referenced by LCE_QuantiInit::init_trait_value().

Here is the caller graph for this function:

mutate()

void TTQuanti::mutate ( )

inlinevirtual

Implements TTrait.

{
  _myProto->mutate(this);
}

References _myProto, and TProtoQuanti::mutate().

operator!=()

bool TTQuanti::operator!= ( const TTrait &  T )

virtual

Implements TTrait.

    {
  if(!((*this) == T) )
    return true;
  else
    return false;
    }

operator=()

TTQuanti & TTQuanti::operator= ( const TTrait &  T )

virtual

Implements TTrait.

{  
  const TTQuanti& TQ = dynamic_cast<const TTQuanti&>(T);
 
  assert(*this == TQ);  // to make sure that the sequences are of same length
 
  if(this != &TQ) {
 
    init();
 
    memcpy(_sequence[0], TQ._sequence[0], _myProto->_seq_length*sizeof(double));
    memcpy(_sequence[1], TQ._sequence[1], _myProto->_seq_length*sizeof(double));
 
    set_value();
  }
 
  return *this;
}

References _myProto, TProtoQuanti::_seq_length, _sequence, init(), and set_value().

operator==()

bool TTQuanti::operator== ( const TTrait &  T )

virtual

Implements TTrait.

    {
  if(this->get_type().compare(T.get_type()) != 0) return false;
 
  const TTQuanti& TQ = dynamic_cast<const TTQuanti&>(T);
 
  if(this != &TQ) {
    if(_myProto->_nb_locus != TQ._myProto->_nb_locus) return false;
    if(_myProto->_nb_traits != TQ._myProto->_nb_traits) return false;
    if(_myProto->_seq_length != TQ._myProto->_seq_length) return false;
  }
  return true;
    }

References _myProto, TProtoQuanti::_nb_locus, TProtoQuanti::_nb_traits, TProtoQuanti::_seq_length, get_type(), and TTrait::get_type().

reset()

void TTQuanti::reset ( )

inlinevirtual

Implements TTrait.

{
  if(_sequence != NULL) {
    delete [] _sequence[0]; 
    delete [] _sequence[1];
    delete [] _sequence; 
    _sequence = NULL;
  }
 
  if(_phenotypes != NULL) delete [] _phenotypes;
  _phenotypes = NULL;
 
}

References _phenotypes, and _sequence.

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

Here is the caller graph for this function:

retrieve_data()

bool TTQuanti::retrieve_data ( BinaryStorageBuffer *  reader )

inlinevirtual

Implements StorableComponent.

{
  reader->read(_sequence[0],_myProto->_seq_length*sizeof(double));
  reader->read(_sequence[1],_myProto->_seq_length*sizeof(double));
  return true;
}

References _myProto, TProtoQuanti::_seq_length, _sequence, and BinaryStorageBuffer::read().

set_allele()

void TTQuanti::set_allele ( int  locus, int  allele, double  value  )

inline

{_sequence[allele][locus] = value;}

References _sequence.

Referenced by LCE_QuantiInit::init_allele_freq(), TProtoQuanti::mutate_diallelic_HC(), TProtoQuanti::mutate_HC(), and TProtoQuanti::mutate_noHC().

Here is the caller graph for this function:

set_allele_value()

void TTQuanti::set_allele_value ( unsigned int  locus, unsigned int  allele, double  value  )

inlinevirtual

Implements TTrait.

{
  assert(locus < _myProto->_nb_locus && allele < 2);
  _sequence[allele][locus] = value;
}

References _sequence.

set_phenotype()

void TTQuanti::set_phenotype	(	unsigned int	trait,
		double	value
	)

{
  assert(trait < _myProto->_nb_traits && _phenotypes != NULL);
 
  _phenotypes[trait] = value;
}

References _phenotypes.

set_proto()

void TTQuanti::set_proto ( TProtoQuanti *  proto )

inline

{_myProto = proto;}

References _myProto.

Referenced by TProtoQuanti::hatch().

Here is the caller graph for this function:

set_sequence()

void TTQuanti::set_sequence ( void **  seq )

virtual

Implements TTrait.

{
  init();
  memcpy(_sequence[0], seq[0], _myProto->_seq_length*sizeof(double));
  memcpy(_sequence[1], seq[1], _myProto->_seq_length*sizeof(double));
}

References _myProto, TProtoQuanti::_seq_length, _sequence, and init().

Referenced by TTQuantiFH::FHread().

Here is the caller graph for this function:

set_trait()

virtual void * TTQuanti::set_trait ( void *  value )

inlinevirtual

Implements TTrait.

{return value;}

set_value()

void TTQuanti::set_value ( )

inlinevirtual

Implements TTrait.

{
  for (int i = 0; i < _myProto->_nb_traits; ++i) {
    _phenotypes[i] = (_myProto->*_myProto->_set_trait_value_func_ptr)(this, i);
  }
}

References _myProto, TProtoQuanti::_nb_traits, _phenotypes, and TProtoQuanti::_set_trait_value_func_ptr.

Referenced by TTQuantiFH::FHread(), LCE_QuantiInit::init_allele_freq(), LCE_QuantiInit::init_trait_value(), and operator=().

Here is the caller graph for this function:

show_up()

void TTQuanti::show_up ( )

virtual

Implements TTrait.

{
  message("\
          Trait's type: QUANTI\n\
          traits: %i\n\
          loci: %i\n\
          seq length: %i\n",_myProto->_nb_traits,_myProto->_nb_locus
          ,_myProto->_seq_length);
 
  for(unsigned int i = 0; i < _myProto->_nb_traits; i++)
    message("phenotype %i: %f\n",i+1,_phenotypes[i]);
 
  message("_sequence: \n0:");
  unsigned int loc;
  for(unsigned int i = 0; i < _myProto->_nb_traits; ++i) {
    message("\nt%i:",i+1);
    for(unsigned int j = 0; (j < _myProto->_nb_locus); ++j) {
      loc = j * _myProto->_nb_traits + i;
      message("%.3f,",_sequence[0][loc]);
    }
  }
  message("\n1:");
  for(unsigned int i = 0; i < _myProto->_nb_traits; ++i) {
    message("\nt%i:",i+1);
    for(unsigned int j = 0; (j < _myProto->_nb_locus); ++j) {
      loc = j * _myProto->_nb_traits + i;
      message("%.3f,",_sequence[1][loc]);
    }
  }
  message("\n");
 
}  

References _myProto, TProtoQuanti::_nb_locus, TProtoQuanti::_nb_traits, _phenotypes, TProtoQuanti::_seq_length, _sequence, and message().

store_data()

void TTQuanti::store_data ( BinaryStorageBuffer *  saver )

inlinevirtual

Implements StorableComponent.

{
  saver->store(_sequence[0],_myProto->_seq_length*sizeof(double));
  saver->store(_sequence[1],_myProto->_seq_length*sizeof(double));
}

References _myProto, TProtoQuanti::_seq_length, _sequence, and BinaryStorageBuffer::store().

Member Data Documentation

_myProto

TProtoQuanti* TTQuanti::_myProto

private

Referenced by get_additive_genotype(), get_allele_value(), get_full_genotype(), inherit(), init(), init_sequence(), mutate(), operator=(), operator==(), retrieve_data(), set_proto(), set_sequence(), set_value(), show_up(), and store_data().

_phenotypes

double* TTQuanti::_phenotypes

private

Referenced by getValue(), init(), reset(), set_phenotype(), set_value(), and show_up().

_sequence

double** TTQuanti::_sequence

private

Referenced by get_additive_genotype(), get_allele_value(), get_full_genotype(), get_sequence(), inherit(), init(), init_sequence(), operator=(), reset(), retrieve_data(), set_allele(), set_allele_value(), set_sequence(), show_up(), and store_data().

---

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

• ttquanti.h
• ttquanti.cc