Osmia.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2019, 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.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
#ifndef OsmiaH
#define OsmiaH
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <forward_list>
 
class Osmia_Population_Manager;
class OsmiaParasitoid_Population_Manager;
class Osmia_Nest_Manager;
class PollenMap_centroidbased;
class probability_distribution;
class Osmia_Egg;
class Osmia_Female;
class struct_Osmia;
class Osmia_Base;
 
//------------------------------------------------------------------------------
//typedef vector<Osmia*> TListOfOsmia;
//---------------------------------------------------------------------------
 
#define __OSMIA_DIST_SIZE 10000
 
static CfgFloat cfg_OsmiaTotalCocoonMassLoss("OSMIATOTALCOCOONMASSLOSS", CFG_CUSTOM, 15.0);
static CfgFloat cfg_OsmiaTotalCocoonMassLossRange("OSMIATOTALCOCOONMASSLOSSRANGE", CFG_CUSTOM, 5.0);
 
enum TTypeOfOsmiaState
{
    toOsmias_InitialState = 0,
    toOsmias_Develop,
    toOsmias_NextStage,
    toOsmias_Disperse,
    toOsmias_NestProvisioning,
    toOsmias_ReproductiveBehaviour,
    toOsmias_Emerged,
    toOsmias_Die
};
 
 
 
enum class TTypeOfOsmiaParasitoids : unsigned // unsigned is used because this may be used as an index to an array
{
    topara_Unparasitised = 0, 
    topara_Bombylid,
    topara_Cleptoparasite,
    topara_foobar
};
 
class OsmiaForageMask
{
public:
    int m_mask[20][8][2];
    int m_step;
    int m_step2;
    OsmiaForageMask();
};
 
class OsmiaForageMaskDetailed
{
public:
    vector<APoint> m_mask;
    int m_step;
    int m_maxdistance;
    OsmiaForageMaskDetailed(int a_step, int a_maxdistance);
};
 
class OsmiaNestData
{
public:
    int m_no_eggs;
    int m_no_females;
    vector<double> m_cell_provision;
};
 
class Osmia_Nest : public TAnimal
{
protected:
    int m_x;
    int m_y;
    int m_PolyRef;
    std::forward_list<TAnimal*>m_cells;
    omp_nest_lock_t* m_cell_lock;
    static Osmia_Nest_Manager* m_OurManager;
    bool m_isOpen;
    int m_aspectdelay;
public:
    Osmia_Nest(int a_x, int a_y, int a_polyref, Osmia_Nest_Manager* a_manager);
    virtual ~Osmia_Nest(){
        omp_destroy_nest_lock(m_cell_lock);
        delete m_cell_lock;
    }
    void SetCellLock(void) { omp_set_nest_lock(m_cell_lock); }
    void ReleaseCellLock(void) { omp_unset_nest_lock(m_cell_lock); }
    void AddCocoon (TAnimal* a_cocoon) {
        m_cells.push_front(a_cocoon);
    }
    void AddEgg(TAnimal* a_egg) { m_cells.push_front(a_egg); }
    void ReplaceNestPointer(TAnimal* a_oldpointer, TAnimal* a_newpointer) {
        std::replace(m_cells.begin(), m_cells.end(), a_oldpointer, a_newpointer); // replaces the old life stage pointer with the new one in-place
    }
    void RemoveCell(TAnimal* a_oldpointer);
    bool Find(TAnimal* a_osmia)
    {
        if (std::find(m_cells.begin(), m_cells.end(), a_osmia) != m_cells.end()) return true;
        else {
            return false;
        }
    }
    void KillAllSubsequentCells(TAnimal* a_osmia);
    int GetPolyRef() { return m_PolyRef; }
    int GetNoNests();
    int GetNoCells() { return std::distance(std::begin(m_cells), std::end(m_cells)); };
    bool ZeroCells() {
        if (std::distance(std::begin(m_cells), std::end(m_cells)) < 1) return false; else return true;
    }
    int GetAspectDelay() { return m_aspectdelay; }
    bool GetIsOpen() { return m_isOpen; }
    void CloseNest() { m_isOpen = false; }
    // Debug
    Osmia_Female* m_owner;
};
 
class Osmia_Base : public TAnimal
{
protected:
    TTypeOfOsmiaState m_CurrentOState;
    int m_Age;
    Osmia_Population_Manager* m_OurPopulationManager;
    static OsmiaParasitoid_Population_Manager* m_OurParasitoidPopulationManager;
    static double m_TempToday;
    static int m_TempTodayInt;
    static double m_DailyDevelopmentMortEggs;
    static double m_DailyDevelopmentMortLarvae;
    static double m_DailyDevelopmentMortPrepupae;
    static double  m_DailyDevelopmentMortPupae;
    static double m_OsmiaEggDevelTotalDD;
    static double m_OsmiaEggDevelThreshold;
    static double m_OsmiaLarvaDevelTotalDD;
    static double m_OsmiaLarvaDevelThreshold;
    static double m_OsmiaPupaDevelTotalDD;
    static double m_OsmiaPupaDevelThreshold;
    static double m_OsmiaPrepupalDevelTotalDays;
    static double m_OsmiaPrepupalDevelTotalDays10pct;
    static double m_OsmiaInCocoonOverwinteringTempThreshold;
    static double m_OsmiaInCocoonEmergenceTempThreshold;
    static double m_OsmiaInCocoonPrewinteringTempThreshold;
    static double m_OsmiaInCocoonWinterMortConst;
    static double m_OsmiaInCocoonWinterMortSlope;
    static double m_OsmiaInCocoonEmergCountConst;
    static double m_OsmiaInCocoonEmergCountSlope;
    static double m_OsmiaFemaleMassFromProvMassConst;
    static double m_OsmiaFemaleMassFromProvMassSlope;
    static double m_MaleMinTargetProvisionMass;
    static double m_MaleMaxTargetProvisionMass;
    static double m_FemaleMinTargetProvisionMass;
    static double m_FemaleMaxTargetProvisionMass;
    static double m_FemaleMaxMass;
    static double m_FemaleMinMass;
    static double m_MaleMaxMass;
    static double m_PollenScoreToMg;
    static double m_DensityDependentPollenRemovalConst;
    static double m_MinimumCellConstructionTime;
    static double m_MaximumCellConstructionTime;
    static int m_TotalNestsPossible;
    static double m_BombylidProbability;
    static double m_ParasitismProbToTimeCellOpen;
    static vector<double> m_ParasitoidAttackChance;
    static double m_OsmiaFemaleR50distance;
    static double m_OsmiaFemaleR90distance;
    static int m_OsmiaFemalePrenesting;
    static int m_OsmiaFemaleLifespan;
    static probability_distribution  m_generalmovementdistances;
    static probability_distribution  m_dispersalmovementdistances;
    static probability_distribution  m_eggspernestdistribution;
    static probability_distribution  m_exp_ZeroToOne;
    static double m_CocoonToProvisionMass;
    static double m_ProvisionToCocoonMass;
    static double m_TotalProvisioningMassLoss;
    static double m_TotalProvisioningMassLossRange;
    static double m_TotalProvisioningMassLossRangeX2;
    static bool m_UsingMechanisticParasitoids;
    static double m_OsmiaFemaleBckMort;
    static int m_OsmiaFemaleMinEggsPerNest;
    static int m_OsmiaFindNestAttemptNo;
    static int m_OsmiaFemaleMaxEggsPerNest;
    static probability_distribution m_emergenceday;
    TTypeOfOsmiaParasitoids m_ParasitoidStatus;
    Osmia_Nest* m_OurNest;
    double m_Mass;
    int m_foragehours;
 
public:
    Osmia_Base(struct_Osmia* data);
    void ReInit(struct_Osmia* data);
    virtual ~Osmia_Base();
    virtual void st_Dying(void);
    virtual void BeginStep(void) { ; } // NB this is not used in the Osmia_Base code
    virtual void Step(void) { ; } // NB this is not used in the Osmia_Base code
    virtual void EndStep(void) { ; } // NB this is not used in the Osmia_Base code
    int GetAge() { return m_Age; }
    void SetAge(int a_age) { m_Age = a_age; }
    double GetMass() { return m_Mass; }
    void SetMass(double a_mass) { m_Mass = a_mass; }
    void SetParasitised(TTypeOfOsmiaParasitoids a_status) { 
        m_ParasitoidStatus = a_status; 
    }
    TTypeOfOsmiaParasitoids GetParasitised( void ) { return m_ParasitoidStatus; }
    Osmia_Nest* GetNest() { return m_OurNest; }
    static void SetParameterValues();
             /* Not currently using temperature related mortality
         void SetNestMortality(double a_MortsByTemp[3][80]) {
            for (int i = 0; i < 80; i++) {
            m_DailyDevelopmentMortEggToCocoon[i] = a_MortsByTemp[0][i];
            m_DailyDevelopmentMortPupa[i] = a_MortsByTemp[1][i];
            m_DailyDevelopmentMortOverWinter[i] = a_MortsByTemp[2][i];
            */
    static void SetTemp(double a_temperature) { 
        m_TempToday = a_temperature;
        m_TempTodayInt = int(floor(a_temperature + 0.5)); 
    }
    static void SetParasitoidManager(OsmiaParasitoid_Population_Manager* a_popman) 
    { 
        m_OurParasitoidPopulationManager = a_popman; 
    }
};
 
class Osmia_Egg : public Osmia_Base
{
protected:
    double m_AgeDegrees = 0.0;
    bool m_Sex;
    int m_StageAge;
    double m_egg_pest_mortality;
public:
    Osmia_Egg(struct_Osmia* data);
    virtual void ReInit(struct_Osmia* data);
    virtual ~Osmia_Egg();
    virtual void Step(void);
    double GetAgeDegrees() { return m_AgeDegrees; }
    void SetAgeDegrees(unsigned a_agedegrees) { m_AgeDegrees = a_agedegrees; }
protected:
    virtual TTypeOfOsmiaState st_Develop(void);
    virtual TTypeOfOsmiaState st_Hatch(void);
    virtual bool DailyMortality() { if (g_rand_uni_fnc() < m_DailyDevelopmentMortEggs) return true; else return false; }
};
 
class Osmia_Larva : public Osmia_Egg
{
protected:
public:
    Osmia_Larva(struct_Osmia* data);
    virtual void ReInit(struct_Osmia* data);
    virtual ~Osmia_Larva();
    virtual void Step(void);
protected:
    virtual TTypeOfOsmiaState st_Develop(void);
    virtual TTypeOfOsmiaState st_Prepupate(void);
    virtual bool DailyMortality() { if (g_rand_uni_fnc() < m_DailyDevelopmentMortLarvae) return true; else return false; }
};
 
class Osmia_Prepupa : public Osmia_Larva
{
public:
    Osmia_Prepupa(struct_Osmia* data);
    virtual void ReInit(struct_Osmia* data);
    virtual ~Osmia_Prepupa();
    virtual void Step(void);
protected:
    virtual TTypeOfOsmiaState st_Develop(void);
    virtual TTypeOfOsmiaState st_Pupate(void);
    virtual bool DailyMortality() { if (g_rand_uni_fnc() < m_DailyDevelopmentMortPrepupae) return true; else return false; }
    double m_myOsmiaPrepupaDevelTotalDays;
};
 
class Osmia_Pupa : public Osmia_Prepupa
{
public:
    Osmia_Pupa(struct_Osmia* data);
    virtual void ReInit(struct_Osmia* data);
    virtual ~Osmia_Pupa();
    virtual void Step(void);
protected:
    virtual TTypeOfOsmiaState st_Develop(void);
    virtual TTypeOfOsmiaState st_Emerge(void);
    virtual bool DailyMortality() { if (g_rand_uni_fnc() < m_DailyDevelopmentMortPupae) return true; else return false; }
 
};
 
class Osmia_InCocoon : public Osmia_Pupa
{
protected:
    int m_emergencecounter;
 
    double m_DDPrewinter;
public:
    Osmia_InCocoon(struct_Osmia* data);
    virtual void ReInit(struct_Osmia* data);
    virtual ~Osmia_InCocoon();
    virtual void Step(void);
    static void SetOverwinteringTempThreshold(double a_temp) { m_OverwinteringTempThreshold = a_temp; }
    double GetDDPreWinter() { return m_DDPrewinter; }
protected:
    virtual TTypeOfOsmiaState st_Develop(void);
    virtual TTypeOfOsmiaState st_Emerge(void);
    bool WinterMortality();
    static double m_OverwinteringTempThreshold;
};
 
class Osmia_Female : public Osmia_InCocoon
{
public:
#ifdef __OSMIARECORDFORAGE
    static double m_foragesum;
    static int m_foragecount;
#endif
protected:
    //Attributes
    static OsmiaForageMask m_foragemask;
    static OsmiaForageMaskDetailed m_foragemaskdetailed;
    double m_currentpollenlevel;
    static double m_pollengiveupthreshold;
    static double m_pollengiveupreturn;
    //int m_DensityIndex;
    int m_CellOpenDays;
    double m_CellCarryOver;
    int m_EggsToLay;
    int m_EggsThisNest;
    bool m_ToDisperse;
    int m_EmergeAge;
    APoint m_CurrentNestLoc;
    int m_ProvisioningTime;
    int m_FlyingCounter;
    double m_CurrentProvisioning;
    int m_BeeSizeScore1;
    int m_BeeSizeScore2;
    deque<double>m_NestProvisioningPlan;
    deque<bool>m_NestProvisioningPlanSex;
    bool m_ForageLoc;
    int m_ForageLocPoly;
    static int m_ForageSteps;
    static double m_PollenCompetitionsReductionScaler;
    static vector<double> m_FemaleForageEfficiency;
    int m_ForageLocX;
    int m_ForageLocY;
#ifdef __OSMIA_PESTICIDE
public:
    static double m_OsmiaPPPEffectProb;
    static double m_OsmiaPPPThreshold;
protected:
    static double GetPPPThreshold() { return m_OsmiaPPPThreshold; }
    static double GetPPPEffectProb() { return m_OsmiaPPPEffectProb; }
    PesticideStore m_my_pest_store_for_laying_eggs;
#endif
 
#ifdef __OSMIATESTING
    OsmiaNestData m_target;
    OsmiaNestData m_achieved;
    bool m_firstnestflag;
#endif // __OSMIATESTING
 
 
    //Methods
    virtual void st_Dying(void);
    //--------------------------------------------------------------------------------------------------------------------------------
    virtual TTypeOfOsmiaState st_Develop(void);
    virtual bool FindNestLocation(void);
    virtual TTypeOfOsmiaState st_Dispersal(void);
    double Forage(void);
    virtual TTypeOfOsmiaState st_ReproductiveBehaviour(void);
    int PlanEggsPerNest();
    void CalculateEggLoad() {
        m_EggsToLay = int((m_TotalNestsPossible * (0.0371 * m_Mass + 2.8399)) + (g_rand_uni_fnc() * 6) - 3);
        m_EggsThisNest = PlanEggsPerNest() + 2; // 2 is added because it will be removed at the start of each nest
    }
    TTypeOfOsmiaParasitoids CalcParaistised(double a_daysopen);
    void LayEgg();
 
public:
    Osmia_Female(struct_Osmia* data);
    virtual void ReInit(struct_Osmia* data);
    virtual ~Osmia_Female();
    virtual void Init(double a_mass);
    virtual void BeginStep(void);
    virtual void Step(void);
    static void SetForageSteps(int a_sz) { m_ForageSteps = a_sz; }
    static void SetForageMaskDetailed(int a_step, int a_max) {
        OsmiaForageMaskDetailed fmd(a_step, a_max);
        m_foragemaskdetailed = fmd;
    }
    static void SetPollenGiveUpThreshold(double a_prop) { m_pollengiveupthreshold = a_prop; }
    static void SetPollenGiveUpReturn(double a_value) { m_pollengiveupreturn = a_value; }
    static void  SetDailyMort(double a_prob) { m_OsmiaFemaleBckMort = a_prob; }
    static void SetNestFindAttempts(int a_no) { m_OsmiaFindNestAttemptNo = a_no; }
    static void SetMinEggsPerNest(int a_eggs) { m_OsmiaFemaleMinEggsPerNest = a_eggs; }
    static void SetMaxEggsPerNest(int a_eggs) { m_OsmiaFemaleMaxEggsPerNest = a_eggs; }
    static void SetCocoonToProvisionMass(double a_ratio) {
        m_CocoonToProvisionMass = a_ratio;
        m_TotalProvisioningMassLoss = cfg_OsmiaTotalCocoonMassLoss.value() * a_ratio;
        m_TotalProvisioningMassLossRange = cfg_OsmiaTotalCocoonMassLossRange.value() * a_ratio;
        m_TotalProvisioningMassLossRangeX2 = m_TotalProvisioningMassLossRange * 2.0;
    }
    static void SetProvisionToCocoonMass(double a_ratio) { m_ProvisionToCocoonMass = a_ratio; }
    static void SetPollenScoreToMg(double a_ratio) { m_PollenScoreToMg = a_ratio; }
    void SetMaleMinTargetProvisionMass(double a_mass) { m_MaleMinTargetProvisionMass = a_mass; }
    void SetFemaleMinTargetProvisionMass(double a_mass) { m_FemaleMinTargetProvisionMass = a_mass; }
    void SetFemaleMaxTargetProvisionMass(double a_mass) { m_FemaleMaxTargetProvisionMass = a_mass; }
    static void SetMinimumCellConstructionTime(double a_time) { m_MinimumCellConstructionTime = a_time; }
    static void SetMaximumCellConstructionTime(double a_time) { m_MaximumCellConstructionTime = a_time; }
    static void SetTotalNestsPossible(int a_total) { m_TotalNestsPossible = a_total; }
    static void SetBombylidProbability(double a_prob) { m_BombylidProbability = a_prob; }
    static void SetParasitismProbToTimeCellOpen(double a_ratio) { m_ParasitismProbToTimeCellOpen = a_ratio; }
    static void SetUsingMechanisticParasitoids(bool a_flag) { m_UsingMechanisticParasitoids = a_flag; }
    static void SetParasitoidParameters(vector<double> a_params) { m_ParasitoidAttackChance = a_params; }
    void SetDensityDependentPollenRemovalConst(double a_value) { m_DensityDependentPollenRemovalConst = a_value; }
    static void AddForageEfficiency(double a_eff) { m_FemaleForageEfficiency.push_back(a_eff); }
    void GetPollenInPolygon(double& a_required_amount, double& a_foraged_amount, int a_polygon, int a_loc_x, int a_loc_y);
    virtual bool OnFarmEvent( FarmToDo event );
 
    //code used for pestiside store
    #ifdef __OSMIA_PESTICIDE_STORE
    unsigned int m_animal_id;
    #endif
};
#endif