Ladybird_All.h

Go to the documentation of this file.

//
// Last modified by Chris Topping 8 July 2023
/*
*******************************************************************************************************
Copyright (c) 2023, Christopher John Topping & Andrey Chuhutin, 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 LADYBIRD_ALL_H
#define LADYBIRD_ALL_H
 
#pragma warning( disable : 4250 )
 
//---------------------------------------------------------------------------
 
#include "Beetle_BaseClasses.h"
#include "Beetles/Ladybird_toletov.h"
#include <Eigen/Dense>
 
enum {
    hibernacula_Memory = 5,
    flight_Memory_Size = 32
};
 
extern const char* g_simulationName;
 
 
//------------------------------------------------------------------------------
// Forward Declarations
 
class Ladybird_Population_Manager;
class Landscape;
class MovementMap;
class SimplePositionMap;
class Aphid_Population_Manager;
class probability_distribution;
 
 
//------------------------------------------------------------------------------
enum LadybirdObjects : unsigned {
    lobs_Egg = 0,
    lobs_Larva1,
    lobs_Larva2,
    lobs_Larva3,
    lobs_Larva4,
    lobs_Pupa,
    lobs_Adult,
    lobs_Foobar
}; // Ladybirds Objects enum
//------------------- EndEnumerations -------------------
 
struct CannibalisationEvent
{
    int m_X;
    int m_Y;
    int m_No;
};
 
class Ladybird_Base : virtual public Beetle_Base {
 protected:
     int m_EatenToday{ 0 };
     int m_WantToEatToday{ 0 };
     int m_AphidsAppetite{ 0 };
     int m_MoveCounter{ 0 };
     Ladybird_Population_Manager* m_OurPopulationLadybird{ nullptr };
     static vector<int> m_LadybirdStagesNutritionalValue;
     void EatToday(const int a_add) { m_EatenToday += a_add; }
     virtual int GetEatenToday() const { return m_EatenToday; }
     virtual void SetEatenToday(int a) { m_EatenToday = a; }
     int GetAphidsToEat() { return GetAphidsAppetite() - GetEatenToday(); }
     virtual int GetAphidsAppetite() { return 10; } 
     virtual void ResetAphidsAppetite() { m_AphidsAppetite = 0; }
     virtual int EatAphids(int a_x, int a_y, int a_appetite);
     int Cannibalise(int a_appetite);
     static int GetTempMortRange(double a_temp);
     virtual void CalcAphidsAppetite(){m_AphidsAppetite=0;}
     bool CanMove() {
         const auto maxdistance = GetMaxDailyDistance();
         return (m_MoveCounter < maxdistance);
      }
     int GetMaxDailyDistance() {
         return 0; // todo interface with calcMaxDistance functions
     }
public:
     explicit Ladybird_Base(Ladybird_Population_Manager* a_lpm_ptr);
     ~Ladybird_Base() override = default;
 
     static void SetLadybirdStagesNutritionalValue(const vector<int>& a_list) { m_LadybirdStagesNutritionalValue = a_list; }
 };
 
class Ladybird_Egg_List : public  Beetle_Egg_List
{
 
public:
    Ladybird_Egg_List(int a_today,Ladybird_Population_Manager* a_bpm_ptr, Landscape* a_l_ptr);
};
 
 
// ------------------------------------------------------------------------------------------
//                         Start Ladybird_Larvae2 class 
// ------------------------------------------------------------------------------------------
 
class Ladybird_Larvae1 : public virtual Beetle_Larvae, public virtual Ladybird_Base {
protected:
    double m_AphidTotalNum{0};
    static int m_LadybirdLarvaeNoMoves;
    static int m_LadybirdLarvaeMoveStep;
    static int m_MaxUsefulAphids[4];
    static vector<double> m_LadybirdLarvalPreyDevelScalers[4];
    static int m_LarvalAppetite[4];
    int m_StarvationCount{0};
public:
    Ladybird_Larvae1(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_bpm_ptr);
    ~Ladybird_Larvae1() override = default;
    virtual void ReInit(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_bpm_ptr);
    bool IsLocationAllowed(int a_x, int a_y) override;
    static void SetLadybirdLarvalPreyDevelParameters(const vector<double>& a_array, int a_no_stages);
    static void SetLadybirdLarvaeMoveMax(const int a_value) { m_LadybirdLarvaeNoMoves = a_value; }
    static void SetLadybirdLarvaeMoveStep(const int a_value) { m_LadybirdLarvaeMoveStep = a_value; }
    static void SetLarvalAppetite(const vector<int>& a_value) { for (int i=0; i<4; i++) m_LarvalAppetite[i] = a_value[i]; }
 
protected:
    void BeginStep() override;
    TTypesOfBeetleState St_Develop() override;
    int GetAphidsAppetite() override { return m_LarvalAppetite[m_LarvalStage]; }
};
 
 
// -------------------- End Ladybird_Larvae1 class --------------------
 
// ------------------------------------------------------------------------------------------
//                         Start Ladybird_Larvae2 class 
// ------------------------------------------------------------------------------------------
class Ladybird_Larvae2 : public Ladybird_Larvae1 {
public:
    Ladybird_Larvae2(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_bpm_ptr);
    void ReInit(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_bpm_ptr) override;
};
// -------------------- End Ladybird_Larvae2 class --------------------
 
// ------------------------------------------------------------------------------------------
//                         Start Ladybird_Larvae3 class 
// ------------------------------------------------------------------------------------------
class Ladybird_Larvae3 : public Ladybird_Larvae2 {
public:
    Ladybird_Larvae3(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_lpm_ptr);
    void ReInit(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_lpm_ptr) override;
};
// -------------------- End Ladybird_Larvae3 class --------------------
 
// ------------------------------------------------------------------------------------------
//                         Start Ladybird_Larvae4 class 
// ------------------------------------------------------------------------------------------
class Ladybird_Larvae4 : public Ladybird_Larvae3 {
public:
    Ladybird_Larvae4(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_lpm_ptr);
    void ReInit(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_lpm_ptr) override;
};
// -------------------- End Ladybird_Larvae3 class --------------------
 
// ------------------------------------------------------------------------------------------
//                         Start Ladybird_Pupae class 
// ------------------------------------------------------------------------------------------
class Ladybird_Pupae final :  virtual public Ladybird_Base, virtual public Beetle_Pupae {
public:
    Ladybird_Pupae(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_bpm_ptr);
    void ReInit(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_bpm_ptr);
    TTypesOfBeetleState St_Emerge() override;
    void BeginStep() override;
    double calcDailyMortChance(int a_temp2, const double a_lengthOfStageAtTemp) override;
    TTypesOfBeetleState St_Develop() override;
};
 
 
class Ladybird_Adult final : virtual public Ladybird_Base, virtual public Beetle_Adult {
protected:
    int m_EmergenceDay{ 0 };
    bool m_IsHibernating{ false };
    bool m_HasOverwintered{ false };
    int m_DailyEggs{ 0 };
    double m_ADayDeg{ 0 };
    int m_UnsuccessfulAphidsAttempts{ 0 };
    int m_OviMaturation{0};
    static int m_AphidsPerPreyLevel;
    int m_HibernationClumpSize{ 0 };
    static vector<double> m_HibernationClumpeSizeDist;
    static vector<double>m_OvipositionRateTemp;
    static vector<double>m_BackgroundMortTemp;
    static int m_ShortRangeDistToday;
public:
    // member functions
    Ladybird_Adult( int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_lpm_ptr );
    void ReInit(int a_x, int a_y, Landscape* a_l_ptr, Ladybird_Population_Manager* a_lpm_ptr);
    void BeginStep() override;
    void SetOverwintered(const bool a_value) { m_HasOverwintered = a_value; }
    void SetIsHibernating(const bool a_val){ m_IsHibernating = a_val;  }
    static void SetOvipositionPeriod(const bool a_cond) { m_OvipostionPeriod = a_cond; }
    static void SetAphidsPerPreyLevel(const int a_value) { m_AphidsPerPreyLevel = a_value; }
    static void SetHibernationClumpeSizeDist(const vector<double>& a_dist) { m_HibernationClumpeSizeDist = a_dist; }
    static void SetOvipositionRateTemp(const vector<double>& a_dist) { m_OvipositionRateTemp = a_dist; }
    static void SetBackgroundMortTemp(const vector<double>& a_vector) { m_BackgroundMortTemp = a_vector; }
    static void SetShortRangeDistToday(const int a_value) { m_ShortRangeDistToday = a_value; }
protected:
    // Member Functions
    double GetExtremeTempMin() const;
    bool WinterMort() const override { return false; }
    TTypesOfBeetleState St_Aggregate() override;
    TTypesOfBeetleState St_Hibernate() override;
    TTypesOfBeetleState St_Forage() override;
    TTypesOfBeetleState St_Dispersal() override;
    void TryToReproduce() override;
    static bool m_OvipostionPeriod;
    bool LongRangeFind(int a_distance, int a_minimumflightlength, int a_target, bool (Ladybird_Adult::* a_func)(int, int, int));
    bool FindTarget(int a_distance, int a_minimumflightlength, int a_target);
    bool ShouldStartAggregating();
    bool IsProbhibited(int a_x, int a_y) const;
    inline bool IsAggregationSite(const int a_x, const int a_y, const int a_unused);
    inline bool IsForageSite(const int a_x, const int a_y, const int a_target);
    void setEggCounter(int num){ m_EggCounter=num; }
    void decEggCounter(int num){ m_EggCounter-=num;}
    int getEggCounter(){ return m_EggCounter;}
    void setDailyEggs(int num){ m_DailyEggs=num; }
    void decDailyEggs(int num){ m_DailyEggs-=num; }
};
 
class Ladybird_Population_Manager: public Beetle_Population_Manager
{
public:
    std::vector<Aphid_Population_Manager*> m_AphidPopulationManagerPtrList;
protected:
    vector<double> m_EggTemperatureMortality{ };
    int m_MortalityTempIndexToday{ 0 };
    LadybirdToleTovs m_LadybirdToleTovs;
    vector<Eigen::MatrixXi> m_cannibalism_dead_num_map;
    vector<int> m_cannibalism_dead_total_num;
    void DoExtremeTempActions(double a_atemptoday) override;
    void DoEggDailyMortalityActions(double a_atemptoday) override;
    void DoLarvalDailyMortalityActions(double a_atemptoday)  override;
    int GetTempMortRange(double a_temp) const;
    //void EnforceCannibalistionEvents();
    TTovList m_LadybirdProhibitedTovsForMovementLarva;
    void DayDegreeCalculations(int a_dayinyear, bool a_usehourly) override;
    void CalculateDailyEggProduction(double a_temptoday) override {}
 
public:
    // Attributes - todo move these when the best place to put them is found, after first implementation
    TTovList m_LadybirdProhibitedTovsForMovement;
    TToleList  m_LadybirdProhibitedTolesForMovement;
    TToleList m_LadybirdAggregationToles;
    //TTovList LadybirdProhibitedTovsForMovementLarva;
    TToleList  LadybirdProhibitedTolesForMovementLarva;
    TTovList LadybirdLongRangeTovs;
    TToleList LadybirdLongRangeToles;
    TTovList LadybirdAggregationTovs;
 
    // Member functions
    explicit Ladybird_Population_Manager(Landscape* a_l_ptr, int a_numberLifeStages);
    ~Ladybird_Population_Manager() override;
    bool IsLocationAllowedLarvae(TTypesOfVegetation a_tov) {
        if ((m_LadybirdProhibitedTovsForMovementLarva).find(a_tov) != (m_LadybirdProhibitedTovsForMovementLarva).end()) {
            return false;
        }
        return true;
    }
    void CreateObjects(int a_ob_type, TAnimal *a_pvo, void* ,Struct_Beetle* a_data, int a_number) override;
    bool OnFarmEvent(FarmToDo a_event, Beetle_Base* a_caller) override;
    inline bool GetFlyingWeather() const;
    bool GetLadybirdLarvaCanMove() const { return m_LadybirdLarvaCanMove_bool; }
    static inline double getLongRangeDuration(){return 3000.;} // 50 min * 60 sec/min // todo: move parameters to constants class
    void SetAphidPopulationManager(Aphid_Population_Manager* a_aphid_population_manager_ptr) { m_AphidPopulationManagerPtrList.push_back(a_aphid_population_manager_ptr); }
    int GetAphidPopulationManagerSize() const { return static_cast<int>(m_AphidPopulationManagerPtrList.size()); }
    Aphid_Population_Manager* GetAphidPopulationManager(const int a_index) const { return m_AphidPopulationManagerPtrList[a_index]; }
    double GetAphidDensity(int a_x, int a_y) override;
    void DecAphids(int a_x, int a_y, int a_num);
    void TheAOROutputProbe() override;
    void AddCannibalismDeath(int a_ob_type, int a_x, int a_y) {m_cannibalism_dead_num_map[a_ob_type](a_y, a_x)+=1; m_cannibalism_dead_total_num[a_ob_type]+=1;}
    void DoSpecialBetweenLifeStages(int a_life_stage) override;
protected:
    /*************************/
    /*************************/
    double TodaysEggProductionTempFactor{0.0};
    double m_LadybirdLarvaMovementThreshold{ 10.0 };
    bool m_LadybirdLarvaCanMove_bool {true};
    void DoFirst() override;
};
#endif