metapop.h

Go to the documentation of this file.

 
#ifndef __METAPOP_H
#define __METAPOP_H
 
#include <list>
#include <deque>
#include <map>
#include <time.h>
#include "types.h"
#include "indfactory.h"
#include "MPStatHandler.h"
#include "binarydataloader.h"
#include "MPImanager.h"
#include "tmatrix.h"
#include "output.h"
#include "filehandler.h"
 
class Patch;
 
class LifeCycleEvent;
 
class MPFileHandler;
 
//CLASS METAPOP
 
class Metapop : public StorableComponent, public SimComponent, public IndFactory
{
 
    friend Metapop *BinaryDataLoader::extractPop(std::string&, unsigned int, SimBuilder*, Metapop*);
 
private:
  MPImanager *_mpimgr;
 
  MPStatHandler _statHandler;
 
  MPFileHandler *_writer;
 
  deque< Patch* > _vPatch;
  
 
  BinaryDataLoader _loader;
  Metapop* _source;
  bool _source_preserve;
  bool _source_load;
  unsigned int _source_replicates;
  unsigned int _source_replicate_digits;
  unsigned int _source_start_at_replicate;
  unsigned int _source_generation;
  std::string _source_name;
  std::string _source_filetype;
  std::string _source_required_age;
  unsigned int _source_load_periodicity;
  vector< string > _source_param_override;
 
  
  age_t _requiredAge;
  
  //parameters:
  unsigned int _patchNbr;
  unsigned int _patchK;
  unsigned int _patchKfem, _patchKmal;
  TMatrix _patchSizes;
  
  unsigned int _generations;
  unsigned int _replicates;
  //counters:
  unsigned int _currentGeneration;
  unsigned int _currentReplicate;
//  unsigned int Current_LC_Rank;
  age_t        _currentAge;
  
public: 
  
  Metapop();
  virtual ~Metapop();
  bool init();
  
  virtual bool setParameters ();
  bool setPopulationParameters();
  bool setSourceParameters();
  bool updatePopulationParameters();
  void reset();
  void clear();
 
  void setMPImanager(MPImanager *mgr) {_mpimgr = mgr;}
    
 
  void resizePatchArray ();
  void buildPatchArray();
  void updatePatchArray();
  void updatePatchState();
  void setPatchCapacities();
  void setPatchCapacities(string param);
  void setPatchCapacities(sex_t SEX, string param);
  void setPatchCapacities(string paramfem, string parammal);
  void loadSourcePopulation ( );
  void loadPopFromBinarySource ( string &filename );
  void loadPopFromTraitFile ( string &filename );
  void setPopulation (unsigned int currentReplicate, unsigned int replicates);
  void setPopulationFromSourceInPreserveMode ();
  void setPopulationFromSource () ;
  void fillPopulationFromSource(age_idx AGE, sex_t SEX, deque<Individual*>& src_pool);
  void fillPatchFromSource(sex_t SEX, Patch* src, Patch* patch, age_t AGE);
  
  //SimComponent implementation:
  virtual void loadFileServices ( FileServices* loader );
  
  virtual void loadStatServices ( StatServices* loader ) {loader->attach(&_statHandler);}
  
  virtual bool resetParameterFromSource (std::string param, SimComponent* cmpt) {return false;}
 
  //StoprableComponent implementation:
  virtual void store_data    ( BinaryStorageBuffer* saver  );
  
  virtual bool retrieve_data ( BinaryStorageBuffer* reader );
  
  void store_trait (int trait_idx, BinaryStorageBuffer* saver);
  
  void read_trait (int trait_idx, BinaryStorageBuffer* loader);
  
  
  
  Patch*       getPatch              (unsigned int i) {return (i > _vPatch.size() -1 ? 0 : _vPatch[i]);}
  
  Patch*       getPatchPtr           (unsigned int patch){
    if(!(patch < _vPatch.size())) 
      fatal("Metapop::getPatchPtr()::_vPatch overflow (id=%i nb=%i)\n", patch, _vPatch.size());
    
    if (_vPatch[patch] == NULL) fatal("Metapop::getPatchPtr()::NULL ptr\n");
    
    return _vPatch[patch];
  }
  
  deque< Patch* >* getPatchArray     ( ) {return &_vPatch;}
  unsigned int getPatchArraySize     ( ) {return _vPatch.size();}
  void getAllIndividuals(age_idx AGE, deque<Individual*>& fem_pool, deque<Individual*>& mal_pool);
  void         setGenerations        (unsigned int gen) {_generations = gen;}
  unsigned int getGenerations        ( ) {return _generations;}
  void         setReplicates         (unsigned int repl) {_replicates = repl;}
  unsigned int getReplicates         ( ) {return _replicates;}
  unsigned int getPatchNbr           ( ) {return _patchNbr;}
  unsigned int getPatchKFem          ( ) {return _patchKfem;}
  unsigned int getPatchKMal          ( ) {return _patchKmal;}
  unsigned int getPatchCapacity      ( ) {return _patchK;}
  unsigned int getPatchCapacity      (sex_t SEX, unsigned int patch) {return (unsigned int)_patchSizes.get(SEX, patch);}
  TMatrix*     getPatchCapacities    ( ) {return &_patchSizes;}
  bool         isSourceLoad          ( ) {return _source_load;}
  string       getSourceName         ( ) {return _source_name;}
  string       getSourceFileType     ( ) {return _source_filetype;}
  unsigned int getSourceReplDigits   ( ) {return _source_replicate_digits;}
  
  void         setPatchNbr           (unsigned int val) {_patchNbr = val;}
  void         setPatchSizes         (TMatrix& mat) {_patchSizes.copy(mat);}
 
  unsigned int getNumAgeClasses       ( ) {return 2;}
  
  unsigned int getCurrentReplicate   ( ) {return _currentReplicate;}
  unsigned int getCurrentGeneration  ( ) {return _currentGeneration;}
  void setCurrentReplicate   (unsigned int repl) {_currentReplicate = repl;}
  void setCurrentGeneration  (unsigned int gen) {_currentGeneration = gen;}
  age_t        getCurrentAge         ( ) {return _currentAge;}
  
  void setCurrentAge                 (age_t age) {_currentAge = age;}
  void setCurrentAge                 (LifeCycleEvent* LCE) ;
 
  bool         isAlive               ( ) {return size() != 0;}
 
  unsigned int size                  ( ) {return size(ALL);}
  
  unsigned int size ( sex_t SEX, age_t AGE );
  
  unsigned int size ( sex_t SEX, age_idx IDX );
 
  unsigned int size (age_idx IDX);
  unsigned int size (age_idx IDX, unsigned int deme);
  unsigned int size (sex_t SEX, age_idx IDX, unsigned int deme);
  
  unsigned int size (sex_t SEX, age_t AGE, unsigned int deme);
    
  unsigned int size ( age_t AGE )
  { return size( FEM, AGE ) + size( MAL, AGE );}
  
  unsigned int size ( age_t AGE, unsigned int deme )
  { return size( FEM, AGE, deme ) + size( MAL, AGE, deme );}
  
  Individual* get (sex_t SEX, age_idx AGE, unsigned int at, unsigned int deme);
  
  void move (sex_t SEX, age_idx from_age, unsigned int from_deme, 
             age_idx to_age, unsigned int to_deme, unsigned int at);
  
  void flush ();
  void flush (sex_t SEX, age_idx AGE);
  void flush (age_idx AGE);
  void flush (age_t AGE);
  Patch* removePatch (unsigned int i);
  void deletePatch (unsigned int i);
  void addPatch (Patch* patch);
  void addPatch (unsigned int num);
  
  void show_up();
};
//------------------------------------------------------------------------------------------
//
//                                        CLASS PATCH
//
//------------------------------------------------------------------------------------------
 
class Patch
{
  unsigned int _ID;
  unsigned int _K;
  unsigned int _KFem, _KMal;
  bool _isExtinct;
  unsigned int _age;
  unsigned int _nb_age_class;
  unsigned int _sizes[2][3];
  unsigned int _capacities[2][3];
  deque <Individual*> _containers[2][3];
  
 public:
//counters:
  unsigned short nbEmigrant, nbImigrant, nbPhilopat;
  short nbKolonisers;
 
//at construction, the capacities should be at least 1 to allow a patch to be filled (see add)
  Patch() : _ID(0), _K(1), _KFem(1), _KMal(1), _isExtinct(0), _age(0), _nb_age_class(3),
      nbEmigrant(0), nbImigrant(0), nbPhilopat(0), nbKolonisers(0)
  { for(unsigned int i = 0; i < _nb_age_class; i++) {
    _sizes[MAL][i] = 0;
    _sizes[FEM][i] = 0;
    _capacities[MAL][i] = 0;
    _capacities[FEM][i] = 0;}
  }
 
  ~Patch();
 
  Patch*        init                      (unsigned int nbfem, unsigned int nbmal, unsigned int id);
  void          setID                     (unsigned int i) {_ID = i;}
  void          set_K                     (unsigned int k) {_K = k;}
  void          set_KFem                  (unsigned int k) {_KFem = k;}
  void          set_KMal                  (unsigned int k) {_KMal = k;}
  void          set_isExtinct             (bool status)    {_isExtinct = status;}
  void          set_age                   (unsigned int a) {_age = a;}
  unsigned int  getID                     ()               {return _ID;}
  unsigned int  get_K                     ()               {return _K;}
  unsigned int  get_K                     (sex_t SEX)      {return (SEX ? _KFem : _KMal);}
  unsigned int  get_KFem                  ()               {return _KFem;}
  unsigned int  get_KMal                  ()               {return _KMal;}
  bool          get_isExtinct             ()               {return _isExtinct;}
  unsigned int  get_age                   ()               {return _age;}
  bool          isEmpty                   ()               {return (size(ALL) == 0);}
  unsigned int  getAdultsNumber           ()               {return size(ADLTx);}
  double        getDensity                (age_idx age)    {return (double)size(age)/_K;}
  
 
  unsigned int size       (age_t AGE)
  { return size(MAL,AGE) + size(FEM,AGE); }
  
  unsigned int size       (sex_t SEX, age_t AGE)
  { 
    unsigned int mask = 1, s = 0;
    for(unsigned int i = 0; i < _nb_age_class; i++) {
      if( (mask & AGE) != 0) s +=  _sizes[SEX][i];
      mask <<= 1;
    }
    return s;
  }
  
  unsigned int size       (sex_t SEX, age_idx AGE)
  { return _sizes[SEX][AGE]; }
  
  unsigned int size       (age_idx AGE)
  { return _sizes[0][AGE] + _sizes[1][AGE]; }
  
  Individual*  get        (sex_t SEX, age_idx AGE, unsigned int at)
  { return _containers[SEX][AGE][at]; }
  
  void         set        (sex_t SEX, age_idx AGE, unsigned int at, Individual* ind)
  { _containers[SEX][AGE][at] = ind; }
  
  void         add        (sex_t SEX, age_idx AGE, Individual* ind)
  {
    if( _sizes[SEX][AGE] + 1 > _capacities[SEX][AGE] ) {
      _containers[SEX][AGE].resize( _capacities[SEX][AGE] + (_K + 1) );
      _capacities[SEX][AGE] += (_K + 1); //the +1 is here to avoid seg faults when K=0
    }
    _containers[SEX][AGE][ _sizes[SEX][AGE]++ ] = ind;
  }
  
  void         assign     (sex_t SEX, age_idx AGE, size_t n)
  { _containers[SEX][AGE].assign(n,0);
   _sizes[SEX][AGE] = 0;
   _capacities[SEX][AGE] = n;
  }
  
  void        resize     (sex_t SEX, age_idx AGE, size_t new_size)
  {
    if( new_size > _capacities[SEX][AGE] ) {
      _containers[SEX][AGE].resize( new_size );
      _capacities[SEX][AGE] = new_size;
    }
    _sizes[SEX][AGE] = new_size;
  }
  Individual*   remove     (sex_t SEX, age_idx AGE, unsigned int at)
  {
    if(_sizes[SEX][AGE] == 0) {
      error("Patch::remove:: container already empty!!");
      return NULL;
    }
    unsigned int last = _sizes[SEX][AGE] - 1;
    Individual* ind = _containers[SEX][AGE][at];
    _containers[SEX][AGE][at] = _containers[SEX][AGE][ last ];
    _containers[SEX][AGE][ last ] = 0;
    _sizes[SEX][AGE]--;
    return ind;
  }
  
  void         move       (sex_t SEX, age_idx from, age_idx to, unsigned int at)
  {
    add( SEX, to, _containers[SEX][from][at] );
    remove( SEX, from, at );
  }
  
  void         move      (sex_t SEX, age_idx from, age_idx to)
  {
    if( _sizes[SEX][from] > _capacities[SEX][to] ) {
      _containers[SEX][to].resize( _sizes[SEX][from] );
      _capacities[SEX][to] = _sizes[SEX][from];
    }
    
    for(unsigned int i = 0; i < _sizes[SEX][from]; ++i)
      _containers[SEX][to][i] = _containers[SEX][from][i];
//    _containers[SEX][to].assign(_containers[SEX][from].begin(), _containers[SEX][from].end());
    
    _sizes[SEX][to] = _sizes[SEX][from];
    clear(SEX, from);
  }
 
  void         swap_new      (sex_t SEX, age_idx from, age_idx to)
  {
    deque<Individual*> temp(_containers[SEX][to].begin(), _containers[SEX][to].end());
    unsigned int to_size = _sizes[SEX][to];
 
    if( _sizes[SEX][from] > _capacities[SEX][to] ) {
      _containers[SEX][to].resize( _sizes[SEX][from] );
      _capacities[SEX][to] = _sizes[SEX][from];
    }
    
    // copy content of 'from' into 'to', but restrict to the 'size' of 'from' to not copy over the actual number of individuals
    _containers[SEX][to].assign(_containers[SEX][from].begin(), _containers[SEX][from].begin() + _sizes[SEX][from]);
    _sizes[SEX][to] = _containers[SEX][to].size(); // this should be equal to _sizes[SEX][from]
 
    if( _sizes[SEX][to] > _capacities[SEX][from] ) {
      _capacities[SEX][from] = _sizes[SEX][to];
    }
 
    _containers[SEX][from].assign(temp.begin(), temp.begin()+to_size);
    _sizes[SEX][from] = _containers[SEX][from].size();
  }
 
  void         clear      (sex_t SEX, age_idx AGE) { _sizes[SEX][AGE] = 0;}
  void         clear      () { for(int i = 0; i < 3; i++) {_sizes[0][i] = 0;_sizes[1][i] = 0;}}
 
  void         flush      (sex_t SEX, age_idx AGE, Metapop* pop)
  {
    for (unsigned int i = 0; i < _sizes[SEX][AGE]; ++i) {
      pop->recycle(_containers[SEX][AGE][i]);
      _containers[SEX][AGE][i] = 0;
    }
    _sizes[SEX][AGE] = 0;
  }
  
  void         flush      (age_idx AGE, Metapop* pop)
  { flush(FEM, AGE, pop); flush(MAL, AGE, pop); }
  
  void         flush      (age_t AGE, Metapop* pop)
  {
    unsigned int mask = 1;
    
    for(unsigned int i = 0; i < _nb_age_class; i++) {
      if( (mask & AGE) != 0) {
        flush(MAL, age_idx(i), pop);
        flush(FEM, age_idx(i), pop);
      }
      mask <<= 1;
    }
  }
  
  void         flush      (Metapop* pop)
  {
    for(unsigned int i = 0; i < _nb_age_class; i++) {
      flush(MAL, age_idx(i), pop);
      flush(FEM, age_idx(i), pop);
    }
  }
  
  void         getCopy   (sex_t SEX, age_idx AGE, deque< Individual* >& to)
  {
    for (unsigned int i = 0; i < _sizes[SEX][AGE]; ++i) {
      to.push_back(_containers[SEX][AGE][i]);
    }
  }
  
  void       copy2patch (sex_t from_sex, sex_t to_sex, age_idx from_age, age_idx to_age, Patch* to_patch)
  {
    for (unsigned int i = 0; i < _sizes[from_sex][from_age]; ++i)
      to_patch->add(to_sex, to_age, _containers[from_sex][from_age][i] );
  }
  
  void       copy2patch (sex_t SEX, age_idx AGE, Patch* patch)
  {
    for (unsigned int i = 0; i < _sizes[SEX][AGE]; ++i)
      patch->add(SEX, AGE, get(SEX, AGE, i) );
  }
    
  void       copy2patch (age_idx AGE, Patch* patch)
  {
    copy2patch(FEM, AGE, patch);
    copy2patch(MAL, AGE, patch);
  }
  
  void       copy2patch (Patch* patch)
  {
    for (unsigned int i = 0; i < _nb_age_class; ++i){
      copy2patch(FEM, static_cast<age_idx> (i), patch);
      copy2patch(MAL, static_cast<age_idx> (i), patch);
    }
  }
  
  void reset_counters();
  void reset_containers();
  void setNewGeneration(age_t AGE, Metapop* pop);
  void setNewGeneration(age_idx AGE, Metapop* pop);
  
  void show_up();
  
};
 
//------------------------------------------------------------------------------------------
//
//                                       MPFileHandler
//
//------------------------------------------------------------------------------------------
class MPFileHandler : public FileHandler {
 
        int _patch_sample_size;
 
public:
        MPFileHandler () : FileHandler(".ped"), _patch_sample_size(0) {}
 
        virtual ~MPFileHandler() {}
 
        void setOption(int size){_patch_sample_size = size;}
 
        virtual void FHwrite();
        virtual void FHread (string& filename){}
 
        void createAndPrintSample (age_idx AGE, Patch* patch, ofstream& FH);
        void printNoSample (sex_t SEX, age_idx AGE, Patch* patch, ofstream& FH);
};
 
//------------------------------------------------------------------------------------------
//
//                                  Metapop inline functions
//
//------------------------------------------------------------------------------------------
inline unsigned int Metapop::size (age_idx IDX)
{ 
  return size(FEM, IDX) + size(MAL, IDX); 
}
 
inline unsigned int Metapop::size (age_idx IDX, unsigned int deme)
{ 
  return size(FEM, IDX, deme) + size(MAL, IDX, deme); 
}
 
inline unsigned int Metapop::size ( sex_t SEX, age_idx IDX )
{
  unsigned int s = 0;
  for(unsigned int i = 0; i < _patchNbr; i++)
    s += _vPatch[i]->size(SEX, IDX);
  return s;
}
 
inline unsigned int Metapop::size ( sex_t SEX, age_idx IDX, unsigned int deme)
{
  return _vPatch[deme]->size(SEX, IDX);
}
 
inline unsigned int Metapop::size ( sex_t SEX, age_t AGE )
{
  unsigned int s = 0;
  for(unsigned int i = 0; i < _vPatch.size(); i++)
    s += _vPatch[i]->size(SEX, AGE);
  return s;
}
 
inline unsigned int Metapop::size (sex_t SEX, age_t AGE, unsigned int deme)
{
  Patch* patch = getPatch(deme);
  return (patch!=0? patch->size(SEX, AGE) : 0);
}  
 
inline Individual* Metapop::get (sex_t SEX, age_idx AGE, unsigned int at, unsigned int deme)
{ return getPatchPtr(deme)->get(SEX, AGE, at); }
 
inline void Metapop::move (sex_t SEX, age_idx from_age, unsigned int from_deme, 
                           age_idx to_age, unsigned int to_deme, unsigned int at)
{//cout << "  add "<<get(SEX, from_age, at, from_deme)->getID()<<" to "<<to_deme<<endl;
  _vPatch[to_deme]->add( SEX, to_age, get(SEX, from_age, at, from_deme));
  //cout << "  remove "<<get(SEX, from_age, at, from_deme)->getID()<<" from "<<from_deme<<endl;
  _vPatch[from_deme]->remove(SEX, from_age, at);
  //cout << "  sizes: "<<from_deme<<": "<<_vPatch[from_deme]->size(SEX, from_age)<<", "
  //     << to_deme << ": " <<_vPatch[to_deme]->size( SEX, to_age)<<endl;
}
 
inline void Metapop::flush() 
{
  for(unsigned int i = 0; i < _patchNbr; i++) _vPatch[i]->flush(this);
}
 
inline void Metapop::flush(sex_t SEX, age_idx AGE) 
{
  for(unsigned int i = 0; i < _patchNbr; i++) _vPatch[i]->flush(SEX, AGE, this);
}
 
inline void Metapop::flush(age_idx AGE) 
{
  for(unsigned int i = 0; i < _patchNbr; i++) _vPatch[i]->flush(AGE, this);
}
 
inline void Metapop::flush(age_t AGE) 
{
  for(unsigned int i = 0; i < _patchNbr; i++) _vPatch[i]->flush(AGE, this);
}
 
inline Patch* Metapop::removePatch (unsigned int i)
{
  Patch* patch = getPatchPtr(i);
  _vPatch.erase(_vPatch.begin() + i);
  return patch;
}
 
inline void Metapop::deletePatch (unsigned int i)
{
  delete _vPatch[i];
  for (unsigned int k = i; k < _vPatch.size() -1; k++) {
    _vPatch[k] = _vPatch[k + 1];
    _vPatch[k]->setID(k);
  }
  _vPatch.pop_back();
}
 
inline void Metapop::addPatch (Patch* patch)
{
  _vPatch.push_back(patch);
}
 
inline void Metapop::addPatch (unsigned int num)
{
  for (unsigned int i = 0; i < num; i++)
    _vPatch.push_back(new Patch());
}
 
 
 
 
#endif