Goose_Base.cpp

Go to the documentation of this file.

/* 
*******************************************************************************************************
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.
********************************************************************************************************
*/
#include <iostream>
#include <fstream>
#include <list>
#include <vector>
#include "../Landscape/ls.h"
#include "../BatchALMaSS/PopulationManager.h"
#include "../GooseManagement/GooseMemoryMap.h"
#include "../GooseManagement/Goose_Base.h"
#include "../BatchALMaSS/CurveClasses.h"
#include "../Hunters/Hunters_all.h"
#include "../GooseManagement/Goose_Population_Manager.h"
#include "../BatchALMaSS/BoostRandomGenerators.h"
 
extern boost::variate_generator<base_generator_type&, boost::uniform_real<> > g_rand_uni;
extern boost::variate_generator<base_generator_type&, boost::uniform_int<> > g_rand_uni2;
extern MapErrorMsg *g_msg;
extern ALMaSS_MathFuncs g_AlmassMathFuncs;
 
using namespace std;
 
//*******************************************************************************************************
extern CfgFloat cfg_goose_MinForageRateDecayRate;
extern CfgInt cfg_goose_AfterDarkTime;
extern CfgInt cfg_goose_RoostLeaveDistMean;
extern CfgInt cfg_goose_RoostLeaveDistSD;
extern CfgInt cfg_goose_pf_springmigdatestart;
extern CfgInt cfg_goose_pf_springmigdateend;
extern CfgFloat cfg_goose_BMRconstant1;
extern CfgFloat cfg_goose_BMRconstant2;
extern CfgFloat cfg_goose_daytime_BMR_multiplier;
extern CfgFloat cfg_goose_nighttime_BMR_multiplier;
extern CfgFloat cfg_goose_InitialEnergyReserveProportion;
extern CfgFloat cfg_goose_snow_scaler;
//*******************************************************************************************************
 
//*******************************************************************************************************
// Initialise static members.
// Note that it is possible to do this only here - but the config variables have not been read in - so these need to be done again
// afterwards. This is done in the population manager by creating an instance of the Goose_Base and assinging these variables again
double Goose_Base::m_flightcost = -1;
double Goose_Base::m_mingooseforagerate[ 3 ] = { -1, -1, -1 };
double Goose_Base::m_GooseMaxAppetiteScaler = -1;
double Goose_Base::m_GooseMaxEnergyReserveProportion = -1;
double Goose_Base::m_GooseKJtoFatConversion = -1;
double Goose_Base::m_GooseFattoKJConversion = -1;
double Goose_Base::m_GooseMinForageOpenness = -1;
double Goose_Base::m_GooseLeavingThreshold = -1;
double Goose_Base::m_GooseForageDistX2[3] = { -1, -1, -1 };
double Goose_Base::m_GooseForageDist[3] = { -1, -1, -1 };
double Goose_Base::m_GooseFieldForageDistX2[3] = { -1, -1, -1 };
double Goose_Base::m_GooseFieldForageDist[3] = { -1, -1, -1 };
int Goose_Base::m_followinglikelyhood [ gst_foobar ] = { -1, -1, -1 , -1, -1, -1 };
double Goose_Base::m_SnowDepth = 0.0;
//*******************************************************************************************************
//************************************* Goose_Base ******************************************************
//*******************************************************************************************************
 
void Goose_Base::Init(Goose_Population_Manager* p_NPM, double a_weight, bool a_sex, APoint a_roost) {
        m_OurPopulationManager = p_NPM;
        CurrentGState = togs_InitialState;
        SetSex(a_sex);
        m_weight = a_weight;
        m_DailyMaxAppetite = 0.0;
        m_DailyMaxAppetiteHitTime = 0;
        m_energyReserve = m_weight * cfg_goose_InitialEnergyReserveProportion.value(); 
        int today = m_OurLandscape->SupplyDayInYear();
        if ((today >= cfg_goose_pf_springmigdatestart.value()) && (today <= cfg_goose_pf_springmigdateend.value())) {
                m_energyReserve = m_weight * 0.22; 
        }
        m_weightTotal = m_weight + m_energyReserve;
        m_BMR = pow(m_weightTotal / 1000, cfg_goose_BMRconstant2.value())*cfg_goose_BMRconstant1.value(); // BMR is used to scale other energetic costs on a daily basis
        m_energyToday = 0.0;
        m_BodyConditionCounter = 0;
        m_TheBodyCondition = 0.0;
        for (unsigned i = 0; i < 5; i++)
        {
                double condition = m_weightTotal / m_weight; // total weight divided by lean weight.
                SetBodyCondition(condition, i);
                AddBodyCondition(m_BodyCondition[i]);
        }
        m_LeaveRoostTime = 0; // intialisation
        m_myForageIndex = -1; // -1 signals not currently foraging
        m_MaxIntakeSource.m_maxintakesource = tomis_foobar;  // The source of the max forage intake rate has not been determined yet.
        // Assume a default groupsize of 1, if otherwise it needs setting in descendent classes
        m_groupsize = 1;
        // Set the roost and location
        m_Location_x = a_roost.m_x;
        m_Location_y = a_roost.m_y;
        m_MyRoost.m_x = a_roost.m_x;
        m_MyRoost.m_y = a_roost.m_y;
 
        // Any other intialisation will be done by descendent class constructors
        m_MyMemory = new GooseMemoryMap(this);
        // the species must be reset by the goose constructor
        m_myspecies = gs_foobar;
        // Must calculate the DEB now or risk use of an undefined m_DEB in StartDay
        m_DEB = 0;
        // Set the individual minimum forage rate acceptable. Overwritten later in StartDay
        Set_Indivmingooseforagerate(0.0);
        m_FlightNumber = 0;
        m_FlightDistance = 0;
        m_forageLocCount = 0;
}
 
Goose_Base::Goose_Base(Landscape* p_L, Goose_Population_Manager* p_NPM, double a_weight, bool a_sex, APoint a_roost) : TAnimal(0, 0, p_L)
{
        Init(p_NPM, a_weight, a_sex, a_roost);
}
 
void Goose_Base::ReInit(Landscape* p_L, Goose_Population_Manager* p_NPM, double a_weight, bool a_sex, APoint a_roost) {
        TAnimal::ReinitialiseObject(0, 0, p_L);
        // Assign the pointer to the population manager
        Init(p_NPM, a_weight, a_sex, a_roost);
}
 
//-------------------------------------------------------------------------------------------------------
 
Goose_Base::~Goose_Base(void)
{
        if (m_MyMemory!=NULL) delete m_MyMemory;
}
//-------------------------------------------------------------------------------------------------------
void Goose_Base::StartDay(void)
{ 
        // Adjust the energy reserves
        if (m_OurPopulationManager->GetDayTime() == 0)  
        {
                // Remove our DEB from our net energy collection for the day
                m_energyToday -= m_DEB;
                if (m_energyToday > 0)
                {
                        m_energyReserve += m_energyToday * m_GooseKJtoFatConversion;
                }
                else m_energyReserve += m_energyToday * m_GooseFattoKJConversion;
                
                m_weightTotal = m_weight + m_energyReserve;
                if (m_weightTotal < m_weight) {
                        On_Migrate(tolr_leanweight);
                }
                // Some goose output recording
                int foraging_time = GetForagingTime(m_DailyMaxAppetiteHitTime, m_LeaveRoostTime);
                m_OurPopulationManager->RecordForagingTime(foraging_time, m_myspecies);
                m_OurPopulationManager->RecordFlightDistance(m_FlightDistance, m_myspecies);
                m_OurPopulationManager->RecordDailyEnergyBudget(m_DEB, m_myspecies);
                m_OurPopulationManager->RecordDailyEnergyBalance(m_energyToday, m_myspecies);
                m_OurPopulationManager->RecordWeight(m_weightTotal, m_myspecies);
                m_OurPopulationManager->RecordIndForageLoc(double(m_forageLocCount), m_groupsize, m_myspecies);
                m_forageLocCount = 0;
 
                // Set the body condition as % by weight of fat. This is a running sum over the last 5 days.
                m_BodyConditionCounter = ++m_BodyConditionCounter & 5;
                SubtractBodyCondition(m_BodyCondition[m_BodyConditionCounter]);
                double condition = m_weightTotal / m_weight;
                SetBodyCondition( condition, m_BodyConditionCounter );
                AddBodyCondition( m_BodyCondition[m_BodyConditionCounter]);
                // Here we limit the maximum growth possible
                if (m_energyReserve / m_weight > m_GooseMaxEnergyReserveProportion)     {
                        m_energyReserve = m_GooseMaxEnergyReserveProportion *  m_weight;
                }
                if (m_TheBodyCondition < m_GooseLeavingThreshold)
                {
                        On_Migrate(tolr_bodycondition);
                }
                // Reset energy intake
                m_energyToday = 0;
                m_FlightNumber = 0;
                m_FlightDistance = 0;
                // Reset the roost leaving time
                m_LeaveRoostTime = (*m_OurPopulationManager->m_variate_generator)();
                // Reset the time when m_DailyMaxAppetite was hit. If reaching dailymaxappetite takes less than a whole day, the time is recorded. Therefore we "reset" to 1440, not 0.
                m_DailyMaxAppetiteHitTime = 1440;
                // Decay all memories before adding new information today
                m_MyMemory->DecayAllMemory();
                // Calculate the new DEB
                double daylightprop = m_OurLandscape->SupplyDaylightProp();
                double nighttimeprop = m_OurLandscape->SupplyNightProp();
                double multiplier = cfg_goose_daytime_BMR_multiplier.value() * daylightprop + cfg_goose_nighttime_BMR_multiplier.value() * nighttimeprop; 
                m_DEB = m_BMR * multiplier + m_OurPopulationManager->GetThermalCosts( m_myspecies );
                double minforagerate = (m_DEB / (1440 * daylightprop));  // They accept forage rates so they can optain positive energy balance
                Set_mingooseforagerate( minforagerate, m_myspecies );
                Set_Indivmingooseforagerate( minforagerate );  // At the start of the day, give the individual the MFR for the species
                m_SnowDepth = m_OurLandscape->SupplySnowDepth();  // We store the current snow depth here for speed optimization. 
        }
} 
 
void Goose_Base::Step(void)
{
    m_OurLandscape->Warn("Goose_Base::Step()","attempt to instantiate and use the base class!");
    exit(1);
}
//-------------------------------------------------------------------------------------------------------
 
void Goose_Base::st_Dying( void )
{
        m_CurrentStateNo = -1; // this will kill the animal object and free up space
        m_StepDone = true;
        delete m_MyMemory; // this is reinitisalised in the object pool.
}
//-------------------------------------------------------------------------------------------------------
TTypeOfGoose_BaseState Goose_Base::st_ChooseForageLocation( void )
{
        // Debugging
        m_OurPopulationManager->RecordState();
        int today = m_OurLandscape->SupplyDayInYear();
        int dtime = m_OurPopulationManager->GetDayTime();
        int daylength = m_OurLandscape->SupplyDaylength();
        if (dtime >= daylength + cfg_goose_AfterDarkTime.value())
        {
#ifdef __DEBUG_GOOSE
                if (m_myForageIndex != -1)
                {
                        if (m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) < m_groupsize) {
                                g_msg->Warn("Goose_Base::st_ChooseForageLocation - Removing negative geese from forage location", (double)(m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) - m_groupsize));
                                exit(0);
                        }
                }
#endif
                return togs_ToRoost;
        }
 
        if (g_rand_uni2() <= m_followinglikelyhood[m_myGooseSpeciesType])
        {
#ifdef __FOLLOW_FIELD
                int index = -1;
                        int forageindex = m_OurPopulationManager->GetForageLocIndex( m_myspecies, m_Location_x, m_Location_y );
                        if (forageindex > -1) {
                                index = forageindex;
                        }
#endif
 
#ifdef __FOLLOW_BIRD  
                Goose_Base* leader = m_OurPopulationManager->GetLeader( m_MyRoost, m_myspecies );
                if (leader != NULL) {
                        int index = leader->GetForageLocIndex();
        }
#endif
 
                        if (index > -1) 
                        {
 
                                GooseActiveForageLocation* gafl = m_OurPopulationManager->GetForageLocation( index );
                                FlyTo( m_OurLandscape->SupplyCentroid( gafl->GetPolygonref() ) );
                                Set_GooseLeavingRoost(false);  // We've left the roost now, so reset
                                GooseMemoryLocation aThought;
                                int poly = gafl->GetPolygonref();
                                double grain = gafl->GetGrainDensity();  // grain/m2
                                double maize = gafl->GetMaizeDensity();  // kJ/m2
                                aThought.m_grain = m_OurPopulationManager->GetFeedingRate(grain, m_myspecies);  // kJ/min
                                aThought.m_maize = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies);  // kJ/min
                                aThought.m_grazing = gafl->GetGrazing( (int)m_myspecies );  // kJ/min
                                aThought.m_foodresource = GetMaxIntakeRate(aThought.m_grain, aThought.m_maize, aThought.m_grazing);
                                aThought.m_polygonid = poly;
                                aThought.m_x = m_OurLandscape->SupplyCentroidX( poly );
                                aThought.m_y = m_OurLandscape->SupplyCentroidY( poly );
                                aThought.m_threat = 0;
                                int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y );
                                aThought.m_score = m_MyMemory->CalcScore(dist, aThought.m_foodresource, aThought.m_threat);
                                if (!m_MyMemory->IsKnownArea( gafl->GetPolygonref() )) m_MyMemory->MemAdd( aThought );
                                // Once the goose arrives at a forage location it needs to add itself to the geese already there, or initiate a forage location if one does not exist 
                                m_myForageIndex = m_OurPopulationManager->ForageLocationInUse( aThought.m_polygonid );
                                if (m_myForageIndex != -1) m_OurPopulationManager->AddGeeseToForageLocation( m_myGooseSpeciesType, m_myForageIndex, m_groupsize );
                                else {
                                        g_msg->Warn( "TTypeOfGoose_BaseState Goose_Base::st_ChooseForageLocation() : No geese at foraging location when following", "" );
                                        exit( 0 );
                                }
                                // some stats recording
                                m_forageLocCount++;
                                m_myMemPolyID = aThought.m_polygonid;
                                return togs_Forage;
                        }
        }
        if (m_LeavingRoost) Explore();  // Go for an exploration trip to initialise the memory.
        GooseMemoryLocation aThought = m_MyMemory->GetBestFeedingScore();
        if (aThought.m_score<=0)
        {
                Explore();  // Go for an exploration trip
                aThought = m_MyMemory->GetBestFeedingScore();
                // Did we find anything suitable?:
                if (aThought.m_score <= 0) {
                        // if not, start this method over again.
                        return togs_ChooseForageLocation;
                }
        }
        m_Location_x = aThought.m_x;
        m_Location_y = aThought.m_y;
        int polyref = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
        double grazing = m_OurLandscape->GetActualGooseGrazingForage(polyref, m_myspecies);  // kJ/min
        double grain = m_OurLandscape->SupplyBirdSeedForage(polyref);  // kJ/m2
        double maize = m_OurLandscape->SupplyBirdMaizeForage(polyref);  // kJ/m2
        bool instubble = m_OurLandscape->SupplyInStubble(polyref);
        TTypesOfVegetation veg = m_OurLandscape->SupplyVegType(polyref);
        TTypesOfVegetation lastsowncrop = m_OurLandscape->SupplyLastSownVeg(polyref);
        bool iscereal = m_OurLandscape->SupplyIsCereal2(lastsowncrop);
    // Here we make a test to see if the forage location is in use before going further
        m_myForageIndex = m_OurPopulationManager->ForageLocationInUse(aThought.m_polygonid);
        // Here we do the forage calculation.The intake rate depends on :
        // -1 The grain or grazing resource available in grain and grazing
        double grain_intake = m_OurPopulationManager->GetFeedingRate(grain, m_myspecies); // kJ/min
        double maize_intake = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies); // kJ/min
        m_MyMemory->ChangeSetFoodRes(aThought.m_polygonid, grain_intake, maize_intake, grazing);  // Remember these
// -2 The relationship between resource and intake rate.This is dependent on the species and family or non - breeder. It also depends on the 
        // type of resource, i.e. the response for grain is different than for grazing.
        // -3 The number of geese which will determine an interference competition factor, which reduces intake rate
        double geese = m_groupsize;  // if m_myForageIndex = -1, nobody else is there.
        if ( m_myForageIndex != -1) geese = m_OurPopulationManager->GetForageGooseDensity(m_myForageIndex);
        // -4 The interference factor is a look-up from a pre-calculated curve in the goose population manager
        double interferenceComp = m_OurPopulationManager->GetForageRateDensity(geese);
        // A simplification here is to assume that they either eat grain or graze but not both
        double myforagerate;
        myforagerate = GetMaxForageRate( grain_intake, maize_intake, grazing, interferenceComp, iscereal, veg, instubble, lastsowncrop);  // GetMaxForageRate determines the source of max intake rate and adjust intake for snow cover if needed.
        // Now decide if this is OK or not. The intake rate is compared to the current minimum intake rate for the individual.
        if (myforagerate < m_Indivmingooseforagerate)
        {
                m_myForageIndex = -1; // If we don't do this we will get a negative number of geese on the forage location later unless they find somewhere else to go.
                return togs_ChooseForageLocation;
        }
        // OK we are staying
        m_forageLocCount++;
        if (m_myForageIndex != -1){
                m_OurPopulationManager->AddGeeseToForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
        }
        else {
                m_myForageIndex = m_OurPopulationManager->NewForageLocation(m_myGooseSpeciesType, m_groupsize, aThought.m_polygonid);
        }
        m_myMemPolyID = aThought.m_polygonid;
        return togs_Forage;
}
//-------------------------------------------------------------------------------------------------------
 
void Goose_Base::FlyTo(APoint a_pt )
{
        FlyTo(a_pt.m_x,a_pt.m_y);
}
//-------------------------------------------------------------------------------------------------------
 
void Goose_Base::FlyTo(int a_x, int a_y )
{
        if ((m_Location_x == a_x) && (m_Location_y == a_y)) return;
        int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_Location_x, m_Location_y, a_x, a_y );
        double cost = dist * GetFlightCost();
        m_energyToday-=cost;
        m_Location_x = a_x;
        m_Location_y = a_y;
        m_FlightNumber++;
        m_FlightDistance += dist;
 
}
//-------------------------------------------------------------------------------------------------------
 
TTypeOfGoose_BaseState Goose_Base::st_Forage()
{
        int dtime = m_OurPopulationManager->GetDayTime();
        int daylength = m_OurLandscape->SupplyDaylength();
        if (dtime >= daylength + cfg_goose_AfterDarkTime.value())
        {
#ifdef __DEBUG_GOOSE
                if (m_myForageIndex != -1)
                {
                        if (m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) < m_groupsize) {
                                g_msg->Warn("Goose_Base::st_Forage - Removing negative geese from forage location", (double)(m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) - m_groupsize));
                                exit(0);
                        }
                }
#endif
                return togs_ToRoost;
        }
        if (m_energyToday >= m_DailyMaxAppetite)
        {
                if (m_DailyMaxAppetiteHitTime > dtime) {
                        m_DailyMaxAppetiteHitTime = dtime;
                }
                return togs_Forage;  
        }
        //
        // Get the grain and forage density - NB grain/m2 and maize in kJ/m2, which needs to be to needs to be remembered.
        //
        int polyref = m_OurPopulationManager->m_GooseForageLocations[m_myForageIndex].GetPolygonref();
        double grazing = m_OurLandscape->GetActualGooseGrazingForage(polyref, m_myspecies);  // kJ/min
        double grain = m_OurLandscape->SupplyBirdSeedForage(polyref);  // kJ/m2
        double maize = m_OurLandscape->SupplyBirdMaizeForage(polyref);  // kJ/m2
        bool instubble = m_OurLandscape->SupplyInStubble(polyref);
        TTypesOfVegetation veg = m_OurLandscape->SupplyVegType(polyref);
        TTypesOfVegetation lastsowncrop = m_OurLandscape->SupplyLastSownVeg(polyref);
        bool iscereal = m_OurLandscape->SupplyIsCereal2(lastsowncrop);
        // Here we do the forage calculation.The intake rate depends on :
        // -1 The grain, maize or grazing resource available in grain, maize and grazing
        double grain_intake = m_OurPopulationManager->GetFeedingRate( grain, m_myspecies ); // KJ/min
        double maize_intake = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies); // KJ/min
        m_MyMemory->ChangeSetFoodRes(m_myMemPolyID, grain_intake, maize_intake, grazing);  // Remember these
        // -2 The relationship between resource and intake rate. This is dependent on the species and family or non-breeder. It also depends on the 
        // type of resource, i.e. the response for grain or maize is different than for grazing.
    // -3 The number of geese which will determine an interference competition factor, which reduces intake rate
        double geese = m_OurPopulationManager->GetForageGooseDensity(m_myForageIndex);
        // -4 The interfence factor is a look-up from a pre-calculated curve in the goose population manager
        double interferenceComp = m_OurPopulationManager->GetForageRateDensity(geese);
        // A simplification here is to assume that they either eat grain, maize or graze but any combination
        double myforagerate;
        myforagerate = GetMaxForageRate( grain_intake, maize_intake, grazing, interferenceComp, iscereal, veg, instubble, lastsowncrop);  // GetMaxForageRate determines the source of max intake rate and adjust intake for snow cover if needed.
        // Now decide if this is OK or not. The simplest here is to compare to a standard intake rate threshold for the species/type combination.
        if (myforagerate < m_Indivmingooseforagerate)
        {
                m_MyMemory->MemDel(m_myMemPolyID);
                Set_Indivmingooseforagerate( m_Indivmingooseforagerate * cfg_goose_MinForageRateDecayRate.value() );   
                
                m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
                m_myForageIndex = -1; 
                return togs_ChooseForageLocation;
        }
        // We have lots of food, stay and eat until full.
        double forage = myforagerate * 10; // 10 for 10 minutes
        m_energyToday += forage; 
        // Scale the amount of forage removed from the field to the size of the group (1 for non-breeders)
        forage = ScaleForageToGroupsize(forage);
        m_OurPopulationManager->RemoveMaxForageKj( forage, m_MaxIntakeSource.m_maxintakesource, m_myForageIndex );  // Removes kJ from the field 
        if (dtime >= daylength + cfg_goose_AfterDarkTime.value())
        {
                Set_Indivmingooseforagerate( GetGooseMinForageRate(m_myspecies) );  // Okay, we found food today, so reset the minimum acceptable MFR.
            return togs_ToRoost;
        }
        return togs_Forage;
}
//--------------------------------------------------------------------------------------------------------
 
TTypeOfGoose_BaseState Goose_Base::st_ToRoost()
{
        return togs_foobar;
}
//--------------------------------------------------------------------------------------------------------
 
TTypeOfGoose_BaseState Goose_Base::st_Roost()
{
        if ( !m_OurPopulationManager->GetIsDaylight() )
        {
                return togs_Roost;
        }
        if (m_LeaveRoostTime > m_OurPopulationManager->GetDayTime())
        {
                return togs_Roost;
        }
        Set_GooseLeavingRoost( true );  // Indicate that we are coming from the roost. Used to trigger memory initialisation via explore.
        return togs_ChooseForageLocation;
}
//--------------------------------------------------------------------------------------------------------
 
void Goose_Base::Explore()
{
        APoint HopLoc;
        for (int i = 0; i < 1; i++)
        {
                HopLoc = ChooseHopLoc(); // The distance moved is dependent on the species and this is controlled by the inherited ChooseHopLoc code.
        }
        FlyTo( HopLoc );
}
//--------------------------------------------------------------------------------------------------------
 
void Goose_Base::EvaluateForageToHopLoc( APoint a_HopLoc )
{
        double dx = a_HopLoc.m_x - m_Location_x;
        double dy = a_HopLoc.m_y - m_Location_y;
        int dist = g_AlmassMathFuncs.CalcDistPythagoras( a_HopLoc.m_x, a_HopLoc.m_y, m_Location_x, m_Location_y );
        double tx = m_Location_x;
        double ty = m_Location_y;
        // We are looking for big things, so no need to move at 1m steps
        double ddx = (dx/dist)*100;
        double ddy = (dy/dist)*100;
        int lastpoly = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
    for (int d=0; d<dist/100; d++)
        {
                tx += ddx;
                ty += ddy;
                        if (m_OurLandscape->SupplyPolyRef((int)tx, (int)ty) != lastpoly)
                        {
                                lastpoly = m_OurLandscape->SupplyPolyRef((int)tx, (int)ty);
                                int openness = (int)m_OurLandscape->SupplyOpenness(lastpoly); // Score calculated by Landscape::CaclulateOpenness
                                if (openness >= m_GooseMinForageOpenness)
                                {
                                        GooseMemoryLocation aThought;
                                        double grain = m_OurLandscape->SupplyBirdSeedForage(lastpoly); // grain/m2
                                        double maize = m_OurLandscape->SupplyBirdMaizeForage(lastpoly); // kJ/m2
                                        aThought.m_grain = m_OurPopulationManager->GetFeedingRate(grain, m_myspecies); // kJ/min
                                        aThought.m_maize = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies); // kJ/min
                                        aThought.m_grazing = m_OurLandscape->GetActualGooseGrazingForage(lastpoly, m_myspecies); // kJ/min
                                        aThought.m_foodresource = GetMaxIntakeRate(aThought.m_grain, aThought.m_maize, aThought.m_grazing);
                                        if (aThought.m_foodresource > 0)  // don't remember poor food locations
                                        {
                                                aThought.m_polygonid = lastpoly;
                                                aThought.m_x = m_OurLandscape->SupplyCentroidX(lastpoly);
                                                aThought.m_y = m_OurLandscape->SupplyCentroidY(lastpoly);
                                                aThought.m_threat = 0;
                                                int the_dist = g_AlmassMathFuncs.CalcDistPythagorasApprox(m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y);
                                                aThought.m_score = m_MyMemory->CalcScore(the_dist, aThought.m_foodresource, aThought.m_threat);
                                                m_MyMemory->MemAdd(aThought);
                                        }
                                }
                        }
                }
 
}
//--------------------------------------------------------------------------------------------------------
 
void Goose_Base::On_Bang(int a_polyid ) 
{ 
        if (m_CurrentStateNo == -1) return;
        if (!m_MyMemory->ChangeAddThreat(a_polyid, 1.0))
        {
                GooseMemoryLocation aThought;
                aThought.m_polygonid = a_polyid;
                aThought.m_x = m_OurLandscape->SupplyCentroidX(a_polyid);
                aThought.m_y = m_OurLandscape->SupplyCentroidY(a_polyid);
                aThought.m_threat = 1;
                int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y );
                aThought.m_score = m_MyMemory->CalcScore( dist, aThought.m_foodresource, aThought.m_threat );
                m_MyMemory->MemAdd(aThought);
        }
        if (m_myForageIndex != -1)
        {
                m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
        }
        m_myForageIndex = -1;
        CurrentGState = st_ChooseForageLocation();
}
//--------------------------------------------------------------------------------------------------------
 
void Goose_Base::On_Bang(int a_polyid, double a_scare ) 
{ 
        if (m_CurrentStateNo == -1) return;
        if (!m_MyMemory->ChangeAddThreat(a_polyid, a_scare))
        {
                GooseMemoryLocation aThought;
                aThought.m_polygonid = a_polyid;
                aThought.m_x = m_OurLandscape->SupplyCentroidX(a_polyid);
                aThought.m_y = m_OurLandscape->SupplyCentroidY(a_polyid);
                aThought.m_threat = a_scare;
                int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y );
                aThought.m_score = m_MyMemory->CalcScore( dist, aThought.m_foodresource, aThought.m_threat );
                m_MyMemory->MemAdd(aThought);
        }
        if (m_myForageIndex != -1)
        {
                m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
        }
        m_myForageIndex = -1;
        CurrentGState = st_ChooseForageLocation();
}
//--------------------------------------------------------------------------------------------------------
 
void Goose_Base::KillThis()
{
        if (m_myForageIndex != -1)
        {
                m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, 1);
        }
        TAnimal::KillThis(); // Sets CurrentStateNo to -1, and StepDone to true
}
//--------------------------------------------------------------------------------------------------------
 
void Goose_Base::On_Migrate(TTypeOfLeaveReason a_leavereason)
{
        CurrentGState = togs_Die;
        m_OurPopulationManager->RecordLeaveReason(a_leavereason, m_myGooseSpeciesType);
}
//-------------------------
 
 
double Goose_Base::AdjustIntakeRateToSnowDepth(double a_intakerate) {
        if (m_SnowDepth > 0.0) {
                a_intakerate = a_intakerate * (1 - (m_SnowDepth * cfg_goose_snow_scaler.value()));
        }
        return a_intakerate;
}
//-------------------------
 
int Goose_Base::GetForagingTime(int a_EndForagingTime, double a_RoostLeaveTime)
{
        int foraging_time = -1;
        int day_length = m_OurLandscape->SupplyDaylength();
        int roost_leave_time = (int)a_RoostLeaveTime;
        if (roost_leave_time < 0) {
                roost_leave_time = 0;
        }
        // If they never hit their daily max, they are assigned 1440.
        if (a_EndForagingTime == 1440)
        {
                foraging_time = day_length - roost_leave_time;
        }
        else
        {
                foraging_time = a_EndForagingTime - roost_leave_time;
        }
        if (foraging_time == -1)
        {
                m_OurLandscape->Warn("Goose_Base::CalcForagingTime()","error in foraging time calculation");
                exit(0);
        }
        return foraging_time;
}
 
/*********************************************************************************************************/