ttrait_with_map.h

Go to the documentation of this file.

 
#ifndef TTRAIT_WITH_MAP_H
#define TTRAIT_WITH_MAP_H
 
#include <string>
#include <vector>
#include <map>
#include <utility>
#include "ttrait.h"
 
 
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
 
class GeneticMap {
  
private:
  
  unsigned long _currentIndividual;
  
  map< trait_t, unsigned int > _traits;
  
  unsigned int _nTrait;
  
  vector< unsigned int* >  _lociLookupTable; //this is the actual map, for each trait
  vector< unsigned int >   _numChrsmPerTrait;
  vector< unsigned int >   _numLociPerTrait;
  vector< unsigned int* >  _numLociPerChrsmPerTrait;
  vector< unsigned int* >  _locPositionsPerTrait;
  
  vector< vector < unsigned int > > _recPositions[2];
  
  vector< bool >  _chrsmFirstRecombPosition[2];
  
  vector< unsigned int > _junctions;
 
  unsigned int  _numChromosome;
  unsigned int  *_perChrsmLength;          //array length is _numChromosome
  unsigned int  *_chrsmFirstLocusPosition; //array length is _numChromosome
  unsigned int  _totalLength;  // total map length
  unsigned int  _recombLength; // this is _totalLength + 1; used to draw the x-over spots
  unsigned int  _totalNumLoci;
  double        _resolution;
  double        _totRecombEventsMean;
  double        _recombinationRate;
  
  
public:
  
  GeneticMap() :_currentIndividual(0), _nTrait(0),
  _numChromosome(0), _perChrsmLength(0), 
  _chrsmFirstLocusPosition(0), _totalLength(0), _recombLength(0), _totalNumLoci(0), _resolution(1),
  _totRecombEventsMean(0), _recombinationRate(0.5) {}
  
  ~GeneticMap() {reset_tables();}
  
  bool getGeneticMap (trait_t trait, double** table, unsigned int table_length);
 
  double getResolution ( ) {return _resolution;}
  
  double setResolution (double val) 
  {
    _resolution = (val < _resolution ? val : _resolution); 
    return _resolution;
  }
  
  void   rescaleMap (double val);
  void   reset_tables ();
  void   clear ();
  
  void   setLookupTable (unsigned int idx);
  
  void   recombine  (sex_t SEX);
 
  vector< pair<unsigned int, unsigned int> >   reduceJunctions (sex_t SEX, unsigned int trait_idx);
 
  bool   registerIndForRecombine (unsigned long ID) 
  {
    if (ID == _currentIndividual) return false;
    else  _currentIndividual = ID;
    return true;
  }
  
  unsigned int addTrait (trait_t trait, unsigned int nChrm, unsigned int nLoc, unsigned int* nLocChrm,
                         double resolution, unsigned int* locPositions);
  
  void unregisterTrait (trait_t trait);
  
  bool checkRegisteredTrait (trait_t trait);
 
//  void unregisterTrait_at (unsigned int traitIdx);
  
  vector< unsigned int>&  getRecLoci (sex_t SEX, unsigned int trait)
  {
    return _recPositions[SEX][trait];
  }
  
  vector< bool >& getFirstRecPosition (sex_t SEX) 
  { return _chrsmFirstRecombPosition[SEX]; }
 
  unsigned int* getLocusPositionTable  (const trait_t trait)
  {return _locPositionsPerTrait[ _traits[ trait ] ];}
};
 
 
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
class TTProtoWithMap : public TraitPrototype {
  
  string _paramPrefix;
  
  bool _isRegistered;
  
protected:
  
  //recombination:
  unsigned int _mapIndex;
  double       _totRecombEventsMean;
  double       _recombRate;
  double       _mapResolution;
  unsigned int _numChromosome;
  unsigned int _numLoci;
  double       *_recombRatePerChrmsm;
  unsigned int *_numLociPerChrmsm;
  unsigned int *_chrsmLength;
  unsigned int *_lociMapPositions;
  
  friend class TTraitWithMap;
  
public:
  
  
  static GeneticMap   _map;
  
  
  TTProtoWithMap():_isRegistered(0), _mapIndex(0), _totRecombEventsMean(0),
  _recombRate(0), _mapResolution(1), _numChromosome(0), _numLoci(0),
  _recombRatePerChrmsm(0), _numLociPerChrmsm(0), _chrsmLength(0),
  _lociMapPositions(0) 
  {}
  
  TTProtoWithMap(const TTProtoWithMap& TP);
  
  virtual ~TTProtoWithMap(); 
  
 
  virtual   bool                   is_mappable () {return true;}
  virtual   bool                   is_mapped () {return _map.checkRegisteredTrait(this->get_type());}
  virtual   vector< unsigned int > get_locus_map_positions ();
 
  void setMapIndex (unsigned int idx) {_mapIndex = idx;}
  
  unsigned int getMapIndex () {return _mapIndex;}
 
  static GeneticMap& getGeneticMapRef () {return _map;}
 
  double getRecombRate () const {return _recombRate;}
  
  bool setGeneticMapParameters (string prefix, unsigned int numLoci = 0);
 
  void addGeneticMapParameters (string prefix);
  
  bool setRecombinationMapRandom ();
  
  bool setRecombinationMapNonRandom (vector< vector<double> >& lociPositions);
  
  bool setRecombinationMapFixed ();
  
  bool setNumLociPerChromosome (string param_name);
  
  void reset_recombination_pointers();
  
  void registerGeneticMap ();
  
  void unregisterFromGeneticMap ();
 
  bool areGeneticMapParamSet(string prefix);
 
  bool isRecombinationFree(string prefix);
 
  void recordRandomMap ();
 
  static void recombine (unsigned long indID);
  
  virtual void reset ();
  
};
 
 
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
class TTraitWithMap : public TTrait {
  
protected:
  
  TTProtoWithMap* _myProto;
  
public:
  
  TTraitWithMap():_myProto(0) {}
  
  virtual ~TTraitWithMap() {}
  
};
 
#endif