Goose_Base.h

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.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
 
#ifndef Goose_BaseH
#define Goose_BaseH
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
 
class APoint;
class TAnimal;
class GooseMemoryMap;
class Goose_Base;
class Goose_Population_Manager;
 
//------------------------------------------------------------------------------
//typedef vector<Goose_Base*> TListOfGoose_Base;
//---------------------------------------------------------------------------
 
typedef enum
{
   gst_PinkfootFamilyGroup = 0, 
   gst_PinkfootNonBreeder, 
   gst_BarnacleFamilyGroup, 
   gst_BarnacleNonBreeder, 
   gst_GreylagFamilyGroup, 
   gst_GreylagNonBreeder, 
   gst_foobar 
} GooseSpeciesType;
 
 
typedef enum
{
        togs_InitialState=0, 
        togs_ChooseForageLocation, 
        togs_Forage, 
        togs_ToRoost, 
        togs_Roost, 
        togs_Die, 
        togs_Emigrate, 
        togs_foobar 
} TTypeOfGoose_BaseState;
 
typedef enum
{
        tomis_grass = 0, 
        tomis_sowncrop, 
        tomis_maize, 
        tomis_grain, 
        tomis_foobar 
} TTypeOfMaxIntakeSource;
 
typedef enum
{
        tolr_migration = 0, 
        tolr_bodycondition, 
        tolr_leanweight, 
        tolr_foobar 
} TTypeOfLeaveReason;
 
class TMaxIntakeSource
{
public:
  TTypeOfMaxIntakeSource m_maxintakesource;
  bool m_iscereal;
  TTypesOfVegetation m_veg;
  bool m_instubble;
  TTypesOfVegetation m_prevsowncrop;
};
 
class Goose_Base : public TAnimal
{
protected:
   TTypeOfGoose_BaseState CurrentGState;
   Goose_Population_Manager*  m_OurPopulationManager;
   bool m_sex;
   GooseSpecies m_myspecies;
   GooseSpeciesType m_myGooseSpeciesType;
   APoint m_MyRoost;
   int m_groupsize;
   double m_weight;
   double m_weightTotal;
   int m_forageLocCount;
   double m_BMR;
   double m_DEB;
   double m_DailyMaxAppetite;
   static double m_SnowDepth;
   int m_DailyMaxAppetiteHitTime;
   double m_energyToday;
   TMaxIntakeSource m_MaxIntakeSource;
   double m_LeaveRoostTime;
   bool m_LeavingRoost;
   double m_energyReserve;
   static double m_flightcost;
   double m_Indivmingooseforagerate;
   static double m_mingooseforagerate[ gs_foobar ];
   static double m_GooseForageDist[gs_foobar];
   static double m_GooseForageDistX2[gs_foobar];
   static double m_GooseFieldForageDist[gs_foobar];
   static double m_GooseFieldForageDistX2[gs_foobar];
   static double m_GooseLeavingThreshold;
   static double m_GooseMaxAppetiteScaler;
   static double m_GooseMaxEnergyReserveProportion;
   static double m_GooseKJtoFatConversion;
   static double m_GooseFattoKJConversion;
   static double m_GooseMinForageOpenness;
   double m_BodyCondition[5];
   double m_TheBodyCondition; 
   unsigned m_BodyConditionCounter;
   int m_myForageIndex;
   int m_myMemPolyID;
   GooseMemoryMap* m_MyMemory;
   static int m_followinglikelyhood[ (int)gst_foobar ];
   int m_FlightNumber;
   int m_FlightDistance;
      
public:
        Goose_Base(Landscape* p_L, Goose_Population_Manager* p_NPM, double a_weight, bool a_sex, APoint a_roost);
        void Init(Goose_Population_Manager* p_NPM, double a_weight, bool a_sex, APoint a_roost);
        void ReInit(Landscape* p_L, Goose_Population_Manager* p_NPM, double a_weight, bool a_sex, APoint a_roost);
        virtual ~Goose_Base();
   void st_Dying( void );
   void Explore();
   TTypeOfGoose_BaseState st_Forage();
   virtual TTypeOfGoose_BaseState st_ToRoost();
   APoint GetRoost() { return m_MyRoost; }
   TMaxIntakeSource GetMaxIntakeSource() {
           return m_MaxIntakeSource;
   }
   virtual void ChangeRoost() { ; }
   TTypeOfGoose_BaseState st_Roost();
   virtual APoint ChooseHopLoc() { return m_MyRoost; }  
   void EvaluateForageToHopLoc( APoint a_HopLoc );
   virtual void StartDay(void);
   virtual void BeginStep(void) { StartDay(); }
   virtual void Step(void);
   virtual void EndStep(void) {} // NB this is not used in the Goose_Base code
   virtual void On_Emigrate() 
   {
           CurrentGState = togs_Emigrate; 
   }
   double GetBodyCondition() { return m_TheBodyCondition; }
   void SetBodyCondition(double a_condition, unsigned a_index) { m_BodyCondition[a_index] = a_condition; }
   void AddBodyCondition(double a_condition) { m_TheBodyCondition += a_condition; }
   void SubtractBodyCondition( double a_condition) { m_TheBodyCondition -= a_condition; }
   int GetGroupsize() { return m_groupsize; }
   double ScaleForageToGroupsize(double a_forage) { return m_groupsize * a_forage; }
   int GetForageLocIndex() { return m_myForageIndex; }
   GooseSpecies GetSpecies() {
           return m_myspecies;
   }
   bool GetSex() { return m_sex; }
   int GetMaxAppetiteHitTime() {
           return m_DailyMaxAppetiteHitTime;
   }
   int GetFlightNumber() {
           return m_FlightNumber;
   }
   int GetFlightDistance() {
           return m_FlightDistance;
   }
   double GetDailyEnergyBudget() {
           return m_DEB;
   }
   double GetDailyEnergyExpenditure() {
           return m_energyToday;
   }
   int GetForagingTime(int a_EndForagingTime, double a_RoostLeaveTime);
   double GetGooseMinForageRate(GooseSpecies a_species)
   {
       return m_mingooseforagerate[a_species];
   }
   double GetMaxForageRate(double a_grain, double a_maize, double a_grass, double a_interferenceComp, bool a_iscereal, TTypesOfVegetation a_veg, bool a_stubble, TTypesOfVegetation a_prevcrop) {
           double MaxRate = 0.0;
           if (a_grain > MaxRate) {
                   MaxRate = a_grain;
                   m_MaxIntakeSource.m_maxintakesource = tomis_grain;
           }
           else if (a_maize > MaxRate) {
                   MaxRate = a_maize;
                   m_MaxIntakeSource.m_maxintakesource = tomis_maize;
           }
           else if (a_grass > MaxRate) {
                   MaxRate = a_grass;
                   if (a_iscereal == false) m_MaxIntakeSource.m_maxintakesource = tomis_grass; else m_MaxIntakeSource.m_maxintakesource = tomis_sowncrop;
           }
           else
           {
                   MaxRate = 0;
                   m_MaxIntakeSource.m_maxintakesource = tomis_foobar;
           }
           MaxRate *= a_interferenceComp;
           MaxRate = AdjustIntakeRateToSnowDepth(MaxRate);
           m_MaxIntakeSource.m_iscereal = a_iscereal;
           m_MaxIntakeSource.m_instubble = a_stubble;
           m_MaxIntakeSource.m_veg = a_veg;
           m_MaxIntakeSource.m_prevsowncrop = a_prevcrop;
           /**** CJT DEBUG ****
           if ((a_stubble) && (!a_iscereal) && (m_MaxIntakeSource.m_maxintakesource == tomis_grain))
           {
                   g_msg->WarnAddInfo(WARN_BUG, "Day ", m_OurLandscape->SupplyDayInYear());
                   g_msg->WarnAddInfo(WARN_BUG, "Veg ", a_veg);
                   g_msg->WarnAddInfo(WARN_BUG, "Prev Crop ", a_prevcrop);
                   g_msg->WarnAddInfo(WARN_BUG, "Grain ", a_grain);
                   g_msg->WarnAddInfo(WARN_BUG, "******** ", 0);
           }
           //**** END ****/
                   
                   
                   return MaxRate;
   }
 
   double GetMaxIntakeRate( double a_grain, double a_maize, double a_grass) {
           double MaxRate = 0.0;
           if (a_grain > MaxRate) {
                   MaxRate = a_grain;
           }
           if (a_maize > MaxRate) {
                   MaxRate = a_maize;
           }
           if (a_grass > MaxRate) {
                   MaxRate = a_grass;
           }
           return MaxRate;
   }
   void SetSex( bool a_sex ) {
           m_sex = a_sex;
   }
   double GetTotalWeight() {return m_weightTotal;}
   double GetRoostLeaveTime() { return m_LeaveRoostTime; }
   void SetFlightCost(double a_cost) { m_flightcost = a_cost; }
   double GetFlightCost() {
           return m_flightcost * m_weightTotal;
   }
   void Set_mingooseforagerate(double a_cost, GooseSpecies a_species) { m_mingooseforagerate[a_species] = a_cost; }
   void Set_Indivmingooseforagerate( double a_cost) {
           m_Indivmingooseforagerate = a_cost;
   }
   void Set_GooseLeavingThreshold(double a_threshold) { m_GooseLeavingThreshold = a_threshold; }
   void Set_GooseMaxAppetiteScaler(double a_cost) { m_GooseMaxAppetiteScaler = a_cost; }
   void Set_GooseMaxEnergyReserveProportion(double a_prop) { m_GooseMaxEnergyReserveProportion = a_prop; }
   void Set_GooseKJtoFatConversion(double a_cost) { m_GooseKJtoFatConversion = a_cost; }
   void Set_GooseFattoKJConversion(double a_cost) { m_GooseFattoKJConversion = a_cost; }
   void Set_GooseMinForageOpenness(double a_cost) { m_GooseMinForageOpenness = a_cost; }
   void Set_GooseForageDist(double sp1, double sp2, double sp3) 
   { 
           //Dist
           m_GooseForageDist[gs_Pinkfoot] = sp1;
           m_GooseForageDist[gs_Barnacle] = sp2;
           m_GooseForageDist[gs_Greylag] = sp3;
           // DistX2
           m_GooseForageDistX2[gs_Pinkfoot] = sp1 * 2.0;
           m_GooseForageDistX2[gs_Barnacle] = sp2 * 2.0;
           m_GooseForageDistX2[gs_Greylag] = sp3 * 2.0;
   }
   void Set_GooseFieldForageDist(double sp1, double sp2, double sp3)
   {
           //Dist
           m_GooseFieldForageDist[gs_Pinkfoot] = sp1;
           m_GooseFieldForageDist[gs_Barnacle] = sp2;
           m_GooseFieldForageDist[gs_Greylag] = sp3;
           // DistX2
           m_GooseFieldForageDistX2[gs_Pinkfoot] = sp1 * 2.0;
           m_GooseFieldForageDistX2[gs_Barnacle] = sp2 * 2.0;
           m_GooseFieldForageDistX2[gs_Greylag] = sp3 * 2.0;
   }
   void Set_GooseFollowingLikelyhood( int a_likelyhood, GooseSpeciesType a_speciestype) { m_followinglikelyhood[a_speciestype] = a_likelyhood;}
   void Set_GooseLeavingRoost( bool a_leaving) {m_LeavingRoost = a_leaving;}
   void On_MoveTo(int a_x, int a_y ) { FlyTo( a_x, a_y); }
   virtual void KillThis();
   void On_Bang(int a_polyid );
   void On_Bang(int a_polyid, double a_scare );
   void On_Migrate(TTypeOfLeaveReason a_leavereason);
   double AdjustIntakeRateToSnowDepth(double a_intakerate);
protected:
        TTypeOfGoose_BaseState st_ChooseForageLocation( void );
        void FlyTo(int a_x, int a_y );
        void FlyTo( APoint a_pt );
 };
 
#endif