bembidion_all.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, 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 Bembidion_allH
#define Bembidion_allH
 
//---------------------------------------------------------------------------
 
extern const char* SimulationName;
 
typedef enum
{
  tobs_Initiation=0,
// Egg
  tobs_EDeveloping,
  tobs_Hatching,
  tobs_EDying,
// Larva
  tobs_LDeveloping,
  tobs_Pupating,
  tobs_LDying,
// Pupa
  tobs_PDeveloping,
  tobs_Emerging,
  tobs_PDying,
// Adult
  tobs_Foraging,
  tobs_Aggregating,
  tobs_Hibernating,
  tobs_Dispersing,
  tobs_ADying,
// Destroy
  tobs_Destroy,
} TTypesOfBeetleState;
 
//------------------------------------------------------------------------------
 
typedef enum
{
    bob_Egg = 0,
    bob_Larva,
    bob_Pupa,
    bob_Adult
} BeetleObjects;
 
//------------------------------------------------------------------------------
 
typedef vector<APoint> TListOfEggs;
 
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// Forward Declarations
 
class Bembidion_Population_Manager;
class Landscape;
class MovementMap;
class SimplePositionMap;
 
 
 
//------------------------------------------------------------------------------
/* Not used
class ListOfPositions
{
 public:
  int locs[2][30];
  int NoLocs;
};
//------------------------------------------------------------------------------
*/
class param_Point
{
 public:
  int x;
  int y;
  unsigned direction;
};
//------------------------------------------------------------------------------
 
class param_List15
{
 public:
  int BeenThereX[101];
  int BeenThereY[101];
  int nsteps;
};
//------------------------------------------------------------------------------
 
class struct_Bembidion
{
 public:
  int DayDegrees;
  int x;
  int y;
  Landscape* L;
  Bembidion_Population_Manager * BPM;
  int HowMany;
};
//------------------------------------------------------------------------------
 
class CompareEggX {
public:
  bool operator() ( APoint A1, APoint A2 ) const {
      return (A1.m_x > A2.m_x);
  }
};
//------------------------------------------------------------------------------
 
class Bembidion_Base : public TAnimal
{
public:
    Bembidion_Base( int x, int y, Landscape* L,
        Bembidion_Population_Manager* BPM );
    void ReInit( int x, int y, Landscape* L, Bembidion_Population_Manager* BPM );
    virtual void BeginStep(){}
    virtual void Step(){}
    virtual void EndStep(){}
    virtual void st_Die();
 // Attributes
    TTypesOfBeetleState CurrentBState;
    Bembidion_Population_Manager * m_OurPopulation;
    void CopyMyself(int a_beetle);
    void CopyMyselfB(int a_beetle);
};
//------------------------------------------------------------------------------
class Bembidion_Egg_List : public Bembidion_Base
{
 
public:
    Bembidion_Egg_List(int today,Bembidion_Population_Manager* BPM, Landscape* L);
    virtual void Step();
    virtual void BeginStep();
    void AddEgg(int x, int y) {
      APoint E;
      E.m_x=x;
      E.m_y=y;
      EggList.push_back(E);
    };
    void DeleteEgg(int x, int y); // Very slow do not use unless absolutely necessary
    TListOfEggs EggList;
protected:
    int st_Develop();
    void st_Hatch();
    void DailyMortality();
 // Attributes
    int m_DayMade;
    // The list of eggs is in a vector of type APoint
    void SortXR();
};
//------------------------------------------------------------------------------
 
class Bembidion_Larvae : public Bembidion_Base {
public:
    Bembidion_Larvae( int x, int y, Landscape* L, Bembidion_Population_Manager* BPM );
    void ReInit( int x, int y, Landscape* L, Bembidion_Population_Manager* BPM );
    virtual void BeginStep();
    virtual void Step();
    virtual void KillThis();
protected:
    int  st_Develop();
    void st_Pupate();
    virtual bool DailyMortality();
    virtual bool OnFarmEvent( FarmToDo event );
    inline bool TempRelatedLarvalMortality( int temp2 );
    // Attributes
    double m_AgeDegrees;
    int m_LarvalStage;
    int m_DayMade;
 
};
//------------------------------------------------------------------------------
 
class Bembidion_Pupae : public Bembidion_Base
{
public:
    Bembidion_Pupae(int x, int y, Landscape* L,
                              Bembidion_Population_Manager* BPM);
 
    void ReInit( int x, int y, Landscape* L, Bembidion_Population_Manager* BPM );
    virtual void BeginStep();
    virtual void Step();
    virtual void KillThis();
protected:
    int st_Develop();
    void st_Emerge();
    virtual bool DailyMortality();
    virtual bool OnFarmEvent(FarmToDo event);
 // Attributes
    double m_AgeDegrees;
    int m_DayMade;
 
};
//------------------------------------------------------------------------------
class Bembidion_Adult : public Bembidion_Base
{
public:
    Bembidion_Adult(int x, int y, Landscape* L,
                                            Bembidion_Population_Manager* BPM);
    void ReInit( int x, int y, Landscape* L, Bembidion_Population_Manager* BPM );
    virtual ~Bembidion_Adult();
    virtual void Step();
    virtual void BeginStep();
    virtual void EndStep();
    void SetBodyBurden(double a_pcide) { m_body_burden = a_pcide; }
    void SetPPPThreshold(double a_thresh) { m_PPPThreshold = a_thresh; }
    void SetPPPEffectProb(double a_conc) { m_PPPEffectProb = a_conc; }
    void SetPPPEffectProbDecay(double a_decay) { m_PPPEffectProbDecay = a_decay; }
    void SetAdultPPPElimRate(double a_rate) { m_AdultPPPElimRate = a_rate; }
protected:
    void Init();
    int st_Forage();
    int st_Aggregate();
    int st_Hibernate();
    int st_Dispersal();
    bool st_Aging();
    bool WinterMort();
    bool DDepMort();
    int DailyMovement(int p_distance, bool disp_aggreg);
    void MoveTo(int p_dist, unsigned p_direction, int p_turning);
    inline int MoveTo_quality_assess();
    int MoveToAggr(int p_dist, unsigned p_direction, int p_turning);
    void Reproduce(int p_x, int p_y);
    void CanReproduce();
    virtual bool DailyMortality();
    virtual bool OnFarmEvent(FarmToDo event);
    virtual void InternalPesticideHandlingAndResponse();
  // Attributes
    double m_negDegrees;
    double m_HibernateDegrees;
    //double OldBest;
    int OldDirection;
    int m_EggCounter;
    bool m_CanReproduce;
    static param_List15 pList;
    static param_Point pPoint;
    static double m_AdultPPPElimRate;
    double m_body_burden;
    double m_currentPPPEffectProb;
    static double m_PPPThreshold;
    static double m_PPPEffectProb;
    static double m_PPPEffectProbDecay;
 
};
//------------------------------------------------------------------------------
 
class Bembidion_Population_Manager: public Population_Manager
{
 public:
   void CreateObjects(int ob_type, TAnimal *pvo,void* null ,
                                         struct_Bembidion * data,int number);
    virtual void Init (void);
   virtual void DoFirst (void);
   virtual void DoBefore (void);
   virtual void DoAlmostLast (void);
   virtual void DoLast (void);
   virtual float Probe(int ListIndex,probe_data* p_TheProbe );
   Bembidion_Population_Manager(Landscape* p_L);
   virtual ~Bembidion_Population_Manager();
   int SupplyAdPopSize() {return m_AdPopSize;}
   int SupplyEggPopSize() {return m_EPopSize;}
   int SupplyLarvaePopSize() {return m_LPopSize;}
   int SupplyPupaePopSize() {return m_PPopSize;}
   double SupplyEDayDeg(int day) { return m_EDayDeg[day];}
   double SupplyLDayDeg(int L, int day) { return m_LDayDeg[day][L];}
   double SupplyPDayDeg(int day) { return m_PDayDeg[day];}
 protected:
   virtual void Catastrophe();
   virtual void TheRipleysOutputProbe(FILE* a_prb);
   virtual void TheReallyBigOutputProbe();
   virtual void TheAOROutputProbe(  );
    bool IsStartHabitat(int a_x, int a_y);
#ifdef __BEETLEPESTICIDE1
 
    void LocOutputError( void );
    void LocOutputOpen( void );
    void DoInFieldLocationOutput();
#endif
#ifdef __RECORD_RECOVERY_POLYGONS
 
   void RecordRecoveryPolygons();
   int m_RecoveryPolygons[101];
   int m_RecoveryPolygonsC[101];
#endif
 
 
//Attributes
 protected:
    Landscape* The_Landscape;
   int m_AdPopSize;
   int m_EPopSize;
   int m_LPopSize;
   int m_PPopSize;
   double m_EDayDeg[365];
   double m_LDayDeg[365][3];
   double m_PDayDeg[365];
 public:
   MovementMap* m_MoveMap;
   SimplePositionMap* m_LarvaePosMap;  //   Modified ***CJT*** 26-05-2009
   SimplePositionMap* m_AdultPosMap;  //   Modified ***CJT*** 26-05-2009
   int LDDepMort0; // Must be range 1-8
   double LDDepMort1; // 0-100
   int ADDepMort0; //
   double ADDepMort1; // 0-100
   int TodaysEggProduction;
   Bembidion_Egg_List* m_EList[365];
 
#ifdef __BEETLEPESTICIDE1
protected:
    int m_InFieldNo;
    int m_InCropNo;
    int m_OffFieldNo;
    TTypesOfVegetation m_InCropRef;
    void incInField() { m_InFieldNo++; }
    void incInCrop() { m_InCropNo++; }
    void incOffField() { m_OffFieldNo++; }
    void PestMortLocOutputOpen( void );
    void PestMortLocOutput( void );
    void PestMortLocOutputError( void );
public:
    void RecordPesticideMortLoc(int a_x, int a_y)
    {
        // Need to get the element type, if a field need to check the crop
        TTypesOfLandscapeElement tole = m_TheLandscape->SupplyElementType(a_x, a_y);
        if  (tole == tole_Orchard) incInCrop();
        else if  (tole == tole_Field)
        {
            if (m_TheLandscape->SupplyVegType(a_x, a_y) == m_InCropRef) incInCrop(); 
            else incInField();
        } else 
        {   
            incOffField();
        }
    }
#endif
 
};
 
 
 
#endif