individual.h

Go to the documentation of this file.

 
#ifndef INDIVIDUAL_H
#define INDIVIDUAL_H
#include <map>
#include <deque>
#include <limits>
#include "types.h"
#include "ttrait.h"
#include "ttrait_with_map.h"
#include "binarystoragebuffer.h"
 
class Individual {
private:
  unsigned long _id;
  unsigned short _age;
  sex_t _sex;
  unsigned long _motherID, _fatherID;
  Individual *_mother, *_father;
  unsigned short _home;
  unsigned char _pedigreeClass;
  double _fecundity;
  unsigned short _matings[5];
  unsigned short _realizedFecundity[5];
  unsigned int _trait_nb;
  
public:
  
  static unsigned long currentID;
  
  typedef int IDX;
  
  std::deque<TTrait*> Traits;
  
  Individual ();
  ~Individual () {clearTraits();}
  Individual*     init                    ();
  void            reset                   ();
  
  void            setID                  (unsigned long value)  {_id = value;}
  void            setAge                 (unsigned short value) {_age = value;}
  void            Aging                  ()                     {_age++;}
  void            setFatherID            (unsigned long value)  {_fatherID = value;}
  void            setMotherID            (unsigned long value)  {_motherID = value;}
  void            setFather              (Individual* f)        {_father = f;}
  void            setMother              (Individual* m)        {_mother = m;}
  void            setHome                (unsigned short value) {_home = value;}
  void            setSex                 (sex_t sex)            {_sex = sex;}
  void            setCurrentID           (unsigned long value)  {currentID = value;}
  void            setIsSelfed            (bool s)               {_pedigreeClass = (s ? 4 : 0);}
  void            setPedigreeClass       (Individual* mother, Individual* father) {_pedigreeClass = getPedigreeClass(mother,father);}
  void            setPedigreeClass       (unsigned char ped)    {_pedigreeClass = ped;}
 
  
  unsigned long   getID                  ()                      {return _id;}
  unsigned short  getAge                 ()                      {return _age;}
  unsigned long   getFatherID            ()                      {return _fatherID;}
  unsigned long   getMotherID            ()                      {return _motherID;}
  Individual*     getFather              ()                      {return _father;}
  Individual*     getMother              ()                      {return _mother;}
  unsigned short  getHome                ()                      {return _home;}
  sex_t           getSex                 ()                      {return _sex;}
  bool            isFemale               ()                      {return (_sex == FEM);}
  bool            getIsSelfed            ()                      {return (_pedigreeClass == 4);}
  unsigned long   getcurrentID           ()                      {return currentID;}
  double          getFecundity           ()                      {return _fecundity;}
  unsigned short  getMatings (unsigned int cat)
  {
    return _matings[cat];
  }
  unsigned short  getLocalMatings        ( )
  {
    return _matings[1]+_matings[2]+_matings[3]+_matings[4];
  }
  unsigned int    getTotMatings          ( )
  {
    return _matings[0] + getLocalMatings();
  }
  unsigned short  getRealizedFecundity   (unsigned int cat)
  {
    return _realizedFecundity[cat];
  }
  
  unsigned int    getLocalRealizedFecundity( )
  {
    return _realizedFecundity[1]+_realizedFecundity[2]+_realizedFecundity[3]+_realizedFecundity[4];
  }
  
  unsigned int    getTotRealizedFecundity( )        {return _realizedFecundity[0] + getLocalRealizedFecundity( );}
 
  unsigned int    getPedigreeClass       ( )
  {
    return _pedigreeClass;
  }
  unsigned int    getPedigreeClass       (Individual* mother, Individual* father);
  
  void store_data    ( BinaryStorageBuffer* saver  );
  
  void retrieve_data ( BinaryStorageBuffer* reader );
  
 
  double          setFecundity            (double value)         {_fecundity = value; return value;}
 
  void            reset_counters         ( )                     
  { 
    for(unsigned int i = 0; i < 5; i++) {
      _matings[i] = 0; _realizedFecundity[i] = 0;
    } }
 
  void   addMating  (unsigned int category) 
  { _matings[category]++; }
 
  void   DidHaveABaby  (unsigned int category)
  { _matings[category]++; _realizedFecundity[category]++; }
 
  double getFecWithHomePatchMate  () 
  { 
    unsigned short mate = getLocalMatings();
    return (mate != 0 ? (double) getLocalRealizedFecundity()/mate : 0.0);
  }
  double getFecWithOtherPatchMate () 
  {
    return (_matings[0] != 0 ? (double) _realizedFecundity[0]/_matings[0] : 0.0);
  }
 
  
  unsigned int getTraitNumber() { return _trait_nb;}
  
  std::deque<TTrait *>& getTraits() {return Traits;}
  
  void*  setTrait (IDX T, void* value) 
  { return getTrait(T)->set_trait(value); }
  
  void   setTraitValue (IDX T)
  {  getTrait(T)->set_value(); }
  
  void   setTraitValue ()    
  { for(unsigned int i = 0; i < _trait_nb; i++) Traits[i]->set_value(); }
  
  void*  getTraitValue (IDX T)
  { return getTrait(T)->getValue(); }
  
  TTrait*  getTrait (IDX T) 
  { if( T == -1 || !(T < (int)_trait_nb) )
    fatal("Individual::Trying to access a trait not present in the traits table (at %i, size %i)\n",T,_trait_nb);
    return Traits[T]; 
  }
  
  void  addTrait (TTrait* theTrait, IDX pos)
  { if((int)_trait_nb != pos)
    fatal("Individual::adding a trait to the wrong position (at %i, size %i)!\n",pos,_trait_nb);
    Traits.push_back(theTrait); _trait_nb++;
  }
  
  void  removeTrait (IDX T)
  { delete Traits[T]; Traits.erase(Traits.begin() + T); _trait_nb--;}
  
  void  clearTraits ( )
  { if(_trait_nb != 0) {for(unsigned int i = 0; i < Traits.size(); ++i) delete Traits[i];
    Traits.clear(); _trait_nb = 0;}
  }
  
  void  inheritTrait (IDX T, Individual* mother, Individual* father) 
  {  
    recombine(_id);
    getTrait(T)->inherit(mother->getTrait(T), father->getTrait(T)); 
  }
  
  void  mutateTrait (IDX T)
  {  getTrait(T)->mutate(); }
  
  void createTrait (IDX i, Individual* mother, Individual* father)
  { if(!(mother && father)) 
      fatal("Individual::create::received null pointer!!!\n");
    TTrait* T = Traits[i];
    recombine(_id);
    T->inherit(mother->getTrait(i),father->getTrait(i));
    T->mutate();  
    T->set_value();
  }
  
  Individual*  createTrait (IDX i, bool do_inherit, bool do_mutate)
  {
    if(do_inherit) inheritTrait(i, _mother, _father);
    if(do_mutate)  mutateTrait(i);
    setTraitValue(i);
    return this;
  } 
  
  Individual*  create_first_gen ()
  {
    for(unsigned int i = 0; i < _trait_nb; i++) {
      Traits[i]->init_sequence();
      Traits[i]->set_value();
    }
    //we have to set the parents ids otherwise the first offspring generation will be made of full sibs only.
    static unsigned long ID = std::numeric_limits< unsigned long >::max();
    _motherID = ID--;
    _fatherID = ID--;
    return this;
  }  
  
  Individual*  create ()
  { 
    inherit(_mother, _father);
    mutate();
    setTraitValue();
    return this;
  } 
  Individual*  create (bool do_inherit, bool do_mutate)
  { 
    if(do_inherit) inherit(_mother, _father);
    if(do_mutate)  mutate();
    setTraitValue();
    return this;
  } 
  
  Individual*  create (Individual* mother, Individual* father)
  { 
    if(!(mother && father))
      fatal("Individual::create::received null parents pointer!!!\n");
    TTrait *TT;
    recombine(_id);
    for(unsigned int i = 0; i < _trait_nb; i++) {
      TT = Traits[i];
      TT->inherit(mother->getTrait(i), father->getTrait(i));
      TT->mutate();
      TT->set_value();
    }
    return this;
  }
  
  void  inherit (Individual* mother, Individual* father)
  { 
    recombine(_id);
    for(unsigned int i = 0; i < _trait_nb; i++) 
      Traits[i]->inherit(mother->getTrait(i), father->getTrait(i)); 
  }
  
  void mutate ()
  { for(unsigned int i = 0; i < _trait_nb; i++) Traits[i]->mutate(); }
  
  void recombine (unsigned long ID)
  {  TTProtoWithMap::recombine(ID); }
  
  void  show_up();
  
  Individual*  clone ();
  
 
  Individual& operator=(const Individual& i);
  bool operator==(const Individual& i);
  bool operator!=(const Individual& i);
};
 
#endif //INDIVIDUAL_H