LCEselection.h

Go to the documentation of this file.

 
#ifndef LCE_SELECTION_H
#define LCE_SELECTION_H
 
#include <cmath>
#include "lifecycleevent.h"
#include "filehandler.h"
#ifdef HAS_GSL
#include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h>
#endif
 
class LCE_SelectionSH;
class LCE_SelectionFH;
//CLASS LCE_Selection_base
//
class LCE_Selection_base : public virtual LifeCycleEvent
{
  
  vector< TMatrix* >           _selection_matrix;
  vector< gsl_matrix* >        _gsl_selection_matrix;
  gsl_vector                   *_diffs,
                               *_res1;
  TMatrix                      _local_optima;
  TMatrix                      _rate_of_change_local_optima;
  bool                         _do_change_local_opt,
                               _rate_of_change_is_std;
  unsigned int                 _set_std_rate_at_generation;
  int                          _std_rate_reference_patch;
 
  //double *_phe;      // do we need this here?
  
 
  TMatrix                      _linear_selection_strength;
  vector<double>               _mean_trait_value;
  unsigned int                 _linearSelTraitIndex;
  age_idx                      _linearSelAgeClass;
 
  TMatrix                      _selection_offset;
 
  TMatrix                      _truncation_threshold;
  bool                         _truncation_upper;
 
 
  double                       _letheq;
 
  double                       _Fpedigree[5];
  
  double                       _FitnessFixModel[5];
  
  
  
  friend class LCE_SelectionSH;
  friend class LCE_SelectionFH;
  friend class LCE_Breed_Selection;
  
protected:
 
  double                       _base_fitness;
  double                       _mean_fitness, _max_fitness, _scaling_factor;
  bool                         _is_local,
                               _is_absolute;
 
  double _fitness[5], _survival[5], _ind_cntr[5]; 
 
  
  int _selectTraitDimension;
 
  vector<unsigned int> _selectTraitMapping;
 
  vector< double > _selection_variance;
  
  double _eVariance;
  
  vector< string > _Traits;
 
  vector< unsigned int > _TraitIndices;
  
  vector< string > _SelectionModels;  
  
 
  vector< double (LCE_Selection_base::* ) (Individual*, unsigned int, unsigned int) > _getRawFitness;
  
  double (LCE_Selection_base::* _getFitness) (Individual*, unsigned int);
  
  void (LCE_Selection_base::* _setScalingFactor) (age_idx, unsigned int);
  
  void (LCE_Selection_base::* _setNewLocalOptima) (void);
 
  
  LCE_SelectionSH* _stater;
  LCE_SelectionFH* _writer;
    
public:
    
  LCE_Selection_base ( );
  
  virtual ~LCE_Selection_base ( );
  
  bool setSelectionMatrix();
  bool setSelectTraitMapping(unsigned int num_quanti_traits);
  bool setSelectionOffset(double default_val, double min_val);
  bool setLocalOptima ();
  const TMatrix& getLocalOptima () const {return _local_optima;}
  bool set_sel_model  ();
  bool set_fit_model  ();
  bool set_local_optima ();
  bool set_param_rate_of_change();
  
  void set_std_rate_of_change();
  void addPhenotypicSD (unsigned int deme, double *stDev);
  void changeLocalOptima ();
 
  void resetCounters  ();
 
  void setMeans       (unsigned int tot_ind);
  
  void updateFitnessCounters    (double fitness, unsigned int ped_class, bool survived);
 
  double getMeanFitness         (age_idx age);
  
  double getMeanPatchFitness    (age_idx age, unsigned int p);
  
  double getMaxFitness         (age_idx age);
  
  double getMaxPatchFitness    (age_idx age, unsigned int p);
  
  
  double setMeanFitness         (age_idx age) { return (_mean_fitness = getMeanFitness(age));}
 
  double getFitness (Individual* ind, unsigned int patch)
  {
    return (this->*_getFitness)(ind, patch);
  }
  
  double getFitnessFixedEffect (Individual* offsprg, unsigned int patch, unsigned int trait)
  {
    return _FitnessFixModel[ offsprg->getPedigreeClass() ];
  }
  
  double getFitnessDirect (Individual* offsprg, unsigned int patch, unsigned int trait)
  { 
    return *(double*)offsprg->getTraitValue(trait); 
  }
  double getFitnessUnivariateQuadratic ( Individual* ind, unsigned int patch, unsigned int trait);
 
   double getFitnessUnivariateLinear (Individual* offsprg, unsigned int patch, unsigned int trait);
 
  double getFitnessUnivariateDisruptive (Individual* offsprg, unsigned int patch, unsigned int trait);
 
  double getFitnessMultivariateDisruptive (Individual* offsprg, unsigned int patch, unsigned int trait);
 
  double getFitnessTruncation (Individual* offsprg, unsigned int patch, unsigned int trait);
 
  double getFitnessMultivariateGaussian (Individual* offsprg, unsigned int patch, unsigned int trait);
  
  double getFitnessUnivariateGaussian (Individual* offsprg, unsigned int patch, unsigned int trait);
  
  double getFitnessMultivariateGaussian_VE (Individual* offsprg, unsigned int patch, unsigned int trait);
  
  double getFitnessUnivariateGaussian_VE (Individual* offsprg, unsigned int patch, unsigned int trait);
  
  
  double getFitnessAbsolute (Individual* ind, unsigned int patch);
  
  double getFitnessRelative (Individual* ind, unsigned int patch)
  {
    return getFitnessAbsolute(ind, patch) * _scaling_factor;
  }
  
  void   setScalingFactorLocal  (age_idx age, unsigned int p);
  
  void   setScalingFactorGlobal (age_idx age, unsigned int p);
  
  void   setScalingFactorMaxLocal  (age_idx age, unsigned int p);
  
  void   setScalingFactorMaxGlobal (age_idx age, unsigned int p);
  
  void   setScalingFactorForLinearSelection (age_idx age, unsigned int p);
 
  void   setScalingFactorAbsolute (age_idx age, unsigned int p) { _scaling_factor = 1; }
  
  void   doViabilitySelection   (sex_t SEX, age_idx AGE, Patch* patch, unsigned int p);
  
  void   checkChangeLocalOptima();
 
  virtual bool setParameters ();
  virtual void execute ();
  virtual void loadStatServices (StatServices* loader);
  virtual void loadFileServices (FileServices* loader);
  virtual bool resetParameterFromSource (std::string param, SimComponent* cmpt) {return false;}
  virtual LifeCycleEvent* clone () {return new LCE_Selection_base();}
  virtual age_t removeAgeClass   () {return NONE;}
  virtual age_t addAgeClass      () {return NONE;}
  virtual age_t requiredAgeClass () {return OFFSPRG;}
};
 
 
class LCE_SelectionSH : public EventStatHandler< LCE_Selection_base, LCE_SelectionSH >
{
  
  vector< vector< double > > _phenoTable;
  unsigned int _table_set_gen, _table_set_age, _table_set_repl;
  
public:
  
  LCE_SelectionSH (LCE_Selection_base* event) :
  EventStatHandler< LCE_Selection_base, LCE_SelectionSH > (event),
  _table_set_gen(999999), _table_set_age(999999), _table_set_repl(999999)
  {}
  
  virtual ~LCE_SelectionSH() {}
  
  virtual bool setStatRecorders (string& token);
  
  void   addMeanPerPatch (age_t AGE);
  void   addVarPerPatch  (age_t AGE);
  void   setDataTable    (age_t AGE);
  void   setAdultTable   ( ) {setDataTable(ADULTS);}
  void   setOffsprgTable ( ) {setDataTable(OFFSPRG);}
 
  
  double getMeanFitness  () {return _SHLinkedEvent->_mean_fitness;}
  double getFitness  (unsigned int i) {return _SHLinkedEvent->_fitness[i];}
  double getSurvival (unsigned int i) {return _SHLinkedEvent->_survival[i];}
  double getPedProp  (unsigned int i) {return _SHLinkedEvent->_ind_cntr[i];}
  double getMeanPatchFitness (unsigned int i, unsigned int int_agex);
  double getMeanPatchFitness (unsigned int i);
  double getVarPatchFitness (unsigned int i, unsigned int int_agex);
};
 
class LCE_SelectionFH : public virtual EventFileHandler< LCE_Selection_base >
{
  
  public:
  
  LCE_SelectionFH(LCE_Selection_base *event) : EventFileHandler< LCE_Selection_base >(event, ".fit") { }
  
  virtual ~LCE_SelectionFH() {}
  
  virtual void FHwrite();
  
  virtual void FHread(string& filename) {}
  
  void print(ofstream& FH, sex_t SEX, age_idx AGE, unsigned int i, Patch* patch, unsigned int ntraits);
};
 
 
#endif