Hare_All.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, 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 HaresH
#define HaresH
 
 
#include <mutex>
//---------------------------------------------------------------------------
 
class THare;
class THare_Population_Manager;
class Hare_Female;
 
//------------------------------------------------------------------------------
typedef vector<THare*> TListOfHares;
//---------------------------------------------------------------------------
 
typedef enum {
    hob_Infant,
    hob_Young,
    hob_Juvenile,
    hob_Male,
    hob_Female,
    hob_Foobar
}Hare_Object;
 
typedef enum {
    tohs_InitialState = 0,
    tohs_NextStage,
    tohs_Developing,
    tohs_Dispersal,
    tohs_Foraging,
    tohs_Resting,
    tohs_ReproBehaviour,
    tohs_Running,
    tohs_Dying,
    tohs_DestroyObject // Used to signal that all necessary behaviour is
    // done, safe to remove the object
}TTypeOfHareState;
 
typedef enum {
    activity_Resting = 0,
    activity_Running,
    activity_Foraging,
    activity_Walking,
    activity_Dispersal,
    activity_Recovery,
    activity_oestrouscycle,
    activity_inoestrous,
    activity_gestation,
    activity_givebirth,
    activity_lactation,
    activity_nonAdult
}TTypeOfActivity;
 
 
struct MRR_Entry {
    int m_HareRefNum;
    int m_trappings1;
    int m_trappings2;
};
 
class MRR_Data {
public:
    MRR_Data();
    void AddEntry(int a_RefNum);
    void OutputToFile();
    void IncTrapping() { m_currenttrapping++; }
 
protected:
    // Class for the MRR data before it is written to file-
    int m_currenttrapping;
    vector<MRR_Entry> m_Entries;
};
 
class struct_Hare {
public:
    int x;
    int y;
    int age;
    Landscape* L;
    THare_Population_Manager* HM;
    Hare_Female* Mum;
    int RefNum;
    double weight;
};
 
/*-------------------------------------------------------------------------------------------
--------------------------------------    THARE    ------------------------------------------
---------------------------------------------------------------------------------------------*/
class THare : public TAnimal {
protected:
    // Attributes
    TTypeOfHareState m_CurrentHState;
    int m_Age = 0;
    Hare_Object m_Type;
    double m_weight = 0.0;
    double m_old_weight = 0.0;
    Hare_Female* m_MyMum = nullptr;
    THare_Population_Manager* m_OurPopulationManager;
    int m_Lifespan = 0;
    int m_ActivityTime = 0;
    int m_StarvationDays = 0;
    double m_fatReserve = 0.0;
    double m_TodaysEnergy = 0.0;
    double m_EnergyMax = 0.0;;
    double m_KJRunning = 0.0;; // KJ/metre
    double m_KJWalking = 0.0; // KJ/metre
    double m_KJForaging = 0.0;; // KJ/minute
    double m_SpeedRunning = 0.0;; // metre/min
    double m_SpeedWalking = 0.0;; // metre/min
    double m_foragingenergy = 0.0;;
    int m_peg_x = 0;
    int m_peg_y = 0;
    int m_RefNum = 0;
 
    int m_experiencedDensity = 0;
    int m_lastYearsDensity = 0;
    int m_ddindex = 0;
    int m_expDensity[365] = {};
    int m_DensitySum = 0;
    bool m_IamSick = false;
 
    double m_pesticide_burden = 0.0;;
    double m_pesticidedegradationrate = 0.0;;
    bool m_pesticideInfluenced1 = false;
 
public:
    static double* m_vegPalatability;;
    // Methods
    THare(int p_x, int p_y, Landscape* p_L, THare_Population_Manager* p_PPM);
    void THareInit(int p_x, int p_y, THare_Population_Manager* p_PPM);
    ~THare() override;
    virtual TTypeOfHareState st_Dispersal();
    void BeginStep(void) override {
    }
    void Step(void) override {
    }
    void EndStep(void) override { MovePeg(); }
 
    // Interface Functions
    double GetWeight() { return m_weight; }
    double GetTotalWeight() { return m_weight * 3.8 + m_fatReserve; }
 
    int GetAge() { return m_Age; }
    void ON_MumDead(Hare_Female* a_Mum) {
        if (a_Mum != m_MyMum)
        {
            m_OurLandscape->Warn("Hare_Infant::On_MumDead  - not my mum!!", "");
            exit(1);
        }
        // I am now an orphan
        m_MyMum = nullptr;
    }
    static void SetMum(Hare_Female* /*a_af*/) {
    }
    Hare_Female* GetMum() { return m_MyMum; }
    double GetRMR();
    virtual bool WasPredated();
    int GetRefNum() { return m_RefNum; }
    virtual void ON_Dead(void) {
    }
    void loadVegPalatability(void);
 
protected:
    bool Run(int a_dist, int a_direction);
    void EnergyBalance(TTypeOfActivity a_activity, int dist);
    void TimeBudget(TTypeOfActivity a_activity, int dist);
    void st_Dying();
    virtual void Running(int a_max_dist);
    void Walking(int a_dist, int a_direction);
    double Forage(int& time); // Returns energy obtained
    double ForageP(int& time); // Returns energy obtained
    virtual void InternalPesticideHandlingAndResponse();
    virtual void GeneralEndocrineDisruptor(double /* a_pesticide_dose */) {
    }
    virtual void GeneralOrganoPhosphate(double /* a_pesticide_dose */) {
    }
    double ForageSquare(int a_x, int a_y);
    double ForageSquareP(int a_x, int a_y, double* a_pestexposure);
    int GetPegDistance();
    int GetPegPull();
    int GetPegDirection();
    void MovePeg();
    bool OnFarmEvent(FarmToDo event) override;
};
 
class THare_Population_Manager : public Population_Manager {
public:
    // Methods
    THare_Population_Manager(Landscape* L);
    ~THare_Population_Manager(void) override;
    void TheAOROutputProbe() override;
    void CreateObjects(int ob_type, TAnimal* pvo, void* null, struct_Hare* data, int number);
    double GetRMR(int a_age, double a_size);
    int GetHareRefNum() { return ++m_RefNums; }
    double GetMaxDailyGrowthEnergy(int a_age) {
#ifdef __BOUNDSCHECK
       if ((a_age<0) || (a_age>5000)) {
             m_TheLandscape->Warn( "Hare GetMaxDailyGrowthEnergy a_age out of bounds", NULL );
             exit( 1 );
       }
#endif
        return m_MaxDailyGrowthEnergy[a_age];
    }
    double GetMaxDailyGrowthEnergyP(int a_age) {
#ifdef __BOUNDSCHECK
       if ((a_age<0) || (a_age>5000)) {
             m_TheLandscape->Warn( "Hare GetMaxDailyGrowthEnergyP a_age out of bounds", NULL );
             exit( 1 );
       }
#endif
        return m_MaxDailyGrowthEnergyP[a_age];
    }
    double GetMaxDailyGrowthEnergyF(int a_age) {
#ifdef __BOUNDSCHECK
       if ((a_age<0) || (a_age>5000)) {
             m_TheLandscape->Warn( "Hare GetMaxDailyGrowthEnergyF a_age out of bounds", NULL );
             exit( 1 );
       }
#endif
        return m_MaxDailyGrowthEnergyF[a_age];
    }
    double GetGrowthEfficiency(int a_age) {
#ifdef __BOUNDSCHECK
       if ((a_age<0) || (a_age>5000)) {
             m_TheLandscape->Warn( "Hare GetGrowthEfficiency a_age out of bounds", NULL );
             exit( 1 );
       }
#endif
        return m_GrowthEfficiency[a_age];
    }
    double GetGrowthEfficiencyP(int a_age) {
#ifdef __BOUNDSCHECK
       if ((a_age<0) || (a_age>5000)) {
             m_TheLandscape->Warn( "Hare GetGrowthEfficiencyP a_age out of bounds", NULL );
             exit( 1 );
       }
#endif
        return m_GrowthEfficiencyP[a_age];
    }
    double GetGrowthEfficiencyF(int a_age) {
#ifdef __BOUNDSCHECK
       if ((a_age<0) || (a_age>5000)) {
             m_TheLandscape->Warn( "Hare m_GrowthEfficiencyF a_age out of bounds", NULL );
             exit( 1 );
       }
#endif
        return m_GrowthEfficiencyF[a_age];
    }
    double GetKJperM(int a_size) {
#ifdef __BOUNDSCHECK
       if ((a_size<0) || (a_size>7000)) {
           m_TheLandscape->Warn( "Hare GetKJperM a_size out of bounds", std::to_string(a_size) );
           exit( 1 );
       }
#endif
        return m_KJperM[a_size];
    }
    int GetLitterSize(int noLitters);
    void AddHareDensity(int x, int y, Hare_Object a_type) {
        m_DensityMap[a_type][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]++;
    }
    void SubtractHareDensity(int x, int y, Hare_Object a_type) {
        m_DensityMap[a_type][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]--;
    }
    int GetInfantDensity(int x, int y) { return m_DensityMap[hob_Infant][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]; }
    int GetYoungDensity(int x, int y) { return m_DensityMap[hob_Young][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]; }
    int GetJuvenileDensity(int x, int y) {
        return m_DensityMap[hob_Juvenile][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT];
    }
    int GetMaleDensity(int x, int y) { return m_DensityMap[hob_Male][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]; }
    int GetFemaleDensity(int x, int y) { return m_DensityMap[hob_Female][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]; }
    int GetTotalDensity(int x, int y) { return m_DensityMap[5][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT]; }
    int GetAdultDensity(int x, int y) {
        return m_DensityMap[hob_Male][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT] + m_DensityMap[hob_Female][x >>
            __DENSITYSHIFT][y >> __DENSITYSHIFT];
    }
    int GetDelayedAdultDensity(int x, int y) {
        return m_DensityMap[6][x >> __DENSITYSHIFT][y >> __DENSITYSHIFT];
    }
    double GetInterference(int h) {
#ifdef __BOUNDSCHECK
       if ((h<0) || (h>2499)) {
             g_msg->Warn( "Hare Interference range out of bounds", std::to_string(h) );
             exit( 1 );
       }
#endif
        return m_Interference[h]; //[m_variableDD];
    }
    double GetPolyFood(int a_poly) { return m_PolyFood[a_poly]; }
    void SetPolyFood(int a_poly, double a_value) { m_PolyFood[a_poly] = a_value; }
    void BodyBurdenOut(int a_year, int a_day, double a_bb, double a_mgkg) {
        fprintf(BodyBurdenPrb, "%d\t%d\t%g\t%g\n", a_year, a_day, a_bb, a_mgkg);
    }
 
    double m_JuvMortRate;
    double m_AdultMortRate;
    double m_YoungMortRate;
    float m_GoodYearBadYear;
    double m_DMWeight[5001];
    int m_HareThresholdDD;
 
protected:
    // Attributes
    int m_RefNums;
    int m_shot;
    double m_MortStochast;
    double m_Interference[2500];
    //[21]; // this limit should never be reached, but it may be under debugging tests so watch out.
    int m_DensityMap[8][200][200]; //NB maps larger than 50km in any one dimension -> memory overun
    int m_variableDD;
    int m_LitterSize[12][7];
    double* m_PolyFood;
    // Energetic constants will go into these arrays
    // They are filled by the Init method
    double m_RMR[2][366]; // Will also needs bounds checking
    double m_MaxDailyGrowthEnergy[5001]; // Will also needs bounds checking
    double m_GrowthEfficiency[5001]; // Will also needs bounds checking
    double m_MaxDailyGrowthEnergyP[5001]; // Will also needs bounds checking
    double m_MaxDailyGrowthEnergyF[5001]; // Will also needs bounds checking
    double m_GrowthEfficiencyP[5001]; // Will also needs bounds checking
    double m_GrowthEfficiencyF[5001]; // Will also needs bounds checking
    double m_KJperM[7001];
    MRR_Data* m_OurMRRData;
    FILE* BodyBurdenPrb;
    // Methods
    void Init();
    void CalcLitterSize(double mean, double SD, int litter);
    //   virtual bool StepFinished();
    void DoFirst() override;
    //   virtual void DoBefore(){}
    //   virtual void DoAfter(){}
    void DoLast() override;
    void POMOutputs();
    void MRROutputs();
    virtual void TheRipleysOutputProbe(FILE* a_prb);
    void ExtraPopMort(void);
    void Hunting(void);
    void HuntingGrid(void);
    void HuntingDifferentiatedBeetleBankArea(void);
    void Catastrophe() override;
};
 
class Hare_Infant : public THare {
public:
    void BeginStep(void) override;
    void Step(void) override;
    void EndStep(void) override;
    Hare_Infant(int p_x, int p_y, Landscape* p_L, THare_Population_Manager* p_PPM);
    void ReInit(struct_Hare a_data);
    void Init();
    ~Hare_Infant() override;
    // Interface Functions
    void ON_Dead() override;
    void ON_BeingFed(double a_someMilk);
    void SetWeight(double w) { m_weight = w; }
    void SetMum(Hare_Female* a_af) { m_MyMum = a_af; }
 
protected:
    TTypeOfHareState st_Developing();
    void st_NextStage();
    bool OnFarmEvent(FarmToDo event) override;
    // Attributes
};
 
class Hare_Young : public Hare_Infant {
public:
    void BeginStep(void) override;
    void Step(void) override;
    void EndStep(void) override;
    Hare_Young(int p_x, int p_y, Landscape* p_L, THare_Population_Manager* p_PPM, double p_weight);
    void ReInit(struct_Hare a_data);
    void Init(double p_weight);
    ~Hare_Young() override;
    // Interface
    void ON_Dead() override;
 
protected:
    TTypeOfHareState st_Developing();
    TTypeOfHareState st_Dispersal() override;
    TTypeOfHareState st_Foraging();
    void st_NextStage();
    TTypeOfHareState st_Resting();
    bool OnFarmEvent(FarmToDo event) override;
};
 
class Hare_Juvenile : public THare {
public:
    void BeginStep(void) override;
    void Step(void) override;
    void EndStep(void) override;
    Hare_Juvenile(int p_x, int p_y, Landscape* p_L, THare_Population_Manager* p_PPM, double p_weight);
    void ReInit(struct_Hare a_data);
    void Init(double p_weight);
    ~Hare_Juvenile() override;
    // Interface
    void ON_Dead() override;
 
protected:
    // States
    virtual TTypeOfHareState st_Developing();
    TTypeOfHareState st_Dispersal() override;
    TTypeOfHareState st_Foraging();
    void st_NextStage();
    TTypeOfHareState st_Resting();
    // Methods
    bool ShouldMature();
    bool WasPredated() override;
};
 
class Hare_Male : public Hare_Juvenile {
public:
    void BeginStep(void) override;
    void Step(void) override;
    void EndStep(void) override;
    Hare_Male(int p_x, int p_y, Landscape* p_L, THare_Population_Manager* p_PPM, double p_weight, int a_age, int a_Ref);
    void ReInit(struct_Hare a_data);
    void Init(double p_weight, int a_age, int a_Ref);
    ~Hare_Male() override;
    // Interface
    void ON_Dead() override;
 
protected:
    // States
    TTypeOfHareState st_Developing() override;
    TTypeOfHareState st_Foraging();
    static TTypeOfHareState st_Resting();
    static TTypeOfHareState st_ReproBehaviour();
    // Methods
    void InternalPesticideHandlingAndResponse() override;
    void GeneralEndocrineDisruptor(double /* a_pesticide_dose */) override;
    void GeneralOrganoPhosphate(double /* a_pesticide_dose */) override;
};
 
class Hare_Female : public Hare_Juvenile {
protected:
    // Attributes
    int m_NoYoung;
    int m_litter_no;
    bool m_sterile;
    //double m_SurplusEnergy;
    int m_OestrousCounter;
    int m_GestationCounter;
    double m_LeveretMaterial;
    TTypeOfActivity m_reproActivity;
    TListOfHares m_MyYoung;
    std::mutex m_MyYoungMutex;
 
    void UpdateOestrous();
    void UpdateGestation();
    void GiveBirth();
    APoint PlaceYoung();
    void DoLactation();
    void Mating();
 
public:
    void BeginStep(void) override;
    void Step(void) override;
    void EndStep(void) override;
    Hare_Female(int p_x, int p_y, Landscape* p_L, THare_Population_Manager* p_PPM, double p_weight, int a_age,
                int a_Ref);
    void ReInit(struct_Hare a_data);
    void Init(double p_weight, int a_age, int a_Ref);
    ~Hare_Female() override;
    // Interface functions
    void dumpEnergy();
    void SetSterile() { m_sterile = true; }
    void ON_Dead() override;
    bool UpdateYoung(THare* a_old, THare* a_new);
    void AddYoung(THare* a_new);
    void ON_YoungKilled(THare* a_young);
    void ON_RemoveYoung(THare* a_young);
    void AllYoungKilled();
    void AllYoungMatured();
    // *** DeBugging Methods ***
    bool ON_AreYouMyMum(THare* a_young);
    bool SanityCheckYoungList();
    // *** End Debug ***
 
protected:
    // States
    TTypeOfHareState st_Dispersal() override;
    TTypeOfHareState st_Developing() override;
    TTypeOfHareState st_Foraging();
    static TTypeOfHareState st_Resting();
    TTypeOfHareState st_ReproBehaviour();
    //Methods
    void InternalPesticideHandlingAndResponse() override;
    void GeneralEndocrineDisruptor(double a_pesticide_dose) override;
    void GeneralOrganoPhosphate(double a_pesticide_dose) override;
};
 
//---------------------------------------------------------------------------
#endif