SubPopulation_Population_Manager.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2021, Xiaodong Duan, Aarhus University
All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
#ifndef SubPopulation_Population_ManagerH
#define SubPopulation_Population_ManagerH
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
 
class SubPopulation;
class SubPopulation_Population_Manager;
 
class struct_SubPopulation
{
 public:
  int x;
  int y;
  int w;
  int h;
  int species;
  Landscape* L;
  SubPopulation_Population_Manager * NPM;
  bool empty_flag;
  double* starting_suitability;
  double* starting_popu_density;
  int index_x;
  int index_y;
};
 
class SubPopulation_Population_Manager : public Population_Manager_Base
{
private:
   blitz::Array<double, 1> m_total_num_each_stage;
   double m_size_cell;
   
   std::vector<std::vector<int>> m_index_next_life_stage;
   blitz::Array<double, 1> m_lowest_temperature_die;
   blitz::Array<double, 1> m_highest_temperature_die;
   blitz::Array<double, 1> m_optimal_temperature; 
   friend class Subpopulation;
 
protected:
   blitz::Array<double, 2> m_development_degree_day;
   int m_num_x_range;
   int m_num_y_range;
   int m_num_life_stage;
   bool m_mul_hosts_flag;
   int m_sub_w;
   int m_sub_h;
   blitz::Array<double, 2> m_cell_popu_density;
   blitz::Array<double, 2> m_cell_suitability;
   blitz::Array<SubPopulation*, 2> m_the_subpopulation_array;
   blitz::Array<double, 4> m_short_move_mask;
   blitz::Array<double, 4> m_long_move_mask;
   int m_max_long_distance;
   int m_peak_long_distance;
   float m_scale_wind_speed;
   float m_max_flying_wind_speed;
   int m_wind_speed_step_size;
   int m_wind_direction_num;
   int m_wind_speed_num;
   blitz::Array<int,1> m_wind_speed_lookup_table;
   double m_max_short_distance;
   int m_long_move_mask_x_num;
   int m_long_move_mask_y_num;
   int m_long_move_mask_x_num_half;
   int m_long_move_mask_y_num_half;
   blitz::Array<int,1> m_long_move_mask_x_num_half_array;
   blitz::Array<int,1> m_long_move_mask_y_num_half_array;
   int m_short_move_mask_x_num;
   int m_short_move_mask_y_num;
   blitz::Array<double, 2> m_accumu_degree_days;
   blitz::Array<int, 2> m_index_new_old;
   int m_max_alive_days;
   blitz::Array<double, 1> m_lowest_temp_dev;
   blitz::Array<double, 2> m_life_circle_path;
   bool m_hibernated_hatch_flag;
   blitz::Array<bool, 1> m_first_flag_life_stage;
    blitz::Array<double, 1> m_current_flying_array;
    blitz::Array<double, 1> m_current_landing_array;
   std::vector <TTypesOfLandscapeElement> m_winter_hosts_tole;
   std::vector <std::vector<int>> m_winter_hosts_tole_period;
   std::map <int, int> m_winter_hosts_tole_period_map;
   std::vector <TTypesOfVegetation> m_winter_hosts_tov;
   std::vector <TTypesOfLandscapeElement> m_summer_hosts_tole;
   std::vector <std::vector<int>> m_summer_hosts_tole_period;
   std::map <int, int> m_summer_hosts_tole_period_map;
   std::vector <TTypesOfVegetation> m_summer_hosts_tov;
   blitz::Array<double, 2> m_current_mortality_array;
   blitz::Array<double, 2> m_wind_direction_array;
 
   blitz::Array<blitz::Array<double, 2>, 2> m_landing_masks;
 
   std::vector<int>  m_flying_life_stage_array;
   std::vector<int> m_landing_life_stage_array;
   std::vector<int>  m_local_moving_life_stage_array;
   std::ofstream m_subpopulation_base_prb_file;
   std::vector<std::vector<SubPopulation*>> m_vec_subpopulation_pointers_polygon;
   bool m_summer_host_on;
   bool m_winter_host_on;
 
 
 
 
public:
   SubPopulation_Population_Manager(Landscape* L, string DevReproFile ="", int a_sub_w=10, int a_sub_h=10, int a_num_life_stage=5, int a_max_long_dist = 1000, int a_peak_long_dist = 100, float a_scale_wind_speed = 1.1, float a_max_wind_speed = 16, int a_wind_direc_num = 8, int a_wind_speed_step_size = 2, int a_max_alive_day = 300);
   virtual ~SubPopulation_Population_Manager (void);
   double supplyAllPopulationGivenStage(int index);
   double supplyTotalPopulationInCell(int x_indx, int y_indx);
   int supplyCellNumX(){return m_num_x_range;}
   int supplyCellNumY(){return m_num_y_range;}
   double supplyCellWidth(){return m_sub_w;}
   double supplyCellHeight(){return m_sub_h;}
   double supplySizeSubpopulationCell() {return m_size_cell;}
   bool openSubpopulationBaseProbeFile();
   virtual void subpopuBaseOutputProbe();
   double getTotalSubpopulationInCell(int x_indx, int y_indx);
   double getSubpopulationInCellLifeStage( int x_indx, int y_indx, int a_life_stage);
   double getSuitabilityInCell(int x_indx, int y_indx) {return m_cell_suitability(y_indx, x_indx);}
   SubPopulation* supplySubPopulationPointer(int indx, int indy);
   int supplyLifeStageNum(){return m_num_life_stage;}
   int supplyMaxColNum() {return m_max_alive_days;}
   int supplyNextLifeStage(int life_circle_index, int life_stage_index) {return m_life_circle_path(life_circle_index, life_stage_index);}
   std::vector<int> supplyOldEnoughIndex(int life_stage_index) {return m_index_next_life_stage.at(life_stage_index);}
   int supplyNewestIndex(int life_stage_index) { return m_index_new_old(life_stage_index, 0);}
   virtual unsigned GetLiveArraySize(int a_listindex);
   void readDevReproFile(string inputfile);
   void relocatePopulation(void);
   virtual void DoLast();
   virtual void DoFirst();
   virtual void calLongMovementMask(void);
   void doDevelopment();
   void addNewDay();
   //virtual int calNextStage(int current_stage);
   virtual int calNextStage(int current_stage, double density = 1);
   virtual int calOffspringStage(int current_stage, double *offspring_num=NULL, double a_age=1, double a_density = -1, double a_growth_stage=0, double* a_propotion=NULL, bool winter_host_flag=false);
   virtual void updateDevelopmentSeason(){};
   void updateWholePopulationArray(int a_listindex, double number);
   void updateWholePopulationArray(blitz::Array<double, 1> a_array);
   void setFirstFlagLifeStage(int life_stage, bool pvalue) {m_first_flag_life_stage(life_stage) = pvalue;}
   bool supplyFirstFlagLifeStage(int life_stage) {return m_first_flag_life_stage(life_stage);}
   void setOldIndex(int life_stage, int p_value);
   void doFlying(int ind, int index_x, int index_y);
   void doLocalMovement(int index_x, int index_y, double proportion);
   bool  isWinterHostTole(TTypesOfLandscapeElement a_ele);
   bool  isSummerHostTole(TTypesOfLandscapeElement a_ele);
   bool  isWinterHostTov(TTypesOfVegetation a_ele);
   bool  isSummerHostTov(TTypesOfVegetation a_ele);
   virtual unsigned supplyDevelopmentSeason () {return 0;};
   virtual void updateMortalityArray (void);
   double supplyMortality(int a_life_stage, int a_age) {return m_current_mortality_array(a_life_stage, a_age);}
   blitz::Array<double, 2> supplyMortalityWholeArray(void) {return m_current_mortality_array;}
   blitz::Array<double, 1> supplyMortalityStageArray(int a_life_stage) {return m_current_mortality_array(a_life_stage, blitz::Range::all());}
   double calLandingCurve(double a_dis, double a_peak, double a_furthest);
   virtual void initialisePopulation();
   SubPopulation* CreateObjects(TAnimal *pvo, struct_SubPopulation* data, int number);
   int supplyAgeInDay(int lifestage_index, int column_index);
   double supplyAgeInDayDegree(int lifestage_index, int column_index) {return m_accumu_degree_days(lifestage_index, column_index);}
   virtual void SupplyLocXY(unsigned index_x, unsigned index_y, int & x, int & y)
   {
      int indx = index_x;
      int indy = index_y;
      x = m_the_subpopulation_array(indy, indx)->Supply_m_Location_x();
      y = m_the_subpopulation_array(indy, indx)->Supply_m_Location_y();
   }
   std::vector<int> supplyVecFlyingLifeStages() {return m_flying_life_stage_array; };
   int supplyNumFlyingLifeStages() {return m_flying_life_stage_array.size();}
   std::vector<int> supplyVecLocMoveLifeStages() {return m_local_moving_life_stage_array; };
   int supplyNumLocMovLifeStages() {return m_local_moving_life_stage_array.size();}
   virtual unsigned GetPopulationSize(int a_listindex) {
        return supplyAllPopulationGivenStage(a_listindex);
    }
 
   virtual bool isEnoughNextLifeStage(int a_life_stage);
   std::vector<int> supplyWinterTolePeriod(TTypesOfLandscapeElement a_tole) {return m_winter_hosts_tole_period.at(m_winter_hosts_tole_period_map.at(a_tole)); }
   std::vector<int> supplySummerTolePeriod(TTypesOfLandscapeElement a_tole) {return m_summer_hosts_tole_period.at(m_summer_hosts_tole_period_map.at(a_tole)); }
 
   virtual void doParasitoidDevelopment(){;};
   virtual void doSpecicesLastThing(){;}
   void updateWholePopulation();
    virtual void SetNoProbesAndSpeciesSpecificFunctions(int a_pn);
   virtual void readHosts(string a_file_name);
 
   virtual void writeCalibrationFiles(void){;};
 
   bool supplySummerHostOn(void){return m_summer_host_on;}
   bool supplyWinterHostOn(void){return m_winter_host_on;}
 
 
   #ifdef APHID_DEBUG
   double m_num_killed_by_parasitoid;
   double m_num_parasitoid;
   double m_num_parasitoid_egg;
   double m_num_new_parasitoid_egg_daily;
   #endif
 
protected:
   virtual void Run(int NoTSteps);
};
 
#endif