Goose Management Model ODdox  1.02
elements.h
Go to the documentation of this file.
1 //
2 // elements.h
3 //
4 /*
5 *******************************************************************************************************
6 Copyright (c) 2011, Christopher John Topping, University of Aarhus
7 All rights reserved.
8 
9 Redistribution and use in source and binary forms, with or without modification, are permitted provided
10 that the following conditions are met:
11 
12 Redistributions of source code must retain the above copyright notice, this list of conditions and the
13 following disclaimer.
14 Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
15 the following disclaimer in the documentation and/or other materials provided with the distribution.
16 
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
18 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
19 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
20 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
22 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 ********************************************************************************************************
26 */
27 
28 #ifndef ELEMENTS_H
29 #define ELEMENTS_H
30 
31 #define FMDEBUG
32 #include <fstream>
33 extern class Landscape * g_landscape_p;
34 
35 class APoint;
36 
37 typedef unsigned int LE_Signal;
38 
39 static CfgBool l_el_read_bug_percentage_file("ELEM_READ_BUG_PERCENTAGE_FILE", CFG_CUSTOM, false);
40 static CfgStr l_el_bug_percentage_file("ELEM_BUG_PERCENTAGE_FILE", CFG_CUSTOM,"bugpercents.txt");
41 
42 #define LE_SIG_NO_FUNGICIDE 0x0001
43 #define LE_SIG_NO_INSECTICIDE 0x0002
44 #define LE_SIG_NO_SYNG_INSECT 0x0004
45 #define LE_SIG_NO_GROWTH_REG 0x0008
46 #define LE_SIG_NO_MOLLUSC 0x0010
47 #define LE_SIG_NO_HERBICIDE 0x0020
48 
49 // Number of user defined storage locations for farm management
50 // states. For ridiculously active farm management plans this
51 // might have to be increased. Ie. bump this number if there is
52 // a chance of more than 10 farm events for an given polygon on
53 // any given day.
54 #define EL_MAX_USERSPACE 10 // Has to be a #define.
55 
56 // Decay time for treatment generated tramlines (in days).
57 #define EL_TRAMLINE_DECAYTIME (g_el_tramline_decaytime_days.value())
59 // Delay time before regrowth of weeds after herbicide treatment.
60 #define EL_HERBICIDE_DELAYTIME (g_el_herbicide_delaytime_days.value())
61 #define EL_STRIGLING_DELAYTIME (g_el_strigling_delaytime_days.value())
64 
65 
66 // Will be declared in other .h files, but these are needed here to break circular class definitions.
67 class Farm;
68 extern class LE_TypeClass *g_letype;
69 
71 {
72  public:
74  TTypesOfVegetation TranslateVegTypes(int VegReference);
75 
77  int BackTranslateVegTypes(TTypesOfVegetation VegReference);
78  int VegTypeToCurveNum( TTypesOfVegetation VegReference);
79 };
80 
81 class LE {
82 public:
83  LE(void);
84  virtual ~LE( void );
90  //double m_volegrazing;
91  // /** \brief Variable used to reduce the grazing pressure */
92  //double m_voleResregrowth;
94  //double m_volegrazingDensity;
96  //void AddVoleGrazing(int a_number) { m_volegrazing+=a_number; }
98  //double GetVoleGrazing( void ) {return m_volegrazing; }
100  //void CalcVoleGrazingDensity( void ) { m_volegrazing *= m_voleResregrowth; m_volegrazingDensity = (m_volegrazing/m_area); }
102  //double GetVoleGrazingDensity( void ) {return m_volegrazingDensity; }
105  long m_user[ EL_MAX_USERSPACE ];
106  bool m_repeat_start;
107  LE_Signal GetSignal( void ) { return m_signal_mask; }
108  void SetSignal( LE_Signal a_signal ) { m_signal_mask = a_signal; }
109  int GetSubType( void ) { return m_subtype; }
110  void SetSubType( int a_subtype ) { m_subtype = a_subtype; }
111  int GetALMaSSEleType(void) { return m_almass_le_type; }
112  void SetALMaSSEleType(int a_type) { m_almass_le_type = a_type; }
113  virtual TTypesOfLandscapeElement GetElementType( void ) { return m_type; }
114  void SetElementType( int a_type ) { m_type = (TTypesOfLandscapeElement) a_type; }
115  void Trace( int a_value );
116  void ResetTrace( void );
117  long GetRunNum( void ) { return m_running; }
118  void BumpRunNum( void ) { m_running++; }
119  long GetMgtLoopDetectDate ( void ) { return m_management_loop_detect_date; }
120  void SetMgtLoopDetectDate ( long a_num ) { m_management_loop_detect_date = a_num; }
121  long GetMgtLoopDetectCount ( void ) { return m_management_loop_detect_count; }
122  void SetMgtLoopDetectCount ( long a_num ) { m_management_loop_detect_count = a_num; }
123  void Tick( void );
124  virtual TTypesOfVegetation
125  GetVegType( void ) { return tov_None; }
126  int GetVegStore( void ) { return m_vege_danger_store; }
127  void SetVegStore( int a_veg )
128  { m_vege_danger_store = a_veg; }
129  void ZeroVegAge() { m_vegage=0; }
130  int GetVegAge() { return m_vegage; }
131  virtual void DoDevelopment( void );
132  virtual void RecalculateBugsNStuff( void ) { }
133  virtual int GetVegPhase(void) { return vegphase_foobar; }
134  virtual double GetVegCover(void) { return 0.0; }
135  virtual double GetVegHeight( void ) { return 0.0; }
136  virtual APoint GetCentroid();
137  virtual int GetCentroidX() { return m_centroidx; }
138  virtual int GetCentroidY() { return m_centroidy; }
139  virtual void SetCentroid(int x, int y) { m_centroidx=x; m_centroidy=y; }
140  virtual double GetDigestability( void ) { return 0.0; }
141  virtual int GetVegDensity( void ) { return 0; }
142  virtual bool GetSkScrapes( void ) { return false; }
143  virtual bool IsMatureCereal() { return false; }
144  virtual bool IsCereal() { return false; }
145  virtual bool IsGrass() { return false; }
146  virtual bool GetVegPatchy(void) { return false; }
147  //virtual void SetVegPatchy( bool p ) { ;}
148  virtual void SetVegPatchy( bool /* p */ ) { ;}
149  virtual double GetDayDegrees( void ) { return m_ddegs; }
150  virtual double GetLAGreen( void ) { return 0.0; }
151  virtual double GetLATotal( void ) { return 0.0; }
152  virtual double GetGreenBiomass( void ) { return 0.0; }
153  virtual double GetDeadBiomass( void ) { return 0.0; }
154  virtual double GetVegBiomass( void ) { return 0.0; }
155  virtual double GetWeedBiomass( void ) { return 0.0; }
156  virtual double GetInsectPop( void ) { return 0.0; }
157  virtual void SetInsectPop( double /* i */ ) { ; }
158  virtual void Insecticide( double /* a_fraction */ ) { ; }
159  virtual void InsectMortality( double /* a_fraction */ ) { ; }
160  virtual void ReduceWeedBiomass( double /* a_fraction */ ) { ; }
161  virtual void ToggleCattleGrazing( void ) {;}
162  virtual void TogglePigGrazing( void ) {;}
163  virtual void SetVegBiomass( int /* a_biomass */ ) {;}
164  virtual void SetVegType( TTypesOfVegetation /* a_type */, TTypesOfVegetation /* a_weed_type */ ) {;}
165  virtual void SetVegHeight(double /* a_height */) { ; }
166  virtual void SetVegParameters(double /* a_height */, double /* a_LAtotal */, double /* a_LAgreen */, double /* a_WeedBiomass */) { ; }
167  virtual void SetCropData(double, double, double, TTypesOfVegetation, double, int) { ; }
168  virtual void SetCropDataAll(double,double,double, double,TTypesOfVegetation, double, double , int, double , bool, double) {;}
169  virtual void StoreLAItotal() {;}
170  virtual void SetGrowthPhase( int /* a_phase */ ) {;}
171  virtual void ForceGrowthInitialize( void ) {;}
172  virtual void ForceGrowthTest( void ) {;}
173  virtual void ForceGrowthDevelopment( void ) {;}
174  virtual void ZeroVeg( void ) {;}
175  virtual void ReduceVeg( double /* a_reduc */ ) {;}
176  virtual void ReduceVeg_Extended(double /* a_reduc */) { ; }
177  virtual void GrazeVeg_Extended(double /* a_reduc */) { ; }
178  virtual double GetTrafficLoad(void) { return 0.0; }
179  virtual TTypesOfVegetation GetPreviousCrop(int /* a_index */) { return tov_None; }
180  bool GetPoison( void ) { return m_poison; }
181  void SetPoison( bool a_poison ) { m_poison = a_poison; }
182  bool GetHigh( void ) { return m_high; }
183  int GetCattleGrazing( void ) { return m_cattle_grazing; }
184  bool GetPigGrazing( void ) { return m_pig_grazing; }
185  bool HasTramlines( void ) { return ( m_tramlinesdecay>0 ); }
186  bool IsRecentlyMown( void ) { return ( m_mowndecay>0 ); }
187  int IsRecentlySprayed( void ) { return ( m_herbicidedelay ); }
189  int GetPoly( void ) { return m_poly; }
190  int GetMapIndex( void ) { return m_map_index; }
191  void SetMapIndex( int a_map_index ) { m_map_index = a_map_index; }
192  int GetOwnerFile( void ) { return m_owner_file; }
193  int GetOwnerIndex( void ) { return m_owner_index; }
194  int GetLastTreatment( int *a_index );
195  Farm* GetOwner( void ) { return m_owner; }
196  double GetArea( void ) { return m_area; }
197  double GetGooseGrazingForage(GooseSpecies a_goose) { return m_goosegrazingforage[a_goose]; }
198  double GetBirdSeed( void ) {
199  return m_birdseedforage;
200  }
201  void SetBirdSeed( double a_forage ) {
202  m_birdseedforage = a_forage;
203  }
204  double GetBirdMaize(void) {
205  return m_birdmaizeforage;
206  }
207  /*
208  double GetIsCereal(void) {
209  if ( m_goosegrazingforage[gs_foobar] == 1) return true;
210  return false;
211  }
212 */
213  void SetBirdMaize( double a_forage ) {
214  m_birdmaizeforage = a_forage;
215  }
217  void SetCountryDesignation( int a_designation ) { m_countrydesignation = a_designation; }
218  long GetOldDays( void ) { return m_olddays; }
219  void SetOwner( Farm *a_owner, int a_owner_num, int a_owner_index )
220  {
221  m_owner = a_owner;
222  m_owner_file = a_owner_num;
223  m_owner_index = a_owner_index;
224  }
225  void SetHigh( bool a_high ) { m_high = a_high; }
226  void SetPoly( int a_poly ) { m_poly = a_poly; }
227  void SetMapValid( bool a_valid ) { m_is_in_map = a_valid; }
228  bool GetMapValid( void ) { return m_is_in_map; }
229  void SetArea( double a_area ) { m_area = a_area; }
231  virtual void GrazeVegetation( double /* m_grams */, bool )
232  {
233  ;
234  }
236  virtual void GrazeVegetationTotal( double /* m_grams */ )
237  {
238  ;
239  }
241  int GetSoilType( ) {
259  return m_soiltype;
260  }
262  int GetSoilTypeR( ) {
267  switch (m_soiltype)
268  {
269  case 0: return 3;
270  case 1: return 1;
271  case 2: return 3;
272  case 3: return 3;
273  case 4: return 0;
274  case 5: return 1;
275  case 6: return 0;
276  case 7: return 0;
277  case 8: return 1;
278  case 9: return 0;
279  case 10: return 0;
280  case 11: return 0;
281  case 12: return 0;
282  case 13: return 3;
283  default:
284  return 3;
285  }
286  }
287  void SetSoilType( int a_st ) {
288  m_soiltype = a_st;
289  }
294  m_lastsownvegtype = a_tov;
295  }
300  return m_lastsownvegtype;
301  }
302  void SetLastTreatment(int a_treatment);
303  void SetSprayedToday(bool a_didit) { m_sprayedtoday = a_didit; }
304  bool GetSprayedToday() { return m_sprayedtoday; }
305  void SetCopyTreatment(int a_treatment);
306  void SetOldDays( long a_days ) { m_olddays = a_days; }
307  void SetRotIndex( int a_index ) { m_rot_index = a_index; }
308 
309  int GetRotIndex( void ) { return m_rot_index; }
310  void SetTramlinesDecay( int a_decaytime_days )
311  { m_tramlinesdecay = a_decaytime_days; }
312  void SetHerbicideDelay( int a_decaytime_days )
313  { m_herbicidedelay = a_decaytime_days; }
314  void SetMownDecay( int a_decaytime_days )
315  { m_mowndecay = a_decaytime_days; }
316  void AddArea( double a_area_diff ) { m_area += a_area_diff; }
317  LE* GetBorder( void ) { return m_border; }
318 // LE* GetUnsprayedMargin( void ) { return m_unsprayedmargin; }
320  void SetBorder( LE* a_border ) { m_border = a_border; }
321 // void SetUnsprayedMargin( LE* a_unsprayedmargin ) { m_unsprayedmargin = a_unsprayedmargin; }
322  void SetUnsprayedMarginPolyRef( int a_unsprayedmargin ) { m_unsprayedmarginpolyref = a_unsprayedmargin; }
323  void SetPesticideCell( int a_cell ) { m_PesticideGridCell = a_cell; }
325  void SetValidXY( int a_valid_x, int a_valid_y )
326  {
327  m_valid_x = a_valid_x;
328  m_valid_y = a_valid_y;
329  }
330  int GetValidX( void ) { return m_valid_x; }
331  int GetValidY( void ) { return m_valid_y; }
332 
333  int GetMaxX( void ) { return m_maxx; }
334  int GetMaxY( void ) { return m_maxy; }
335  int GetMinX( void ) { return m_minx; }
336  int GetMinY( void ) { return m_miny; }
337  void SetMaxX( int x ) { m_maxx=x; }
338  void SetMaxY( int y ) { m_maxy=y; }
339  void SetMinX( int x ) { m_minx=x; }
340  void SetMinY( int y ) { m_miny=y; }
341  int GetMDates(int a, int b) {return MDates[a][b];}
342  void SetMDates(int a, int b, int c) {MDates[a][b]=c;}
343  int GetMConstants(int a) {return MConsts[a];}
344  void SetMConstants(int a, int c) {MConsts[a]=c;}
346  double GetVegDDegs() {
347  return m_vegddegs; //
348  }
350  int GetOpenness( void ) { return m_openness; }
352  void SetGooseNos(int a_number, int a_day) { m_gooseNos[a_day] = a_number; }
354  void SetGooseSpNos(int a_number, int a_day, GooseSpecies a_goose) {
355  m_gooseSpNos[a_day][a_goose] = a_number;
356  }
358  void SetGooseNosTimed(int a_number, int a_day) { m_gooseNosTimed[a_day] = a_number; }
360  void SetGooseSpNosTimed(int a_number, int a_day, GooseSpecies a_goose) {
361  m_gooseSpNosTimed[a_day][a_goose] = a_number;
362  }
364  void SetGooseRoostDist(int a_dist, GooseSpecies a_goose) { m_dist_to_closest_roost[a_goose] = a_dist; }
366  int GetGooseNosToday();
368  int GetGooseNosTodayTimed();
370  int GetGooseNos( );
372  int GetQuarryNos();
374  int GetGooseSpNosToday(GooseSpecies a_goose);
376  int GetGooseSpNosTodayTimed(GooseSpecies a_goose);
378  int GetGooseRoostDist(GooseSpecies a_goose);
380  void SetOpenness( int a_openness ) { m_openness=a_openness; }
382  virtual void ResetDigestability() { ; }
384  void DoCopy(const LE* a_Le);
386  virtual void SetMaleNewtPresent(bool) { ; };
388  virtual bool IsMaleNewtPresent() { return false; };
390  void SetStubble(bool a_flag) { m_instubble = a_flag; }
392  bool GetStubble() { return m_instubble; }
393  /* *********************** Bee Helper Methods *********************** */
395  bool GetOsmiaNest() {
396  if ((m_currentOsmiaNests < m_maxOsmiaNests) && (g_rand_uni() < m_OsmiaNestProb)) return true;
397  return false;
398  }
399 
403  }
404 
407  {
408  if (m_maxOsmiaNests <= 0) m_OsmiaNestProb = 0.0;
409  else {
411  }
412  }
413 
416  {
418  }
419 
421  void SetMaxOsmiaNests(double a_noNests)
422  {
423  m_maxOsmiaNests = int(a_noNests * m_area);
424  if (m_maxOsmiaNests < 1) m_maxOsmiaNests = 0;
425  }
426  /* ********************* End Bee Helper Methods ********************* */
427 
429  void SetPollenNectarData(int a_almasstype);
432  virtual double GetTotalPollen() { return m_totalPollen; }
433  virtual double GetTotalNectar() { return m_totalNectar; }
436  m_pollencurve = a_pollencurnve;
437  m_nectarcurve = a_nectarcurve;
438  }
439 protected:
440 #ifdef FMDEBUG
441  int m_ptrace[256]; // Change bitmap in 'elements.cpp' if this
442  int m_pdates[256]; // needs to be increased!
443  int m_pindex; // Points to the next *empty* location, so last
444  // program step is in the location below this...
445 #endif
446  long m_running;
449  // May be -1 if no unsprayed margin or this element is a margin!
450  // Valid map coordinate inside this landscape element
451  // before(!) adding the border.
458  // Whether this polygon is actually mentioned in the main map.
460  // Quick hack to discern different hedgebank types.
462  int m_maxx;
463  int m_minx;
464  int m_maxy;
465  int m_miny;
466  long m_olddays;
477  int m_poly;
478  // Copy of the index stored in the main map at run time.
479  // Needed by the pesticide machinery.
489  double m_area;
491  int m_gooseNos[366];
493  int m_gooseSpNos[366][gs_foobar];
495  int m_gooseNosTimed[366];
497  int m_gooseSpNosTimed[366][gs_foobar];
505  double m_goosegrazingforage[ gs_foobar ];
511  double m_dist_to_closest_roost[gs_foobar];
512  int m_vegage;
515  bool m_high;
516  bool m_poison;
520  double m_vegddegs; // Total of day degrees for the crop/veg on this element.
521  double m_yddegs; // Yesterdays total of day degrees for this element.
522  double m_ddegs; // Total of day degrees for this element when today
523  // is taken into consideration.
524  vector <int> m_lasttreat;
525  unsigned int m_lastindex;
526  // Only one copy of these is stored for use by all landscape elements.
527  static double m_monthly_traffic[];
528  static double m_largeroad_load[];
529  static double m_smallroad_load[];
530  int MDates[2][25];
531  int MConsts[10];
543  double m_PollenM2;
544  double m_NectarM2;
549 };
550 
551 //---------------------------------------------------------------------------
552 
556  bool taken;
559  bool harvested;
560  double area;
561  int no_herb_app; //number of herbicide applications
565 };
566 
567 
568 class VegElement : public LE {
569 public:
570  VegElement( void );
571  virtual ~VegElement( void ) { ; };
572  virtual void DoDevelopment( void );
573  virtual double GetDigestability( void ) { return m_digestability; }
574  virtual double GetLAGreen( void ) { return m_LAgreen; }
575  virtual double GetLATotal( void ) { return m_LAtotal; }
576  virtual double GetVegCover( void ) { return m_veg_cover; }
577  virtual double GetVegHeight( void ) { return m_veg_height; }
578  virtual double GetVegBiomass( void ) { return m_veg_biomass; }
579  virtual double GetDeadBiomass( void ) { return m_dead_biomass; }
580  virtual double GetGreenBiomass( void ) { return m_green_biomass; }
581  virtual double GetWeedBiomass( void ) { return m_weed_biomass; }
582  virtual int GetVegDensity( void ) { return m_veg_density; }
583  virtual bool GetSkScrapes( void ) { return m_skylarkscrapes; }
584  virtual bool GetVegPatchy( void ) { return m_veg_patchy; }
585  virtual void SetVegPatchy( bool p ) { m_veg_patchy=p; }
586  virtual double GetInsectPop( void ) { return m_insect_pop; }
587  virtual void SetInsectPop( double insects ) { m_insect_pop=insects; }
588  virtual TTypesOfVegetation GetVegType( void ) { return m_vege_type; }
589  virtual void Insecticide( double a_fraction )
590  {
591  m_insect_pop *= a_fraction;
593  }
594  virtual bool IsCereal();
595  virtual bool IsMatureCereal();
596  virtual bool IsMaize();
597  virtual bool IsGrass();
598  virtual bool IsGooseGrass();
599  virtual void InsectMortality(double a_fraction);
600  virtual void ReduceWeedBiomass( double a_fraction )
601  {
602  m_weed_biomass *= a_fraction;
603  }
605  virtual void TogglePigGrazing( void ) { m_pig_grazing = !m_pig_grazing; }
607  virtual void GrazeVegetation( double a_grams, bool a_force );
609  virtual void GrazeVegetationTotal( double a_grams);
610  // Outdated! Use ReduceVeg() below instead. Total biomass is
611  // (re)calculated from the total leaf area, it cannot just be
612  // set or changed to an arbitrary value.
613  //virtual void SetVegBiomass( int a_veg_biomass )
614  // { m_veg_biomass = a_veg_biomass; }
615  virtual void SetVegType(TTypesOfVegetation a_vege_type, TTypesOfVegetation a_weed_type);
616  virtual void SetCropData(double,double,double,TTypesOfVegetation, double, int);
617  virtual void SetCropDataAll(double,double,double, double,TTypesOfVegetation, double, double , int, double , bool, double);
618  virtual void SetVegHeight(double a_veg_height) { m_veg_height = a_veg_height; }
619  virtual void SetVegParameters(double a_veg_height, double a_LAtotal, double a_LAgreen, double a_WeedBiomass) {
620  m_veg_height = a_veg_height;
621  m_LAtotal = a_LAtotal;
622  m_LAgreen = a_LAgreen;
623  m_weed_biomass = a_WeedBiomass;
624  //RecalculateBugsNStuff();
625  }
626  virtual void SetGrowthPhase( int a_phase );
627  virtual void StoreLAItotal() { m_oldLAtotal = m_LAtotal; }
628  virtual void ForceGrowthInitialize( void );
629  virtual void ForceGrowthTest( void );
630  virtual void ForceGrowthDevelopment( void );
631  virtual void ZeroVeg( void );
632  virtual void ReduceVeg(double a_reduc);
633  virtual void ReduceVeg_Extended(double a_reduc);
634 
635  //added 09.04.13 - moved from Field
636  //seems all get function not necessary
637  void Set_taken(bool a_taken, int index){m_CropDataStorage[index].taken = a_taken;};
638  bool Get_taken(int index){return m_CropDataStorage[index].taken;};
639  void Set_tov_type(TTypesOfVegetation a_tov_type, int index){m_CropDataStorage[index].tov_type = a_tov_type;};
640  //TTypesOfVegetation Get_tov_type (int index){return m_CropDataStorage[index].tov_type;};
641  void Set_area_in_crop_data(double a_area){m_CropDataStorage[0].area = a_area;};
642  void Set_biomass_at_harvest(double a_biomass, int index){m_CropDataStorage[index].biomass_at_harvest = a_biomass;};
643  //double Get_biomass_at_harvest(int index){return m_CropDataStorage[index].biomass_at_harvest;};
645  bool Get_harvested(int index){return m_CropDataStorage[index].harvested;};
646  //void Add_no_herb_app(int index){m_CropDataStorage[index].no_herb_app++;};
648  //int Get_no_herb_app (int index){return m_CropDataStorage[index].no_herb_app;};
649  //void Add_no_fi_app(int index){m_CropDataStorage[index].no_fi_app++;};
651  //int Get_no_fi_app (int index){return m_CropDataStorage[index].no_fi_app;};
652 
653  //void Add_missed_herb_app(int index){m_CropDataStorage[index].missed_herb_app++;}; //index not necessary - always save at position 0.
654  //int Get_missed_herb_app (int index){return m_CropDataStorage[index].missed_herb_app;};
655  //void Add_missed_fi_app(int index){m_CropDataStorage[index].missed_fi_app++;};
656  //int Get_missed_fi_app (int index){return m_CropDataStorage[index].missed_fi_app;};
659 
660  //void Set_crop_index(int a_index){m_crop_index = a_index;}; //probably not needed
661  //int Get_crop_index(void){return m_crop_index;};
662  void Set_CropDataStorage(int index, CropActualValues a_struct){m_CropDataStorage[index] = a_struct;};
664 
665  void Clean_CropDataStorage(int index);
666  //09.04
668  virtual void ResetDigestability()
669  {
670  for (int i = 0; i<32; i++) m_oldnewgrowth[i] = 0.0;
671  }
672 
673  virtual int GetVegPhase() { return m_veg_phase; }
674 
675 protected:
682  double m_LAtotal;
683  double m_oldLAtotal;
684  double m_LAgreen;
685  double m_insect_pop;
692  double m_veg_height;
695  double m_veg_cover;
698  double m_oldnewgrowth[32];
701  double m_force_Weed;
706  ifstream m_ifile;
707  void ReadBugPercentageFile( void );
709  virtual void RecalculateBugsNStuff( void );
712  void RandomVegStartValues( double *a_LAtotal,double *a_LAgreen,double *a_veg_height,double *a_weed_biomass );
713  void ForceGrowthSpringTest( void );
717  void ResetGeese(void);
718 
719  //added 09.04 .13 - moved from Field!
724 };
725 
726 
727 class Field : public VegElement
728 {
729 public:
730  Field( void );
731  virtual void DoDevelopment( void );
732  TTypesOfVegetation GetPreviousCrop(int a_index);
733 
734 
735 protected:
736 
737 };
738 
739 
740 class PermPasture : public VegElement
741 {
742 public:
743  PermPasture( void );
744 };
745 
746 
748 {
749  public:
750  PermPastureLowYield( void );
751 };
752 
753 
755 {
756  public:
757  PermPastureTussocky( void );
758 };
759 
760 
762 {
763 public:
764  PermanentSetaside( void );
765 };
766 
767 
768 class Hedges : public VegElement
769 {
770 public:
771  Hedges( void );
772  virtual void DoDevelopment( void ) {
774  m_insect_pop=0;
775  }
776 };
777 
778 
779 class HedgeBank : public VegElement
780 {
781 public:
782  HedgeBank( void );
783  virtual void DoDevelopment( void );
784 };
785 
786 
787 class BeetleBank : public VegElement
788 {
789 public:
790  BeetleBank( void );
791  virtual void DoDevelopment( void );
792 };
793 
794 
795 class RoadsideVerge : public VegElement
796 {
797  // Attributes
798  void Cutting(int a_today);
799  long m_DateCut;
800 
801  public:
802  RoadsideVerge( void );
803  // Is needed due to special development for this element
804  // type, cutting of the roadside verges.
805  virtual void DoDevelopment( void );
806 };
807 
809 {
810  void ResetingVeg(int a_today);
811 public:
812  WaterBufferZone(void);
813  // Is needed due to special development for this element
814  // We want to reset the vegetation every year
815  virtual void DoDevelopment(void);
816 };
817 
819 {
820  public:
821  RoadsideSlope( void );
822  virtual void DoDevelopment( void );
823 };
824 
825 class GreenElement : public VegElement
826 {
827 public:
828  GreenElement( void );
829  virtual ~GreenElement( void ) { ; }
830  virtual void DoDevelopment( void );
831 };
832 
833 class Scrub : public GreenElement
834 {
835 public:
836  Scrub( void );
837  virtual void DoDevelopment( void ) {
839  m_insect_pop=0;
840  }
841 };
842 
843 class Marsh : public GreenElement
844 {
845 public:
846  Marsh( void );
847 };
848 
849 class Saltmarsh : public Marsh
850 {
851 public:
852  Saltmarsh( void );
853 };
854 
855 class Heath : public GreenElement
856 {
857 public:
858  Heath( void );
859 };
860 
862 {
863 public:
864  RiversidePlants( void );
865 };
866 
868 {
869 public:
870  NaturalGrassDry( void );
871  virtual void DoDevelopment();
872 };
873 
875 {
876 public:
877  NaturalGrassWet( void );
878  virtual void DoDevelopment();
879 };
880 
881 class Wasteland : public GreenElement
882 {
883 public:
884  Wasteland( void );
885  virtual void DoDevelopment();
886 };
887 
889 {
890 public:
891  FieldBoundary( void );
892 };
893 
895 {
896 public:
897  UnsprayedFieldMargin( void );
898  virtual void DoDevelopment( void );
906 };
907 
909 {
910 public:
911  RiversideTrees( void );
912 };
913 
914 class Vildtager : public GreenElement
915 {
916 public:
917  Vildtager( void );
918 };
919 
920 class Railway : public GreenElement
921 {
922 public:
923  Railway( void );
924 };
925 
926 //---------------------------------------------------------------------------
927 
928 
929 class ForestElement : public VegElement
930 {
931 public:
932  ForestElement( void );
933  virtual void DoDevelopment( void ) {
935  m_insect_pop=0;
936  }
937 };
938 
939 
941 {
942 public:
943  DeciduousForest( void );
944 };
945 
946 
947 class Copse : public ForestElement
948 {
949 public:
950  Copse( void );
951 };
952 
953 
955 {
956 public:
957  IndividualTree(void);
958 };
959 
960 
962 {
963 public:
964  ConiferousForest( void );
965 };
966 
968 {
969 public:
970  WoodlandMargin(void);
971 };
972 
973 
975 {
976 public:
977  MixedForest( void );
978 };
979 
981 {
982 public:
983  YoungForest( void );
984 };
985 
987 {
988 public:
989  WoodyEnergyCrop( void );
990 };
991 
992 class Orchard : public GreenElement
993 {
994  void Cutting(int a_today);
995  long m_DateCut;
996 
997 public:
998  Orchard( void );
999  // Is needed due to special development for this element
1000  // type, cutting of the roadside verges.
1001  virtual void DoDevelopment( void );
1002 };
1003 
1005 {
1007 
1008 public:
1009  OrchardBand( void );
1010  // Is needed due to special development for this element
1011  // type, cutting of the roadside verges.
1012  virtual void DoDevelopment( void );
1013 };
1014 
1015 class MownGrass : public GreenElement
1016 {
1017  void Cutting(int a_today);
1019 
1020 public:
1021  MownGrass( void );
1025  virtual void DoDevelopment( void );
1026 };
1027 
1028 class NonVegElement : public LE
1029 {
1030 public:
1031  NonVegElement( void );
1032 };
1033 
1035 {
1036 public:
1037  ChameleonLE(void);
1038 };
1039 
1040 class Garden : public NonVegElement
1041 {
1042 public:
1043  Garden(void);
1044 };
1045 
1046 class Building : public NonVegElement
1047 {
1048 public:
1049  Building( void );
1050 };
1051 
1052 class Pylon : public NonVegElement
1053 {
1054 public:
1055  Pylon(void);
1056 };
1057 
1059 {
1060 public:
1061  WindTurbine(void);
1062 };
1063 
1065 {
1066 public:
1067  PlantNursery(void);
1068 };
1069 
1070 class Urban : public NonVegElement
1071 {
1072 public:
1073  Urban( void );
1074 };
1075 
1077 {
1078 public:
1079  AmenityGrass( void );
1080 };
1081 
1082 class Parkland : public NonVegElement
1083 {
1084 public:
1085  Parkland( void );
1086 };
1087 
1089 {
1090 public:
1091  UrbanNoVeg( void );
1092 };
1093 
1094 class UrbanVeg : public NonVegElement
1095 {
1096 public:
1097  UrbanVeg(void);
1098 };
1099 
1100 class UrbanPark : public NonVegElement
1101 {
1102 public:
1103  UrbanPark( void );
1104 };
1105 
1106 class Suburban : public NonVegElement
1107 {
1108 public:
1109  Suburban( void );
1110 };
1111 
1113 {
1114 public:
1115  RuralResidential( void );
1116 };
1117 
1119 {
1120 public:
1121  BuiltUpWithParkland( void );
1122 };
1123 
1124 class SandDune : public NonVegElement
1125 {
1126 public:
1127  SandDune( void );
1128 };
1129 
1130 class BareRock : public NonVegElement
1131 {
1132 public:
1133  BareRock( void );
1134 };
1135 
1136 class StoneWall : public NonVegElement
1137 {
1138 public:
1139  StoneWall( void );
1140 };
1141 
1142 
1143 
1145 {
1146 public:
1147  PitDisused( void );
1148 };
1149 
1150 
1151 
1152 class Saltwater : public NonVegElement
1153 {
1154 public:
1155  Saltwater( void );
1156 };
1157 
1158 
1159 
1160 class Freshwater : public NonVegElement {
1161 public:
1162  Freshwater(void);
1163 };
1164 
1165 
1166 class FishFarm : public NonVegElement {
1167 public:
1168  FishFarm(void);
1169 };
1170 
1171 class Fence : public NonVegElement
1172 {
1173 public:
1174  Fence(void);
1175 };
1176 
1177 
1183 class Pond : public Freshwater {
1184 protected:
1195 public:
1196  Pond( void );
1200  virtual void DoDevelopment(void);
1202  void CalcPondPesticide();
1204  void CalcLarvalFood();
1206  bool SubtractLarvalFood(double a_food);
1210  virtual void SetMaleNewtPresent(bool a_ispresent) { m_MaleNewtPresent = a_ispresent; };
1213 };
1214 
1215 class RiverBed : public NonVegElement
1216 {
1217 public:
1218  RiverBed(void);
1219 };
1220 
1221 class River : public NonVegElement
1222 {
1223 public:
1224  River(void);
1225 };
1226 
1227 class Canal : public NonVegElement
1228 {
1229 public:
1230  Canal(void);
1231 };
1232 
1234 {
1235 public:
1236  RefuseSite(void);
1237 };
1238 
1240 {
1241 public:
1242  DrainageDitch(void);
1243 };
1244 
1245 class Coast : public NonVegElement
1246 {
1247 public:
1248  Coast( void );
1249 };
1250 
1251 class ActivePit : public NonVegElement
1252 {
1253 public:
1254  ActivePit( void );
1255 };
1256 
1257 class LargeRoad : public NonVegElement
1258 {
1259 public:
1260  virtual double GetTrafficLoad( void );
1261  LargeRoad( void );
1262 };
1263 
1264 
1265 
1266 class SmallRoad : public NonVegElement
1267 {
1268 public:
1269  virtual double GetTrafficLoad( void );
1270  SmallRoad( void );
1271 };
1272 
1273 
1274 class Track : public NonVegElement
1275 {
1276 public:
1277  Track( void );
1278 };
1279 
1281 {
1282 public:
1283  MetalledPath( void );
1284 };
1285 
1286 class Carpark : public NonVegElement
1287 {
1288 public:
1289  Carpark( void );
1290 };
1291 
1293 {
1294 public:
1295  Churchyard( void );
1296 };
1297 
1298 class Stream : public NonVegElement
1299 {
1300 public:
1301  Stream( void );
1302 };
1303 
1305 {
1306 public:
1307  HeritageSite( void );
1308 };
1309 
1310 #endif // ELEMENTS_H
1311 
LE_TypeClass::BackTranslateEleTypes
int BackTranslateEleTypes(TTypesOfLandscapeElement EleReference)
Definition: elements.cpp:3610
LE::GetMDates
int GetMDates(int a, int b)
Definition: elements.h:341
LE::m_pdates
int m_pdates[256]
Definition: elements.h:442
VegElement::ReduceVeg_Extended
virtual void ReduceVeg_Extended(double a_reduc)
Definition: elements.cpp:2097
VegElement::Set_CropDataStorage
void Set_CropDataStorage(int index, CropActualValues a_struct)
Definition: elements.h:662
Pond::m_MaleNewtPresent
bool m_MaleNewtPresent
Flag for presence of a male newt.
Definition: elements.h:1192
LE::SetMaxOsmiaNests
void SetMaxOsmiaNests(double a_noNests)
Add an occupied nest.
Definition: elements.h:421
LE::GetMinX
int GetMinX(void)
Definition: elements.h:335
WaterBufferZone::WaterBufferZone
WaterBufferZone(void)
Definition: elements.cpp:2346
VegElement::Add_no_fi_app
void Add_no_fi_app()
Definition: elements.h:650
LE::GetLastSownVeg
TTypesOfVegetation GetLastSownVeg()
Returns the last vegetation type to be sown.
Definition: elements.h:299
Urban::Urban
Urban(void)
HeritageSite
Definition: elements.h:1304
ConiferousForest
Definition: elements.h:961
LE::m_monthly_traffic
static double m_monthly_traffic[]
Used for birds that feed on grain on cereal fields 3% spill is expected.
Definition: elements.h:527
CropActualValues
Struct for storing actual data on crop type, area of a field it is grown in, biomass at harvest,...
Definition: elements.h:555
LE::SetOwner
void SetOwner(Farm *a_owner, int a_owner_num, int a_owner_index)
Definition: elements.h:219
DeciduousForest::DeciduousForest
DeciduousForest(void)
Definition: elements.cpp:2685
LE::SetOldDays
void SetOldDays(long a_days)
Definition: elements.h:306
LE::SetMDates
void SetMDates(int a, int b, int c)
Definition: elements.h:342
VegElement::SetCropData
virtual void SetCropData(double, double, double, TTypesOfVegetation, double, int)
Definition: elements.cpp:2181
LE::~LE
virtual ~LE(void)
Definition: elements.cpp:452
StoneWall::StoneWall
StoneWall(void)
Definition: elements.cpp:2744
LE::GetNectar
virtual PollenNectarQuality GetNectar()
Definition: elements.h:431
DrainageDitch
Definition: elements.h:1239
VegElement::GetGreenBiomass
virtual double GetGreenBiomass(void)
Definition: elements.h:580
LE::ForceGrowthInitialize
virtual void ForceGrowthInitialize(void)
Definition: elements.h:171
LE::m_area
double m_area
The element area in m2.
Definition: elements.h:489
VegElement::IsCereal
virtual bool IsCereal()
Definition: elements.cpp:1467
LE::GrazeVegetationTotal
virtual void GrazeVegetationTotal(double)
Definition: elements.h:236
LE::SetLastSownVeg
void SetLastSownVeg(TTypesOfVegetation a_tov)
Records the last vegetation type to be sown.
Definition: elements.h:293
VegElement::m_newgrowthsum
double m_newgrowthsum
Definition: elements.h:700
LE::m_pollenquality
PollenNectarQuality m_pollenquality
Definition: elements.h:539
LE::GetArea
double GetArea(void)
Definition: elements.h:196
LE::UpdateOsmiaNesting
void UpdateOsmiaNesting()
Recalculate the nest finding probability.
Definition: elements.h:406
VegElement::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2004
VegElement::GetVegPhase
virtual int GetVegPhase()
Definition: elements.h:673
ChameleonLE::ChameleonLE
ChameleonLE(void)
Definition: elements.cpp:2727
Orchard
Definition: elements.h:992
NaturalGrassWet
Definition: elements.h:874
CropActualValues::taken
bool taken
Definition: elements.h:556
LE::GetBirdSeed
double GetBirdSeed(void)
Definition: elements.h:198
Railway
Definition: elements.h:920
LE::m_subtype
int m_subtype
Definition: elements.h:461
Copse
Definition: elements.h:947
Churchyard::Churchyard
Churchyard(void)
Definition: elements.cpp:2962
Pond::SubtractLarvalFood
bool SubtractLarvalFood(double a_food)
Called by a larva when feeding, removes an age specific amount of larval food
Definition: elements.cpp:2849
VegElement::GetVegPatchy
virtual bool GetVegPatchy(void)
Definition: elements.h:584
Railway::Railway
Railway(void)
Definition: elements.cpp:2655
LE::GetMConstants
int GetMConstants(int a)
Definition: elements.h:343
LE::SetPoison
void SetPoison(bool a_poison)
Definition: elements.h:181
LE::m_running
long m_running
Definition: elements.h:446
UrbanVeg::UrbanVeg
UrbanVeg(void)
Definition: elements.cpp:2911
LE::m_PesticideGridCell
int m_PesticideGridCell
Definition: elements.h:457
PollenNectarQuality
Definition: plants.h:215
VegElement::Set_taken
void Set_taken(bool a_taken, int index)
Definition: elements.h:637
LE::SetMinY
void SetMinY(int y)
Definition: elements.h:340
LE::GetStubble
bool GetStubble()
Return the in stubble flag.
Definition: elements.h:392
VegElement::m_force_LAtotal
double m_force_LAtotal
Definition: elements.h:703
LE::m_gooseNos
int m_gooseNos[366]
The number of geese each day.
Definition: elements.h:491
VegElement::m_LAgreen
double m_LAgreen
Definition: elements.h:684
Fence::Fence
Fence(void)
Definition: elements.cpp:2749
VegElement::GetDeadBiomass
virtual double GetDeadBiomass(void)
Definition: elements.h:579
Saltmarsh::Saltmarsh
Saltmarsh(void)
Definition: elements.cpp:2397
LE::GetMaxX
int GetMaxX(void)
Definition: elements.h:333
LE::m_squares_in_map
int m_squares_in_map
Definition: elements.h:86
LE::StoreLAItotal
virtual void StoreLAItotal()
Definition: elements.h:169
Field::Field
Field(void)
Definition: elements.cpp:2122
LE::GetDayDegrees
virtual double GetDayDegrees(void)
Variable used to record the current grazing pressure by e.g. voles *‍/ double m_volegrazing; /**.
Definition: elements.h:149
Pond::CalcLarvalFood
void CalcLarvalFood()
Calculates the amount of larval food present
Definition: elements.cpp:2822
LE::GetHigh
bool GetHigh(void)
Definition: elements.h:182
Suburban::Suburban
Suburban(void)
Pond
Ponds are defined as freshwater bodies between 25m2 and 5000m2. For newts the effective size is limit...
Definition: elements.h:1183
Parkland
Definition: elements.h:1082
LE::GetPoly
int GetPoly(void)
Returns the polyref number for this polygon.
Definition: elements.h:189
LE::SetGooseNosTimed
void SetGooseNosTimed(int a_number, int a_day)
Definition: elements.h:358
VegElement::m_total_biomass_old
double m_total_biomass_old
Definition: elements.h:688
UnsprayedFieldMargin
Definition: elements.h:894
VegElement::Add_no_herb_app
void Add_no_herb_app()
Definition: elements.h:647
LE::m_pindex
int m_pindex
Definition: elements.h:443
VegElement::m_ifile
ifstream m_ifile
Definition: elements.h:706
VegElement::Get_taken
bool Get_taken(int index)
Definition: elements.h:638
VegElement::m_force_veg_height
double m_force_veg_height
Definition: elements.h:704
LE::m_currentOsmiaNests
int m_currentOsmiaNests
to record the number of actual osmia nests
Definition: elements.h:538
Heath::Heath
Heath(void)
Definition: elements.cpp:2403
CropActualValues::missed_fi_app
int missed_fi_app
Definition: elements.h:564
LE::ForceGrowthTest
virtual void ForceGrowthTest(void)
Definition: elements.h:172
CfgStr
String configurator entry class.
Definition: configurator.h:144
VegElement::m_green_biomass
double m_green_biomass
Definition: elements.h:689
VegElement::ForceGrowthTest
virtual void ForceGrowthTest(void)
Definition: elements.cpp:1904
LE::m_pollencurve
PollenNectarDevelopmentCurve * m_pollencurve
pointer to the correct pollen curve set
Definition: elements.h:546
LE::SetGooseSpNos
void SetGooseSpNos(int a_number, int a_day, GooseSpecies a_goose)
Definition: elements.h:354
Wasteland
Definition: elements.h:881
VegElement::m_force_LAgreen
double m_force_LAgreen
Definition: elements.h:702
ChameleonLE
Definition: elements.h:1034
LE::GetPesticideCell
int GetPesticideCell()
Definition: elements.h:324
LE::SetSoilType
void SetSoilType(int a_st)
Definition: elements.h:287
LE::SetCropData
virtual void SetCropData(double, double, double, TTypesOfVegetation, double, int)
Definition: elements.h:167
Building::Building
Building(void)
Definition: elements.cpp:2737
VegElement::m_veg_cover
double m_veg_cover
Definition: elements.h:695
LE::SetBorder
void SetBorder(LE *a_border)
Definition: elements.h:320
Orchard::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2433
VegElement::SetGrowthPhase
virtual void SetGrowthPhase(int a_phase)
Definition: elements.cpp:1851
ConiferousForest::ConiferousForest
ConiferousForest(void)
Definition: elements.cpp:2690
LE::m_totalNectar
double m_totalNectar
Definition: elements.h:542
LE::SetCountryDesignation
void SetCountryDesignation(int a_designation)
Definition: elements.h:217
LE::m_openness
int m_openness
The openness metric for a field (if any)
Definition: elements.h:509
LE::GetGooseNos
int GetGooseNos()
For goose model functionality, returns the number of geese yesterday.
Definition: elements.cpp:542
Coast
Definition: elements.h:1245
WaterBufferZone::ResetingVeg
void ResetingVeg(int a_today)
Definition: elements.cpp:2365
NaturalGrassDry::NaturalGrassDry
NaturalGrassDry(void)
Definition: elements.cpp:2562
LE::m_maxy
int m_maxy
Definition: elements.h:464
LE::SetTramlinesDecay
void SetTramlinesDecay(int a_decaytime_days)
Definition: elements.h:310
Pond::IsMaleNewtPresent
bool IsMaleNewtPresent()
Gets whether there is a male newt as present.
Definition: elements.h:1212
Field::GetPreviousCrop
TTypesOfVegetation GetPreviousCrop(int a_index)
Definition: elements.cpp:2176
PermPastureTussocky
Definition: elements.h:754
Freshwater
Definition: elements.h:1160
LE::GetInsectPop
virtual double GetInsectPop(void)
Definition: elements.h:156
IndividualTree
Definition: elements.h:954
LE::GetValidX
int GetValidX(void)
Definition: elements.h:330
LE::m_soiltype
int m_soiltype
Definition: elements.h:513
WoodlandMargin::WoodlandMargin
WoodlandMargin(void)
Definition: elements.cpp:2707
LE::MDates
int MDates[2][25]
Definition: elements.h:530
LE::IsMaleNewtPresent
virtual bool IsMaleNewtPresent()
Sets a male newt as present/absent in descendent classes - here only to prevent need for dynamic cast...
Definition: elements.h:388
RuralResidential::RuralResidential
RuralResidential(void)
VegElement::ResetDigestability
virtual void ResetDigestability()
sets growth record to zero
Definition: elements.h:668
SandDune
Definition: elements.h:1124
LE::ReduceVeg_Extended
virtual void ReduceVeg_Extended(double)
Definition: elements.h:176
HedgeBank
Definition: elements.h:779
LE::SetMinX
void SetMinX(int x)
Definition: elements.h:339
VegElement::GrazeVegetationTotal
virtual void GrazeVegetationTotal(double a_grams)
Definition: elements.cpp:2056
LE::GetOldDays
long GetOldDays(void)
Definition: elements.h:218
MownGrass
Definition: elements.h:1015
LE::m_valid_y
int m_valid_y
Definition: elements.h:453
VegElement::Set_area_in_crop_data
void Set_area_in_crop_data(double a_area)
Definition: elements.h:641
VegElement::GetVegType
virtual TTypesOfVegetation GetVegType(void)
Definition: elements.h:588
LargeRoad::LargeRoad
LargeRoad(void)
Definition: elements.cpp:2934
VegElement::GetInsectPop
virtual double GetInsectPop(void)
Definition: elements.h:586
NaturalGrassWet::NaturalGrassWet
NaturalGrassWet(void)
Definition: elements.cpp:2570
Saltmarsh
Definition: elements.h:849
VegElement::m_forced_phase_shift
bool m_forced_phase_shift
Definition: elements.h:696
ForestElement::ForestElement
ForestElement(void)
Definition: elements.cpp:2675
Pond::m_LarvalFood
double m_LarvalFood
The amount of larval food present
Definition: elements.h:1186
LE::m_largeroad_load
static double m_largeroad_load[]
Definition: elements.h:528
LE::m_maxx
int m_maxx
Definition: elements.h:462
PlantNursery
Definition: elements.h:1064
VegElement::RandomVegStartValues
void RandomVegStartValues(double *a_LAtotal, double *a_LAgreen, double *a_veg_height, double *a_weed_biomass)
Definition: elements.cpp:1843
WoodyEnergyCrop::WoodyEnergyCrop
WoodyEnergyCrop(void)
Definition: elements.cpp:2715
Suburban
Definition: elements.h:1106
VegElement::m_insect_pop
double m_insect_pop
Definition: elements.h:685
VegElement::m_vege_type
TTypesOfVegetation m_vege_type
Definition: elements.h:676
HedgeBank::HedgeBank
HedgeBank(void)
Definition: elements.cpp:2260
Hedges::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.h:772
Saltwater::Saltwater
Saltwater(void)
Definition: elements.cpp:2761
Field::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2160
PermanentSetaside::PermanentSetaside
PermanentSetaside(void)
Definition: elements.cpp:2238
RoadsideSlope::RoadsideSlope
RoadsideSlope(void)
Definition: elements.cpp:2333
LE::SetInsectPop
virtual void SetInsectPop(double)
Definition: elements.h:157
LE::SetUnsprayedMarginPolyRef
void SetUnsprayedMarginPolyRef(int a_unsprayedmargin)
Definition: elements.h:322
VegElement::m_veg_phase
int m_veg_phase
Definition: elements.h:679
LE::GetMinY
int GetMinY(void)
Definition: elements.h:336
VegElement::ResetGeese
void ResetGeese(void)
Reset geese numbers to zero in case this was not done by the population manager (the normal situation...
Definition: elements.cpp:2048
GreenElement::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2379
LE::m_minx
int m_minx
Definition: elements.h:463
VegElement::GetVegDensity
virtual int GetVegDensity(void)
Definition: elements.h:582
AmenityGrass::AmenityGrass
AmenityGrass(void)
Definition: elements.cpp:2896
VegElement::Add_missed_herb_app
void Add_missed_herb_app()
Definition: elements.h:657
RiverBed::RiverBed
RiverBed(void)
Definition: elements.cpp:2860
MetalledPath
Definition: elements.h:1280
LE::SetMaxY
void SetMaxY(int y)
Definition: elements.h:338
LE::GetOsmiaNest
bool GetOsmiaNest()
Test to see if a nest is found.
Definition: elements.h:395
g_el_strigling_delaytime_days
CfgInt g_el_strigling_delaytime_days
VegElement::GetVegCover
virtual double GetVegCover(void)
Definition: elements.h:576
LE::GetVegBiomass
virtual double GetVegBiomass(void)
Definition: elements.h:154
EL_MAX_USERSPACE
#define EL_MAX_USERSPACE
Definition: elements.h:54
UrbanPark::UrbanPark
UrbanPark(void)
Definition: elements.cpp:2917
Saltwater
Definition: elements.h:1152
Wasteland::Wasteland
Wasteland(void)
Definition: elements.cpp:2578
VegElement::Get_harvested
bool Get_harvested(int index)
Definition: elements.h:645
Carpark
Definition: elements.h:1286
RiversideTrees
Definition: elements.h:908
BareRock::BareRock
BareRock(void)
Definition: elements.cpp:2886
LE::IsRecentlySprayed
int IsRecentlySprayed(void)
Definition: elements.h:187
LE::SetVegHeight
virtual void SetVegHeight(double)
Definition: elements.h:165
LE::GetDeadBiomass
virtual double GetDeadBiomass(void)
Definition: elements.h:153
LE::m_herbicidedelay
int m_herbicidedelay
Definition: elements.h:486
LE::TogglePigGrazing
virtual void TogglePigGrazing(void)
Definition: elements.h:162
vegphase_foobar
Definition: plants.h:57
LE::m_poison
bool m_poison
Definition: elements.h:516
LE::SetOpenness
void SetOpenness(int a_openness)
Records the openness statistic for this polygon.
Definition: elements.h:380
VegElement::m_weed_curve_num
int m_weed_curve_num
Definition: elements.h:678
Orchard::Cutting
void Cutting(int a_today)
Definition: elements.cpp:2475
YoungForest::YoungForest
YoungForest(void)
Definition: elements.cpp:2699
VegElement::m_nutrient_status
int m_nutrient_status
Definition: elements.h:681
VegElement::IsMaize
virtual bool IsMaize()
Definition: elements.cpp:1591
LE::m_centroidx
int m_centroidx
Definition: elements.h:454
VegElement::ForceGrowthSpringTest
void ForceGrowthSpringTest(void)
Definition: elements.cpp:1915
PitDisused
Definition: elements.h:1144
PitDisused::PitDisused
PitDisused(void)
Definition: elements.cpp:2755
LE::m_birdmaizeforage
double m_birdmaizeforage
The maize forage present in KJ/m2.
Definition: elements.h:503
LE::m_management_loop_detect_date
long m_management_loop_detect_date
Definition: elements.h:467
Pylon
Definition: elements.h:1052
Pond::m_pondpesticide
double m_pondpesticide
Holds the pesticide content per unit pond water.
Definition: elements.h:1190
LE::m_lastindex
unsigned int m_lastindex
Definition: elements.h:525
Pond::SetMaleNewtPresent
virtual void SetMaleNewtPresent(bool a_ispresent)
Sets a male as present/absent.
Definition: elements.h:1210
DrainageDitch::DrainageDitch
DrainageDitch(void)
Definition: elements.cpp:2872
LE::GetWeedBiomass
virtual double GetWeedBiomass(void)
Definition: elements.h:155
PlantNursery::PlantNursery
PlantNursery(void)
Definition: elements.cpp:2666
LE::GetSprayedToday
bool GetSprayedToday()
Definition: elements.h:304
Orchard::Orchard
Orchard(void)
Definition: elements.cpp:2411
VegElement::Insecticide
virtual void Insecticide(double a_fraction)
Definition: elements.h:589
VegElement::m_veg_patchy
bool m_veg_patchy
Definition: elements.h:694
WoodlandMargin
Definition: elements.h:967
LE_TypeClass::TranslateEleTypes
TTypesOfLandscapeElement TranslateEleTypes(int EleReference)
Definition: elements.cpp:2995
LE::m_valid_x
int m_valid_x
Definition: elements.h:452
LE::m_smallroad_load
static double m_smallroad_load[]
Definition: elements.h:529
Pylon::Pylon
Pylon(void)
Definition: elements.cpp:2978
LE::SetSprayedToday
void SetSprayedToday(bool a_didit)
Definition: elements.h:303
BuiltUpWithParkland::BuiltUpWithParkland
BuiltUpWithParkland(void)
Definition: elements.cpp:2922
WindTurbine::WindTurbine
WindTurbine(void)
Definition: elements.cpp:2984
VegElement::PollenNectarPhenologyCalculation
void PollenNectarPhenologyCalculation()
This methods calculates the daily availability of pollen and nectar per square meter and in total.
Definition: elements.cpp:1790
LE::m_vegage
int m_vegage
Definition: elements.h:512
VegElement::IsGooseGrass
virtual bool IsGooseGrass()
Definition: elements.cpp:1644
Landscape
The landscape class containing all environmental and topographical data.
Definition: landscape.h:112
LE::AddArea
void AddArea(double a_area_diff)
Definition: elements.h:316
LE::m_almass_le_type
int m_almass_le_type
This holds the ALMaSS element type reference number.
Definition: elements.h:482
VegElement::m_weed_biomass
double m_weed_biomass
Definition: elements.h:691
Parkland::Parkland
Parkland(void)
Definition: elements.cpp:2901
LE::GetLAGreen
virtual double GetLAGreen(void)
Definition: elements.h:150
RiverBed
Definition: elements.h:1215
MownGrass::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2485
Pond::Pond
Pond(void)
Definition: elements.cpp:2776
VegElement::VegElement
VegElement(void)
Definition: elements.cpp:615
ForestElement::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.h:933
LE::m_lasttreat
vector< int > m_lasttreat
Definition: elements.h:524
LE::m_birdseedforage
double m_birdseedforage
The grain forage present in KJ/m2.
Definition: elements.h:501
MixedForest
Definition: elements.h:974
LE::GetOpenness
int GetOpenness(void)
For goose model functionality, openness score for the polygon.
Definition: elements.h:350
VegElement
Definition: elements.h:568
LE::SetRotIndex
void SetRotIndex(int a_index)
Definition: elements.h:307
LE_TypeClass
Definition: elements.h:70
LE::m_default_grazing_level
int m_default_grazing_level
Definition: elements.h:518
LE::m_pig_grazing
bool m_pig_grazing
Definition: elements.h:519
TTypesOfVegetation
TTypesOfVegetation
Definition: tov_declaration.h:30
LE::IncOsmiaNesting
void IncOsmiaNesting()
Add an occupied nest.
Definition: elements.h:415
AmenityGrass
Definition: elements.h:1076
BeetleBank
Definition: elements.h:787
MownGrass::Cutting
void Cutting(int a_today)
Definition: elements.cpp:2522
LE::m_skylarkscrapes
bool m_skylarkscrapes
For management testing of skylark scrapes.
Definition: elements.h:88
GreenElement::GreenElement
GreenElement(void)
Definition: elements.cpp:2374
CropActualValues::no_herb_app
int no_herb_app
Definition: elements.h:561
VegElement::~VegElement
virtual ~VegElement(void)
Definition: elements.h:571
MixedForest::MixedForest
MixedForest(void)
Definition: elements.cpp:2695
LE::m_OsmiaNestProb
double m_OsmiaNestProb
to record the chance of osmia nesting
Definition: elements.h:534
LE::SetCropDataAll
virtual void SetCropDataAll(double, double, double, double, TTypesOfVegetation, double, double, int, double, bool, double)
Definition: elements.h:168
River::River
River(void)
Definition: elements.cpp:2864
VegElement::InsectMortality
virtual void InsectMortality(double a_fraction)
Definition: elements.cpp:2206
MownGrass::m_DateCut
long m_DateCut
Definition: elements.h:1018
LE::GetSoilType
int GetSoilType()
Definition: elements.h:241
VegElement::Clean_CropDataStorage
void Clean_CropDataStorage(int index)
Definition: elements.cpp:2129
CfgBool
Bool configurator entry class.
Definition: configurator.h:127
WaterBufferZone
Definition: elements.h:808
LE::GetGooseNosTodayTimed
int GetGooseNosTodayTimed()
For goose model functionality, returns the number of geese today at a predefined time.
Definition: elements.cpp:580
LE::m_olddays
long m_olddays
Definition: elements.h:466
LE::m_goosegrazingforage
double m_goosegrazingforage[gs_foobar]
The grazing forage present in KJ/min. The last value indicates cereal 1 or not -1.
Definition: elements.h:505
LE::m_maxOsmiaNests
int m_maxOsmiaNests
to record the number of possible osmia nests
Definition: elements.h:536
g_landscape_p
class Landscape * g_landscape_p
Definition: Landscape.cpp:258
MetalledPath::MetalledPath
MetalledPath(void)
Definition: elements.cpp:2974
LE::SetMownDecay
void SetMownDecay(int a_decaytime_days)
Definition: elements.h:314
LE::m_map_index
int m_map_index
Definition: elements.h:480
UrbanNoVeg::UrbanNoVeg
UrbanNoVeg(void)
Definition: elements.cpp:2906
LE::ReduceVeg
virtual void ReduceVeg(double)
Definition: elements.h:175
FishFarm
Definition: elements.h:1166
Pond::m_pondquality
double m_pondquality
a factor used to alter the pond qualities (default behaviour is random 0.0-1.0)
Definition: elements.h:1194
FieldBoundary::FieldBoundary
FieldBoundary(void)
Definition: elements.cpp:2612
SmallRoad::GetTrafficLoad
virtual double GetTrafficLoad(void)
Definition: elements.cpp:2949
LE::m_NectarM2
double m_NectarM2
Definition: elements.h:544
LE::GetGooseNosToday
int GetGooseNosToday()
For goose model functionality, returns the number of geese today.
Definition: elements.cpp:569
LE::GetGooseRoostDist
int GetGooseRoostDist(GooseSpecies a_goose)
For goose model functionality, returns the distance to closest roost.
Definition: elements.cpp:601
LE::SetMaxX
void SetMaxX(int x)
Definition: elements.h:337
BeetleBank::BeetleBank
BeetleBank(void)
Definition: elements.cpp:2268
UnsprayedFieldMargin::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2626
Hedges
Definition: elements.h:768
g_el_herbicide_delaytime_days
CfgInt g_el_herbicide_delaytime_days
BuiltUpWithParkland
Definition: elements.h:1118
VegElement::GetVegHeight
virtual double GetVegHeight(void)
Definition: elements.h:577
VegElement::ForceGrowthDevelopment
virtual void ForceGrowthDevelopment(void)
Definition: elements.cpp:1976
UnsprayedFieldMargin::UnsprayedFieldMargin
UnsprayedFieldMargin(void)
Definition: elements.cpp:2618
RiversidePlants::RiversidePlants
RiversidePlants(void)
Definition: elements.cpp:2557
Pond::SupplyPondPesticide
double SupplyPondPesticide()
supply the current pesticide concentration per litre
Definition: elements.h:1208
LE::m_miny
int m_miny
Definition: elements.h:465
VegElement::m_CropDataStorage
CropActualValues m_CropDataStorage[2]
Keeps data on pesticide applications, biomass at harvest etc. Data for maximum two crops can be store...
Definition: elements.h:722
Orchard::m_DateCut
long m_DateCut
Definition: elements.h:995
MownGrass::MownGrass
MownGrass(void)
Definition: elements.cpp:2418
RefuseSite
Definition: elements.h:1233
LE::SetPoly
void SetPoly(int a_poly)
Definition: elements.h:226
LE::GetLastTreatment
int GetLastTreatment(int *a_index)
Definition: elements.cpp:511
Pond::m_LarvalFoodScaler
double m_LarvalFoodScaler
The proportion of larval food per m2
Definition: elements.h:1188
Stream::Stream
Stream(void)
Definition: elements.cpp:2958
LE::ResetDigestability
virtual void ResetDigestability()
sets growth record to zero in descendent classes
Definition: elements.h:382
Canal
Definition: elements.h:1227
OrchardBand::m_LastSprayed
long m_LastSprayed
Definition: elements.h:1006
VegElement::SetInsectPop
virtual void SetInsectPop(double insects)
Definition: elements.h:587
VegElement::SetVegType
virtual void SetVegType(TTypesOfVegetation a_vege_type, TTypesOfVegetation a_weed_type)
Definition: elements.cpp:2144
RoadsideVerge
Definition: elements.h:795
Stream
Definition: elements.h:1298
PollenNectarDevelopmentCurve
A standard class to contain a pollen or nectar curve based on indexed rates.
Definition: plants.h:183
LE::ForceGrowthDevelopment
virtual void ForceGrowthDevelopment(void)
Definition: elements.h:173
LE::m_lastsownvegtype
TTypesOfVegetation m_lastsownvegtype
Records the last vegegetation type that was sown on the element.
Definition: elements.h:507
LE::GetCattleGrazing
int GetCattleGrazing(void)
Definition: elements.h:183
LE::GetRotIndex
int GetRotIndex(void)
Definition: elements.h:309
LE::SetPesticideCell
void SetPesticideCell(int a_cell)
Definition: elements.h:323
VegElement::m_newoldgrowthindex
int m_newoldgrowthindex
Definition: elements.h:699
VegElement::m_veg_biomass
double m_veg_biomass
Definition: elements.h:686
LE::m_yddegs
double m_yddegs
Definition: elements.h:521
VegElement::Set_tov_type
void Set_tov_type(TTypesOfVegetation a_tov_type, int index)
Definition: elements.h:639
l_el_read_bug_percentage_file
static CfgBool l_el_read_bug_percentage_file("ELEM_READ_BUG_PERCENTAGE_FILE", CFG_CUSTOM, false)
SmallRoad
Definition: elements.h:1266
Hedges::Hedges
Hedges(void)
Definition: elements.cpp:2250
CropActualValues::tov_type
TTypesOfVegetation tov_type
Definition: elements.h:557
ActivePit
Definition: elements.h:1251
VegElement::GetLATotal
virtual double GetLATotal(void)
Definition: elements.h:575
VegElement::m_crop_index
int m_crop_index
Definition: elements.h:723
VegElement::GetSkScrapes
virtual bool GetSkScrapes(void)
Definition: elements.h:583
Pond::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2783
RoadsideSlope
Definition: elements.h:818
PermPasture
Definition: elements.h:740
LE::m_high
bool m_high
Definition: elements.h:515
LE::m_gooseSpNos
int m_gooseSpNos[366][gs_foobar]
The number of geese of each species each day.
Definition: elements.h:493
Field
Definition: elements.h:727
LE::m_days_since_insecticide_spray
int m_days_since_insecticide_spray
Definition: elements.h:514
Scrub::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.h:837
VegElement::StoreLAItotal
virtual void StoreLAItotal()
Definition: elements.h:627
LE::GetTrafficLoad
virtual double GetTrafficLoad(void)
Definition: elements.h:178
VegElement::IsMatureCereal
virtual bool IsMatureCereal()
Definition: elements.cpp:1534
g_el_tramline_decaytime_days
CfgInt g_el_tramline_decaytime_days
CropActualValues::biomass_at_harvest
double biomass_at_harvest
Definition: elements.h:558
LE_Signal
unsigned int LE_Signal
Definition: elements.h:35
SandDune::SandDune
SandDune(void)
Definition: elements.cpp:2891
NonVegElement
Definition: elements.h:1028
LE::m_farmfunc_tried_to_do
int m_farmfunc_tried_to_do
Definition: elements.h:483
OrchardBand::OrchardBand
OrchardBand(void)
Definition: elements.cpp:2425
CropActualValues::area
double area
Definition: elements.h:560
LE::InsectMortality
virtual void InsectMortality(double)
Definition: elements.h:159
VegElement::Get_CropDataStorage
CropActualValues Get_CropDataStorage(int index)
Definition: elements.h:663
RiversideTrees::RiversideTrees
RiversideTrees(void)
Definition: elements.cpp:2649
Churchyard
Definition: elements.h:1292
LE::MConsts
int MConsts[10]
Definition: elements.h:531
RuralResidential
Definition: elements.h:1112
LE::m_countrydesignation
int m_countrydesignation
Definition: elements.h:470
UrbanPark
Definition: elements.h:1100
LE::ToggleCattleGrazing
virtual void ToggleCattleGrazing(void)
Definition: elements.h:161
BeetleBank::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:3708
LE::SetValidXY
void SetValidXY(int a_valid_x, int a_valid_y)
Definition: elements.h:325
PermanentSetaside
Definition: elements.h:761
LE::SetMapValid
void SetMapValid(bool a_valid)
Definition: elements.h:227
VegElement::m_dead_biomass
double m_dead_biomass
Definition: elements.h:690
LE_TypeClass::TranslateVegTypes
TTypesOfVegetation TranslateVegTypes(int VegReference)
Definition: elements.cpp:3088
LargeRoad
Definition: elements.h:1257
LE::GetGreenBiomass
virtual double GetGreenBiomass(void)
Definition: elements.h:152
LE::m_owner_index
int m_owner_index
Definition: elements.h:472
GreenElement::~GreenElement
virtual ~GreenElement(void)
Definition: elements.h:829
LE::ReduceWeedBiomass
virtual void ReduceWeedBiomass(double)
Definition: elements.h:160
VegElement::m_oldLAtotal
double m_oldLAtotal
Definition: elements.h:683
LE::m_totalPollen
double m_totalPollen
Definition: elements.h:541
RoadsideVerge::Cutting
void Cutting(int a_today)
Definition: elements.cpp:2323
VegElement::SetVegHeight
virtual void SetVegHeight(double a_veg_height)
Definition: elements.h:618
LE::SetGooseSpNosTimed
void SetGooseSpNosTimed(int a_number, int a_day, GooseSpecies a_goose)
Definition: elements.h:360
Wasteland::DoDevelopment
virtual void DoDevelopment()
Definition: elements.cpp:2603
LE::SetStubble
void SetStubble(bool a_flag)
Sets the in stubble flag.
Definition: elements.h:390
LE::SetPollenNectarData
void SetPollenNectarData(int a_almasstype)
sets the pollen and nectar information
Definition: elements.cpp:605
BareRock
Definition: elements.h:1130
LE::GetGooseSpNosTodayTimed
int GetGooseSpNosTodayTimed(GooseSpecies a_goose)
For goose model functionality, returns the number of geese per species yesterday at a predefined time...
Definition: elements.cpp:597
WindTurbine
Definition: elements.h:1058
CFG_CUSTOM
Definition: configurator.h:60
VegElement::m_LAtotal
double m_LAtotal
Definition: elements.h:682
VegElement::TogglePigGrazing
virtual void TogglePigGrazing(void)
Definition: elements.h:605
RiversidePlants
Definition: elements.h:861
River
Definition: elements.h:1221
LE::m_border
LE * m_border
Definition: elements.h:447
LE::SetGooseNos
void SetGooseNos(int a_number, int a_day)
Definition: elements.h:352
LE::GetMapValid
bool GetMapValid(void)
Definition: elements.h:228
LE::GetTotalPollen
virtual double GetTotalPollen()
Definition: elements.h:432
LE::GrazeVeg_Extended
virtual void GrazeVeg_Extended(double)
Definition: elements.h:177
LE
Definition: elements.h:81
LE::m_tramlinesdecay
int m_tramlinesdecay
Definition: elements.h:484
Vildtager
Definition: elements.h:914
PermPasture::PermPasture
PermPasture(void)
Definition: elements.cpp:2210
LE::SetBirdMaize
void SetBirdMaize(double a_forage)
Definition: elements.h:213
Track
Definition: elements.h:1274
LE::SetHigh
void SetHigh(bool a_high)
Definition: elements.h:225
LE::GetOwnerFile
int GetOwnerFile(void)
Definition: elements.h:192
LE::SetCopyTreatment
void SetCopyTreatment(int a_treatment)
Definition: elements.cpp:486
VegElement::m_force_Weed
double m_force_Weed
Definition: elements.h:701
LE::m_cattle_grazing
int m_cattle_grazing
Definition: elements.h:517
OrchardBand::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2533
Carpark::Carpark
Carpark(void)
Definition: elements.cpp:2966
LE::SetPollenNectarCurves
void SetPollenNectarCurves(PollenNectarDevelopmentCurve *a_pollencurnve, PollenNectarDevelopmentCurve *a_nectarcurve)
Set method for pollen and nectar curves.
Definition: elements.h:435
ForestElement
Definition: elements.h:929
VegElement::GetVegBiomass
virtual double GetVegBiomass(void)
Definition: elements.h:578
VegElement::ReduceVeg
virtual void ReduceVeg(double a_reduc)
Definition: elements.cpp:2086
Garden
Definition: elements.h:1040
LE::SetLastTreatment
void SetLastTreatment(int a_treatment)
Definition: elements.cpp:490
VegElement::Set_harvested
void Set_harvested()
Definition: elements.h:644
LE::m_owner_file
int m_owner_file
Definition: elements.h:471
LE::GrazeVegetation
virtual void GrazeVegetation(double, bool)
Definition: elements.h:231
LE::m_ddegs
double m_ddegs
Definition: elements.h:522
CfgInt
Integer configurator entry class.
Definition: configurator.h:87
VegElement::Set_biomass_at_harvest
void Set_biomass_at_harvest(double a_biomass, int index)
Definition: elements.h:642
VegElement::SetVegParameters
virtual void SetVegParameters(double a_veg_height, double a_LAtotal, double a_LAgreen, double a_WeedBiomass)
Definition: elements.h:619
LE::m_centroidy
int m_centroidy
Definition: elements.h:455
FishFarm::FishFarm
FishFarm(void)
Definition: elements.cpp:2771
OrchardBand
Definition: elements.h:1004
UrbanNoVeg
Definition: elements.h:1088
LE::SetVegBiomass
virtual void SetVegBiomass(int)
Definition: elements.h:163
Farm
The base class for all farm types.
Definition: farm.h:767
VegElement::SetVegPatchy
virtual void SetVegPatchy(bool p)
Definition: elements.h:585
LargeRoad::GetTrafficLoad
virtual double GetTrafficLoad(void)
Definition: elements.cpp:2939
VegElement::m_curve_num
int m_curve_num
Definition: elements.h:677
PermPastureLowYield::PermPastureLowYield
PermPastureLowYield(void)
Definition: elements.cpp:2218
Vildtager::Vildtager
Vildtager(void)
Definition: elements.cpp:2659
LE::GetGooseSpNosToday
int GetGooseSpNosToday(GooseSpecies a_goose)
For goose model functionality, returns the number of geese per species yesterday.
Definition: elements.cpp:592
TTypesOfLandscapeElement
TTypesOfLandscapeElement
Definition: tole_declaration.h:36
LE::DoCopy
void DoCopy(const LE *a_Le)
a copy function to be used because a copy constuctor won't work
Definition: elements.cpp:372
Marsh
Definition: elements.h:843
Urban
Definition: elements.h:1070
VegElement::RecalculateBugsNStuff
virtual void RecalculateBugsNStuff(void)
This method is responsible for.
Definition: elements.cpp:1678
ActivePit::ActivePit
ActivePit(void)
Definition: elements.cpp:2928
RoadsideSlope::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2339
VegElement::m_digestability
double m_digestability
Definition: elements.h:697
NaturalGrassWet::DoDevelopment
virtual void DoDevelopment()
Definition: elements.cpp:2594
RoadsideVerge::RoadsideVerge
RoadsideVerge(void)
Definition: elements.cpp:2276
LE::m_gooseNosTimed
int m_gooseNosTimed[366]
The number of geese at a predefined time per day.
Definition: elements.h:495
Scrub
Definition: elements.h:833
VegElement::SetCropDataAll
virtual void SetCropDataAll(double, double, double, double, TTypesOfVegetation, double, double, int, double, bool, double)
Definition: elements.cpp:2191
LE::m_owner
Farm * m_owner
Definition: elements.h:469
Scrub::Scrub
Scrub(void)
Definition: elements.cpp:2384
LE::m_vegddegs
double m_vegddegs
Definition: elements.h:520
l_el_bug_percentage_file
static CfgStr l_el_bug_percentage_file("ELEM_BUG_PERCENTAGE_FILE", CFG_CUSTOM,"bugpercents.txt")
LE::m_tried_to_do
int m_tried_to_do
Definition: elements.h:85
Garden::Garden
Garden(void)
Definition: elements.cpp:2731
DeciduousForest
Definition: elements.h:940
LE::SetBirdSeed
void SetBirdSeed(double a_forage)
Definition: elements.h:201
Heath
Definition: elements.h:855
CropActualValues::harvested
bool harvested
Definition: elements.h:559
LE::GetCountryDesignation
int GetCountryDesignation(void)
Definition: elements.h:216
Copse::Copse
Copse(void)
Definition: elements.cpp:2680
VegElement::m_veg_density
int m_veg_density
Definition: elements.h:693
LE::m_gooseSpNosTimed
int m_gooseSpNosTimed[366][gs_foobar]
The number of geese of each species at a predefined time per day.
Definition: elements.h:497
StoneWall
Definition: elements.h:1136
LE::SetGrowthPhase
virtual void SetGrowthPhase(int)
Definition: elements.h:170
CropActualValues::no_fi_app
int no_fi_app
Definition: elements.h:563
WoodyEnergyCrop
Definition: elements.h:986
VegElement::m_total_biomass
double m_total_biomass
Definition: elements.h:687
LE::GetUnsprayedMarginPolyRef
int GetUnsprayedMarginPolyRef(void)
Definition: elements.h:319
VegElement::GetDigestability
virtual double GetDigestability(void)
Definition: elements.h:573
NaturalGrassDry
Definition: elements.h:867
VegElement::IsGrass
virtual bool IsGrass()
Definition: elements.cpp:1610
FieldBoundary
Definition: elements.h:888
LE::m_nectarcurve
PollenNectarDevelopmentCurve * m_nectarcurve
pointer to the correct nectar curve set
Definition: elements.h:548
YoungForest
Definition: elements.h:980
VegElement::m_growth_scaler
double m_growth_scaler
Definition: elements.h:680
g_rand_uni
boost::variate_generator< base_generator_type &, boost::uniform_real<> > g_rand_uni
A random number generator (0-1)
LE::GetSoilTypeR
int GetSoilTypeR()
Definition: elements.h:262
LE::SetArea
void SetArea(double a_area)
Definition: elements.h:229
PermPastureTussocky::PermPastureTussocky
PermPastureTussocky(void)
Definition: elements.cpp:2227
LE::GetOwner
Farm * GetOwner(void)
Definition: elements.h:195
LE::SetGooseRoostDist
void SetGooseRoostDist(int a_dist, GooseSpecies a_goose)
Definition: elements.h:364
LE::GetGooseGrazingForage
double GetGooseGrazingForage(GooseSpecies a_goose)
Definition: elements.h:197
VegElement::ZeroVeg
virtual void ZeroVeg(void)
Definition: elements.cpp:1989
LE::ZeroVeg
virtual void ZeroVeg(void)
Definition: elements.h:174
VegElement::GetWeedBiomass
virtual double GetWeedBiomass(void)
Definition: elements.h:581
LE::SetHerbicideDelay
void SetHerbicideDelay(int a_decaytime_days)
Definition: elements.h:312
LE_TypeClass::BackTranslateVegTypes
int BackTranslateVegTypes(TTypesOfVegetation VegReference)
Definition: elements.cpp:3345
PermPastureLowYield
Definition: elements.h:747
LE::GetPollen
virtual PollenNectarQuality GetPollen()
Definition: elements.h:430
LE::m_PollenM2
double m_PollenM2
Definition: elements.h:543
WaterBufferZone::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2354
GreenElement
Definition: elements.h:825
LE::GetLATotal
virtual double GetLATotal(void)
Definition: elements.h:151
LE::GetBorder
LE * GetBorder(void)
Definition: elements.h:317
LE::GetBirdMaize
double GetBirdMaize(void)
Definition: elements.h:204
RoadsideVerge::m_DateCut
long m_DateCut
Definition: elements.h:799
VegElement::m_oldnewgrowth
double m_oldnewgrowth[32]
Definition: elements.h:698
LE::GetTotalNectar
virtual double GetTotalNectar()
Definition: elements.h:433
LE::m_sprayedtoday
bool m_sprayedtoday
flag to indicate an overspray situation
Definition: elements.h:475
Marsh::Marsh
Marsh(void)
Definition: elements.cpp:2390
LE::m_dist_to_closest_roost
double m_dist_to_closest_roost[gs_foobar]
An array holding the distance to the nearest goose roost.
Definition: elements.h:511
g_letype
class LE_TypeClass * g_letype
Definition: elements.cpp:277
VegElement::GrazeVegetation
virtual void GrazeVegetation(double a_grams, bool a_force)
Definition: elements.cpp:2061
CropActualValues::missed_herb_app
int missed_herb_app
Definition: elements.h:562
LE::Insecticide
virtual void Insecticide(double)
Definition: elements.h:158
HeritageSite::HeritageSite
HeritageSite(void)
Definition: elements.cpp:2970
LE::m_rot_index
int m_rot_index
Definition: elements.h:473
LE::GetVegDDegs
double GetVegDDegs()
Get the total of day degrees for the crop/veg on this element.
Definition: elements.h:346
LE::ReleaseOsmiaNest
void ReleaseOsmiaNest()
Test to see if a nest is found.
Definition: elements.h:401
LE::SetMConstants
void SetMConstants(int a, int c)
Definition: elements.h:344
Canal::Canal
Canal(void)
Definition: elements.cpp:2868
LE::m_poly
int m_poly
The polyref number for this polygon.
Definition: elements.h:477
LE::m_signal_mask
LE_Signal m_signal_mask
Definition: elements.h:532
Fence
Definition: elements.h:1171
LE::GetMaxY
int GetMaxY(void)
Definition: elements.h:334
Coast::Coast
Coast(void)
Definition: elements.cpp:2881
VegElement::m_force_growth
bool m_force_growth
Definition: elements.h:705
LE::m_ptrace
int m_ptrace[256]
Definition: elements.h:441
Track::Track
Track(void)
Definition: elements.cpp:2954
LE::GetPigGrazing
bool GetPigGrazing(void)
Definition: elements.h:184
LE::m_vege_danger_store
int m_vege_danger_store
Definition: elements.h:456
VegElement::Add_missed_fi_app
void Add_missed_fi_app()
Definition: elements.h:658
LE::HasTramlines
bool HasTramlines(void)
Definition: elements.h:185
VegElement::ToggleCattleGrazing
virtual void ToggleCattleGrazing(void)
Definition: elements.h:604
LE::SetMaleNewtPresent
virtual void SetMaleNewtPresent(bool)
Sets a male newt as present/absent in descendent classes - here only to prevent need for dynamic cast...
Definition: elements.h:386
VegElement::CalcGooseForageResources
void CalcGooseForageResources()
Calculates spilled grain and grazing forage resources for geese.
Definition: elements.cpp:1805
LE::m_mowndecay
int m_mowndecay
Definition: elements.h:485
LE::GetValidY
int GetValidY(void)
Definition: elements.h:331
HedgeBank::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:3703
VegElement::ForceGrowthInitialize
virtual void ForceGrowthInitialize(void)
Definition: elements.cpp:1930
Freshwater::Freshwater
Freshwater(void)
Definition: elements.cpp:2766
VegElement::m_veg_height
double m_veg_height
Definition: elements.h:692
NonVegElement::NonVegElement
NonVegElement(void)
Definition: elements.cpp:2722
LE_TypeClass::VegTypeToCurveNum
int VegTypeToCurveNum(TTypesOfVegetation VegReference)
LE::m_instubble
bool m_instubble
A flag describing the state of the field from a visual perspective - will be in stubble following a c...
Definition: elements.h:499
LE::SetMapIndex
void SetMapIndex(int a_map_index)
Definition: elements.h:191
LE::LE
LE(void)
Definition: elements.cpp:279
Pond::CalcPondPesticide
void CalcPondPesticide()
Calculates the amount of pesticide per unit pond water
Definition: elements.cpp:2791
VegElement::GetLAGreen
virtual double GetLAGreen(void)
Definition: elements.h:574
LE::SetVegType
virtual void SetVegType(TTypesOfVegetation, TTypesOfVegetation)
Definition: elements.h:164
VegElement::ReduceWeedBiomass
virtual void ReduceWeedBiomass(double a_fraction)
Definition: elements.h:600
VegElement::ReadBugPercentageFile
void ReadBugPercentageFile(void)
Definition: elements.cpp:1439
LE::GetOwnerIndex
int GetOwnerIndex(void)
Definition: elements.h:193
LE::GetPreviousCrop
virtual TTypesOfVegetation GetPreviousCrop(int)
Definition: elements.h:179
UrbanVeg
Definition: elements.h:1094
Building
Definition: elements.h:1046
LE::GetQuarryNos
int GetQuarryNos()
For goose model functionality, returns the number of geese yesterday which can be hunted as legal qua...
Definition: elements.cpp:555
LE::m_unsprayedmarginpolyref
int m_unsprayedmarginpolyref
Definition: elements.h:448
LE::m_management_loop_detect_count
long m_management_loop_detect_count
Definition: elements.h:468
NaturalGrassDry::DoDevelopment
virtual void DoDevelopment()
Definition: elements.cpp:2585
tov_None
Definition: tov_declaration.h:39
SmallRoad::SmallRoad
SmallRoad(void)
Definition: elements.cpp:2944
RoadsideVerge::DoDevelopment
virtual void DoDevelopment(void)
Definition: elements.cpp:2284
LE::GetPoison
bool GetPoison(void)
Definition: elements.h:180
LE::SetVegParameters
virtual void SetVegParameters(double, double, double, double)
Definition: elements.h:166
LE::IsRecentlyMown
bool IsRecentlyMown(void)
Definition: elements.h:186
LE::m_nectarquality
PollenNectarQuality m_nectarquality
Definition: elements.h:540
LE::m_is_in_map
bool m_is_in_map
Definition: elements.h:459
LE::GetMapIndex
int GetMapIndex(void)
Definition: elements.h:190
RefuseSite::RefuseSite
RefuseSite(void)
Definition: elements.cpp:2876
LE::m_type
TTypesOfLandscapeElement m_type
Definition: elements.h:487
IndividualTree::IndividualTree
IndividualTree(void)
Definition: elements.cpp:2711