PopulationManager.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 PopulationManagerH
#define PopulationManagerH
 
extern CfgBool l_pest_enable_pesticide_engine;
 
#include <omp.h>
#include <forward_list>
// Forwards
class TAnimal;
class AlleleFreq;
class AOR_Probe;
 
// Start defines
using AnsiString = char*;
using TListOfAnimals = vector<TAnimal*>;
// END defines
 
//------------------------------------------------------------------------------
enum TTypesOfPopulation :int {
    TOP_NoSpecies = -1,
    TOP_Skylark = 0,
    TOP_Vole,
    TOP_Erigone,
    TOP_Bembidion,
    TOP_Hare,
    TOP_Partridge,
    TOP_Goose,
    TOP_RoeDeer,
    TOP_Rabbit,
    TOP_Newt,
    TOP_Osmia,
    TOP_ApisRAM,
    TOP_Oedothorax,
    TOP_OliveMoth,
    TOP_Bombus,
    TOP_Lacewing,
    TOP_Aphid,
    TOP_Ladybird,
    //17
    TOP_PoecilusCupreus,
    // Above this line are used for menu items and have to be in this order and present
    TOP_Predators,
    TOP_Hunters,
    TOP_OsmiaParasitoids,
    TOP_Beetle,
    TOP_Disturbers,
    TOP_foobar
};
 
//------------------------------------------------------------------------------
 
enum to_BeforeStepActions :unsigned {
    toBSA_Shuffle = 0,
    toBSA_SortX,
    toBSA_SortY,
    toBSA_Nothing,
    toBSA_ShuffleEvery500,
    toBSA_foobar
};
 
struct IntArray100 {
public:
    int n[100];
};
 
//------------------------------------------------------------------------------
 
struct rectangle {
public:
    unsigned m_x1;
    unsigned m_y1;
    unsigned m_x2;
    unsigned m_y2;
};
 
//------------------------------------------------------------------------------
 
class TALMaSSObject {
protected:
    int m_CurrentStateNo;
    bool m_StepDone;
 
public:
    int GetCurrentStateNo() const { return m_CurrentStateNo; }
    void SetCurrentStateNo(int a_num) { m_CurrentStateNo = a_num; }
    bool GetStepDone() const { return m_StepDone; }
    void SetStepDone(bool a_bool) { m_StepDone = a_bool; }
    virtual void BeginStep() {
    }
    virtual void Step() {
    }
    virtual void EndStep() {
    }
    void ReinitialiseObjectBase() {
        m_StepDone = false;
        m_CurrentStateNo = 0;
    }
    TALMaSSObject();
    virtual ~TALMaSSObject() = default;
    static void OnArrayBoundsError();
};
 
//------------------------------------------------------------------------------
 
class AnimalPosition
    // used to communicate the position of an animal to inquiring objects
{
public:
    unsigned m_x{0};
    unsigned m_y{0};
    TTypesOfLandscapeElement m_EleType{tole_Foobar};
    TTypesOfVegetation m_VegType{tov_Undefined};
};
 
//------------------------------------------------------------------------------
 
class RoeDeerInfo : public AnimalPosition {
public:
    double m_Size{0};
    int m_Age{0};
    APoint m_Range;
    APoint m_OldRange;
};
 
//------------------------------------------------------------------------------
 
class TAnimal : public TALMaSSObject {
public:
    TAnimal(int x, int y, Landscape* L);
    TAnimal(int x, int y);
    void SetGuardMapIndex(int a_index_x, int a_index_y) {
        m_guard_cell_x = a_index_x;
        m_guard_cell_y = a_index_y;
    }
    unsigned SupplyFarmOwnerRef() const;
    AnimalPosition SupplyPosition() const;
    APoint SupplyPoint() const {
        APoint p(m_Location_x, m_Location_y);
        return p;
    }
    int SupplyPolygonRef() const { return m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y); }
    TTypesOfLandscapeElement SupplyPolygonType() const {
        return m_OurLandscape->GetOwner_tole(m_Location_x, m_Location_y);
    }
    int Supply_m_Location_x() const { return m_Location_x; }
    int Supply_m_Location_y() const { return m_Location_y; }
    int SupplyGuardCellX() const { return m_guard_cell_x; }
    int SupplyGuardCellY() const { return m_guard_cell_y; }
    int SupplyAge() const { return m_AgeDays; }
    void SetAge(int a_age) { m_AgeDays = a_age; }
    virtual void KillThis() {
        m_CurrentStateNo = -1;
        m_StepDone = true;
        //reset the toxicity object
        if(l_pest_enable_pesticide_engine.value())
            m_my_pesticide.reset();
    }
    virtual void CopyMyself() { }
    void SetX(const int a_x) { m_Location_x = a_x; }
    void SetY(const int a_y) { m_Location_y = a_y; }
        virtual void ReinitialiseObject(int a_x, int a_y, Landscape* a_l_ptr) {
        m_OurLandscape = a_l_ptr;
        m_Location_x = a_x;
        m_Location_y = a_y;
        m_AgeDays = 0;
        ReinitialiseObjectBase();
    }
    virtual void ReinitialiseObject(int a_x, int a_y) {
        m_Location_x = a_x;
        m_Location_y = a_y;
        m_AgeDays = 0;
        ReinitialiseObjectBase();
    }
    virtual int WhatState() { return 0; }
    virtual void Dying() { KillThis(); }
    void CheckManagement();
    void CheckManagementXY(int a_x, int a_y);
    virtual bool OnFarmEvent(FarmToDo /* event */) { return false; }
    static void SetSimulationWidth(int a_value) { m_SimulationWidth = a_value; }
    static void SetSimulationHeight(int a_value) { m_SimulationHeight = a_value; }
    static void SetDayInYear(int a_value) { m_DayInYear = a_value; }
    static void SetOurLandscape(Landscape* a_value) { m_OurLandscape = a_value; }
    static void SetTempToday(double a_value) { m_TemperatureToday = a_value; }
protected:
    static Landscape* m_OurLandscape;
    static int m_SimulationWidth;
    static int m_SimulationHeight;
    static double m_TemperatureToday;
    static int m_DayInYear;
    int m_Location_x;
    int m_Location_y;
    int m_guard_cell_x;
    int m_guard_cell_y;
    int m_AgeDays {0};
    PesticideToxicity m_my_pesticide;
    void CorrectWrapRound() {
        m_Location_x = (m_Location_x + m_OurLandscape->SupplySimAreaWidth()) % m_OurLandscape->SupplySimAreaWidth();
        m_Location_y = (m_Location_y + m_OurLandscape->SupplySimAreaHeight()) % m_OurLandscape->SupplySimAreaHeight();
    }
};
 
//------------------------------------------------------------------------------
 
class ReturnLessThanX {
public:
    bool operator()(TAnimal* a_a1, int a_x) const { return a_a1->Supply_m_Location_x() < a_x; }
};
 
//---------------------------------------------------------------------------
 
class ReturnMoreThanX {
public:
    bool operator()(TAnimal* a_a1, int a_x) const { return a_a1->Supply_m_Location_x() > a_x; }
};
//---------------------------------------------------------------------------
 
class Probe_Data {
protected:
    ofstream* m_MyFile;
    int m_Time;
    char m_MyFileName[255];
 
public:
    bool m_FileRecord;
    bool m_FullLandscapeProbe;
    // true if the probe is a full landscape probe, then no need to check the position and we can just ask PM for numbers: most of the time is like that
    unsigned m_ReportInterval; // from 1-10
    unsigned m_NoAreas; // from 1-10
    rectangle m_Rect[16]; // can have up to thirty two areas
    unsigned m_NoEleTypes;
    unsigned m_NoVegTypes;
    unsigned m_NoFarms;
    TTypesOfVegetation m_RefVeg[25]; // up to 25 reference types
    TTypesOfLandscapeElement m_RefEle[25]; // up to 25 reference types
    unsigned m_RefFarms[25]; // up to 25 reference types
    // Species Specific Code below:
    bool m_TargetTypes[16]; // eggs,nestlings,fledgelings,males,females etc.
    void FileOutput(int No, int time, int ProbeNo) const;
    void FileAppendOutput(int No, int time) const;
    Probe_Data();
    void SetFile(ofstream* F);
    ofstream* OpenFile(const string& Nme);
 
    bool OpenForAppendToFile() {
        m_MyFile = new ofstream(m_MyFileName, ios::app);
        if (!(*m_MyFile).is_open())
        {
            g_msg->Warn(WARN_FILE, "PopulationManager::AppendToFile() Unable to open file for append: ", m_MyFileName);
            exit(1);
        }
        return true;
    }
    void CloseFile() const;
    ~Probe_Data() = default;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class SimpleStatistics {
protected:
    double m_K{0};
    double m_n{0};
    double m_Sum{0};
    double m_SumX{0};
    double m_SumX2{0};
 
public:
    SimpleStatistics() = default;
    void add_variable(double x) {
        // This uses the computing shifted data equation. 
        if (m_n < 1) m_K = x;
        m_n++;
        m_Sum += x;
        m_SumX += x - m_K;
        m_SumX2 += (x - m_K) * (x - m_K);
    }
    void remove_variable(double x) {
        m_n--;
        m_Sum -= x;
        m_SumX -= x - m_K;
        m_SumX2 -= (x - m_K) * (x - m_K);
    }
    double get_N() const { return m_n; }
    double get_Total() const { return m_Sum; }
    double get_meanvalue() const {
        if (m_n < 1) return -1;
        return m_K + m_SumX / m_n;
    }
    double get_varianceP() {
        if (m_n < 2)
        {
            return -1; // Ilegal n value, but don't want to exit
        }
        return (m_SumX2 - m_SumX * m_SumX / m_n) / m_n;
    }
    double get_varianceS() {
        if (m_n < 2)
        {
            return -1; // Ilegal n value, but don't want to exit
        }
        return (m_SumX2 - m_SumX * m_SumX / m_n) / (m_n - 1);
    }
    double get_SD() {
        if (m_n < 2)
        {
            return -1; // Ilegal n value, but don't want to exit
        }
        return sqrt(get_varianceS());
    }
    double get_SE() {
        if (m_n < 2)
        {
            return -1; // Ilegal n value, but don't want to exit
        }
        return sqrt(get_varianceS() / get_N());
    }
    void ClearData() {
        m_K = 0;
        m_n = 0;
        m_Sum = 0;
        m_SumX = 0;
        m_SumX2 = 0;
    }
};
 
//------------------------------------------------------------------------------
class Population_Manager_Base {
public:
    // Methods
    Population_Manager_Base(Landscape* L);
    virtual unsigned GetLiveArraySize(int a_listindex) { return 0; }
    virtual unsigned GetPopulationSize(int a_listindex) { return 0; }
    virtual void Catastrophe(int /* a_mort */) {
    }
    int SupplySimW() const { return SimW; }
    int SupplySimH() const { return SimH; }
    int SupplySimWH() const { return SimWH; }
    int SupplySimHH() const { return SimHH; }
    virtual void Run(int a_NoTSteps) {
        for (int i = 0; i < a_NoTSteps; i++)
        {
        }
    }
    virtual void SetNoProbesAndSpeciesSpecificFunctions(int /*a_pn*/) {
    }
    virtual int ProbeFileInput(char* p_Filename, int p_ProbeNo);
    virtual char* SpeciesSpecificReporting(int /*a_species*/, int /*a_time*/) { return nullptr; }
    Probe_Data* TheProbe[100] = {nullptr}; // lct: Array of pointers
    int SupplyListNameLength() const { return m_ListNameLength; }
    const char* SupplyListName(int a_i) const { return m_ListNames[a_i]; }
    virtual void SupplyLocXY(unsigned /*listindex */, unsigned /*j*/, int& /*x*/, int& /*y*/) {
    }
    virtual TAnimal* FindClosest(int /*x*/, int /*y*/, unsigned /*Type*/) { return nullptr; }
    std::string SupplySimulationName() { return m_SimulationName; }
    virtual void OpenTheAOROutputProbe(const string& a_string) {
    }
 
    void SetStepCounterInADay(int a_counter) {m_step_counter_in_a_day = a_counter;}
    int GetStepCounterInADay(void) {return m_step_counter_in_a_day;}
    virtual double GetAphidDensity(int /*a_x*/, int /*a_y*/) { return 0; }
    virtual TAnimal* SupplyAnimalPtr(unsigned int a_index, unsigned int a_animal) { return nullptr; }
 
protected:
    ~Population_Manager_Base() = default;
    int SimH;
    int SimW;
    int SimHH;
    int SimWH;
    string m_SimulationName;
    Landscape* m_TheLandscape;
    int m_ListNameLength{};
    const char* m_ListNames[32]{};
    std::string m_AORProbeFileName{"AOR_Probe.txt"};
    std::string m_ProbeFileName{"Probe.res"};
    int m_step_counter_in_a_day;
};
//------------------------------------------------------------------------------
 
class Population_Manager : public Population_Manager_Base {
public:
    // Methods
    Population_Manager(Landscape* a_l_ptr, int a_numberLifeStages = 12);
    virtual ~Population_Manager(void);
 
    void SetNoProbesAndSpeciesSpecificFunctions(int a_pn) override;
    void OpenTheAOROutputProbe(const string& a_AORFilename) override;
 
    unsigned GetLiveArraySize(int a_listindex) override { return m_LiveArraySize[a_listindex]; }
    unsigned GetPopulationSize(int a_listindex) override { return GetLiveArraySize(a_listindex); }
    void IncLiveArraySize(int a_listindex) { m_LiveArraySize[a_listindex]++; }
    unsigned int FarmAnimalCensus(unsigned int a_farm, unsigned int a_typeofanimal);
    char* SpeciesSpecificReporting(int a_species, int a_time) override;
    char* ProbeReport(int a_time);
    char* ProbeReportTimed(int a_time);
    void ImpactProbeReport(int a_Time);
    bool BeginningOfMonth();
    void LOG(const char* fname);
    int SupplyStepSize() const { return m_StepSize; }
    void Run(int NoTSteps) override;
    virtual unsigned Probe(int ListIndex, Probe_Data* p_TheProbe);
    virtual void ImpactedProbe();
    virtual TAnimal* SupplyAnimalPtr(unsigned int a_index, unsigned int a_animal) {
        //reset
        if(a_animal == 0 || a_animal < TheSubArrayPreviousIndex[a_index]){
            //let's find the first non-empty subarray
            TheSubArrayPreviousIndex[a_index] = 0;
            TheSubArrayThreadIndex[a_index] = 0;
            TheSubArraysIterators[a_index] = TheSubArrays[a_index][0]->begin();
            for (int j = 0; j < TheSubArraysSizes[a_index].size(); j++){
                if(TheSubArraysSizes[a_index][j] > 0){
                    TheSubArrayThreadIndex[a_index] = j;
                    TheSubArraysIterators[a_index] = TheSubArrays[a_index][j]->begin();
                    break;
                }
            }
            if(a_animal == 0)
                return *(TheSubArraysIterators[a_index]);
        }
 
        if(a_animal == TheSubArrayPreviousIndex[a_index]){
            return *(TheSubArraysIterators[a_index]);
        }
 
        //start the search from right after the previous position
        int temp_animal_num = TheSubArrayPreviousIndex[a_index];
        int temp_thread_num = TheSubArrayThreadIndex[a_index];
 
        TheSubArraysIterators[a_index]++;
        while(temp_animal_num < a_animal){
            for (auto it = TheSubArraysIterators[a_index]; it != TheSubArrays[a_index][temp_thread_num]->end(); ++it)
            {   
                temp_animal_num++;
                if(temp_animal_num == a_animal){
                    TheSubArrayPreviousIndex[a_index] = temp_animal_num;
                    TheSubArrayThreadIndex[a_index] = temp_thread_num;
                    TheSubArraysIterators[a_index] = it;
                    return *it;
                }
            }
            //we need to move to the next thread subarray and search from the beginning
            temp_thread_num++;
            TheSubArraysIterators[a_index] = TheSubArrays[a_index][temp_thread_num]->begin();
        }
 
        //if reach here means error happens,quite 
        exit(1);
    }
 
    virtual unsigned SupplyListIndexSize() { return static_cast<unsigned>(TheSubArrays.size()); }
    unsigned SupplyListSize(unsigned listindex) const {
        int return_value = 0;
        for (unsigned i = 0; i < TheSubArraysSizes[listindex].size(); i++)
        {
            return_value += TheSubArraysSizes[listindex][i];
        }
        return return_value; 
    }
 
 
    void PushIndividual(const unsigned a_listindex, TAnimal* a_individual_ptr);
 
    const char* SupplyStateNames(int i) const { return StateNames[i]; }
    unsigned SupplyStateNamesLength() const { return StateNamesLength; }
    virtual void DisplayLocations();
 
 
    bool ProbesSet{};
    TAnimal* FindIndividual(unsigned Type, TAnimal* a_me);
    // used to show when probes are needed to be set
    virtual TAnimal* FindClosest(int x, int y, unsigned Type, TAnimal* a_me);
 
    omp_nest_lock_t* GetGuardMapElement(unsigned a_x_index, unsigned a_y_index)
    {
        return m_MapGuard[a_y_index][a_x_index];
    }
 
    void SetGuardMapElement(unsigned a_x_index, unsigned a_y_index)
    {
        omp_set_nest_lock(m_MapGuard[a_y_index][a_x_index]);
    }
 
    void UnsetGuardMapElement(unsigned a_x_index, unsigned a_y_index)
    {
        omp_unset_nest_lock(m_MapGuard[a_y_index][a_x_index]);
    }
 
    void UpdateGuardMap(int a_x, int a_y, int& a_index_x, int& a_index_y)
    {
        int temp_index_x = a_x / m_guard_cell_size;
        int temp_index_y = a_y / m_guard_cell_size;
        
        //a new cell, we need to reset the guard
        if(a_index_x != temp_index_x || a_index_y != temp_index_y){
            omp_unset_nest_lock(m_MapGuard[a_index_y][a_index_x]);
            omp_set_nest_lock(m_MapGuard[temp_index_y][temp_index_x]);
            a_index_x = temp_index_x;
            a_index_y = temp_index_y;
        }
        
    }
 
protected:
    // Attributes
    // Holds the number of live animals represented in each element of vector of vectors TheArray
    vector<unsigned> m_LiveArraySize;
    int m_NoProbes = 0;
 
    std::vector<std::vector<omp_nest_lock_t*>> m_MapGuard;
    int m_guard_cell_height_num;
    int m_guard_cell_width_num;
    int m_guard_cell_size;
 
    bool m_is_paralleled;
 
    //FILE* m_AlleleFreqsFile;
    //FILE* m_EasyPopRes;
    //FILE* m_FledgelingFile;
    const char* StateNames[100]{};
    int m_StepSize{};
    vector<vector<forward_list<TAnimal*>*>> TheSubArrays;
    vector<vector<int>> TheSubArraysSizes;
    vector<int> m_LifeStageOrderVec;
    vector<forward_list<TAnimal*>::iterator> TheSubArraysIterators;
    vector<int> TheSubArrayPreviousIndex;
    vector<int> TheSubArrayThreadIndex;
    unsigned StateNamesLength;
    FILE* TestFile{};
    FILE* TestFile2{};
    vector<unsigned> BeforeStepActions;
    int m_SeasonNumber;
 
    virtual bool StepFinished();
    virtual void DoFirst();
    virtual void DoBefore();
    virtual void DoAfter();
    virtual void DoLast();
    virtual void DoSpecialBetweenLifeStages(int a_life_stage) {;}
    virtual void SortX(unsigned Type);
    void SortXIndex(unsigned Type);
    virtual void SortY(unsigned Type);
    void SortState(unsigned Type);
    void SortStateR(unsigned Type);
    virtual unsigned PartitionLiveDead(unsigned Type);
    virtual void Shuffle_or_Sort(unsigned Type);
    virtual void Shuffle(unsigned Type);
    virtual void Catastrophe();
 
public:
    // Grid related functions
    bool OpenTheRipleysOutputProbe();
    //virtual void OpenTheAOROutputProbe(string a_AORFilename);
    bool OpenTheMonthlyRipleysOutputProbe();
    bool OpenTheReallyBigProbe();
    virtual void TheAOROutputProbe();
    virtual void TheRipleysOutputProbe(ofstream* a_prb);
    virtual void TheReallyBigOutputProbe();
    void CloseTheMonthlyRipleysOutputProbe() const;
    virtual void CloseTheRipleysOutputProbe();
    virtual void CloseTheReallyBigOutputProbe();
    TTypesOfPopulation GetPopulationType() { return m_population_type; }
    int GetSeasonNumber() { return m_SeasonNumber; }
 
protected:
    TTypesOfPopulation m_population_type{TOP_NoSpecies};
    ofstream* AOROutputPrb{};
    ofstream* RipleysOutputPrb{};
    ofstream* RipleysOutputPrb1{};
    ofstream* RipleysOutputPrb2{};
    ofstream* RipleysOutputPrb3{};
    ofstream* RipleysOutputPrb4{};
    ofstream* RipleysOutputPrb5{};
    ofstream* RipleysOutputPrb6{};
    ofstream* RipleysOutputPrb7{};
    ofstream* RipleysOutputPrb8{};
    ofstream* RipleysOutputPrb9{};
    ofstream* RipleysOutputPrb10{};
    ofstream* RipleysOutputPrb11{};
    ofstream* RipleysOutputPrb12{};
    ofstream* ReallyBigOutputPrb{};
    AOR_Probe* m_AOR_Probe{};
 
    long int lamdagrid[2][257][257]{}; // THIS ONLY WORKS UP TO 10x10 KM !!!!
public:
    void LamdaDeath(int x, int y) {
        // inlined for speed
        lamdagrid[1][x / __lgridsize][y / __lgridsize]++;
    }
    void LamdaBirth(int x, int y) { lamdagrid[0][x / __lgridsize][y / __lgridsize]++; }
    void LamdaBirth(int x, int y, int z) { lamdagrid[0][x / __lgridsize][y / __lgridsize] += z; }
    void LamdaClear() {
        for (int i = 0; i < 257; i++)
        {
            for (int j = 0; j < 257; j++)
            {
                lamdagrid[0][i][j] = 0;
                lamdagrid[1][i][j] = 0;
            }
        }
    }
    void LamdaDumpOutput();
    // end grid stuff
public: // Special ones for compatability to descended managers
    virtual int SupplyPegPosx(int /*unused*/) { return 0; }
    virtual int SupplyPegPosy(int /*unused*/) { return 0; }
    virtual int SupplyCovPosx(int /*unused*/) { return 0; }
    virtual int SupplyCovPosy(int /*unused*/) { return 0; }
    virtual bool OpenTheFledgelingProbe() { return false; }
    virtual bool OpenTheBreedingPairsProbe() { return false; }
    virtual bool OpenTheBreedingSuccessProbe() { return false; }
    virtual void BreedingPairsOutput(int /*unused*/) {
    }
    virtual int TheBreedingFemalesProbe(int /*unused*/) { return 0; }
    virtual int TheFledgelingProbe() { return 0; }
    virtual void BreedingSuccessProbeOutput(double /*unused*/, int /*unused*/, int /*unused*/, int /*unused*/, int
                                            /*unused*/, int /*unused*/, int /*unused*/, int /*unused*/) {
    }
    virtual int TheBreedingSuccessProbe(int& /*unused*/, int& /*unused*/, int& /*unused*/, int& /*unused*/, int&
                                        /*unused*/, int& /*unused*/) { return 0; }
    virtual void FledgelingProbeOutput(int /*unused*/, int /*unused*/) {
    }
    virtual void TheGeneticProbe(unsigned /*unused*/, int /*unused*/, unsigned& /*unused*/) {
    }
    virtual void GeneticsResultsOutput(FILE* /*unused*/, unsigned /*unused*/) {
    }
 
    void Debug_Shuffle(unsigned int Type);
 
    virtual void RunStepMethods();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class None_Population_Manager : public Population_Manager {
public:
    None_Population_Manager(Landscape* L) : Population_Manager(L, 0) {
        m_ListNameLength = 0; // This is for life stages
        TheProbe[0] = nullptr;
    }
};
 
//------------------------------------------------------------------------------
 
class PopulationManagerList {
public:
    PopulationManagerList() {;}
    void SetPopulation(std::shared_ptr<Population_Manager_Base> p_pm, int a_pt) {
        m_populationlist[a_pt].push_back(p_pm);
        if (p_pm != nullptr) m_populationarray.at(a_pt) = true;
        else m_populationarray.at(a_pt) = false;
    }
 
 
    int GetPopulationManagerNum(int a_pt) { return static_cast<int>(m_populationlist[a_pt].size()); }
 
    /*
     * The following function returns raw pointer-- it should never be used
     * */
    Population_Manager_Base* GetPopulation(int a_pt, int a_index=0) { if( m_populationlist[a_pt].size()<1) return nullptr; return m_populationlist[a_pt][a_index].get(); }
    /*
     * In the bright future only the next function will be used (or the prototype of the former one will be changed)
     * */
    std::shared_ptr<Population_Manager_Base> GetPopulation_smart(int a_pt, int a_index=0) { if( m_populationlist[a_pt].size()<1) return nullptr; return m_populationlist[a_pt][a_index]; }
    int SupplyActivePopulationsCount();
 
protected:
    std::vector<std::shared_ptr<Population_Manager_Base>> m_populationlist[static_cast<int>(TOP_foobar)];
    std::array<bool, TOP_foobar> m_populationarray{false};
};
 
//------------------------------------------------------------------------------
 
#endif