Osmia_Population_Manager.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2017, Christopher John Topping, 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.
********************************************************************************************************
*/
#include <forward_list>
 
//---------------------------------------------------------------------------
#ifndef Osmia_Population_ManagerH
#define Osmia_Population_ManagerH
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
 
class Osmia;
class OsmiaParasitoid_Population_Manager;
 
 
enum class TTypeOfOsmiaLifeStages : int // int is used because this may be used as an index to an array passed in CreateObjects
{
    to_OsmiaEgg = 0,
    to_OsmiaLarva,
    to_OsmiaPrepupa,
    to_OsmiaPupa,
    to_OsmiaInCocoon,
    to_OsmiaFemale
};
 
typedef vector<double>  eggsexratiovsagelogisticcurvedata;
typedef vector<double>  femalecocoonmassvsagelogisticcurvedata;
//------------------------------------------------------------------------------
class OsmiaPollenNectarThresholds
{
public:
    double m_pollenTqual = 0.0;
    double m_nectarTqual = 0.0;
    double m_pollenTquan = 0.0;
    double m_nectarTquan = 0.0;
};
//------------------------------------------------------------------------------
 
class OsmiaParasitoidSubPopulation
{
protected:
    // Attributes
    double m_NoParasitoids;
    double m_DiffusionRate;
    double m_DiffusionConstant; 
    int m_CellIndexArray[8]; 
    int m_x;
    int m_y;
    OsmiaParasitoid_Population_Manager* m_OurPopulationManager;
    static array<double,12> m_MortalityPerMonth;
    static int m_ThisMonth;
    // Methods
public:
    OsmiaParasitoidSubPopulation(double a_dispersalfraction, double a_startno, int a_x, int a_y, int a_wide, int a_high, OsmiaParasitoid_Population_Manager* a_popman);
    ~OsmiaParasitoidSubPopulation();
    void Add(double a_change) { m_NoParasitoids += a_change; }
    void Remove(double a_change) { m_NoParasitoids -= a_change; }
    double GetSubPopnSize() { return m_NoParasitoids; }
    void DailyMortality();
    void Dispersal();
    void Reproduce();
    virtual void DoFirst() {
        DailyMortality();
        Dispersal();
        Reproduce();
    }
    void SetThisMonth(int a_month) { m_ThisMonth = a_month;  }
    void SetMortalities(array<double, 12> a_morts) {
        m_MortalityPerMonth = a_morts;
    }
};
//------------------------------------------------------------------------------
 
class OsmiaParasitoid_Population_Manager : public Population_Manager
{
protected:
    // Attributes
    vector<OsmiaParasitoidSubPopulation*>m_SubPopulations;
    Landscape* m_TheLandscape;
    unsigned m_Wide;
    unsigned m_High;
    unsigned m_CellSize;
    unsigned m_Size;
    // Methods
 
public:
    OsmiaParasitoid_Population_Manager(Landscape* a_landscape, int a_cellsize);
    ~OsmiaParasitoid_Population_Manager();
    void AddDispersers(int a_ref, double a_dispersers) {
        m_SubPopulations[a_ref]->Add(a_dispersers);
    }
    void RemoveParasitoids(int a_ref, double a_dispersers) {
        m_SubPopulations[a_ref]->Remove(a_dispersers);
    }
    double GetSize(int a_ref) { return m_SubPopulations[a_ref]->GetSubPopnSize(); }
    double GetSize(int a_x, int a_y) { return m_SubPopulations[a_x+a_y*m_Wide]->GetSubPopnSize(); }
    array<double, static_cast<unsigned>(TTypeOfOsmiaParasitoids::topara_foobar)> GetParasitoidNumbers(int a_x, int a_y);
    void AddParasitoid(TTypeOfOsmiaParasitoids a_type, int a_x, int a_y) 
    {
        int subpop = ((a_x / m_CellSize) + (a_y / m_CellSize) * m_Wide) + (static_cast<unsigned>(a_type)-1) * m_Size;
        m_SubPopulations[subpop]->Add(1);
    }
};
//------------------------------------------------------------------------------
class struct_Osmia
{
 public:
  int x;
  int y;
  int age;
  bool sex;
  Landscape* L;
  Osmia_Population_Manager * OPM;
  Osmia_Nest* nest;
  TTypeOfOsmiaParasitoids parasitised;
  double mass;
  double pest_mortality = 0;
  double overwintering_degree_days = 0;
};
 
class OsmiaPolygonEntry
{
protected:
    std::forward_list<Osmia_Nest*> m_NestList;
    double m_OsmiaNestProb;
    double m_MaxOsmiaNests; // Needs to be double because its used to divide later
    int m_CurrentOsmiaNests;
    int m_Area;
    int m_Polyindex;
public:
    OsmiaPolygonEntry()
    {
        m_CurrentOsmiaNests = 0;
        m_MaxOsmiaNests = 0;
        m_OsmiaNestProb = 0;
        m_Polyindex = -1;
        m_Area = -1;
    }
    OsmiaPolygonEntry(int a_index, int a_area)
    {
        m_CurrentOsmiaNests = 0;
        m_MaxOsmiaNests = 0;
        m_OsmiaNestProb = 0;
        m_Polyindex = a_index;
        m_Area = a_area;
    }
 
    ~OsmiaPolygonEntry()
    {
        //for (std::vector<Osmia_Nest*>::iterator it = m_NestList.begin(); it != m_NestList.end(); ++it) {
        for(auto it : m_NestList){
            if(it!=NULL)
                delete it;
        }
        m_NestList.clear();
    }
    bool IsOsmiaNestPossible() {
        if ((m_CurrentOsmiaNests < m_MaxOsmiaNests) && (g_rand_uni_fnc() < m_OsmiaNestProb)) return true;
        return false;
    }
    void ReleaseOsmiaNest(Osmia_Nest* a_nest) {
        m_CurrentOsmiaNests--;
        auto prev_point = m_NestList.before_begin();
        for (auto it = m_NestList.begin(); it!=m_NestList.end(); ++it)
        {
            if((*it) == a_nest) 
            {
                //cout << "Osmia nest released" << endl;
                m_NestList.erase_after(prev_point);
                delete a_nest;
                break;
            }
 
            prev_point=it;
        }
    }
    void UpdateOsmiaNesting()
    {
        if (m_MaxOsmiaNests <= 0) m_OsmiaNestProb = 0.0;
        else {
            m_OsmiaNestProb = 1.0 - (m_CurrentOsmiaNests / m_MaxOsmiaNests);
        }
    }
    void IncOsmiaNesting(Osmia_Nest* a_nest)
    {
        m_NestList.push_front(a_nest);
        m_CurrentOsmiaNests++;
    }
    void SetMaxOsmiaNests(double a_noNests)
    {
        double maxnests = a_noNests * m_Area;
        if (maxnests> 2147000000 ) maxnests= 2147000000;
        m_MaxOsmiaNests = int(maxnests);
        if (m_MaxOsmiaNests < 1) m_MaxOsmiaNests = 0;
    }
    void SetAreaAttribute(int a_area) { m_Area = a_area; }
    void SetIndexAttribute(int a_index) { m_Polyindex = a_index; }
    int GetNoNests() { return m_CurrentOsmiaNests; }
    int GetMaxNoNests() { return m_MaxOsmiaNests; }
    bool SanityCheck() { return m_CurrentOsmiaNests == std::distance(std::begin(m_NestList), std::end(m_NestList)); }
    bool SanityCheck2() {
        for (auto it = m_NestList.begin(); it!=m_NestList.end(); ++it)
        {
            if((*it)->ZeroCells()) 
            {
                return false;
            }
        }  
 
        return true;
    }
};
 
class Osmia_Nest_Manager
{
public:
    Osmia_Nest_Manager()
    {
        ;
    }
    ~Osmia_Nest_Manager()
    {
        int nopolys = m_PolyList.size();
        for (int e = 0; e < nopolys; e++) {
            omp_destroy_nest_lock(m_PolyListLocks[e]);
            delete m_PolyListLocks[e];
        }
        m_PolyList.clear();
    }
    void InitOsmiaBeeNesting();
    void UpdateOsmiaNesting() {
        for (unsigned int s = 0; s < m_PolyList.size(); s++) {
            m_PolyList[s].UpdateOsmiaNesting();
        }
    }
    bool IsOsmiaNestPossible(int a_polyindex)
    {
        return m_PolyList[a_polyindex].IsOsmiaNestPossible();
    }
    Osmia_Nest* CreateNest(int a_x, int a_y, int a_polyindex)
    {
        Osmia_Nest* a_nest = new Osmia_Nest(a_x, a_y,a_polyindex, this);    
        m_PolyList[a_polyindex].IncOsmiaNesting(a_nest);
        return a_nest;
    }
    void ReleaseOsmiaNest(int a_polyindex, Osmia_Nest* a_nest)
    {
        omp_set_nest_lock(m_PolyListLocks[a_polyindex]);
        m_PolyList[a_polyindex].ReleaseOsmiaNest(a_nest);
        omp_unset_nest_lock(m_PolyListLocks[a_polyindex]);
    }
    bool GetNestPossible(TTypesOfLandscapeElement index) { return m_PossibleNestType[int(index)]; }
 
    int GetNoNests(int a_polyindex) {
        return m_PolyList[a_polyindex].GetNoNests(); 
    }
 
    bool SanityCheck(int a_polyindex) {  
        return m_PolyList[a_polyindex].SanityCheck();
    }
 
    bool CheckZeroNests() {
        for (unsigned int s = 0; s < m_PolyList.size(); s++) {
            if (!m_PolyList[s].SanityCheck2()) return false;
        }
        return true;
    }
protected:
    vector<OsmiaPolygonEntry> m_PolyList;
    vector<omp_nest_lock_t*> m_PolyListLocks;
    bool m_PossibleNestType[tole_Foobar];
};
 
class Osmia_Population_Manager : public Population_Manager
{
public:
    //code used for pestiside store
    #ifdef __OSMIA_PESTICIDE_STORE
    unsigned int m_female_count = 0;
    #endif
 
    // Methods
    Osmia_Population_Manager(Landscape* L);
    void Init();
    virtual ~Osmia_Population_Manager(void);
    void TheAOROutputProbe() override;
    void CreateObjects(TTypeOfOsmiaLifeStages ob_type, TAnimal* pvo, struct_Osmia* data, int number);
 
    #ifdef __OSMIATESTING
 
    void RecordEggProduction(int a_eggs);
    void RecordEggLength(int a_length);
    void RecordLarvalLength(int a_length);
    void RecordPrePupaLength(int a_length);
    void RecordPupaLength(int a_length);
    void RecordInCocoonLength(int a_length);
    void RecordFemaleWeight(double a_mass) { m_FemaleWeights.push_back(a_mass); };
    void SetFemaleWeightLock(void) {omp_set_nest_lock(m_female_weight_record_lock);}
    void ReleaseFemaleWeightLock(void) {omp_unset_nest_lock(m_female_weight_record_lock);}
    #endif
    
    bool IsEndPreWinter() { return m_PreWinteringEndFlag; }
    bool IsOverWinterEnd() { return m_OverWinterEndFlag; }
    bool IsOsmiaNestPossible(int a_polyindex) { return m_OurOsmiaNestManager.IsOsmiaNestPossible(a_polyindex); }
    bool SantityCheck(int a_polyindex) { return m_OurOsmiaNestManager.SanityCheck(a_polyindex); }
    Osmia_Nest* CreateNest(int a_x, int a_y, int a_polyindex) {
        Osmia_Nest* return_nest_ptr;
        m_TheLandscape->SetPolygonLock(a_polyindex);
        return_nest_ptr = m_OurOsmiaNestManager.CreateNest(a_x, a_y, a_polyindex); 
        m_TheLandscape->ReleasePolygonLock(a_polyindex);
        return return_nest_ptr; 
    }
    void ReleaseOsmiaNest(int a_polyindex, Osmia_Nest* a_nest) {
        m_TheLandscape->SetPolygonLock(a_polyindex);
        m_OurOsmiaNestManager.ReleaseOsmiaNest(a_polyindex, a_nest);
        m_TheLandscape->ReleasePolygonLock(a_polyindex);
    }
    int GetForageHours() { return m_FlyingWeather;  }
    
    double GetProvisioningParams(int a_age) {
        return m_NestProvisioningParameters[a_age];
    }
    double GetFirstCocoonProvisioningMass(int a_age, int a_massclass)
    {
        return m_FemaleCocoonMassEqns[a_massclass][a_age]-(m_exp_ZeroTo1.Get() * m_FemaleCocoonMassEqns[a_massclass][a_age] * 0.6);
    }
    double GetSexRatioEggsAgeMass(int a_massclass, int a_age)
    {
        return m_EggSexRatioEqns[a_massclass][a_age];
    }
    int AddToDensityGrid(APoint a_loc)
    {
        int index = (a_loc.m_x / 1000) + (a_loc.m_y / 1000) * m_GridExtent;
        m_FemaleDensityGrid[index]++;
        return index;
    }
    void AddToDensityGrid(int a_index)
    {
        m_FemaleDensityGrid[a_index]++;
    }
    void RemoveFromDensityGrid(int a_index)
    {
        m_FemaleDensityGrid[a_index]--;
    }
    int GetDensity(APoint a_loc)
    {
        int index = (a_loc.m_x / 1000) + (a_loc.m_y / 1000) * m_GridExtent;
        return m_FemaleDensityGrid[index];
    }
    int GetDensity(int a_index)
    {
        return m_FemaleDensityGrid[a_index];
    }
    void ClearDensityGrid()
    {
        for (int i=0; i< m_FemaleDensityGrid.size(); i++) m_FemaleDensityGrid[i] = 0;
    }
    double GetPrePupalDevelDays() {
        return m_PrePupalDevelDaysToday;
    }
    /* \brief The function to calculate the available foraging hours per day.*/
    void CalForageHours(void);
    //DEBUG//
#ifdef __OSMIATESTING
public:
    ofstream m_eggsfirstnest;
    double m_egghistogram[4][30];
    void WriteNestTestData(OsmiaNestData a_target, OsmiaNestData a_achieved);
#endif // __OSMIATESTING
protected:
    // Attributes
    static probability_distribution  m_exp_ZeroTo1;
    #ifdef __OSMIATESTING
 
    vector<double> m_FemaleWeights;
    omp_nest_lock_t *m_female_weight_record_lock;
    SimpleStatistics m_OsmiaEggProdStats;
    SimpleStatistics m_EggStageLength;
    SimpleStatistics m_LarvalStageLength;
    SimpleStatistics m_PrePupaStageLength;
    SimpleStatistics m_PupaStageLength;
    SimpleStatistics m_InCocoonStageLength;
    #endif
 
    PollenMap_centroidbased* m_ThePollenMap;
    int m_FlyingWeather;
    bool m_PreWinteringEndFlag;
    bool m_OverWinterEndFlag;
    Osmia_Nest_Manager m_OurOsmiaNestManager;
    double m_NestProvisioningParameters[365];
    vector<eggsexratiovsagelogisticcurvedata> m_EggSexRatioEqns;
    vector<femalecocoonmassvsagelogisticcurvedata>  m_FemaleCocoonMassEqns;
    vector<int> m_FemaleDensityGrid;
    int m_GridExtent;
    double m_PollenCompetitionsReductionScaler;
    vector<double> m_PrePupalDevelRates;
    double m_PrePupalDevelDaysToday;
    vector< OsmiaPollenNectarThresholds> m_PN_thresholds;
 
    // Methods
    virtual void DoFirst();
    virtual void DoBefore();
    virtual void DoAfter() {}
    virtual void DoLast()
    {
        int today = m_TheLandscape->SupplyDayInYear();
        if (today > September)
        {
            int day = g_date->OldDays() + g_date->DayInYear();
            double t0 = m_TheLandscape->SupplyTempPeriod(day, 1);
            if (!m_PreWinteringEndFlag)
            {
                double t1 = m_TheLandscape->SupplyTempPeriod(day - 1, 1);
                double t2 = m_TheLandscape->SupplyTempPeriod(day - 2, 1);
                double t3 = m_TheLandscape->SupplyTempPeriod(day - 3, 1);
                double t4 = m_TheLandscape->SupplyTempPeriod(day - 4, 1);
                double t5 = m_TheLandscape->SupplyTempPeriod(day - 5, 1);
                if (((t2 < 13.0) && (t1 < 13.0) && (t0 < 13.0)) && (((t5 - t4 > 1.0) && (t4 - t3 > 1.0)) || ((t3 < 13.0) && (t5 - t4 >= 3.0))))
                {
                    m_PreWinteringEndFlag = true;
                }
            }
        }
        if (today == March)
        {
            m_OverWinterEndFlag = true;
        }
        if (today == June)
        {
            // No emergence after April so we can safely reset this flag here.
            m_PreWinteringEndFlag = false;
            m_OverWinterEndFlag = false;
        }
#ifdef __OSMIARECORDFORAGE
        double meanforage = 0.0;
        if (Osmia_Female::m_foragecount > 0) meanforage = Osmia_Female::m_foragesum / Osmia_Female::m_foragecount;
        cout << meanforage << endl;
        Osmia_Female::m_foragesum = 0.0;
        Osmia_Female::m_foragecount = 0.0;
#endif
 
#ifdef __OSMIATESTING       
        if (today == 364) {
            ofstream file1("OsmiaStageLengths.txt", ios::app);
            file1 << "Year: " << g_date->GetYear() << endl;
            file1 << "Mean egg stage days is:" << '\t'  << m_EggStageLength.get_meanvalue() << endl;
            file1 << "Mean larval stage days is:" << '\t' << m_LarvalStageLength.get_meanvalue() << endl;
            file1 << "Mean prepupal stage days is:" << '\t' << m_PrePupaStageLength.get_meanvalue() << endl;
            file1 << "Mean pupal stage days is:" << '\t' << m_PupaStageLength.get_meanvalue() << endl;
            file1 << "Mean incocoon stage days is:" << '\t' << m_InCocoonStageLength.get_meanvalue() << endl;
            m_EggStageLength.ClearData();
            m_LarvalStageLength.ClearData();
            m_PrePupaStageLength.ClearData();
            m_PupaStageLength.ClearData();
            m_InCocoonStageLength.ClearData();
            file1.close();
        }
#endif
    }
};
 
#endif