ALMaSS/GooseManagement/_goose___population___manager_8h_source.html

/*

*******************************************************************************************************

Copyright (c) 2013, Christopher John Topping, University of Aarhus

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 Goose_Population_ManagerH

#define Goose_Population_ManagerH


//---------------------------------------------------------------------------


class Goose;

class Goose_Population_Manager;

class AOR_Probe_Goose;


//------------------------------------------------------------------------------

typedef std::vector<APoint> roostlist;


class struct_Goose

{

 public:

  bool m_sex;

  bool m_family;

  int m_grpsize;

  int m_x;

  int m_y;

  int m_species;

  double m_weight;

  Landscape* m_L;

  Goose_Population_Manager * m_GPM;

  APoint m_roost;

};


class GooseActiveForageLocation

{

protected:

        int m_polygonref;

        double m_area;

        double m_graindensity;

        double m_maizedensity;

        double m_grazingrate[gs_foobar];

        double m_grazedbiomass;

        double m_grainKJ_total;

        double m_maizeKJ_total;

        TTypeOfMaxIntakeSource m_HabitatType;

        int m_BirdsPresent[gst_foobar];

        int m_MaxBirdsPresent[gst_foobar];

        double m_dist_to_closest_roost[gs_foobar];

        Goose_Population_Manager*  m_OurPopulationManager;

public:

        GooseActiveForageLocation(GooseSpeciesType a_type, int a_number, int a_polyref, int a_area, double a_graindensity, double a_maizedensity, double * a_grazing, Goose_Population_Manager* p_NPM);

        void SetArea( int a_area) { m_area = a_area; }

        double GetArea() { return m_area; }

        int GetPolygonref() { return m_polygonref; }

        int GetMaxBirdsPresent()

        {

                int sum=0;

                for (int i = (int) 0; i<gst_foobar;i++)

                        sum+=m_MaxBirdsPresent[i];

                return sum;

        }

        int GetMaxSpBirdsPresent(GooseSpecies a_goose) {

                int sum = 0;

                        switch (a_goose) {

                                case gs_Pinkfoot:

                                        sum += (m_MaxBirdsPresent[ gst_PinkfootFamilyGroup ] + m_MaxBirdsPresent[ gst_PinkfootNonBreeder ]);

                                        break;

                                case gs_Barnacle:

                                        sum += (m_MaxBirdsPresent[ gst_BarnacleFamilyGroup ] + m_MaxBirdsPresent[ gst_BarnacleNonBreeder ]);

                                        break;

                                case gs_Greylag:

                                        sum += (m_MaxBirdsPresent[ gst_GreylagFamilyGroup ] + m_MaxBirdsPresent[ gst_GreylagNonBreeder ]);

                                        break;

                                default:

                                        return -1;

                        }

                        return sum;

                }


        void SetPolygonref(int a_polyref) { m_polygonref = a_polyref; }

        int GetHuntables(void);

        int GetGooseNumbers( void ) {

                int sum = 0;

                for (int i = 0; i < gst_foobar; i++) {

                        sum += m_BirdsPresent[ i ];

                }

                return sum;

        }

        double GetGooseDensity( void ) {

                //return GetGooseNumbers() / m_area;

                return GetGooseNumbers();

        }

        int GetBirds(GooseSpeciesType a_type) { return m_BirdsPresent[(int)a_type]; }

        int GetBirds( GooseSpecies a_goose ) {

                                int sum = 0;

                switch (a_goose) {

                        case gs_Pinkfoot:

                                sum += (GetBirds(gst_PinkfootFamilyGroup) + GetBirds(gst_PinkfootNonBreeder));

                                break;

                        case gs_Barnacle:

                                sum += (GetBirds(gst_BarnacleFamilyGroup) + GetBirds(gst_BarnacleNonBreeder));

                                break;

                        case gs_Greylag:

                                sum += (GetBirds(gst_GreylagFamilyGroup) + GetBirds(gst_GreylagNonBreeder));

                                break;

                        default:

                                return -1;

                }

                return sum;

        }


        void AddGeese(GooseSpeciesType a_type, int a_number)

        {

                m_BirdsPresent[(int)a_type] += a_number;

                if (m_BirdsPresent[(int)a_type] > m_MaxBirdsPresent[(int)a_type])

                {

                        m_MaxBirdsPresent[(int)a_type] = m_BirdsPresent[(int)a_type];

                }

        }

        void RemoveGeese(GooseSpeciesType a_type, int a_number) {

                m_BirdsPresent[a_type] -= a_number;

#ifdef __DEBUG_GOOSE

                if (m_BirdsPresent[a_type]<0)

                {

                        g_msg->Warn("GooseActiveForageLocation::RemoveGeese - Negative birds at forage location", (double)m_BirdsPresent[a_type]);

                        exit(0);

                }

#endif

        }

        double GetGrainDensity(void) { return m_graindensity; }

        void SetGrainDensity(double a_density) { m_graindensity = a_density; }

        double GetMaizeDensity(void) {

                return m_maizedensity;

        }

        bool GetHabitatType(void) {

                return m_HabitatType;

        }

        void SetMaizeDensity( double a_density ) {

                m_maizedensity = a_density;

        }

        double GetGrazing(int gs) { return m_grazingrate[gs]; }

        double GetRoostDist(int gs) { return m_dist_to_closest_roost[gs]; }

        double GetGrazedBiomass(void) { return m_grazedbiomass; }

        void SetGrazing(int gs, double a_density) { m_grazingrate[gs] = a_density; }

        void SetDistToClosestRoost(int gs, double a_dist) { m_dist_to_closest_roost[gs] = a_dist; }

        void ResetGrazing() { m_grazedbiomass = 0.0; }


        void RemoveGrainKJ(double a_kJ) { m_grainKJ_total -= a_kJ; }


        void RemoveMaizeKJ( double a_kJ ) {

                m_maizeKJ_total -= a_kJ;

        }

        void Graze(double a_kJ) {

                m_grazedbiomass += a_kJ * 0.2857;

        }

        void ClearBirds();


        void UpdateKJ() {

                m_graindensity = (m_grainKJ_total / m_area) / 17.67 / 0.04;

                m_maizedensity = m_maizeKJ_total / m_area;

        }

};


class Goose_Population_Manager : public Population_Manager

{

public:

        // Methods

        Goose_Population_Manager(Landscape* L);

        virtual ~Goose_Population_Manager(void);

        int GetDayTime() { return m_daytime; }

        int GetDaylightLeft() { return m_daylightleft; }

        int GetIsDaylight() { return m_daylight; }

        bool InPinkfootSeason() { return m_PinkfootSeason; }

        bool InGreylagSeason() { return m_GreylagSeason; }

        void CreateObjects(int ob_type, TAnimal *pvo, struct_Goose* data, int number);

        int ForageLocationInUse(int a_polyref);

        void AddGeeseToForageLocationP(GooseSpeciesType a_type, int a_polyref, int a_number);

        void AddGeeseToForageLocation(GooseSpeciesType a_type, int a_index, int a_number);

        void RemoveGeeseFromForageLocation(GooseSpeciesType a_type, int a_index, int a_number);

        int NewForageLocation(GooseSpeciesType a_type, int a_number, int a_polyref);

        GooseActiveForageLocation* GetForageLocation(unsigned int a_index) {

                if ((m_GooseForageLocations.size() == 0) || (m_GooseForageLocations.size() <= a_index)) return NULL; else return &m_GooseForageLocations[a_index];

        }

        double GetFeedingRate(double a_graindensity, GooseSpecies a_species)

        {

                if (a_species == gs_Greylag) return m_IntakeRateVSGrainDensity_PF->GetY(a_graindensity) * 1.21;

                else if (a_species == gs_Pinkfoot) return m_IntakeRateVSGrainDensity_PF->GetY(a_graindensity);

                else return m_IntakeRateVSGrainDensity_PF->GetY(a_graindensity) * 0.74;

        }

        double GetMaizeFeedingRate(double a_maizedensity, GooseSpecies a_species) {

                if (a_species == gs_Greylag) return m_IntakeRateVSMaizeDensity_BN->GetY(a_maizedensity) * 1.64;

                else if (a_species == gs_Pinkfoot) return m_IntakeRateVSMaizeDensity_BN->GetY(a_maizedensity) * 1.35;

                else return m_IntakeRateVSMaizeDensity_BN->GetY(a_maizedensity);

        }

        double GetForageRateDensity(double a_foragedensity) { return m_ForageRateVSGooseDensity->GetY(a_foragedensity); }

        double GetForageGooseDensity(int a_index) { return m_GooseForageLocations[a_index].GetGooseDensity(); }

        double GetForageGrazing(int a_index, int gs) { return m_GooseForageLocations[a_index].GetGrazing(gs); }

        double GetGrainDensity(int a_index) { return m_GooseForageLocations[a_index].GetGrainDensity(); }

        double GetMaizeDensity(int a_index) {

                return m_GooseForageLocations[a_index].GetMaizeDensity();

        }

        void RemoveGrainKJ(double a_kJ, int a_index) { m_GooseForageLocations[a_index].RemoveGrainKJ(a_kJ); }


        void RemoveMaizeKJ(double a_kJ, int a_index) {

                m_GooseForageLocations[a_index].RemoveMaizeKJ(a_kJ);

        }

        void Graze(double a_kJ, int a_index) { m_GooseForageLocations[a_index].Graze(a_kJ); }

        void RemoveMaxForageKj(double a_forage, TTypeOfMaxIntakeSource a_maxintakesource, int m_myForageIndex);

        int GetBirdsAtForageLoc(int a_index, GooseSpeciesType a_type) {

                return m_GooseForageLocations[a_index].GetBirds(a_type);

        }

        int BirdsToShootAtPoly(int a_poly /*, double & a_protectedpct */);

        void BirdsShot(int a_polyref, int a_numbershot, GooseHunter* a_Hunter);

        void BangAtPoly(int a_polyref);


        Goose_Base* GetLeader(APoint a_homeloc, GooseSpecies a_species);


        void FindClosestRoost(int &a_x, int &a_y, unsigned a_type);

        double GetDistToClosestRoost(int a_x, int a_y, unsigned a_type);

        double GetThermalCosts(GooseSpecies a_goose) { return m_thermalcosts[a_goose]; }

        std::vector<GooseActiveForageLocation>m_GooseForageLocations;

        int GetNumberOfForageLocs(void) { return int(m_GooseForageLocations.size()); }

        int GetForageLocIndex(GooseSpecies a_species, int a_x, int a_y);

        Variate_gen* m_variate_generator;

        void RecordIndForageLoc(double a_count, int a_groupsize, GooseSpecies a_species);

        void RecordWeight(double a_weight, GooseSpecies a_species);

        void RecordHabitatUse(int a_habitatype, GooseSpecies a_species, int a_count);

        void RecordHabitatUseFieldObs(int a_habitatype, GooseSpecies a_species, int a_count);

        void RecordForagingTime(int a_time, GooseSpecies a_species);

        void RecordFlightDistance(int a_distance, GooseSpecies a_species);

        void RecordDailyEnergyBudget(int a_deb, GooseSpecies a_species);

        void RecordDailyEnergyBalance(int a_balance, GooseSpecies a_species);

        void RecordState();

        void RecordLeaveReason(TTypeOfLeaveReason a_leavereason, GooseSpeciesType a_speciestype);

protected:

        // Attributes

        int m_daytime;

        bool m_daylight;

        int m_daylightleft;

        double m_thermalcosts[3];

        std::vector<int> m_youngdist;

        int m_migrationnumbers[3][2];

        bool m_PinkfootSeason;

        bool m_GreylagSeason;

        std::vector<roostlist> m_roosts;

        HollingsDiscCurveClass* m_IntakeRateVSGrainDensity_PF;

        HollingsDiscCurveClass* m_IntakeRateVSMaizeDensity_BN;

        //GompertzCurveClass* m_ForageRateVSGooseDensity;

        PettiforFeedingTimeCurveClass* m_ForageRateVSGooseDensity;

        ofstream* m_GoosePopDataFile;

        ofstream* m_GooseEnergeticsDataFile;

        ofstream* m_GooseHabitatUseFile;

        ofstream* m_GooseHabitatUseFieldObsFile;

        ofstream* m_GooseIndLocCountFile;

        ofstream* m_GooseWeightStatsFile;

        ofstream* m_GooseLeaveReasonStatsFile;

        ofstream* m_GooseFieldForageDataFile;

        ofstream* m_GooseGitVersionFile;

                int m_HabitatUseStats[gs_foobar * tomis_foobar];

        int m_HabitatUseFieldObsStats[gs_foobar * tomis_foobar];

        SimpleStatistics m_IndividualForageLocationData[gs_foobar];

        SimpleStatistics m_WeightStats[gs_foobar];

        SimpleStatistics m_ForagingTimeStats[gs_foobar];

        SimpleStatistics m_FlightDistanceStats[gs_foobar];

        SimpleStatistics m_DailyEnergyBudgetStats[gs_foobar];

        SimpleStatistics m_DailyEnergyBalanceStats[gs_foobar];

        ofstream* m_StateStatsFile;

        SimpleStatistics m_StateStats;

        SimpleStatistics m_LeaveReasonStats[gst_foobar][tolr_foobar];

        AOR_Probe_Goose * m_AOR_Pinkfeet;

        AOR_Probe_Goose * m_AOR_Barnacles;

        AOR_Probe_Goose * m_AOR_Greylags;

        ofstream* m_GooseXYDumpFile;


        // Methods

        virtual void Init(void);

        virtual void DoFirst(void);

        virtual void DoBefore() { ; }

        virtual void DoAfter() { ; }

        virtual void DoLast();

        virtual void DoImmigration();

        virtual void DoEmigration();

        void GoosePopulationDescriptionOutput();

        void GooseFieldForageInfoOutput();

        void GooseEnergyRecordOutput();

        void GooseWeightStatOutput();

        void GooseIndLocCountOutput();

        void GooseHabitatUseOutput();

        void GooseHabitatUseFieldObsOutput();

        void ClearIndLocCountStats();

        void ClearGooseWeightStats();

        void ClearGooseHabitatUseStats();

        void ClearGooseHabitatUseFieldObsStats();

        void ClearGooseForagingTimeStats();

        void ClearGooseFlightDistanceStats();

        void ClearGooseDailyEnergyBudgetStats();

        void ClearGooseDailyEnergyBalanceStats();

        void ClearStateStats();

        void StateStatOutput();

        void GooseLeaveReasonStatOutput();

        void ClearGooseLeaveReasonStats();

        void ObservedOpennessQuery();

        void WriteConfig();

        void GetImmigrationNumbers(GooseSpecies a_goose, bool a_season);

        bool InHuntingSeason(int a_day, GooseSpecies a_species);

        void WriteHeaders(ofstream *a_file, std::vector<std::string> a_headers);

        virtual void TheAOROutputProbe();

        virtual void TheRipleysOutputProbe(FILE* /*a_prb*/){ ; };

        virtual void CloseTheRipleysOutputProbe() { ; }

        virtual void CloseTheReallyBigOutputProbe() { ; }

        void XYDump();

        std::string GooseTypeToString(GooseSpeciesType a_gst);

        std::string GooseToString(GooseSpecies a_gs);

        std::string IntakeSourceToString(TTypeOfMaxIntakeSource a_intake_source);

        std::string LeaveReasonToString(TTypeOfLeaveReason a_leave_reason);

};


#endif