File failed to load: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/extensions/ams.js
ALMaSS  1.2 (after EcoStack, March 2024)
The Animal, Landscape and Man Simulation System
•All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | List of all members
DE_OCarrots Class Reference

#include <DE_OCarrots.h>

Inheritance diagram for DE_OCarrots:
Crop

Public Member Functions

bool Do (Farm *a_farm, LE *a_field, FarmEvent *a_ev)
 
 DE_OCarrots (TTypesOfVegetation a_tov, TTypesOfCrops a_toc, Landscape *a_L)
 
void SetUpFarmCategoryInformation ()
 
- Public Member Functions inherited from Crop
virtual ~Crop ()
 
 Crop (TTypesOfVegetation a_tov, TTypesOfCrops a_toc, Landscape *a_L)
 
int GetFirstDate (void)
 
void ChooseNextCrop (int a_no_dates)
 Chooses the next crop to grow in a field. More...
 
int GetCropClassification ()
 
void SetCropClassification (int a_classification)
 
void GetCropType (TTypesOfCrops a_toc)
 
TTypesOfCrops GetCropType ()
 
FarmManagementCategory LookUpManagementCategory (int a_todo)
 
bool GetForceSpringOK ()
 

Additional Inherited Members

- Public Attributes inherited from Crop
TTypesOfVegetation m_tov
 
- Protected Member Functions inherited from Crop
void SimpleEvent (long a_date, int a_todo, bool a_lock)
 Adds an event to this crop management. More...
 
void SimpleEvent_ (long a_date, int a_todo, bool a_lock, Farm *a_farm, LE *a_field)
 Adds an event to this crop management without relying on member variables. More...
 
bool StartUpCrop (int a_spring, std::vector< std::vector< int >> a_flexdates, int a_todo)
 
Holds the translation between the farm operation enum for each cropand the farm management category associated with it More...
 
bool AphidDamage (LE *a_field)
 Compares aphid numbers per m2 with a threshold to return true if threshold is exceeded. More...
 
- Protected Attributes inherited from Crop
Farm * m_farm
 
LE * m_field
 
FarmEvent * m_ev
 
int m_first_date
 
int m_count
 
int m_last_date
 
int m_ddegstoharvest
 
int m_base_elements_no
 
Landscape * m_OurLandscape
 
bool m_forcespringpossible = false
 Used to signal that the crop can be forced to start in spring. More...
 
TTypesOfCrops m_toc
 The Crop type in terms of the TTypesOfCrops list (smaller list than tov, no country designation) More...
 
int m_CropClassification
 Contains information on whether this is a winter crop, spring crop, or catch crop that straddles the year boundary (0,1,2) More...
 
vector< FarmManagementCategory > m_ManagementCategories
 Holds the translation between the farm operation enum for each crop and the farm management category associated with it. More...
 
- Static Protected Attributes inherited from Crop
static int m_date_modifier = 0
 Holds a value that shifts test pesticide use by this many days in crops modified to use it. More...
 

Constructor & Destructor Documentation

◆ DE_OCarrots()

DE_OCarrots::DE_OCarrots ( TTypesOfVegetation  a_tov,
TTypesOfCrops  a_toc,
Landscape *  a_L 
)
inline
74  : Crop(a_tov, a_toc, a_L) {
75  m_first_date=g_date->DayInYear(15,3);
76  SetUpFarmCategoryInformation();
77  }

References Calendar::DayInYear(), g_date, Crop::m_first_date, and SetUpFarmCategoryInformation().

Member Function Documentation

◆ Do()

bool DE_OCarrots::Do ( Farm *  a_farm,
LE *  a_field,
FarmEvent *  a_ev 
)
virtual

Reimplemented from Crop.

32 {
33 /******************** This block can be added to the top of all Crop::Do methods ***********************************************/
34  m_farm = a_farm; // These assignments are necessary, not for this method but for related event calls
35  m_field = a_field;
36  m_ev = a_ev;
37  bool done = false; // The boolean value done indicates when we are totally finished with this plan (i.e. it is set to true).
38  int d1 = 0;
39  TTypesOfVegetation l_tov = tov_DEOCarrots; // The current type - change to match the crop you have
40 /**********************************************To Here *************************************************************************/
41 
42  switch (m_ev->m_todo)
43  {
44  case de_ocar_start:
45  {
46  m_field->ClearManagementActionSum();
47 
48  if (g_rand_uni_fnc() <= 0.50) DE_OCAR_DO_SPR_HARVEST = true; else DE_OCAR_DO_SPR_HARVEST = false; // LKM: flags to mark that some farmers do harvest the year after in spring - date for finished management is different
49  // DE_CAR_SLURRY_DATE = 0;
50  // DE_CAR_DECIDE_TO_HERB = 1;
51  // DE_CAR_DECIDE_TO_FI = 1;
52 
53  m_last_date = g_date->DayInYear(30, 11); // Should match the last flexdate below
54  //Create a 2d array of 1 plus the number of operations you use. Change only 4+1 to what you need in the line below
55  std::vector<std::vector<int>> flexdates(1 + 1, std::vector<int>(2, 0));
56  // Set up the date management stuff
57  // Start and stop dates for all events after harvest
58  flexdates[0][1] = g_date->DayInYear(30, 11); // last possible day of harvest - this is in effect day before the earliest date that a following crop can use
59 
60  flexdates[1][0] = -1; // This date will be moved back as far as necessary and potentially to flexdates 1 (start op 1)
61  flexdates[1][1] = g_date->DayInYear(30, 11); // This date will be moved back as far as necessary and potentially to flexdates 1 (end op 1)
62 
63  // Below if this is a spring crop use 365, otherwise set this to 0, second parameter is fixed, and the third is the start up operation in the first year
64  int isSpring = 365;
65  if (StartUpCrop(isSpring, flexdates, int(de_ocar_stoneburier))) break;
66 
67  // End single block date checking code. Please see next line comment as well.
68  // Reinit d1 to first possible starting date.
69  d1 = g_date->OldDays() + g_date->DayInYear(1, 3) + isSpring;
70  // OK, let's go.
71  SimpleEvent_(d1, de_ocar_stoneburier, false, m_farm, m_field);
72  break;
73  }
74  break;
75 
76  case de_ocar_stoneburier:
77  if (!m_farm->DeepPlough(m_field, 0.0, g_date->DayInYear(15, 3) - g_date->DayInYear())) {
78  SimpleEvent_(g_date->Date() + 1, de_ocar_stoneburier, true, m_farm, m_field);
79  break;
80  }
81  // LKM: Queue up the next event - manure + nutrients (K, S and Mg) done before the 20th of April - if not done, try again + 1 day until the 20th of April when we will succeed
82  if (m_farm->IsStockFarmer()) //Stock Farmer // Main thread
83  {
84  SimpleEvent_(g_date->Date() + 1, de_ocar_FAmanure, false, m_farm, m_field);
85  }
86  else SimpleEvent_(g_date->Date() + 1, de_ocar_FPmanure, true, m_farm, m_field);
87  break;
88  case de_ocar_FAmanure:
89  if (!m_farm->FA_Manure(m_field, 0.0, g_date->DayInYear(20, 3) - g_date->DayInYear())) {
90  SimpleEvent_(g_date->Date() + 1, de_ocar_FAmanure, true, m_farm, m_field);
91  break;
92  }
93  // LKM: Queue up the next event - Deep harrow done before the 20th of April - if not done, try again +1 day until the 20th of April when we will succeed
94  SimpleEvent_(g_date->Date(), de_ocar_deep_harrow, false, m_farm, m_field);
95  break;
96  case de_ocar_FPmanure:
97  if (!m_farm->FP_Manure(m_field, 0.0, g_date->DayInYear(20, 3) - g_date->DayInYear())) {
98  SimpleEvent_(g_date->Date() + 1, de_ocar_FPmanure, true, m_farm, m_field);
99  break;
100  }
101  // LKM: Queue up the next event - Deep harrow done before the 20th of April - if not done, try again +1 day until the 20th of April when we will succeed
102  SimpleEvent_(g_date->Date(), de_ocar_deep_harrow, false, m_farm, m_field);
103  break;
104  case de_ocar_deep_harrow:
105  if (!m_farm->AutumnHarrow(m_field, 0.0, g_date->DayInYear(20, 3) - g_date->DayInYear())) {
106  SimpleEvent_(g_date->Date() + 1, de_ocar_deep_harrow, true, m_farm, m_field);
107  break;
108  }
109  // LKM: Queue up the next event - Bedformer done before the 20th of April - if not done, try again +1 day until the 20th of April when we will succeed
110  SimpleEvent_(g_date->Date(), de_ocar_bedformer, false, m_farm, m_field);
111  break;
112  case de_ocar_bedformer:
113  if (!m_farm->BedForming(m_field, 0.0, g_date->DayInYear(20, 3) - g_date->DayInYear())) {
114  SimpleEvent_(g_date->Date() + 1, de_ocar_bedformer, true, m_farm, m_field);
115  break;
116  }
117  // LKM: Queue up the next event - shallow harrow1 (making seedbed) done after the 5th of February and before the 5th of May - if not done, try again +1 day until the 5th of May when we will succeed
118  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(5, 2), de_ocar_sharrow1, false, m_farm, m_field);
119  break;
120  case de_ocar_sharrow1:
121  if (!m_farm->ShallowHarrow(m_field, 0.0, g_date->DayInYear(5, 4) - g_date->DayInYear()))
122  {
123  SimpleEvent_(g_date->Date() + 1, de_ocar_sharrow1, true, m_farm, m_field);
124  break;
125  }
126  // LKM: Queue up the next event - shallow harrow2 (making seedbed) done 5 days after, and before the 10th of May - if not done, try again +1 day until the 10th of May when we will succeed
127  SimpleEvent_(g_date->Date() + 5, de_ocar_sharrow2, false, m_farm, m_field);
128  break;
129  case de_ocar_sharrow2:
130  if (!m_farm->ShallowHarrow(m_field, 0.0, g_date->DayInYear(10, 4) - g_date->DayInYear()))
131  {
132  SimpleEvent_(g_date->Date() + 1, de_ocar_sharrow2, true, m_farm, m_field);
133  break;
134  }
135  // LKM: Queue up the next event - shallow harrow3 (making seedbed) done 5 days after, and before the 15th of May - if not done, try again +1 day until the 15th of May when we will succeed
136  SimpleEvent_(g_date->Date() + 5, de_ocar_sharrow3, false, m_farm, m_field);
137  break;
138  case de_ocar_sharrow3:
139  if (!m_farm->ShallowHarrow(m_field, 0.0, g_date->DayInYear(15, 4) - g_date->DayInYear()))
140  {
141  SimpleEvent_(g_date->Date() + 1, de_ocar_sharrow3, true, m_farm, m_field);
142  break;
143  }
144  // LKM: Queue up the next event - shallow harrow4 (making seedbed) done 5 days after, and before the 20th of May - if not done, try again +1 day until the 20th of May when we will succeed
145  SimpleEvent_(g_date->Date() + 5, de_ocar_sharrow4, false, m_farm, m_field);
146  break;
147  case de_ocar_sharrow4:
148  if (!m_farm->ShallowHarrow(m_field, 0.0, g_date->DayInYear(20, 4) - g_date->DayInYear()))
149  {
150  SimpleEvent_(g_date->Date() + 1, de_ocar_sharrow4, true, m_farm, m_field);
151  break;
152  }
153  // LKM: Queue up the next event - sow done after the 1st of March and before the 30th of May - if not done, try again +1 day until the 30th of May when we will succeed
154  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(1, 3), de_ocar_sow, false, m_farm, m_field);
155  break;
156  case de_ocar_sow:
157  if (!m_farm->SpringSow(m_field, 0.0, g_date->DayInYear(30, 4) - g_date->DayInYear()))
158  {
159  SimpleEvent_(g_date->Date() + 1, de_ocar_sow, true, m_farm, m_field);
160  break;
161  }
162  // LKM: Queue up the next event - burn weeds1 done before the 5th of May - if not done, try again + 1 day until the 5th of May when we will succeed
163  SimpleEvent_(g_date->Date() + 1, de_ocar_burn_weeds1, false, m_farm, m_field);
164  break;
165  case de_ocar_burn_weeds1:
166  if (!m_farm->BurnStrawStubble(m_field, 0.0, g_date->DayInYear(5, 5) - g_date->DayInYear()))
167  {
168  SimpleEvent_(g_date->Date() + 1, de_ocar_burn_weeds1, true, m_farm, m_field);
169  break;
170  }
171  // LKM: Queue up the next event - burn weeds2 done (+5 days after) before the 10th of May - if not done, try again + 1 day until the 10th of May when we will succeed
172  SimpleEvent_(g_date->Date() + 5, de_ocar_burn_weeds2, false, m_farm, m_field);
173  break;
174  case de_ocar_burn_weeds2:
175  if (!m_farm->BurnStrawStubble(m_field, 0.0, g_date->DayInYear(10, 5) - g_date->DayInYear()))
176  {
177  SimpleEvent_(g_date->Date() + 1, de_ocar_burn_weeds2, true, m_farm, m_field);
178  break;
179  }
180  // LKM: Queue up the next event - Row cultivation1 done before the 15th of May - if not done, try again + 1 day until the 15th of May when we will succeed
181  SimpleEvent_(g_date->Date() + 1, de_ocar_row_cultivation1, false, m_farm, m_field);
182  break;
183  case de_ocar_row_cultivation1:
184  if (!m_farm->RowCultivation(m_field, 0.0, g_date->DayInYear(15, 5) - g_date->DayInYear()))
185  {
186  SimpleEvent_(g_date->Date() + 1, de_ocar_row_cultivation1, true, m_farm, m_field);
187  break;
188  }
189  // LKM: Queue up the next event - Row cultivation2 done (+8 days after) before the 20th of May - if not done, try again + 1 day until the 20th of May when we will succeed
190  SimpleEvent_(g_date->Date() + 8, de_ocar_row_cultivation2, false, m_farm, m_field);
191  break;
192  case de_ocar_row_cultivation2:
193  if (!m_farm->RowCultivation(m_field, 0.0, g_date->DayInYear(25, 5) - g_date->DayInYear()))
194  {
195  SimpleEvent_(g_date->Date() + 1, de_ocar_row_cultivation2, true, m_farm, m_field);
196  break;
197  }
198  // LKM: Queue up the next event - manual weeding (+5 days after) done before the 30th of May - if not done, try again + 1 day until the 30th of May when we will succeed
199  SimpleEvent_(g_date->Date() + 8, de_ocar_manual_weeding, false, m_farm, m_field);
200  break;
201  case de_ocar_manual_weeding:
202  if (!m_farm->ManualWeeding(m_field, 0.0, g_date->DayInYear(30, 5) - g_date->DayInYear()))
203  {
204  SimpleEvent_(g_date->Date() + 1, de_ocar_manual_weeding, true, m_farm, m_field);
205  break;
206  }
207  // LKM: Queue up the next event - water2 done before the 5th of July - if not done, try again +1 day until the 5th of July when we will succeed
208  SimpleEvent_(g_date->Date(), de_ocar_water1, false, m_farm, m_field);
209  break;
210  case de_ocar_water1:
211  if (!m_farm->Water(m_field, 0.0, g_date->DayInYear(5, 6) - g_date->DayInYear()))
212  {
213  SimpleEvent_(g_date->Date() + 1, de_ocar_water1, true, m_farm, m_field);
214  break;
215  }
216  // LKM: Queue up the next event - hilling up1 done before the 5th of July - if not done, try again +1 day until the 5th of July when we will succeed
217  SimpleEvent_(g_date->Date() + 1, de_ocar_hilling_up1, false, m_farm, m_field);
218  break;
219  case de_ocar_hilling_up1:
220  if (!m_farm->HillingUp(m_field, 0.0, g_date->DayInYear(5, 6) - g_date->DayInYear()))
221  {
222  SimpleEvent_(g_date->Date() + 1, de_ocar_hilling_up1, true, m_farm, m_field);
223  break;
224  }
225  // LKM: Queue up the next event - add pfr1 done before the 10th of July - if not done, try again + 1 day until the 10th of July when we will succeed
226  SimpleEvent_(g_date->Date() + 1, de_ocar_boron1_s, false, m_farm, m_field);
227  break;
228  case de_ocar_boron1_s:
229  if (a_farm->IsStockFarmer()) {
230  if (!m_farm->FA_Boron(m_field, 0.0, g_date->DayInYear(10, 6) - g_date->DayInYear()))
231  {
232  SimpleEvent_(g_date->Date() + 1, de_ocar_boron1_s, true, m_farm, m_field);
233  break;
234  }
235  // LKM: Queue up the next event - water2 done after the 10th of June and before the 20th of July - if not done, try again +1 day until the 10th of July when we will succeed
236  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(10, 6), de_ocar_water2, false, m_farm, m_field);
237  break;
238  }
239  SimpleEvent_(g_date->Date() + 1, de_ocar_boron1_p, false, m_farm, m_field);
240  break;
241 
242  case de_ocar_boron1_p:
243  if (!m_farm->FP_Boron(m_field, 0.0, g_date->DayInYear(10, 6) - g_date->DayInYear()))
244  {
245  SimpleEvent_(g_date->Date() + 1, de_ocar_boron1_p, true, m_farm, m_field);
246  break;
247  }
248  // LKM: Queue up the next event - water2 done after the 10th of June and before the 20th of July - if not done, try again +1 day until the 10th of July when we will succeed
249  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(10, 6), de_ocar_water2, false, m_farm, m_field);
250  break;
251 
252  case de_ocar_water2:
253  if (!m_farm->Water(m_field, 0.0, g_date->DayInYear(20, 7) - g_date->DayInYear()))
254  {
255  SimpleEvent_(g_date->Date() + 1, de_ocar_water2, true, m_farm, m_field);
256  break;
257  }
258  // LKM: Queue up the next event - hilling up2 done before the 30th of July - if not done, try again +1 day until the 30th of July when we will succeed
259  SimpleEvent_(g_date->Date() + 1, de_ocar_hilling_up2, false, m_farm, m_field);
260  break;
261  case de_ocar_hilling_up2:
262  if (!m_farm->HillingUp(m_field, 0.0, g_date->DayInYear(30, 7) - g_date->DayInYear()))
263  {
264  SimpleEvent_(g_date->Date() + 1, de_ocar_hilling_up2, true, m_farm, m_field);
265  break;
266  }
267  // LKM: Queue up the next event - boron2 done after the 1st of May, and before the 30th of August - if not done, try again +1 day until the 30th of August when we will succeed
268  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(1, 7), de_ocar_boron2_s, false, m_farm, m_field);
269  break;
270  case de_ocar_boron2_s:
271  if (a_farm->IsStockFarmer()) {
272  if (!m_farm->FA_Boron(m_field, 0.0, g_date->DayInYear(29, 8) - g_date->DayInYear()))
273  {
274  SimpleEvent_(g_date->Date() + 1, de_ocar_boron2_s, true, m_farm, m_field);
275  break;
276  }
277  // LKM: Queue up the next event - hilling up3 done before the 30th of August - if not done, try again +1 day until the 30th of July when we will succeed
278  SimpleEvent_(g_date->Date(), de_ocar_hilling_up3, false, m_farm, m_field);
279  break;
280  }
281  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(1, 7), de_ocar_boron2_p, false, m_farm, m_field);
282  break;
283 
284  case de_ocar_boron2_p:
285  if (!m_farm->FP_Boron(m_field, 0.0, g_date->DayInYear(29, 8) - g_date->DayInYear()))
286  {
287  SimpleEvent_(g_date->Date() + 1, de_ocar_boron2_p, true, m_farm, m_field);
288  break;
289  }
290  // LKM: Queue up the next event - hilling up3 done before the 30th of August - if not done, try again +1 day until the 30th of July when we will succeed
291  SimpleEvent_(g_date->Date(), de_ocar_hilling_up3, false, m_farm, m_field);
292  break;
293 
294  case de_ocar_hilling_up3:
295  if (!m_farm->HillingUp(m_field, 0.0, g_date->DayInYear(30, 8) - g_date->DayInYear()))
296  {
297  SimpleEvent_(g_date->Date() + 1, de_ocar_hilling_up3, true, m_farm, m_field);
298  break;
299  }
300  // LKM: Queue up the next event - harvest carrots, done before the 30th of November - if not done, try again +1 day until the 30th of November when we will succeed
301  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(20, 6), de_ocar_harvest, false, m_farm, m_field);
302  break;
303  case de_ocar_harvest:
304  if (!m_farm->Harvest(m_field, 0.0, m_field->GetMDates(1, 0) - g_date->DayInYear())) {
305  SimpleEvent_(g_date->Date() + 1, de_ocar_harvest, true, m_farm, m_field);
306  break;
307  //if (!m_farm->Harvest(m_field, 0.0, g_date->DayInYear(30, 11) - g_date->DayInYear()))
308  //{
309  // SimpleEvent_(g_date->Date() + 1, de_ca_harvest, true, m_farm, m_field);
310  // break;
311  //}
312  }
313  d1 = g_date->Date();
314  if (d1 < g_date->OldDays() + g_date->DayInYear(1, 7)) {
315  SimpleEvent_(g_date->OldDays() + g_date->DayInYear(1, 7), de_ocar_wait, false, m_farm, m_field);
316  // Because we are ending harvest before 1.7 so we need to wait until the 1.7
317  break;
318  }
319  else {
320  done = true; // end of plan
321  }
322  case de_ocar_wait:
323  done = true;
324  break;
325  // So we are done, and somewhere else the farmer will queue up the start event of the next crop
326  // END of MAIN THREAD
327  break;
328  default:
329  g_msg->Warn(WARN_BUG, "DE_OCarrots::Do(): "
330  "Unknown event type! ", "");
331  exit(1);
332  }
333 
334  return done;
335 }

References Farm::AutumnHarrow(), Farm::BedForming(), Farm::BurnStrawStubble(), LE::ClearManagementActionSum(), Calendar::Date(), Calendar::DayInYear(), de_ocar_bedformer, de_ocar_boron1_p, de_ocar_boron1_s, de_ocar_boron2_p, de_ocar_boron2_s, de_ocar_burn_weeds1, de_ocar_burn_weeds2, de_ocar_deep_harrow, DE_OCAR_DO_SPR_HARVEST, de_ocar_FAmanure, de_ocar_FPmanure, de_ocar_harvest, de_ocar_hilling_up1, de_ocar_hilling_up2, de_ocar_hilling_up3, de_ocar_manual_weeding, de_ocar_row_cultivation1, de_ocar_row_cultivation2, de_ocar_sharrow1, de_ocar_sharrow2, de_ocar_sharrow3, de_ocar_sharrow4, de_ocar_sow, de_ocar_start, de_ocar_stoneburier, de_ocar_wait, de_ocar_water1, de_ocar_water2, Farm::DeepPlough(), Farm::FA_Boron(), Farm::FA_Manure(), Farm::FP_Boron(), Farm::FP_Manure(), g_date, g_msg, g_rand_uni_fnc(), LE::GetMDates(), Farm::Harvest(), Farm::HillingUp(), Farm::IsStockFarmer(), Crop::m_ev, Crop::m_farm, Crop::m_field, Crop::m_last_date, FarmEvent::m_todo, Farm::ManualWeeding(), Calendar::OldDays(), Farm::RowCultivation(), Farm::ShallowHarrow(), Crop::SimpleEvent_(), Farm::SpringSow(), Crop::StartUpCrop(), tov_DEOCarrots, MapErrorMsg::Warn(), WARN_BUG, and Farm::Water().

◆ SetUpFarmCategoryInformation()

void DE_OCarrots::SetUpFarmCategoryInformation ( )
inline
78  {
79  const int elements = 2 + (de_ocar_foobar - DE_OCAR_BASE);
80  m_base_elements_no = DE_OCAR_BASE - 2;
81 
82  FarmManagementCategory catlist[elements] =
83  {
84  fmc_Others, // zero element unused but must be here
85  fmc_Others, // de_ocar_start = 1, // Compulsory, start event must always be 1 (one).
86  fmc_Cultivation, // de_ocar_stoneburier = DE_OCAR_BASE,
87  fmc_Fertilizer, // de_ocar_FAmanure,
88  fmc_Fertilizer, // de_ocar_FPmanure,
89  fmc_Cultivation, // de_ocar_deep_harrow,
90  fmc_Cultivation, // de_ocar_bedformer,
91  fmc_Cultivation, // de_ocar_sharrow1,
92  fmc_Cultivation, // de_ocar_sharrow2,
93  fmc_Cultivation, // de_ocar_sharrow3,
94  fmc_Cultivation, // de_ocar_sharrow4,
95  fmc_Others, // de_ocar_sow,
96  fmc_Others, // de_ocar_burn_weeds1,
97  fmc_Others, // de_ocar_burn_weeds2,
98  fmc_Cultivation, // de_ocar_row_cultivation1,
99  fmc_Cultivation, // de_ocar_row_cultivation2,
100  fmc_Cultivation, // de_ocar_manual_weeding,
101  fmc_Others, // de_ocar_water1,
102  fmc_Cultivation, // de_ocar_hilling_up1,
103  fmc_Fertilizer, // de_ocar_boron1,
104  fmc_Fertilizer, // de_ocar_boron1,
105  fmc_Others, // de_ocar_water2,
106  fmc_Cultivation, // de_ocar_hilling_up2,
107  fmc_Fertilizer, // de_ocar_boron2,
108  fmc_Fertilizer, // de_ocar_boron2,
109  fmc_Cultivation, // de_ocar_hilling_up3,
110  fmc_Harvest, // de_ocar_harvest,
111  fmc_Others, // de_ocar_wait,
112 
113 
114  // no foobar entry
115 
116  };
117  // Iterate over the catlist elements and copy them to vector
118  copy(begin(catlist), end(catlist), back_inserter(m_ManagementCategories));
119 
120  }

References DE_OCAR_BASE, de_ocar_foobar, fmc_Cultivation, fmc_Fertilizer, fmc_Harvest, fmc_Others, Crop::m_base_elements_no, and Crop::m_ManagementCategories.

Referenced by DE_OCarrots().

The documentation for this class was generated from the following files:
LE::GetMDates
int GetMDates(int a, int b)
Definition: Elements.h:405
de_ocar_manual_weeding
Definition: DE_OCarrots.h:55
DE_OCAR_BASE
#define DE_OCAR_BASE
Definition: DE_OCarrots.h:31
de_ocar_row_cultivation1
Definition: DE_OCarrots.h:53
de_ocar_sharrow3
Definition: DE_OCarrots.h:48
de_ocar_sharrow2
Definition: DE_OCarrots.h:47
g_rand_uni_fnc
double g_rand_uni_fnc()
Definition: ALMaSS_Random.cpp:56
Farm::IsStockFarmer
bool IsStockFarmer(void)
Definition: Farm.h:961
DE_OCAR_DO_SPR_HARVEST
#define DE_OCAR_DO_SPR_HARVEST
Definition: DE_OCarrots.h:35
de_ocar_hilling_up2
Definition: DE_OCarrots.h:61
Farm::Harvest
virtual bool Harvest(LE *a_field, double a_user, int a_days)
Carry out a harvest on a_field.
Definition: FarmFuncs.cpp:1364
tov_DEOCarrots
Definition: LandscapeFarmingEnums.h:481
LE::ClearManagementActionSum
void ClearManagementActionSum()
clears the management action counters
Definition: Elements.h:247
de_ocar_sharrow1
Definition: DE_OCarrots.h:46
de_ocar_bedformer
Definition: DE_OCarrots.h:45
de_ocar_sharrow4
Definition: DE_OCarrots.h:49
DE_OCarrots::SetUpFarmCategoryInformation
void SetUpFarmCategoryInformation()
Definition: DE_OCarrots.h:78
de_ocar_row_cultivation2
Definition: DE_OCarrots.h:54
de_ocar_boron2_s
Definition: DE_OCarrots.h:62
de_ocar_FAmanure
Definition: DE_OCarrots.h:42
g_date
class Calendar * g_date
Definition: Calendar.cpp:37
de_ocar_water1
Definition: DE_OCarrots.h:56
Farm::BedForming
virtual bool BedForming(LE *a_field, double a_user, int a_days)
Do bed forming up on a_field, probably of carrots.
Definition: FarmFuncs.cpp:1316
Farm::FA_Manure
virtual bool FA_Manure(LE *a_field, double a_user, int a_days)
Spread manure on a_field owned by an stock farmer.
Definition: FarmFuncs.cpp:1110
Farm::SpringSow
virtual bool SpringSow(LE *a_field, double a_user, int a_days, double a_seed_coating_amount=-1, PlantProtectionProducts a_ppp=ppp_foobar)
Carry out a sowing event in the spring on a_field.
Definition: FarmFuncs.cpp:501
de_ocar_wait
Definition: DE_OCarrots.h:66
Crop::m_base_elements_no
int m_base_elements_no
Definition: Farm.h:505
de_ocar_foobar
Definition: DE_OCarrots.h:67
Crop::m_first_date
int m_first_date
Definition: Farm.h:501
Farm::HillingUp
virtual bool HillingUp(LE *a_field, double a_user, int a_days)
Do hilling up on a_field, probably of potatoes.
Definition: FarmFuncs.cpp:1302
Farm::FP_Manure
virtual bool FP_Manure(LE *a_field, double a_user, int a_days)
Spread manure on a_field owned by an arable farmer.
Definition: FarmFuncs.cpp:896
fmc_Fertilizer
Definition: LandscapeFarmingEnums.h:1004
Calendar::Date
long Date(void)
Definition: Calendar.h:57
fmc_Cultivation
Definition: LandscapeFarmingEnums.h:1008
de_ocar_start
Definition: DE_OCarrots.h:40
de_ocar_boron1_p
Definition: DE_OCarrots.h:59
fmc_Others
Definition: LandscapeFarmingEnums.h:1003
de_ocar_burn_weeds1
Definition: DE_OCarrots.h:51
de_ocar_deep_harrow
Definition: DE_OCarrots.h:44
Calendar::OldDays
long OldDays(void)
Definition: Calendar.h:60
de_ocar_boron2_p
Definition: DE_OCarrots.h:63
MapErrorMsg::Warn
void Warn(MapErrorState a_level, std::string a_msg1, std::string a_msg2)
Definition: MapErrorMsg.cpp:69
Farm::FA_Boron
virtual bool FA_Boron(LE *a_field, double a_user, int a_days)
Apply soluble Boron to a_field owned by a stock farmer.
Definition: FarmFuncs.cpp:868
de_ocar_boron1_s
Definition: DE_OCarrots.h:58
Crop::StartUpCrop
bool StartUpCrop(int a_spring, std::vector< std::vector< int >> a_flexdates, int a_todo)
Holds the translation between the farm operation enum for each cropand the farm management category a...
Definition: Farm.cpp:652
de_ocar_hilling_up3
Definition: DE_OCarrots.h:64
Farm::FP_Boron
virtual bool FP_Boron(LE *a_field, double a_user, int a_days)
Apply soluble Boron to a_field owned by an arable farmer.
Definition: FarmFuncs.cpp:854
de_ocar_harvest
Definition: DE_OCarrots.h:65
Farm::ManualWeeding
virtual bool ManualWeeding(LE *a_field, double a_user, int a_days)
Manual weeding on a_field - no tramlines since weeding by hand, the bush stays on field with same veg...
Definition: FarmFuncs.cpp:2002
Crop::m_farm
Farm * m_farm
Definition: Farm.h:498
Crop::m_field
LE * m_field
Definition: Farm.h:499
Crop::m_ManagementCategories
vector< FarmManagementCategory > m_ManagementCategories
Holds the translation between the farm operation enum for each crop and the farm management category ...
Definition: Farm.h:530
FarmEvent::m_todo
int m_todo
Definition: Farm.h:388
Farm::ShallowHarrow
virtual bool ShallowHarrow(LE *a_field, double a_user, int a_days)
Carry out a shallow harrow event on a_field, e.g., after grass cutting event.
Definition: FarmFuncs.cpp:473
de_ocar_hilling_up1
Definition: DE_OCarrots.h:57
Farm::RowCultivation
virtual bool RowCultivation(LE *a_field, double a_user, int a_days)
Carry out a harrowing between crop rows on a_field.
Definition: FarmFuncs.cpp:1183
Farm::Water
virtual bool Water(LE *a_field, double a_user, int a_days)
Carry out a watering on a_field.
Definition: FarmFuncs.cpp:1330
Crop::m_last_date
int m_last_date
Definition: Farm.h:503
g_msg
MapErrorMsg * g_msg
Definition: MapErrorMsg.cpp:41
Farm::AutumnHarrow
virtual bool AutumnHarrow(LE *a_field, double a_user, int a_days)
Carry out a harrow event in the autumn on a_field.
Definition: FarmFuncs.cpp:285
TTypesOfVegetation
TTypesOfVegetation
Values that represent the types of vegetation that are represented in ALMaSS.
Definition: LandscapeFarmingEnums.h:192
de_ocar_water2
Definition: DE_OCarrots.h:60
Farm::DeepPlough
virtual bool DeepPlough(LE *a_field, double a_user, int a_days)
Carry out a deep ploughing event on a_field.
Definition: FarmFuncs.cpp:408
fmc_Harvest
Definition: LandscapeFarmingEnums.h:1012
de_ocar_sow
Definition: DE_OCarrots.h:50
Calendar::DayInYear
int DayInYear(void)
Definition: Calendar.h:58
Crop::Crop
Crop(TTypesOfVegetation a_tov, TTypesOfCrops a_toc, Landscape *a_L)
Definition: Farm.cpp:733
de_ocar_stoneburier
Definition: DE_OCarrots.h:41
Farm::BurnStrawStubble
virtual bool BurnStrawStubble(LE *a_field, double a_user, int a_days)
Burn stubble on a_field.
Definition: FarmFuncs.cpp:1567
Crop::m_ev
FarmEvent * m_ev
Definition: Farm.h:500
de_ocar_FPmanure
Definition: DE_OCarrots.h:43
WARN_BUG
Definition: MapErrorMsg.h:34
FarmManagementCategory
FarmManagementCategory
Definition: LandscapeFarmingEnums.h:1001
de_ocar_burn_weeds2
Definition: DE_OCarrots.h:52
Crop::SimpleEvent_
void SimpleEvent_(long a_date, int a_todo, bool a_lock, Farm *a_farm, LE *a_field)
Adds an event to this crop management without relying on member variables.
Definition: Farm.cpp:751