Goose Management Model ODdox  1.02
farmfuncs.cpp
Go to the documentation of this file.
1 
14 //
15 // farmfuncs.cpp
16 //
17 /*
18 *******************************************************************************************************
19 Copyright (c) 2011, Christopher John Topping, University of Aarhus
20 All rights reserved.
21 
22 Redistribution and use in source and binary forms, with or without modification, are permitted provided
23 that the following conditions are met:
24 
25 Redistributions of source code must retain the above copyright notice, this list of conditions and the
26 following disclaimer.
27 Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
28 the following disclaimer in the documentation and/or other materials provided with the distribution.
29 
30 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
31 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
32 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
33 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
34 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
35 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 ********************************************************************************************************
39 */
40 #define UNREFERENCED_PARAMETER(P) (P)
41 
42 #include "ls.h"
43 
44 
45 using namespace std;
46 
47 extern Landscape* g_landscape_p;
55 
56 #define DO_IT_PROB (l_farm_event_do_it_prob.value())
57 #define DO_IT_PROB_LONG (l_farm_event_do_it_prob_long.value())
58 
59 static CfgInt l_farm_event_do_it_prob("FARM_EVENT_DO_IT_PROB", CFG_PRIVATE, 50);
60 static CfgInt l_farm_event_do_it_prob_long("FARM_EVENT_DO_IT_PROB_LONG", CFG_PRIVATE, 5);
61 static CfgFloat l_farm_cattle_veg_reduce("FARM_CATTLE_VEG_REDUCE", CFG_CUSTOM, 1.5);
62 static CfgFloat l_farm_cattle_veg_reduce2("FARM_CATTLE_VEG_REDUCE_LOW", CFG_CUSTOM, 1.00 );
63 static CfgFloat l_farm_pig_veg_reduce("FARM_PIG_VEG_REDUCE", CFG_CUSTOM, 0.98 );
64 static CfgFloat cfg_CustomInsecticideKillProp("CUSTOMINSECTIVIDEKILLPROP", CFG_CUSTOM, 0.5,0,1.0);
65 
66 // Determine whether insecticide and herbicide actually
67 // influences the insect population. By default they *do*
68 // kill off some of the little critters.
69 static CfgBool l_farm_insecticide_kills("FARM_INSECTICIDE_KILLS", CFG_CUSTOM, true );
70 static CfgBool l_farm_herbicide_kills("FARM_PESTICIDE_KILLS", CFG_CUSTOM, true );
71 
73 CfgInt cfg_WW_InsecticideDay("PEST_WWINSECTONEDAY", CFG_CUSTOM, 1);
75 CfgInt cfg_WW_InsecticideMonth("PEST_WWINSECTONEMONTH", CFG_CUSTOM, 5);
77 CfgFloat cfg_WW_conv_tillage_prop1("TILLAGE_WWCONVONEPROP", CFG_CUSTOM, 1.0);
79 CfgFloat cfg_WW_conv_tillage_prop2("TILLAGE_WWCONVTWOPROP", CFG_CUSTOM, 1.0);
81 CfgFloat cfg_WW_NINV_tillage_prop1("TILLAGE_WWNINVONEPROP", CFG_CUSTOM, 1.0);
83 CfgFloat cfg_WW_NINV_tillage_prop2("TILLAGE_WWNINVTWOPROP", CFG_CUSTOM, 1.0);
85 CfgFloat cfg_WW_isecticide_prop1("PEST_WWINSECTONEPROP", CFG_CUSTOM, 1.0);
87 CfgFloat cfg_WW_isecticide_prop2("PEST_WWINSECTTWOPROP", CFG_CUSTOM, 1.0);
89 CfgFloat cfg_WW_isecticide_prop3("PEST_WWINSECTTHREEPROP", CFG_CUSTOM, 1.0);
90 
91 
93 CfgInt cfg_SB_InsecticideDay("PEST_SBINSECTONEDAY", CFG_CUSTOM, 15);
95 CfgInt cfg_SB_InsecticideMonth("PEST_SBINSECTONEMONTH", CFG_CUSTOM, 5);
97 CfgInt cfg_OSR_InsecticideDay("PEST_OSRINSECTONEDAY", CFG_CUSTOM, 30);
99 CfgInt cfg_OSR_InsecticideMonth("PEST_OSRINSECTONEMONTH", CFG_CUSTOM, 4);
100 
102 CfgInt cfg_CAB_InsecticideDay("PEST_CABINSECTONEDAY", CFG_CUSTOM, 15);
104 CfgInt cfg_CAB_InsecticideMonth("PEST_CABINSECTONEMONTH", CFG_CUSTOM, 5);
105 
107 CfgInt cfg_TU_InsecticideDay("PEST_TUINSECTONEDAY", CFG_CUSTOM, 15);
109 CfgInt cfg_TU_InsecticideMonth("PEST_TUINSECTONEMONTH", CFG_CUSTOM, 5);
110 
112 CfgInt cfg_POT_InsecticideDay("PEST_POTINSECTONEDAY", CFG_CUSTOM, 15);
114 CfgInt cfg_POT_InsecticideMonth("PEST_POTINSECTONEMONTH", CFG_CUSTOM, 5);
115 
117 CfgInt cfg_BE_InsecticideDay("PEST_BEINSECTONEDAY", CFG_CUSTOM, 15);
119 CfgInt cfg_BE_InsecticideMonth("PEST_BEINSECTONEMONTH", CFG_CUSTOM, 5);
120 
121 
122 //declared in elements.cpp
126 
127 
132 bool Farm::AutumnPlough( LE *a_field, double /*a_user*/, int a_days )
133 {
134 
135  // LE is a pointer to the field element
136  // a_user is a pointer to the farm
137  // a_days is the end of the operation time - today
138  // if a_days <0 then the time to do it is passed
139  // the line below reads 'plough if last day possible OR if not raining and pass a probability test
140  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
141  // this bit sets up the events to occur when ploughing occurs
142  // The trace below is for debugging checks
143  a_field->Trace( autumn_plough );
144  // Record the event for this field, so other objects can find out it has happened
145  a_field->SetLastTreatment( autumn_plough );
146  // Apply mortality to the insects present, in this case 90%. This only affects the general insect model, any ALMaSS model species need to take their specific action.
147  a_field->InsectMortality( 0.1 );
148  // Reduce the vegetation, in this case to zero
149  a_field->ZeroVeg();
150  // If the field has a field margin, then do all this to the field margin too. In events that don't occur on an unsprayed margin, e.g. insecticide, then is part is skipped.
151  int pref=a_field->GetUnsprayedMarginPolyRef();
152  if (pref!=-1){
153  // Must have an unsprayed margin so need to pass the information on to it
154  LE* um=g_landscape_p->SupplyLEPointer(pref);
156  um->InsectMortality( 0.1 );
157  um->ZeroVeg();
158  }
159  return true; // completed
160  }
161  return false; // not completed
162 }
163 
169 bool Farm::StubblePlough(LE *a_field, double /*a_user*/, int a_days)
170 {
171  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
172  a_field->Trace(stubble_plough);
174  a_field->InsectMortality(0.1); // The same global mortality as for normal plough
175  a_field->ZeroVeg();
176  int pref = a_field->GetUnsprayedMarginPolyRef();
177  if (pref != -1) {
178  // Must have an unsprayed margin so need to pass the information on to it
179  LE* um = g_landscape_p->SupplyLEPointer(pref);
181  um->InsectMortality(0.1);
182  um->ZeroVeg();
183  }
184  return true; // completed
185  }
186  return false; // not completed
187 }
188 
193 bool Farm::StubbleCultivatorHeavy(LE *a_field, double /*a_user*/, int a_days)
194 {
195  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
196  a_field->Trace(stubble_cultivator_heavy);
198  a_field->InsectMortality(0.1); // The same global mortality as for normal plough
199  a_field->ZeroVeg(); // Zero veg as with stubble harrowing
200  int pref = a_field->GetUnsprayedMarginPolyRef();
201  if (pref != -1) {
202  // Must have an unsprayed margin so need to pass the information on to it
203  LE* um = g_landscape_p->SupplyLEPointer(pref);
205  um->InsectMortality(0.1);
206  um->ZeroVeg();
207  }
208  return true; // completed
209  }
210  return false; // not completed
211 }
212 
217 bool Farm::HeavyCultivatorAggregate(LE *a_field, double /*a_user*/, int a_days)
218 {
219  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
220  a_field->Trace(heavy_cultivator_aggregate);
222  a_field->InsectMortality(0.1); // The same global mortality as for normal plough
223  a_field->ZeroVeg(); // Zero veg as with stubble harrowing
224  int pref = a_field->GetUnsprayedMarginPolyRef();
225  if (pref != -1) {
226  // Must have an unsprayed margin so need to pass the information on to it
227  LE* um = g_landscape_p->SupplyLEPointer(pref);
229  um->InsectMortality(0.1);
230  um->ZeroVeg();
231  }
232  return true; // completed
233  }
234  return false; // not completed
235 }
236 
241 bool Farm::SleepAllDay( LE *a_field, double /*a_user*/, int a_days)
242 {
243  if (0 >= a_days) {
244  a_field->Trace(sleep_all_day);
246  int pref = a_field->GetUnsprayedMarginPolyRef();
247  if (pref != -1) {
248  // Must have an unsprayed margin so need to pass the information on to it
249  LE* um = g_landscape_p->SupplyLEPointer(pref);
251  }
252  return true;
253  }
254  return false;
255 }
256 
261 bool Farm::AutumnHarrow( LE *a_field, double /*a_user*/, int a_days )
262 {
263 
264  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
265  a_field->Trace( autumn_harrow );
266  a_field->SetLastTreatment( autumn_harrow );
267  // Apply 90% mortality to the insects
268  a_field->InsectMortality( 0.1 );
269  // Reduce the vegetation to zero
270  a_field->ZeroVeg();
271  int pref=a_field->GetUnsprayedMarginPolyRef();
272  if (pref!=-1){
273  // Must have an unsprayed margin so need to pass the information on to it
274  LE* um=g_landscape_p->SupplyLEPointer(pref);
276  um->InsectMortality( 0.1 );
277  um->ZeroVeg();
278  }
279  return true;
280  }
281  return false;
282 }
283 
288 bool Farm::AutumnRoll( LE *a_field, double /*a_user*/, int a_days )
289 {
290 
291  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
292  a_field->Trace( autumn_roll );
293  a_field->SetLastTreatment( autumn_roll );
294  a_field->ZeroVeg();
295  int pref=a_field->GetUnsprayedMarginPolyRef();
296  if (pref!=-1){
297  // Must have an unsprayed margin so need to pass the information on to it
298  LE* um=g_landscape_p->SupplyLEPointer(pref);
300  um->ZeroVeg();
301  }
302  return true;
303  }
304  return false;
305 }
306 
311 bool Farm::PreseedingCultivator(LE *a_field, double /*a_user*/, int a_days)
312 {
313  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
314  a_field->Trace(preseeding_cultivator);
316  // Apply 90% mortality to the insects as for harrowing
317  a_field->InsectMortality(0.1);
318  // Reduce the vegetation to zero as for harrowing
319  a_field->ZeroVeg();
320  int pref = a_field->GetUnsprayedMarginPolyRef();
321  if (pref != -1) {
322  // Must have an unsprayed margin so need to pass the information on to it
323  LE* um = g_landscape_p->SupplyLEPointer(pref);
325  um->InsectMortality(0.1);
326  um->ZeroVeg();
327  }
328  return true;
329  }
330  return false;
331 }
332 
337 bool Farm::PreseedingCultivatorSow(LE *a_field, double /*a_user*/, int a_days)
338 {
339  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
340  a_field->Trace(preseeding_cultivator_sow);
342  a_field->SetGrowthPhase(sow); // as with AutumnSow treatment
343  a_field->SetLastSownVeg(a_field->GetVegType()); // as with AutumnSow treatment
344  // Reduce the vegetation to zero
345  a_field->ZeroVeg();
346  int pref = a_field->GetUnsprayedMarginPolyRef();
347  if (pref != -1) {
348  // Must have an unsprayed margin so need to pass the information on to it
349  LE* um = g_landscape_p->SupplyLEPointer(pref);
351  um->SetGrowthPhase(sow);
352  um->ZeroVeg();
353  um->SetLastSownVeg(um->GetVegType());
354  }
355  return true;
356  }
357  return false;
358 }
359 
364 bool Farm::AutumnSow( LE *a_field, double /*a_user*/, int a_days )
365 {
366 
367  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
368  a_field->Trace( autumn_sow );
369  a_field->SetLastTreatment( autumn_sow );
370  a_field->SetGrowthPhase( sow );
371  a_field->SetLastSownVeg(a_field->GetVegType());
372  // Reduce the vegetation to zero
373  a_field->ZeroVeg();
374  int pref=a_field->GetUnsprayedMarginPolyRef();
375  if (pref!=-1){
376  // Must have an unsprayed margin so need to pass the information on to it
377  LE* um=g_landscape_p->SupplyLEPointer(pref);
379  um->SetGrowthPhase( sow );
380  um->ZeroVeg();
381  um->SetLastSownVeg(um->GetVegType());
382  }
383  return true;
384  }
385  return false;
386 }
387 
392 bool Farm::WinterPlough( LE *a_field, double /*a_user*/, int a_days )
393 {
394 
395  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
396  a_field->Trace( winter_plough );
397  a_field->SetLastTreatment( winter_plough );
398  a_field->InsectMortality( 0.1 );
399  a_field->ZeroVeg();
400  int pref=a_field->GetUnsprayedMarginPolyRef();
401  if (pref!=-1){
402  // Must have an unsprayed margin so need to pass the information on to it
403  LE* um=g_landscape_p->SupplyLEPointer(pref);
405  um->InsectMortality( 0.1 );
406  um->ZeroVeg();
407  }
408  return true;
409  }
410  return false;
411 }
412 
417 bool Farm::DeepPlough( LE *a_field, double /*a_user*/, int a_days )
418 {
419 
420  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
421  a_field->Trace( deep_ploughing );
422  a_field->SetLastTreatment( deep_ploughing );
423  // Apply 90% mortality to the insects
424  a_field->InsectMortality( 0.1 );
425  // Reduce the vegetation to zero
426  a_field->ZeroVeg();
427  int pref=a_field->GetUnsprayedMarginPolyRef();
428  if (pref!=-1){
429  // Must have an unsprayed margin so need to pass the information on to it
430  LE* um=g_landscape_p->SupplyLEPointer(pref);
432  um->InsectMortality( 0.1 );
433  um->ZeroVeg();
434  }
435  return true;
436  }
437  return false;
438 }
439 
444 bool Farm::SpringPlough( LE *a_field, double /*a_user*/, int a_days )
445 {
446 
447  if ((a_days <= 0) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
448  a_field->Trace( spring_plough );
449  a_field->SetLastTreatment( spring_plough );
450  // Apply 90% mortality to the insects
451  a_field->InsectMortality( 0.1 );
452  // Reduce the vegetation to zero
453  a_field->ZeroVeg();
454  int pref=a_field->GetUnsprayedMarginPolyRef();
455  if (pref!=-1){
456  // Must have an unsprayed margin so need to pass the information on to it
457  LE* um=g_landscape_p->SupplyLEPointer(pref);
459  um->InsectMortality( 0.1);
460  um->ZeroVeg();
461  }
462  return true;
463  }
464  return false;
465 }
466 
471 bool Farm::SpringHarrow( LE *a_field, double /*a_user*/, int a_days )
472 {
473 
474  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
475  a_field->Trace( spring_harrow );
476  a_field->SetLastTreatment( spring_harrow );
477  // 30% insect mortality
478  a_field->InsectMortality( 0.7 );
479  // remove all vegetation
480  a_field->ZeroVeg();
481  int pref=a_field->GetUnsprayedMarginPolyRef();
482  if (pref!=-1){
483  // Must have an unsprayed margin so need to pass the information on to it
484  LE* um=g_landscape_p->SupplyLEPointer(pref);
486  um->InsectMortality( 0.7 );
487  um->ZeroVeg();
488  }
489  return true;
490  }
491  return false;
492 }
493 
498 bool Farm::ShallowHarrow(LE *a_field, double /*a_user*/, int a_days)
499 {
500 
501  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
502  a_field->Trace(shallow_harrow);
504  // 30% insect mortality
505  a_field->InsectMortality(0.7);
506  // remove vegetation partly
507  a_field->ReduceVeg(0.8);
508  int pref = a_field->GetUnsprayedMarginPolyRef();
509  if (pref != -1) {
510  // Must have an unsprayed margin so need to pass the information on to it
511  LE* um = g_landscape_p->SupplyLEPointer(pref);
513  um->InsectMortality(0.7);
514  um->ReduceVeg(0.8);
515  }
516  return true;
517  }
518  return false;
519 }
520 
525 bool Farm::SpringRoll( LE *a_field, double /*a_user*/, int a_days )
526 {
527 
528  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
529  a_field->Trace( spring_roll );
530  a_field->SetLastTreatment( spring_roll );
531  int pref=a_field->GetUnsprayedMarginPolyRef();
532  if (pref!=-1){
533  // Must have an unsprayed margin so need to pass the information on to it
534  LE* um=g_landscape_p->SupplyLEPointer(pref);
536  }
537  return true;
538  }
539  return false;
540 }
541 
546 bool Farm::SpringSow( LE *a_field, double /*a_user*/, int a_days )
547 {
548 
549  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
550  a_field->Trace( spring_sow );
551  a_field->SetLastTreatment( spring_sow );
552  a_field->SetGrowthPhase( sow );
553  a_field->SetLastSownVeg(a_field->GetVegType());
554  // Reduce the vegetation to zero - should not strictly be necessary, but prevents any false starts in the crop growth.
555  a_field->ZeroVeg();
556  int pref=a_field->GetUnsprayedMarginPolyRef();
557  if (pref!=-1){
558  // Must have an unsprayed margin so need to pass the information on to it
559  LE* um=g_landscape_p->SupplyLEPointer(pref);
561  um->SetGrowthPhase( sow );
562  um->ZeroVeg();
563  um->SetLastSownVeg(um->GetVegType());
564  }
565  return true;
566  }
567  return false;
568 }
569 
574 bool Farm::SpringSowWithFerti(LE *a_field, double /*a_user*/, int a_days)
575 {
576 
577  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
578  a_field->Trace(spring_sow_with_ferti);
580  a_field->SetGrowthPhase(sow);
581  a_field->SetLastSownVeg(a_field->GetVegType());
582  // Reduce the vegetation to zero - should not strictly be necessary, but prevents any false starts in the crop growth.
583  a_field->ZeroVeg();
584  int pref = a_field->GetUnsprayedMarginPolyRef();
585  if (pref != -1) {
586  // Must have an unsprayed margin so need to pass the information on to it
587  LE* um = g_landscape_p->SupplyLEPointer(pref);
589  um->SetGrowthPhase(sow);
590  um->ZeroVeg();
591  um->SetLastSownVeg(um->GetVegType());
592  }
593  return true;
594  }
595  return false;
596 }
597 
602 bool Farm::FP_NPKS( LE *a_field, double /*a_user*/, int a_days )
603 {
604 
605  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
606  a_field->Trace( fp_npks );
607  a_field->SetLastTreatment( fp_npks );
609  int pref=a_field->GetUnsprayedMarginPolyRef();
610 if (pref!=-1){
611  // Must have an unsprayed margin so need to pass the information on to it
612  LE* um=g_landscape_p->SupplyLEPointer(pref);
614  um->SetGrowthPhase( harvest1 );
615  um->InsectMortality( 0.4 );
617 }
618 
619  return true;
620  }
621  return false;
622 }
623 
624 
629 bool Farm::FP_NPK( LE *a_field, double /*a_user*/, int a_days )
630 {
631 
632  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
633  a_field->Trace( fp_npk );
634  a_field->SetLastTreatment( fp_npk );
636  int pref=a_field->GetUnsprayedMarginPolyRef();
637  if (pref!=-1){
638  // Must have an unsprayed margin so need to pass the information on to it
639  LE* um=g_landscape_p->SupplyLEPointer(pref);
642  }
643  return true;
644  }
645  return false;
646 }
647 
648 
653 bool Farm::FP_PK( LE *a_field, double /*a_user*/, int a_days )
654 {
655 
656  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
657  a_field->Trace( fp_pk );
658  a_field->SetLastTreatment( fp_pk );
660  int pref=a_field->GetUnsprayedMarginPolyRef();
661  if (pref!=-1){
662  // Must have an unsprayed margin so need to pass the information on to it
663  LE* um=g_landscape_p->SupplyLEPointer(pref);
664  um->SetLastTreatment(fp_pk);
666  }
667  return true;
668  }
669  return false;
670 }
671 
672 
677 bool Farm::FP_LiquidNH3( LE *a_field, double /*a_user*/, int a_days )
678 {
679 
680  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
681  a_field->Trace( fp_liquidNH3 );
682  a_field->SetLastTreatment( fp_liquidNH3 );
684  int pref=a_field->GetUnsprayedMarginPolyRef();
685  if (pref!=-1){
686  // Must have an unsprayed margin so need to pass the information on to it
687  LE* um=g_landscape_p->SupplyLEPointer(pref);
690  }
691  return true;
692  }
693  return false;
694 }
695 
696 
701 bool Farm::FP_Slurry( LE *a_field, double /*a_user*/, int a_days )
702 {
703 
704  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
705  !g_weather->Raining() && DoIt(DO_IT_PROB)))
706 {
707  a_field->Trace( fp_slurry );
708  a_field->SetLastTreatment( fp_slurry );
710  int pref=a_field->GetUnsprayedMarginPolyRef();
711  if (pref!=-1){
712  // Must have an unsprayed margin so need to pass the information on to it
713  LE* um=g_landscape_p->SupplyLEPointer(pref);
716  }
717  return true;
718  }
719  return false;
720 }
721 
722 
727 bool Farm::FP_ManganeseSulphate( LE *a_field, double /*a_user*/, int a_days )
728 {
729 
730  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
731  a_field->Trace( fp_manganesesulphate );
734  int pref=a_field->GetUnsprayedMarginPolyRef();
735  if (pref!=-1){
736  // Must have an unsprayed margin so need to pass the information on to it
737  LE* um=g_landscape_p->SupplyLEPointer(pref);
740  }
741  return true;
742  }
743  return false;
744 }
745 
750 bool Farm::FP_AmmoniumSulphate(LE *a_field, double /*a_user*/, int a_days)
751 {
752 
753  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
754  a_field->Trace(fp_ammoniumsulphate);
757  int pref = a_field->GetUnsprayedMarginPolyRef();
758  if (pref != -1) {
759  // Must have an unsprayed margin so need to pass the information on to it
760  LE* um = g_landscape_p->SupplyLEPointer(pref);
763  }
764  return true;
765  }
766  return false;
767 }
768 
773 bool Farm::FP_Manure( LE *a_field, double /*a_user*/, int a_days )
774 {
775 
776  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
777  !g_weather->Raining() && DoIt(DO_IT_PROB))) {
778  a_field->Trace( fp_manure );
779  a_field->SetLastTreatment( fp_manure );
781  int pref=a_field->GetUnsprayedMarginPolyRef();
782  if (pref!=-1){
783  // Must have an unsprayed margin so need to pass the information on to it
784  LE* um=g_landscape_p->SupplyLEPointer(pref);
787  }
788  return true;
789  }
790  return false;
791 }
792 
793 
798 bool Farm::FP_GreenManure( LE *a_field, double /*a_user*/, int a_days )
799 {
800 
801  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
802  a_field->Trace( fp_greenmanure );
803  a_field->SetLastTreatment( fp_greenmanure );
805  int pref=a_field->GetUnsprayedMarginPolyRef();
806  if (pref!=-1){
807  // Must have an unsprayed margin so need to pass the information on to it
808  LE* um=g_landscape_p->SupplyLEPointer(pref);
811  }
812  return true;
813  }
814  return false;
815 }
816 
817 
822 bool Farm::FP_Sludge( LE *a_field, double /*a_user*/, int a_days )
823 {
824  //
825  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
826  !g_weather->Raining() && DoIt(DO_IT_PROB)))
827 {
828  a_field->Trace( fp_sludge );
829  a_field->SetLastTreatment( fp_sludge );
831  int pref=a_field->GetUnsprayedMarginPolyRef();
832  if (pref!=-1){
833  // Must have an unsprayed margin so need to pass the information on to it
834  LE* um=g_landscape_p->SupplyLEPointer(pref);
837  }
838  return true;
839  }
840  return false;
841 }
842 
847 bool Farm::FP_RSM(LE * a_field, double /*a_user*/, int a_days)
848 {
849  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
850  a_field->Trace(fp_rsm);
851  a_field->SetLastTreatment(fp_rsm);
853  int pref = a_field->GetUnsprayedMarginPolyRef();
854  if (pref != -1) {
855  // Must have an unsprayed margin so need to pass the information on to it
856  LE* um = g_landscape_p->SupplyLEPointer(pref);
859  }
860  return true;
861  }
862  return false;
863 }
864 
869 bool Farm::FP_Calcium(LE * a_field, double /*a_user*/, int a_days)
870 {
871  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
872  a_field->Trace(fp_calcium);
873  a_field->SetLastTreatment(fp_calcium);
875  int pref = a_field->GetUnsprayedMarginPolyRef();
876  if (pref != -1) {
877  // Must have an unsprayed margin so need to pass the information on to it
878  LE* um = g_landscape_p->SupplyLEPointer(pref);
881  }
882  return true;
883  }
884  return false;
885 }
886 
891 bool Farm::FA_NPKS(LE *a_field, double /*a_user*/, int a_days)
892 {
893 
894  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
895  a_field->Trace(fa_npks);
896  a_field->SetLastTreatment(fa_npks);
898  int pref = a_field->GetUnsprayedMarginPolyRef();
899  if (pref != -1) {
900  // Must have an unsprayed margin so need to pass the information on to it
901  LE* um = g_landscape_p->SupplyLEPointer(pref);
904  um->InsectMortality(0.4);
906  }
907 
908  return true;
909  }
910  return false;
911 }
912 
917 bool Farm::FA_NPK( LE *a_field, double /*a_user*/, int a_days )
918 {
919 
920  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
921  a_field->Trace( fa_npk );
922  a_field->SetLastTreatment( fa_npk );
924  int pref=a_field->GetUnsprayedMarginPolyRef();
925  if (pref!=-1){
926  // Must have an unsprayed margin so need to pass the information on to it
927  LE* um=g_landscape_p->SupplyLEPointer(pref);
928  um->SetLastTreatment( fa_npk );
930  }
931  return true;
932  }
933  return false;
934 }
935 
936 
941 bool Farm::FA_PK( LE *a_field, double /*a_user*/, int a_days )
942 {
943 
944  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
945  a_field->Trace( fa_pk );
946  a_field->SetLastTreatment( fa_pk );
948  int pref=a_field->GetUnsprayedMarginPolyRef();
949  if (pref!=-1){
950  // Must have an unsprayed margin so need to pass the information on to it
951  LE* um=g_landscape_p->SupplyLEPointer(pref);
952  um->SetLastTreatment( fa_pk );
954  }
955  return true;
956  }
957  return false;
958 }
959 
965 bool Farm::FA_Slurry( LE *a_field, double /*a_user*/, int a_days )
966 {
967 
968  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
969  !g_weather->Raining() && DoIt(DO_IT_PROB)))
970 {
971  a_field->Trace( fa_slurry );
972  a_field->SetLastTreatment( fa_slurry );
974  int pref=a_field->GetUnsprayedMarginPolyRef();
975  if (pref!=-1){
976  // Must have an unsprayed margin so need to pass the information on to it
977  LE* um=g_landscape_p->SupplyLEPointer(pref);
980  }
981  return true;
982  }
983  return false;
984 }
985 
990 bool Farm::FA_AmmoniumSulphate( LE *a_field, double /*a_user*/, int a_days )
991 {
992 
993  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
994  a_field->Trace( fa_ammoniumsulphate );
997  int pref=a_field->GetUnsprayedMarginPolyRef();
998  if (pref!=-1){
999  // Must have an unsprayed margin so need to pass the information on to it
1000  LE* um=g_landscape_p->SupplyLEPointer(pref);
1003  }
1004  return true;
1005  }
1006  return false;
1007 }
1008 
1013 bool Farm::FA_ManganeseSulphate(LE *a_field, double /*a_user*/, int a_days)
1014 {
1015  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1016  a_field->Trace(fa_manganesesulphate);
1019  int pref = a_field->GetUnsprayedMarginPolyRef();
1020  if (pref != -1) {
1021  // Must have an unsprayed margin so need to pass the information on to it
1022  LE* um = g_landscape_p->SupplyLEPointer(pref);
1025  }
1026  return true;
1027  }
1028  return false;
1029 }
1030 
1031 
1036 bool Farm::FA_Manure( LE *a_field, double /*a_user*/, int a_days )
1037 {
1038 
1039  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
1040  !g_weather->Raining() && DoIt(DO_IT_PROB)))
1041 {
1042  a_field->Trace( fa_manure );
1043  a_field->SetLastTreatment( fa_manure );
1045  int pref=a_field->GetUnsprayedMarginPolyRef();
1046  if (pref!=-1){
1047  // Must have an unsprayed margin so need to pass the information on to it
1048  LE* um=g_landscape_p->SupplyLEPointer(pref);
1049  um->SetLastTreatment( fa_manure );
1051  }
1052  return true;
1053  }
1054  return false;
1055 }
1056 
1057 
1062 bool Farm::FA_GreenManure( LE *a_field, double /*a_user*/, int a_days )
1063 {
1064 
1065  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1066  a_field->Trace( fa_greenmanure );
1067  a_field->SetLastTreatment( fa_greenmanure );
1069  int pref=a_field->GetUnsprayedMarginPolyRef();
1070  if (pref!=-1){
1071  // Must have an unsprayed margin so need to pass the information on to it
1072  LE* um=g_landscape_p->SupplyLEPointer(pref);
1075  }
1076  return true;
1077  }
1078  return false;
1079 }
1080 
1081 
1086 bool Farm::FA_Sludge( LE *a_field, double /*a_user*/, int a_days )
1087 {
1088 
1089  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
1090  !g_weather->Raining() && DoIt(DO_IT_PROB)))
1091 {
1092  a_field->Trace( fa_sludge );
1093  a_field->SetLastTreatment( fa_sludge );
1095  int pref=a_field->GetUnsprayedMarginPolyRef();
1096  if (pref!=-1){
1097  // Must have an unsprayed margin so need to pass the information on to it
1098  LE* um=g_landscape_p->SupplyLEPointer(pref);
1099  um->SetLastTreatment( fa_sludge );
1101  }
1102  return true;
1103  }
1104  return false;
1105 }
1106 
1111 bool Farm::FA_RSM(LE * a_field, double /*a_user*/, int a_days)
1112 {
1113  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1114  a_field->Trace(fa_rsm);
1115  a_field->SetLastTreatment(fa_rsm);
1117  int pref = a_field->GetUnsprayedMarginPolyRef();
1118  if (pref != -1) {
1119  // Must have an unsprayed margin so need to pass the information on to it
1120  LE* um = g_landscape_p->SupplyLEPointer(pref);
1121  um->SetLastTreatment(fa_rsm);
1123  }
1124  return true;
1125  }
1126  return false;
1127 }
1128 
1133 bool Farm::FA_Calcium(LE * a_field, double /*a_user*/, int a_days)
1134 {
1135  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1136  a_field->Trace(fa_calcium);
1137  a_field->SetLastTreatment(fa_calcium);
1139  int pref = a_field->GetUnsprayedMarginPolyRef();
1140  if (pref != -1) {
1141  // Must have an unsprayed margin so need to pass the information on to it
1142  LE* um = g_landscape_p->SupplyLEPointer(pref);
1145  }
1146  return true;
1147  }
1148  return false;
1149 }
1150 
1151 
1156 bool Farm::HerbicideTreat( LE *a_field, double /*a_user*/, int a_days )
1157 {
1158 
1159  if (0 >= a_days) // Must do this
1160  {
1161  if (((a_field->GetSignal() & LE_SIG_NO_HERBICIDE)==0 ))
1162  {
1163  a_field->Trace( herbicide_treat );
1164  a_field->SetLastTreatment( herbicide_treat );
1165  if ( l_farm_herbicide_kills.value())
1166  {
1167  a_field->ReduceWeedBiomass( 0.05 );
1168  }
1172 
1173  }
1174  return true;
1175  }
1176  else if ((g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB))
1177  {
1178  if ( !(a_field->GetSignal() & LE_SIG_NO_HERBICIDE) )
1179  {
1180  a_field->Trace( herbicide_treat );
1181  a_field->SetLastTreatment( herbicide_treat );
1182  if ( l_farm_herbicide_kills.value())
1183  {
1184  a_field->ReduceWeedBiomass( 0.05 );
1185  }
1189  }
1190  return true;
1191  }
1192  return false;
1193 }
1194 
1195 
1196 bool OptimisingFarm::HerbicideTreat( LE *a_field, double /*a_user*/, int a_days )
1197 {
1198 
1199  if (0 >= a_days) // Must do this
1200  {
1201  if (((a_field->GetSignal() & LE_SIG_NO_HERBICIDE)==0 ))
1202  {
1203  a_field->Trace( herbicide_treat );
1204  a_field->SetLastTreatment( herbicide_treat );
1205  if ( l_farm_herbicide_kills.value()) {
1206  a_field->ReduceWeedBiomass( 0.05 );
1207  }
1211 
1212 
1214  Field * pf = dynamic_cast<Field*>(a_field);
1215  pf->Add_no_herb_app();
1216  }
1217 
1218  }
1219  return true;
1220  }
1221  else if ((g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB))
1222  {
1223  if ( !(a_field->GetSignal() & LE_SIG_NO_HERBICIDE) )
1224  {
1225  a_field->Trace( herbicide_treat );
1226  a_field->SetLastTreatment( herbicide_treat );
1227  if ( l_farm_herbicide_kills.value()) {
1228  a_field->ReduceWeedBiomass( 0.05 );
1229  }
1233 
1235  Field * pf = dynamic_cast<Field*>(a_field);
1236  pf->Add_no_herb_app();
1237  }
1238  }
1239  return true;
1240  }
1241  return false;
1242 }
1243 
1244 
1245 
1250 bool Farm::GrowthRegulator( LE *a_field, double /*a_user*/, int a_days )
1251 {
1252 
1253  if (0 >= a_days)
1254  {
1255  if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5) &&
1256  (!(a_field->GetSignal() & LE_SIG_NO_GROWTH_REG) )) {
1257  a_field->Trace( growth_regulator );
1258  a_field->SetLastTreatment( growth_regulator );
1260  }
1261  return true;
1262  }
1263  else if ( (g_weather->GetWind()<4.5) &&
1264  (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
1265  if ( ! (a_field->GetSignal() & LE_SIG_NO_GROWTH_REG) ) {
1266  a_field->Trace( growth_regulator );
1267  a_field->SetLastTreatment( growth_regulator );
1269  }
1270  return true;
1271  }
1272  return false;
1273 }
1274 
1279 bool Farm::FungicideTreat( LE *a_field, double /*a_user*/, int a_days )
1280 {
1281 
1282  if (0 >= a_days)
1283  {
1284  if ( ( ! a_field->GetSignal() & LE_SIG_NO_FUNGICIDE ))
1285  {
1286  a_field->Trace( fungicide_treat );
1287  a_field->SetLastTreatment( fungicide_treat );
1290  }
1291  return true;
1292  }
1293  else if ( (g_weather->GetWind()<4.5) &&
1294  (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
1295  if ( ! (a_field->GetSignal() & LE_SIG_NO_FUNGICIDE) ) {
1296  a_field->Trace( fungicide_treat );
1297  a_field->SetLastTreatment( fungicide_treat );
1300  }
1301  return true;
1302  }
1303  return false;
1304 }
1305 
1306 
1307 bool OptimisingFarm::FungicideTreat( LE *a_field, double /*a_user*/, int a_days )
1308 {
1309 
1310  if (0 >= a_days)
1311  {
1312  if ( ( ! a_field->GetSignal() & LE_SIG_NO_FUNGICIDE )) {
1313  a_field->Trace( fungicide_treat );
1314  a_field->SetLastTreatment( fungicide_treat );
1317 
1319  Field * pf = dynamic_cast<Field*>(a_field);
1320  pf->Add_no_fi_app();
1321  }
1322  }
1323  return true;
1324  }
1325  else if ( (g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
1326  if ( ! (a_field->GetSignal() & LE_SIG_NO_FUNGICIDE) ) {
1327  a_field->Trace( fungicide_treat );
1328  a_field->SetLastTreatment( fungicide_treat );
1331 
1333  Field * pf = dynamic_cast<Field*>(a_field);
1334  pf->Add_no_fi_app();
1335  }
1336  }
1337  return true;
1338  }
1339  return false;
1340 }
1341 
1342 
1343 
1348 bool Farm::InsecticideTreat( LE *a_field, double /*a_user*/, int a_days )
1349 {
1350 
1351  if (0 >= a_days)
1352  {
1353  if (( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE) ))
1354  {
1355  // **CJT** Turn this code on to use the pesticide engine with insecticides
1356  // g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
1357  //
1358  a_field->Trace( insecticide_treat );
1359  a_field->SetLastTreatment( insecticide_treat );
1361  {
1362  a_field->Insecticide( 0.36 );
1363  }
1366  }
1367  return true;
1368  }
1369  else if ( (g_weather->GetWind()<4.5) &&
1370  (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
1371  if ( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE )) {
1372 // **CJT** Turn this code on to use the pesticide engine with insecticides
1373 // g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
1374 //
1375  a_field->Trace( insecticide_treat );
1376  a_field->SetLastTreatment( insecticide_treat );
1378  a_field->Insecticide( 0.36 );
1379  }
1382  }
1383  return true;
1384  }
1385  return false;
1386 }
1387 
1388 
1389 bool OptimisingFarm::InsecticideTreat( LE *a_field, double /*a_user*/, int a_days )
1390 {
1391 
1392  if (0 >= a_days)
1393  {
1394  if (( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE) ))
1395  {
1396  // **CJT** Turn this code on to use the pesticide engine with insecticides
1397  // g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
1398  //
1399  a_field->Trace( insecticide_treat );
1400  a_field->SetLastTreatment( insecticide_treat );
1402  a_field->Insecticide( 0.36 );
1403  }
1406 
1408  Field * pf = dynamic_cast<Field*>(a_field);
1409  pf->Add_no_fi_app();
1410  }
1411 
1412  }
1413  return true;
1414  }
1415  else if ( (g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB))
1416  {
1417  if ( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE )) {
1418  // **CJT** Turn this code on to use the pesticide engine with insecticides
1419  // g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
1420  //
1421  a_field->Trace( insecticide_treat );
1422  a_field->SetLastTreatment( insecticide_treat );
1424  a_field->Insecticide( 0.36 );
1425  }
1428 
1430  Field * pf = dynamic_cast<Field*>(a_field);
1431  pf->Add_no_fi_app();
1432  }
1433  }
1434 
1435  return true;
1436  }
1437  return false;
1438 }
1439 
1440 
1445 bool Farm::ProductApplication(LE *a_field, double /*a_user*/, int a_days, double a_applicationrate, PlantProtectionProducts a_ppp)
1446 {
1447  // NOTE Differs from normal pesticide in that it will be done on the last
1448  // day if not managed before
1449  if (0 >= a_days) {
1450  a_field->Trace(product_treat);
1451  a_field->SetLastTreatment(product_treat);
1453  {
1455  }
1458  g_pest->DailyQueueAdd(a_field, a_applicationrate, a_ppp);
1459  return true;
1460  }
1461  else {
1462  if ((!g_weather->Raining()) && (g_weather->GetWind() < 4.5)) {
1463  a_field->Trace(product_treat);
1464  a_field->SetLastTreatment(product_treat);
1467  }
1470  g_pest->DailyQueueAdd(a_field, a_applicationrate, a_ppp);
1471  return true;
1472  }
1473  }
1474  return false;
1475 }
1476 
1481 bool Farm::Molluscicide( LE *a_field, double /*a_user*/, int a_days )
1482 {
1483 
1484  if (0 >= a_days) {
1485  if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5) &&
1486  (! (a_field->GetSignal() & LE_SIG_NO_MOLLUSC ))) {
1487  a_field->Trace( molluscicide );
1488  a_field->SetLastTreatment( molluscicide );
1491  }
1492  return true;
1493  }
1494  else if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1495  if ( ! (a_field->GetSignal() & LE_SIG_NO_MOLLUSC) ) {
1496  a_field->Trace( molluscicide );
1497  a_field->SetLastTreatment( molluscicide );
1500  }
1501  return true;
1502  }
1503  return false;
1504 }
1505 
1510 bool Farm::RowCultivation( LE *a_field, double /*a_user*/, int a_days )
1511 {
1512 
1513  if ( (0 >= a_days) && (g_weather->GetRainPeriod(g_date->Date(),3)<0.1) )
1514  {
1515  // Too much rain, just give up and claim we did it.
1516  return true;
1517  }
1518 
1519  if ( (0 >= a_days) ||
1520  ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
1521  ) {
1522  a_field->Trace( row_cultivation );
1523  a_field->SetLastTreatment( row_cultivation );
1524  a_field->ReduceWeedBiomass( 0.5 );
1525  a_field->InsectMortality( 0.25 );
1527  int pref=a_field->GetUnsprayedMarginPolyRef();
1528  if (pref!=-1){
1529  // Must have an unsprayed margin so need to pass the information on to it
1530  LE* um=g_landscape_p->SupplyLEPointer(pref);
1532  um->InsectMortality( 0.25 );
1533  um->ReduceWeedBiomass( 0.5 );
1535  }
1536  return true;
1537  }
1538  return false;
1539 }
1540 
1545 bool Farm::Strigling( LE *a_field, double /*a_user*/, int a_days )
1546 {
1547 
1548  // Force strigling if it has not been done already!!! This happens regardless of weather as of 26/10/2005
1549  if ( (0 >= a_days) )// && (g_weather->GetRainPeriod(g_date->Date(),3)>0.1) )
1550  {
1551  a_field->Trace( strigling );
1552  a_field->SetLastTreatment( strigling );
1553  a_field->ReduceWeedBiomass( 0.05 );
1554  a_field->InsectMortality( 0.7 );
1557  int pref=a_field->GetUnsprayedMarginPolyRef();
1558  if (pref!=-1){
1559  // Must have an unsprayed margin so need to pass the information on to it
1560  LE* um=g_landscape_p->SupplyLEPointer(pref);
1561  um->SetLastTreatment( strigling );
1562  um->ReduceWeedBiomass( 0.05 );
1563  um->InsectMortality( 0.7 );
1566  return true;
1567  }
1568  }
1569  if ( (0 >= a_days) ||
1570  ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
1571  ) {
1572  a_field->Trace( strigling );
1573  a_field->SetLastTreatment( strigling );
1574  a_field->ReduceWeedBiomass( 0.05 );
1575  a_field->InsectMortality( 0.7 );
1578  int pref=a_field->GetUnsprayedMarginPolyRef();
1579  if (pref!=-1){
1580  // Must have an unsprayed margin so need to pass the information on to it
1581  LE* um=g_landscape_p->SupplyLEPointer(pref);
1582  um->SetLastTreatment( strigling );
1583  um->ReduceWeedBiomass( 0.05 );
1584  um->InsectMortality( 0.7 );
1587  }
1588  return true;
1589  }
1590  return false;
1591 }
1592 
1597 bool Farm::StriglingSow( LE *a_field, double /*a_user*/, int a_days )
1598 {
1599 
1600  //2 days good weather afterwards
1601  if ( (0 >= a_days) && (g_weather->GetRainPeriod(g_date->Date(),3)<0.1) )
1602  {
1603  return true;
1604  }
1605 
1606  if ( (0 >= a_days) ||
1607  ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
1608  ) {
1609  a_field->Trace( strigling_sow );
1610  a_field->SetLastTreatment( strigling_sow );
1611  a_field->ReduceWeedBiomass( 0.05 );
1612  a_field->InsectMortality( 0.7 );
1615  int pref=a_field->GetUnsprayedMarginPolyRef();
1616  if (pref!=-1){
1617  // Must have an unsprayed margin so need to pass the information on to it
1618  LE* um=g_landscape_p->SupplyLEPointer(pref);
1620  um->ReduceWeedBiomass( 0.05 );
1621  um->InsectMortality( 0.7 );
1624  }
1625  return true;
1626  }
1627  return false;
1628 }
1629 
1630 
1635 bool Farm::StriglingHill(LE *a_field, double /*a_user*/, int a_days)
1636 {
1637 
1638  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1639  a_field->Trace(strigling_hill);
1640  a_field->SetLastTreatment(strigling_hill);
1641  a_field->InsectMortality(0.75);
1642  a_field->ReduceWeedBiomass(0.25);
1644  int pref = a_field->GetUnsprayedMarginPolyRef();
1645  if (pref != -1) {
1646  // Must have an unsprayed margin so need to pass the information on to it
1647  LE* um = g_landscape_p->SupplyLEPointer(pref);
1649  um->ReduceWeedBiomass(0.25);
1650  um->InsectMortality(0.75);
1652  }
1653  return true;
1654  }
1655  return false;
1656 }
1657 
1658 
1663 bool Farm::HillingUp( LE *a_field, double /*a_user*/, int a_days )
1664 {
1665 
1666  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1667  a_field->Trace( hilling_up );
1668  a_field->SetLastTreatment( hilling_up );
1669  a_field->InsectMortality( 0.75 );
1670  a_field->ReduceWeedBiomass( 0.25 );
1672  int pref=a_field->GetUnsprayedMarginPolyRef();
1673  if (pref!=-1){
1674  // Must have an unsprayed margin so need to pass the information on to it
1675  LE* um=g_landscape_p->SupplyLEPointer(pref);
1677  um->ReduceWeedBiomass( 0.25 );
1678  um->InsectMortality( 0.75 );
1680  }
1681  return true;
1682  }
1683  return false;
1684 }
1685 
1690 bool Farm::BedForming(LE *a_field, double /*a_user*/, int a_days)
1691 {
1692 
1693  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1694  a_field->Trace(bed_forming);
1695  a_field->SetLastTreatment(bed_forming);
1696  a_field->InsectMortality(0.75);
1697  a_field->ZeroVeg();
1699  int pref = a_field->GetUnsprayedMarginPolyRef();
1700  if (pref != -1) {
1701  // Must have an unsprayed margin so need to pass the information on to it
1702  LE* um = g_landscape_p->SupplyLEPointer(pref);
1704  um->ZeroVeg();
1705  um->InsectMortality(0.75);
1707  }
1708  return true;
1709  }
1710  return false;
1711 }
1712 
1717 bool Farm::Water( LE *a_field, double /*a_user*/, int a_days )
1718 {
1719 
1720 
1721  /* Turn on this code to avoid watering on heavy soils
1722  int soiltype = a_field->GetSoilType();
1723  if ( soiltype < 1 || soiltype > 4 )
1724  return true;
1725 */
1726  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1727  a_field->Trace( water );
1728  a_field->SetLastTreatment( water );
1729  int pref=a_field->GetUnsprayedMarginPolyRef();
1730  if (pref!=-1){
1731  // Must have an unsprayed margin so need to pass the information on to it
1732  LE* um=g_landscape_p->SupplyLEPointer(pref);
1733  um->SetLastTreatment( water );
1734  }
1735  return true;
1736  }
1737  return false;
1738 }
1739 
1744 bool Farm::Swathing( LE *a_field, double /*a_user*/, int a_days )
1745 {
1746 
1747  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
1748  a_field->Trace( swathing );
1749  a_field->SetLastTreatment( swathing );
1750  a_field->InsectMortality( 0.5 );
1752  int pref=a_field->GetUnsprayedMarginPolyRef();
1753  if (pref!=-1){
1754  // Must have an unsprayed margin so need to pass the information on to it
1755  LE* um=g_landscape_p->SupplyLEPointer(pref);
1756  um->SetLastTreatment( swathing );
1757  um->InsectMortality( 0.5 );
1759  }
1760  return true;
1761  }
1762  return false;
1763 }
1764 
1769 bool Farm::Harvest(LE *a_field, double /*a_user*/, int a_days)
1770 {
1771  //5 days good weather before
1772  if ((0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(), 5) < 0.1) && DoIt(DO_IT_PROB))) {
1773  a_field->Trace(harvest);
1774  a_field->SetLastTreatment(harvest);
1775  a_field->SetGrowthPhase(harvest1);
1776  // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
1777  a_field->InsectMortality(0.4);
1778  double insects = a_field->GetInsectPop();
1779  a_field->ResetDigestability();
1780  a_field->RecalculateBugsNStuff();
1781  a_field->SetInsectPop(insects);
1783  int pref = a_field->GetUnsprayedMarginPolyRef();
1784  // Are we a cereal crop? If so we need to have some spilled grain
1785  double someseed = 0.0;
1786  double somemaize = 0.0;
1787  if (dynamic_cast<VegElement*>(a_field)->IsMatureCereal()) {
1788  someseed = m_OurManager->GetSpilledGrain();
1789  a_field->SetStubble(true);
1790  }
1791  else if (dynamic_cast<VegElement*>(a_field)->IsMaize()) {
1792  // Maize in stubble
1793  a_field->SetStubble(true);
1794  somemaize = m_OurManager->GetSpilledMaize();
1795  }
1796  a_field->SetBirdSeed( someseed );
1797  a_field->SetBirdMaize( somemaize );
1798  if (pref != -1){
1799  // Must have an unsprayed margin so need to pass the information on to it
1800  LE* um = g_landscape_p->SupplyLEPointer(pref);
1802  um->SetGrowthPhase(harvest1);
1803  um->InsectMortality(0.4);
1805  um->ResetDigestability();
1806  um->RecalculateBugsNStuff();
1807  um->SetBirdSeed( someseed );
1808  um->SetBirdMaize( somemaize );
1809  if ((somemaize > 0) || (someseed > 0)) um->SetStubble(true);
1810  }
1811  return true;
1812  }
1813  return false;
1814 }
1815 
1816 
1821 bool Farm::HarvestLong(LE *a_field, double /*a_user*/, int a_days)
1822 {
1823 
1824  //5 days good weather before
1825  if ((0 >= a_days) ||
1826  ((g_weather->GetRainPeriod(g_date->Date(), 5)<0.1) && DoIt(DO_IT_PROB_LONG))
1827  ) {
1828  a_field->Trace(harvest);
1829  a_field->SetLastTreatment(harvest);
1830  a_field->SetGrowthPhase(harvest1);
1831  // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
1832  a_field->InsectMortality(0.4);
1833  double insects = a_field->GetInsectPop();
1834  a_field->ResetDigestability();
1835  a_field->RecalculateBugsNStuff();
1836  a_field->SetInsectPop(insects);
1838  int pref = a_field->GetUnsprayedMarginPolyRef();
1839  double someseed = 0.0; //No bird seed or maize forage on sugar beet (which is currently (March 2015) the only crop using HarvestLong.
1840  a_field->SetBirdSeed( someseed );
1841  a_field->SetBirdMaize( someseed );
1842  if (pref != -1){
1843  // Must have an unsprayed margin so need to pass the information on to it
1844  LE* um = g_landscape_p->SupplyLEPointer(pref);
1846  um->SetGrowthPhase(harvest1);
1847  um->InsectMortality(0.4);
1849  um->ResetDigestability();
1850  um->RecalculateBugsNStuff();
1851  um->SetBirdSeed( someseed );
1852  um->SetBirdMaize( someseed );
1853  }
1854  return true;
1855  }
1856  return false;
1857 }
1858 
1859 bool OptimisingFarm::Harvest(LE *a_field, double /*a_user*/, int a_days)
1860 {
1861 
1862  //5 days good weather before
1863  if ( (0 >= a_days) ||
1864  ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB)))
1865  {
1866 
1867  //05.03.13 need to get the info on biomass
1869  Field * pf = dynamic_cast<Field*>(a_field); //ok????? - maybe should be VegElement instead of field!
1870  if(pf->GetVegType()!=tov_Potatoes && pf->GetVegType()!=tov_PotatoesIndustry){ //do not save biomass for potatoes!
1871  double biomass_at_harvest = a_field->GetVegBiomass();
1872  pf->Set_biomass_at_harvest(biomass_at_harvest, 0); //sets the biomass of a current crop; the current crop is at the index 0
1873  pf->Set_harvested(); //mark this crop as harvested
1874  }
1875  }
1876  //05.03.13 end
1877 
1878  a_field->Trace( harvest );
1879  a_field->SetLastTreatment( harvest );
1880  a_field->SetGrowthPhase( harvest1 );
1881  // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
1882  a_field->InsectMortality( 0.4 );
1883  double insects=a_field->GetInsectPop();
1884  a_field->RecalculateBugsNStuff();
1885  a_field->SetInsectPop(insects);
1887  a_field->ResetDigestability();
1888  int pref=a_field->GetUnsprayedMarginPolyRef();
1889  if (pref!=-1){
1890  // Must have an unsprayed margin so need to pass the information on to it
1891  LE* um=g_landscape_p->SupplyLEPointer(pref);
1893  um->SetGrowthPhase( harvest1 );
1894  um->InsectMortality( 0.4 );
1896  um->ResetDigestability();
1897  um->RecalculateBugsNStuff();
1898  }
1899  return true;
1900  }
1901  return false;
1902 }
1903 
1904 
1905 
1910 bool Farm::CattleOut( LE *a_field, double /*a_user*/, int a_days )
1911 {
1915  if ((0 >= a_days) || DoIt( DO_IT_PROB ))
1916  {
1917  a_field->ToggleCattleGrazing();
1918  a_field->Trace( cattle_out );
1919  a_field->SetLastTreatment( cattle_out );
1920  // Reduce the vegetation because of grazing
1921  //double h=a_field->GetVegHeight();
1922  //double reduc = 1-(l_farm_cattle_veg_reduce.value()*((h-15)/15));
1923  //a_field->ReduceVeg_Extended( reduc );
1924  a_field->GrazeVegetation( l_farm_cattle_veg_reduce.value(), false );
1925  int pref = a_field->GetUnsprayedMarginPolyRef();
1926  if (pref != -1)
1927  {
1928  // Must have an unsprayed margin so need to pass the information on to it
1929  // This happens if all arable fields are given unsprayed margins - they have no effect on grass unless it is sprayed with pesticides
1930  LE* um = g_landscape_p->SupplyLEPointer( pref );
1931  um->ToggleCattleGrazing();
1934  }
1935  return true;
1936  }
1937  return false;
1938 }
1939 
1944 bool Farm::CattleOutLowGrazing( LE *a_field, double /*a_user*/, int a_days )
1945 {
1946 
1947  if ( (0 >= a_days)|| DoIt(DO_IT_PROB)) {
1948  a_field->ToggleCattleGrazing();
1949  a_field->Trace( cattle_out_low );
1950  a_field->SetLastTreatment( cattle_out_low );
1951  // Reduce the vegetation because of grazing
1952  //double h=a_field->GetVegHeight();
1953  //double reduc = 1-(l_farm_cattle_veg_reduce.value()*((h-15)/15));
1954  //a_field->ReduceVeg_Extended( reduc );
1955  a_field->GrazeVegetation( l_farm_cattle_veg_reduce2.value( ), false );
1956  int pref=a_field->GetUnsprayedMarginPolyRef();
1957  if (pref!=-1){
1958  // Must have an unsprayed margin so need to pass the information on to it
1959  // This happens if all arable fields are given unsprayed margins - they have no effect on grass unless it is sprayed with pesticides
1960  LE* um=g_landscape_p->SupplyLEPointer(pref);
1961  um->ToggleCattleGrazing();
1964  }
1965  return true;
1966  }
1967  return false;
1968 }
1969 
1974 bool Farm::CattleIsOut(LE *a_field, double /*a_user*/, int a_days, int a_max)
1975 {
1979  double biomass = a_field->GetVegBiomass();
1980  if (biomass > 100.0)
1981  {
1982  a_field->SetLastTreatment(cattle_out);
1983  a_field->Trace(cattle_out);
1984  // Reduce the vegetation because of grazing
1985  //double h=a_field->GetVegHeight();
1986  //double reduc = 1-(l_farm_cattle_veg_reduce.value()*((h-15)/15));
1987  //a_field->ReduceVeg_Extended( reduc );
1988  a_field->GrazeVegetation( l_farm_cattle_veg_reduce.value( ), false );
1989  int pref = a_field->GetUnsprayedMarginPolyRef();
1990  if (pref != -1)
1991  {
1992  // Must have an unsprayed margin so need to pass the information on to it
1993  LE* um = g_landscape_p->SupplyLEPointer(pref);
1996  }
1997  }
1998  int d1 = g_date->DayInYear(10, 9);
1999  if (d1 > a_max) d1 = a_max;
2000  if ((((g_date->DayInYear() > d1) && (10 >= a_days)) && DoIt(10)) || (0 >= a_days))
2001  {
2002  a_field->ToggleCattleGrazing();
2003  int pref = a_field->GetUnsprayedMarginPolyRef();
2004  if (pref != -1){
2005  // Must have an unsprayed margin so need to pass the information on to it
2006  LE* um = g_landscape_p->SupplyLEPointer(pref);
2007  um->ToggleCattleGrazing();
2008  }
2009  return true;
2010  }
2011  return false;
2012 }
2013 
2018 bool Farm::CattleIsOutLow(LE *a_field, double /*a_user*/, int a_days, int a_max)
2019 {
2020 
2021  // Generate a 'cattle_in_out' event for every day the cattle is on the
2022  // field.
2023  double biomass = a_field->GetVegBiomass();
2024  if (biomass > 100.0)
2025  {
2026  a_field->SetLastTreatment(cattle_out_low);
2027  a_field->Trace(cattle_out_low);
2028  // Reduce the vegetation because of grazing
2029  //double h=a_field->GetVegHeight();
2030  //double reduc = 1-(l_farm_cattle_veg_reduce2.value()*((h-15)/15));
2031  //a_field->ReduceVeg_Extended( reduc );
2032  a_field->GrazeVegetation( l_farm_cattle_veg_reduce2.value( ), false );
2033  int pref = a_field->GetUnsprayedMarginPolyRef();
2034  if (pref != -1)
2035  {
2036  // Must have an unsprayed margin so need to pass the information on to it
2037  LE* um = g_landscape_p->SupplyLEPointer(pref);
2040  }
2041  }
2042  int d1 = g_date->DayInYear(10, 9);
2043  if (d1 > a_max) d1 = a_max;
2044  if ((((g_date->DayInYear() > d1) && (10 >= a_days)) && DoIt(10)) || (0 >= a_days))
2045  {
2046  a_field->ToggleCattleGrazing();
2047  int pref = a_field->GetUnsprayedMarginPolyRef();
2048  if (pref != -1){
2049  // Must have an unsprayed margin so need to pass the information on to it
2050  LE* um = g_landscape_p->SupplyLEPointer(pref);
2051  um->ToggleCattleGrazing();
2052  }
2053  return true;
2054  }
2055  return false;
2056 }
2057 
2062 bool Farm::PigsOut( LE *a_field, double /*a_user*/, int a_days )
2063 {
2064 
2065  if ( (0 >= a_days)|| DoIt(DO_IT_PROB))
2066  {
2067  a_field->TogglePigGrazing();
2068  a_field->Trace( pigs_out );
2069  a_field->SetLastTreatment( pigs_out );
2070  // Reduce the vegetation because of grazing
2072  // make this a function of grazing pressure
2073  //and field size - perhaps in a later life
2074  int pref=a_field->GetUnsprayedMarginPolyRef();
2075  if (pref!=-1){
2076  // Must have an unsprayed margin so need to pass the information on to it
2077  LE* um=g_landscape_p->SupplyLEPointer(pref);
2078  um->SetLastTreatment( pigs_out );
2080  }
2081  return true;
2082  }
2083  return false;
2084 }
2085 
2090 bool Farm::PigsAreOutForced( LE *a_field, double /*a_user*/, int /*a_days*/)
2091 {
2092  a_field->SetLastTreatment( pigs_out );
2093  a_field->Trace( pigs_out );
2094  // Reduce the vegetation because of grazing
2096  // make this a function of grazing pressure
2097  //and field size - perhaps in a later life
2098  int pref=a_field->GetUnsprayedMarginPolyRef();
2099  if (pref!=-1){
2100  // Must have an unsprayed margin so need to pass the information on to it
2101  LE* um=g_landscape_p->SupplyLEPointer(pref);
2102  um->SetLastTreatment( pigs_out );
2104  }
2105  return false;
2106 }
2107 
2112 bool Farm::PigsAreOut( LE *a_field, double /*a_user*/, int a_days )
2113 {
2114 
2115  if ( (0 >= a_days)|| DoIt(50/a_days)) {
2116  a_field->TogglePigGrazing();
2117  int pref=a_field->GetUnsprayedMarginPolyRef();
2118  if (pref!=-1){
2119  // Must have an unsprayed margin so need to pass the information on to it
2120  LE* um=g_landscape_p->SupplyLEPointer(pref);
2121  um->TogglePigGrazing();
2122  }
2123  return true;
2124  }
2125  return false;
2126 }
2127 
2132 bool Farm::StrawChopping( LE *a_field, double /*a_user*/, int a_days )
2133 {
2134 
2135  if ( (0 >= a_days) ||
2136  ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))
2137  ) {
2138  a_field->Trace( straw_chopping );
2139  a_field->SetLastTreatment( straw_chopping );
2140  a_field->InsectMortality( 0.4 );
2142  int pref=a_field->GetUnsprayedMarginPolyRef();
2143  if (pref!=-1){
2144  // Must have an unsprayed margin so need to pass the information on to it
2145  LE* um=g_landscape_p->SupplyLEPointer(pref);
2147  um->InsectMortality( 0.4 );
2149  }
2150  return true;
2151  }
2152  return false;
2153 }
2154 
2159 bool Farm::HayTurning( LE *a_field, double /*a_user*/, int a_days )
2160 {
2161 
2162  if ( (0 >= a_days) ||
2163  ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))
2164  ) {
2165  a_field->Trace( hay_turning );
2166  a_field->SetLastTreatment( hay_turning );
2168  int pref=a_field->GetUnsprayedMarginPolyRef();
2169  if (pref!=-1){
2170  // Must have an unsprayed margin so need to pass the information on to it
2171  LE* um=g_landscape_p->SupplyLEPointer(pref);
2174  }
2175  return true;
2176  }
2177  return false;
2178 }
2179 
2184 bool Farm::HayBailing( LE *a_field, double /*a_user*/, int a_days )
2185 {
2186 
2187  if ( (0 >= a_days) ||
2188  ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))
2189  ) {
2190  a_field->Trace( hay_bailing );
2191  a_field->SetLastTreatment( hay_bailing );
2193  int pref=a_field->GetUnsprayedMarginPolyRef();
2194  if (pref!=-1){
2195  // Must have an unsprayed margin so need to pass the information on to it
2196  LE* um=g_landscape_p->SupplyLEPointer(pref);
2199  }
2200  return true;
2201  }
2202  return false;
2203 }
2204 
2209 bool Farm::StubbleHarrowing( LE *a_field, double /*a_user*/, int a_days )
2210 {
2211 
2212  if ( (0 >= a_days) ||
2213  ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
2214  ) {
2215  a_field->Trace( stubble_harrowing );
2216  a_field->SetLastTreatment( stubble_harrowing );
2217  a_field->InsectMortality( 0.25 );
2218  a_field->ZeroVeg();
2219  int pref=a_field->GetUnsprayedMarginPolyRef();
2220  if (pref!=-1){
2221  // Must have an unsprayed margin so need to pass the information on to it
2222  LE* um=g_landscape_p->SupplyLEPointer(pref);
2224  um->ZeroVeg();
2225  um->InsectMortality( 0.25 );
2226  }
2227  return true;
2228  }
2229  return false;
2230 }
2231 
2236 bool Farm::BurnStrawStubble( LE *a_field, double /*a_user*/, int a_days )
2237 {
2238 
2239  if ( (0 >= a_days) && (g_weather->GetRainPeriod(g_date->Date(),3)>0.1))
2240  {
2241  return true;
2242  }
2243  if ( (0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1)
2244  && DoIt(DO_IT_PROB)))
2245  {
2246  a_field->Trace( burn_straw_stubble );
2248  a_field->InsectMortality( 0.4 );
2249  a_field->ReduceVeg( 0.2 );
2251  int pref=a_field->GetUnsprayedMarginPolyRef();
2252  if (pref!=-1){
2253  // Must have an unsprayed margin so need to pass the information on to it
2254  LE* um=g_landscape_p->SupplyLEPointer(pref);
2256  um->ReduceVeg( 0.2 );
2257  um->InsectMortality( 0.4 );
2259  }
2260  return true;
2261  }
2262  return false;
2263 }
2264 
2269 bool Farm::CutToHay( LE *a_field, double /*a_user*/, int a_days )
2270 {
2271 
2272  if ( (0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1)
2273  && DoIt(DO_IT_PROB)))
2274  {
2275  a_field->Trace( cut_to_hay );
2276  a_field->SetLastTreatment( cut_to_hay );
2277  a_field->SetGrowthPhase(harvest1);
2278  a_field->InsectMortality(0.4);
2279  a_field->ReduceVeg_Extended( 0.2 );
2280  a_field->SetVegHeight(10);
2281  //a_field->ResetDigestability();
2283  int pref=a_field->GetUnsprayedMarginPolyRef();
2284  if (pref!=-1){
2285  // Must have an unsprayed margin so need to pass the information on to it
2286  LE* um=g_landscape_p->SupplyLEPointer(pref);
2288  um->SetGrowthPhase(harvest1);
2289  um->InsectMortality(0.4);
2290  um->ReduceVeg_Extended( 0.2 );
2291  um->SetVegHeight( 10);
2293  }
2294  return true;
2295  }
2296  return false;
2297 }
2298 
2303 bool Farm::CutWeeds( LE *a_field, double /*a_user*/, int a_days )
2304 {
2305 
2306  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB)))
2307  {
2308  a_field->Trace( cut_weeds );
2309  a_field->SetLastTreatment( cut_weeds );
2310  a_field->ReduceVeg( 0.8 );
2312  int pref=a_field->GetUnsprayedMarginPolyRef();
2313  if (pref!=-1){
2314  // Must have an unsprayed margin so need to pass the information on to it
2315  LE* um=g_landscape_p->SupplyLEPointer(pref);
2316  um->SetLastTreatment( cut_weeds );
2317  um->ReduceVeg( 0.8 );
2319  }
2320  return true;
2321  }
2322  return false;
2323 }
2324 
2329 bool Farm::CutToSilage( LE *a_field, double /*a_user*/, int a_days )
2330 {
2331 
2332  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
2333  a_field->Trace( cut_to_silage );
2334  a_field->SetLastTreatment( cut_to_silage );
2335  a_field->ReduceVeg_Extended( 0.2 );
2336  a_field->InsectMortality( 0.4 );
2337  a_field->SetVegHeight( 10 );
2339  a_field->SetGrowthPhase(harvest1);
2340  //a_field->ResetDigestability();
2341  int pref=a_field->GetUnsprayedMarginPolyRef();
2342  if (pref!=-1){
2343  // Must have an unsprayed margin so need to pass the information on to it
2344  LE* um=g_landscape_p->SupplyLEPointer(pref);
2346  um->ReduceVeg_Extended( 0.2 );
2347  um->InsectMortality( 0.4 );
2348  um->SetVegHeight( 10 );
2350  um->ResetDigestability();
2351  um->SetGrowthPhase(harvest1);
2352  }
2353  return true;
2354  }
2355  return false;
2356 }
2357 
2362 bool Farm::CutOrch( LE *a_field, double /* a_user */, int a_days )
2363 {
2364 
2365  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
2366  a_field->Trace( mow ); //? tried to do=mow...
2367  a_field->SetLastTreatment( mow );
2368  a_field->SetMownDecay( 12 ); // 12 days of not suitable
2369  //ReduceVeg_Extended( 0.2 );
2370  //a_field->InsectMortality( 0.4 );
2371  a_field->SetGrowthPhase( harvest1 );
2372  //m_DateCut = a_today; ?? what to substitute it with?
2373 
2374  a_field->SetVegParameters( l_el_o_cut_height.value(), l_el_o_cut_total.value(), l_el_o_cut_green.value(), 0 ); //is 0 ok for weed biomass
2375 
2376  int pref=a_field->GetUnsprayedMarginPolyRef();
2377  if (pref!=-1){
2378  // Must have an unsprayed margin so need to pass the information on to it
2379  LE* um=g_landscape_p->SupplyLEPointer(pref);
2380  um->SetLastTreatment( mow );
2381  um->ReduceVeg_Extended( 0.2 ); //are these values ok?
2382  um->InsectMortality( 0.4 );
2384  }
2385  return true;
2386  }
2387  return false;
2388 }
2389 
2390 
2395 // Pesticide Trial Farm Function Code
2396 bool Farm::ProductApplication_DateLimited(LE *a_field, double /*a_user*/, int /*a_days*/, double a_applicationrate, PlantProtectionProducts a_ppp)
2397 {
2399  int year = g_landscape_p->SupplyYearNumber();
2400  if (year < cfg_productapplicstartyear.value()) return false;
2401  if (year > cfg_productapplicendyear.value()) return false;
2402  a_field->Trace(trial_insecticidetreat); // Debug function only
2404  a_field->InsectMortality(cfg_CustomInsecticideKillProp.value()); // Change this manually if it is really a herbicide
2406  a_field->SetSprayedToday(true);
2407  g_pest->DailyQueueAdd(a_field, a_applicationrate, a_ppp);
2408  return true;
2409 }
2410 
2415 bool Farm::Biocide(LE * a_field, double /*a_user*/, int a_days)
2416 {
2417  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
2418  a_field->Trace(biocide);
2419  a_field->SetLastTreatment(biocide);
2421  int pref = a_field->GetUnsprayedMarginPolyRef();
2422  if (pref != -1) {
2423  // Must have an unsprayed margin so need to pass the information on to it
2424  LE* um = g_landscape_p->SupplyLEPointer(pref);
2427  }
2428  return true;
2429  }
2430  return false;
2431 }
2432 
2437 bool Farm::FlowerCutting(LE * a_field, double /*a_user*/, int a_days)
2438 {
2439  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
2440  a_field->Trace(flower_cutting);
2441  a_field->ReduceVeg_Extended(0.8);
2442  a_field->InsectMortality(0.9);
2443  a_field->SetVegHeight(35);
2444  a_field->SetLastTreatment(flower_cutting);
2446  int pref = a_field->GetUnsprayedMarginPolyRef();
2447  if (pref != -1) {
2448  // Must have an unsprayed margin so need to pass the information on to it
2449  LE* um = g_landscape_p->SupplyLEPointer(pref);
2450  um->ReduceVeg_Extended(0.8);
2451  um->InsectMortality(0.9);
2452  um->SetVegHeight(30);
2455  }
2456  return true;
2457  }
2458  return false;
2459 }
2460 
2465 bool Farm::BulbHarvest(LE *a_field, double /*a_user*/, int a_days)
2466 {
2467  //5 days good weather before
2468  if ((0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(), 5) < 0.1) && DoIt(DO_IT_PROB))) {
2469  a_field->Trace(bulb_harvest);
2470  a_field->SetLastTreatment(bulb_harvest);
2471  a_field->SetGrowthPhase(harvest1);
2472  // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
2473  a_field->InsectMortality(0.3);
2474  // remove all vegetation
2475  a_field->ZeroVeg();
2476  double insects = a_field->GetInsectPop();
2477  a_field->ResetDigestability();
2478  a_field->RecalculateBugsNStuff();
2479  a_field->SetInsectPop(insects);
2481  int pref = a_field->GetUnsprayedMarginPolyRef();
2482  if (pref != -1) {
2483  // Must have an unsprayed margin so need to pass the information on to it
2484  LE* um = g_landscape_p->SupplyLEPointer(pref);
2486  um->SetGrowthPhase(harvest1);
2487  um->InsectMortality(0.3);
2488  um->ZeroVeg();
2490  um->ResetDigestability();
2491  um->RecalculateBugsNStuff();
2492  }
2493  return true;
2494  }
2495  return false;
2496 }
2497 
2502 bool Farm::StrawCovering(LE * a_field, double /*a_user*/, int a_days)
2503 {
2504  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
2505  a_field->Trace(straw_covering);
2506  a_field->SetLastTreatment(straw_covering);
2508  int pref = a_field->GetUnsprayedMarginPolyRef();
2509  if (pref != -1) {
2510  // Must have an unsprayed margin so need to pass the information on to it
2511  LE* um = g_landscape_p->SupplyLEPointer(pref);
2514  }
2515  return true;
2516  }
2517  return false;
2518 }
2519 
2524 bool Farm::StrawRemoval(LE * a_field, double /*a_user*/, int a_days)
2525 {
2526  if ((0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
2527  a_field->Trace(straw_removal);
2528  a_field->SetLastTreatment(straw_removal);
2530  int pref = a_field->GetUnsprayedMarginPolyRef();
2531  if (pref != -1) {
2532  // Must have an unsprayed margin so need to pass the information on to it
2533  LE* um = g_landscape_p->SupplyLEPointer(pref);
2536  }
2537  return true;
2538  }
2539  return false;
2540 }
insecticide_treat
Definition: treatment.h:74
Farm::FP_Sludge
virtual bool FP_Sludge(LE *a_field, double a_user, int a_days)
Spread sewege on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:822
Farm::PigsAreOut
virtual bool PigsAreOut(LE *a_field, double a_user, int a_days)
Start a pig grazing event on a_field today or soon.
Definition: farmfuncs.cpp:2112
l_farm_insecticide_kills
static CfgBool l_farm_insecticide_kills("FARM_INSECTICIDE_KILLS", CFG_CUSTOM, true)
VegElement::Add_no_fi_app
void Add_no_fi_app()
Definition: elements.h:650
Farm::SpringRoll
virtual bool SpringRoll(LE *a_field, double a_user, int a_days)
Carry out a roll event in the spring on a_field.
Definition: farmfuncs.cpp:525
Landscape::SupplyLEPointer
LE * SupplyLEPointer(int a_polyref)
Definition: landscape.h:1099
Farm::FA_Slurry
virtual bool FA_Slurry(LE *a_field, double a_user, int a_days)
Spready slurry on a_field owned by an stock farmer.
Definition: farmfuncs.cpp:965
strigling
Definition: treatment.h:77
OptimisingFarm::HerbicideTreat
virtual bool HerbicideTreat(LE *a_field, double, int a_days)
Carries out herbicide application. Saves information on each application for a given crop.
Definition: farmfuncs.cpp:1196
Farm::PreseedingCultivator
virtual bool PreseedingCultivator(LE *a_field, double a_user, int a_days)
Carry out preseeding cultivation on a_field (tilling set including cultivator and string roller to co...
Definition: farmfuncs.cpp:311
hay_bailing
Definition: treatment.h:89
Farm::SpringPlough
virtual bool SpringPlough(LE *a_field, double a_user, int a_days)
Carry out a ploughing event in the spring on a_field.
Definition: farmfuncs.cpp:444
PlantProtectionProducts
PlantProtectionProducts
A list PPP names for tracking by the Pesticide class.
Definition: farm.h:420
flower_cutting
Definition: treatment.h:109
Farm::HerbicideTreat
virtual bool HerbicideTreat(LE *a_field, double a_user, int a_days)
Apply herbicide to a_field.
Definition: farmfuncs.cpp:1156
autumn_roll
Definition: treatment.h:38
cfg_CAB_InsecticideDay
CfgInt cfg_CAB_InsecticideDay("PEST_CABINSECTONEDAY", CFG_CUSTOM, 15)
Provided to allow configuration control of the first insecticide spray in cabbage crops - this change...
spring_sow_with_ferti
Definition: treatment.h:103
Farm::Strigling
virtual bool Strigling(LE *a_field, double a_user, int a_days)
Carry out a mechanical weeding on a_field.
Definition: farmfuncs.cpp:1545
cfg_WW_InsecticideMonth
CfgInt cfg_WW_InsecticideMonth("PEST_WWINSECTONEMONTH", CFG_CUSTOM, 5)
Provided to allow configuration control of the first insecticide spray in winter wheat - this changes...
LE::SetLastSownVeg
void SetLastSownVeg(TTypesOfVegetation a_tov)
Records the last vegetation type to be sown.
Definition: elements.h:293
Farm::Harvest
virtual bool Harvest(LE *a_field, double a_user, int a_days)
Carry out a harvest on a_field.
Definition: farmfuncs.cpp:1769
Farm::PreseedingCultivatorSow
virtual bool PreseedingCultivatorSow(LE *a_field, double a_user, int a_days)
Carry out preseeding cultivation together with sow on a_field (tilling and sowing set including culti...
Definition: farmfuncs.cpp:337
g_pest
class Pesticide * g_pest
Definition: pesticide.cpp:92
Farm::FP_ManganeseSulphate
virtual bool FP_ManganeseSulphate(LE *a_field, double a_user, int a_days)
Apply Manganse Sulphate to a_field owned by an arable farmer.
Definition: farmfuncs.cpp:727
Farm::StubbleCultivatorHeavy
virtual bool StubbleCultivatorHeavy(LE *a_field, double a_user, int a_days)
Carry out a stubble cultivation event on a_field. This is non-inversion type of cultivation which can...
Definition: farmfuncs.cpp:193
Farm::PigsAreOutForced
virtual bool PigsAreOutForced(LE *a_field, double a_user, int a_days)
Start a pig grazing event on a_field today - no exceptions.
Definition: farmfuncs.cpp:2090
Farm::ProductApplication
virtual bool ProductApplication(LE *a_field, double a_user, int a_days, double a_applicationrate, PlantProtectionProducts a_ppp)
Apply test pesticide to a_field.
Definition: farmfuncs.cpp:1445
Farm::CattleIsOut
virtual bool CattleIsOut(LE *a_field, double a_user, int a_days, int a_max)
Generate a 'cattle_out' event for every day the cattle are on a_field.
Definition: farmfuncs.cpp:1974
Farm::FP_NPK
virtual bool FP_NPK(LE *a_field, double a_user, int a_days)
Apply NPK fertilizer, on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:629
Farm::CutToSilage
virtual bool CutToSilage(LE *a_field, double a_user, int a_days)
Cut vegetation for silage on a_field.
Definition: farmfuncs.cpp:2329
OptimisingFarm::Harvest
bool Harvest(LE *a_field, double a_user, int a_days)
OptimisingFarm's virtual version of Farm::Harvest(). Saves information on biomass of a crop at harves...
Definition: farmfuncs.cpp:1859
fa_ammoniumsulphate
Definition: treatment.h:65
autumn_harrow
Definition: treatment.h:37
preseeding_cultivator
Definition: treatment.h:39
cfg_TU_InsecticideDay
CfgInt cfg_TU_InsecticideDay("PEST_TUINSECTONEDAY", CFG_CUSTOM, 15)
Provided to allow configuration control of the first insecticide spray in tulip crops - this changes ...
OptimisingFarm::FungicideTreat
virtual bool FungicideTreat(LE *a_field, double, int a_days)
Carries out fungicide application. Saves information on each application for a given crop.
Definition: farmfuncs.cpp:1307
Farm::Molluscicide
virtual bool Molluscicide(LE *a_field, double a_user, int a_days)
Apply molluscidie to a_field.
Definition: farmfuncs.cpp:1481
Farm::StrawRemoval
virtual bool StrawRemoval(LE *a_field, double a_user, int a_days)
Straw covering applied on a_field.
Definition: farmfuncs.cpp:2524
Farm::StubblePlough
virtual bool StubblePlough(LE *a_field, double a_user, int a_days)
Carry out a stubble ploughing event on a_field. This is similar to normal plough but shallow (normall...
Definition: farmfuncs.cpp:169
Farm::FA_GreenManure
virtual bool FA_GreenManure(LE *a_field, double a_user, int a_days)
Spread green manure on a_field owned by an stock farmer.
Definition: farmfuncs.cpp:1062
VegElement::Add_no_herb_app
void Add_no_herb_app()
Definition: elements.h:647
autumn_sow
Definition: treatment.h:41
l_farm_pig_veg_reduce
static CfgFloat l_farm_pig_veg_reduce("FARM_PIG_VEG_REDUCE", CFG_CUSTOM, 0.98)
harvest
Definition: treatment.h:82
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:1690
LE_SIG_NO_INSECTICIDE
#define LE_SIG_NO_INSECTICIDE
Definition: elements.h:43
LE::SetTramlinesDecay
void SetTramlinesDecay(int a_decaytime_days)
Definition: elements.h:310
cfg_WW_NINV_tillage_prop2
CfgFloat cfg_WW_NINV_tillage_prop2("TILLAGE_WWNINVTWOPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing second non-inversion tilla...
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:1036
fp_slurry
Definition: treatment.h:52
LE::GetInsectPop
virtual double GetInsectPop(void)
Definition: elements.h:156
cfg_SB_InsecticideDay
CfgInt cfg_SB_InsecticideDay("PEST_SBINSECTONEDAY", CFG_CUSTOM, 15)
Provided to allow configuration control of the first insecticide spray in spring barley crops - this ...
Farm::FA_Sludge
virtual bool FA_Sludge(LE *a_field, double a_user, int a_days)
Spread sewege sludge on a_field owned by an stock farmer.
Definition: farmfuncs.cpp:1086
Farm::SpringSowWithFerti
virtual bool SpringSowWithFerti(LE *a_field, double a_user, int a_days)
Carry out a sowing event with start fertilizer in the spring on a_field.
Definition: farmfuncs.cpp:574
LE::ReduceVeg_Extended
virtual void ReduceVeg_Extended(double)
Definition: elements.h:176
Farm::FA_NPKS
virtual bool FA_NPKS(LE *a_field, double a_user, int a_days)
Apply NPKS fertilizer, on a_field owned by a stock farmer.
Definition: farmfuncs.cpp:891
ls.h
fungicide
Definition: landscape.h:63
VegElement::GetVegType
virtual TTypesOfVegetation GetVegType(void)
Definition: elements.h:588
fp_rsm
Definition: treatment.h:58
fa_sludge
Definition: treatment.h:68
fa_rsm
Definition: treatment.h:69
cfg_WW_isecticide_prop1
CfgFloat cfg_WW_isecticide_prop1("PEST_WWINSECTONEPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing first insecticide spray in...
cfg_WW_InsecticideDay
CfgInt cfg_WW_InsecticideDay("PEST_WWINSECTONEDAY", CFG_CUSTOM, 1)
Provided to allow configuration control of the first insecticide spray in winter wheat - this changes...
fp_greenmanure
Definition: treatment.h:56
Farm::ProductApplication_DateLimited
virtual bool ProductApplication_DateLimited(LE *a_field, double, int, double a_applicationrate, PlantProtectionProducts a_ppp)
Special pesticide trial functionality.
Definition: farmfuncs.cpp:2396
cfg_SB_InsecticideMonth
CfgInt cfg_SB_InsecticideMonth("PEST_SBINSECTONEMONTH", CFG_CUSTOM, 5)
Provided to allow configuration control of the first insecticide spray in spring barley crops - this ...
straw_removal
Definition: treatment.h:112
insecticide
Definition: landscape.h:63
Farm::CutToHay
virtual bool CutToHay(LE *a_field, double a_user, int a_days)
Carry out hay cutting on a_field.
Definition: farmfuncs.cpp:2269
hay_turning
Definition: treatment.h:88
LE::SetInsectPop
virtual void SetInsectPop(double)
Definition: elements.h:157
Weather::Raining
bool Raining(void)
Definition: weather.h:432
bulb_harvest
Definition: treatment.h:110
Farm::FA_NPK
virtual bool FA_NPK(LE *a_field, double a_user, int a_days)
Apply NPK fertilizer to a_field owned by an stock farmer.
Definition: farmfuncs.cpp:917
Farm::FungicideTreat
virtual bool FungicideTreat(LE *a_field, double a_user, int a_days)
Apply fungicide to a_field.
Definition: farmfuncs.cpp:1279
straw_covering
Definition: treatment.h:111
shallow_harrow
Definition: treatment.h:107
l_farm_event_do_it_prob
static CfgInt l_farm_event_do_it_prob("FARM_EVENT_DO_IT_PROB", CFG_PRIVATE, 50)
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:1663
LE::GetVegBiomass
virtual double GetVegBiomass(void)
Definition: elements.h:154
heavy_cultivator_aggregate
Definition: treatment.h:108
water
Definition: treatment.h:80
Weather::GetWind
double GetWind(long a_date)
Definition: weather.h:425
LE::SetVegHeight
virtual void SetVegHeight(double)
Definition: elements.h:165
fp_liquidNH3
Definition: treatment.h:51
cfg_productapplicendyear
CfgInt cfg_productapplicendyear
Farm::FP_PK
virtual bool FP_PK(LE *a_field, double a_user, int a_days)
Apply PK fertilizer, on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:653
herbicide
Definition: landscape.h:63
LE::TogglePigGrazing
virtual void TogglePigGrazing(void)
Definition: elements.h:162
molluscicide
Definition: treatment.h:75
Farm::CattleIsOutLow
virtual bool CattleIsOutLow(LE *a_field, double a_user, int a_days, int a_max)
Generate a 'cattle_out_low' event for every day the cattle are on a_field.
Definition: farmfuncs.cpp:2018
Farm::StriglingHill
virtual bool StriglingHill(LE *a_field, double a_user, int a_days)
Carry out a mechanical weeding on a_field followed by hilling up (probably on potatoes)
Definition: farmfuncs.cpp:1635
burn_straw_stubble
Definition: treatment.h:92
harvest1
Definition: plants.h:55
l_pest_productapplic_period
CfgInt l_pest_productapplic_period
cfg_TU_InsecticideMonth
CfgInt cfg_TU_InsecticideMonth("PEST_TUINSECTONEMONTH", CFG_CUSTOM, 5)
Provided to allow configuration control of the first insecticide spray in tulip crops - this changes ...
Farm::CattleOutLowGrazing
virtual bool CattleOutLowGrazing(LE *a_field, double a_user, int a_days)
Start a extensive grazing event on a_field today.
Definition: farmfuncs.cpp:1944
DO_IT_PROB
#define DO_IT_PROB
Definition: farmfuncs.cpp:56
LE_SIG_NO_GROWTH_REG
#define LE_SIG_NO_GROWTH_REG
Definition: elements.h:45
cfg_CustomInsecticideKillProp
static CfgFloat cfg_CustomInsecticideKillProp("CUSTOMINSECTIVIDEKILLPROP", CFG_CUSTOM, 0.5, 0, 1.0)
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:773
cattle_out_low
Definition: treatment.h:100
fp_pk
Definition: treatment.h:50
testpesticide
Definition: landscape.h:63
LE::SetSprayedToday
void SetSprayedToday(bool a_didit)
Definition: elements.h:303
fa_npk
Definition: treatment.h:61
Farm::AutumnSow
virtual bool AutumnSow(LE *a_field, double a_user, int a_days)
Carry out a sowing event in the autumn on a_field.
Definition: farmfuncs.cpp:364
Landscape
The landscape class containing all environmental and topographical data.
Definition: landscape.h:112
cattle_out
Definition: treatment.h:83
l_el_o_cut_height
CfgFloat l_el_o_cut_height
Farm::FA_RSM
virtual bool FA_RSM(LE *a_field, double a_user, int a_days)
RSM (ammonium nitrate solution) applied on a_field owned by a stock farmer.
Definition: farmfuncs.cpp:1111
cfg_POT_InsecticideDay
CfgInt cfg_POT_InsecticideDay("PEST_POTINSECTONEDAY", CFG_CUSTOM, 15)
Provided to allow configuration control of the first insecticide spray in potatoes crops - this chang...
Farm::Biocide
virtual bool Biocide(LE *a_field, double a_user, int a_days)
Biocide applied on a_field.
Definition: farmfuncs.cpp:2415
cfg_WW_isecticide_prop2
CfgFloat cfg_WW_isecticide_prop2("PEST_WWINSECTTWOPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing second insecticide spray i...
Weather::GetTemp
double GetTemp(long a_date)
Get the temperature on a particular date.
Definition: weather.h:417
fp_npk
Definition: treatment.h:49
fa_npks
Definition: treatment.h:60
stubble_harrowing
Definition: treatment.h:90
l_pest_productapplic_enddate
CfgInt l_pest_productapplic_enddate
stubble_plough
Definition: treatment.h:35
autumn_plough
Definition: treatment.h:34
Calendar::Date
long Date(void)
Definition: calendar.h:57
tov_PotatoesIndustry
Definition: tov_declaration.h:50
fp_manure
Definition: treatment.h:55
strigling_sow
Definition: treatment.h:95
cfg_BE_InsecticideDay
CfgInt cfg_BE_InsecticideDay("PEST_BEINSECTONEDAY", CFG_CUSTOM, 15)
Provided to allow configuration control of the first insecticide spray in beet crops - this changes t...
Farm::FP_AmmoniumSulphate
virtual bool FP_AmmoniumSulphate(LE *a_field, double a_user, int a_days)
Apply Ammonium Sulphate to a_field owned by an arable farmer.
Definition: farmfuncs.cpp:750
CfgBool
Bool configurator entry class.
Definition: configurator.h:127
Farm::HayBailing
virtual bool HayBailing(LE *a_field, double a_user, int a_days)
Carry out hay bailing on a_field.
Definition: farmfuncs.cpp:2184
LE::SetMownDecay
void SetMownDecay(int a_decaytime_days)
Definition: elements.h:314
LE::ReduceVeg
virtual void ReduceVeg(double)
Definition: elements.h:175
Farm::FA_Calcium
virtual bool FA_Calcium(LE *a_field, double a_user, int a_days)
Calcium applied on a_field owned by a stock farmer.
Definition: farmfuncs.cpp:1133
Farm::StrawChopping
virtual bool StrawChopping(LE *a_field, double a_user, int a_days)
Carry out straw chopping on a_field.
Definition: farmfuncs.cpp:2132
winter_plough
Definition: treatment.h:42
cfg_OptimiseBedriftsmodelCrops
CfgBool cfg_OptimiseBedriftsmodelCrops
If set to true, the original farm optimisation model's crop set is used in the farmer decision making...
cfg_BE_InsecticideMonth
CfgInt cfg_BE_InsecticideMonth("PEST_BEINSECTONEMONTH", CFG_CUSTOM, 5)
Provided to allow configuration control of the first insecticide spray in beet crops - this changes t...
OptimisingFarm::InsecticideTreat
virtual bool InsecticideTreat(LE *a_field, double, int a_days)
Carries out insecticide application. Saves information on each application for a given crop.
Definition: farmfuncs.cpp:1389
LE_SIG_NO_FUNGICIDE
#define LE_SIG_NO_FUNGICIDE
Definition: elements.h:42
Farm::FA_ManganeseSulphate
virtual bool FA_ManganeseSulphate(LE *a_field, double a_user, int a_days)
Apply manganese sulphate to a_field owned by an stock farmer.
Definition: farmfuncs.cpp:1013
cfg_POT_InsecticideMonth
CfgInt cfg_POT_InsecticideMonth("PEST_POTINSECTONEMONTH", CFG_CUSTOM, 5)
Provided to allow configuration control of the first insecticide spray in potatoes crops - this chang...
l_el_o_cut_green
CfgFloat l_el_o_cut_green
cfg_CAB_InsecticideMonth
CfgInt cfg_CAB_InsecticideMonth("PEST_CABINSECTONEMONTH", CFG_CUSTOM, 5)
Provided to allow configuration control of the first insecticide spray in cabbage crops - this change...
l_farm_herbicide_kills
static CfgBool l_farm_herbicide_kills("FARM_PESTICIDE_KILLS", CFG_CUSTOM, true)
LE::ResetDigestability
virtual void ResetDigestability()
sets growth record to zero in descendent classes
Definition: elements.h:382
cfg_WW_NINV_tillage_prop1
CfgFloat cfg_WW_NINV_tillage_prop1("TILLAGE_WWNINVONEPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing first non-inversion tillag...
EL_STRIGLING_DELAYTIME
#define EL_STRIGLING_DELAYTIME
Definition: elements.h:61
Pesticide::DailyQueueAdd
void DailyQueueAdd(LE *a_element_sprayed, double a_amount, PlantProtectionProducts a_ppp)
Definition: pesticide.cpp:140
l_el_o_cut_total
CfgFloat l_el_o_cut_total
fp_sludge
Definition: treatment.h:57
Farm::CutOrch
virtual bool CutOrch(LE *a_field, double a_user, int a_days)
Cut vegetation on orchard crop. //based on cut to silage - values from cutting function of orchard.
Definition: farmfuncs.cpp:2362
straw_chopping
Definition: treatment.h:87
Farm::FP_Calcium
virtual bool FP_Calcium(LE *a_field, double a_user, int a_days)
Calcium applied on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:869
tov_Potatoes
Definition: tov_declaration.h:50
fungicide_treat
Definition: treatment.h:73
deep_ploughing
Definition: treatment.h:43
preseeding_cultivator_sow
Definition: treatment.h:40
Farm::FlowerCutting
virtual bool FlowerCutting(LE *a_field, double a_user, int a_days)
Flower cutting applied on a_field.
Definition: farmfuncs.cpp:2437
mow
Definition: treatment.h:93
fa_pk
Definition: treatment.h:62
cfg_productapplicstartyear
CfgInt cfg_productapplicstartyear
spring_harrow
Definition: treatment.h:45
Landscape::CheckForPesticideRecord
void CheckForPesticideRecord(LE *a_field, TTypesOfPesticideCategory a_pcide)
Check if needed and record pesticide application.
Definition: Landscape.cpp:669
Landscape::SupplyYearNumber
int SupplyYearNumber(void)
Definition: landscape.h:1616
Field
Definition: elements.h:727
l_farm_cattle_veg_reduce
static CfgFloat l_farm_cattle_veg_reduce("FARM_CATTLE_VEG_REDUCE", CFG_CUSTOM, 1.5)
LE::InsectMortality
virtual void InsectMortality(double)
Definition: elements.h:159
EL_TRAMLINE_DECAYTIME
#define EL_TRAMLINE_DECAYTIME
Definition: elements.h:57
CfgFloat::value
double value(void)
Definition: configurator.h:118
LE::ToggleCattleGrazing
virtual void ToggleCattleGrazing(void)
Definition: elements.h:161
Farm::InsecticideTreat
virtual bool InsecticideTreat(LE *a_field, double a_user, int a_days)
Apply insecticide to a_field.
Definition: farmfuncs.cpp:1348
Farm::AutumnRoll
virtual bool AutumnRoll(LE *a_field, double a_user, int a_days)
Carry out a roll event in the autumn on a_field.
Definition: farmfuncs.cpp:288
hilling_up
Definition: treatment.h:79
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:498
Farm::FP_Slurry
virtual bool FP_Slurry(LE *a_field, double a_user, int a_days)
Apply slurry to a_field owned by an arable farmer.
Definition: farmfuncs.cpp:701
LE::ReduceWeedBiomass
virtual void ReduceWeedBiomass(double)
Definition: elements.h:160
Farm::HarvestLong
virtual bool HarvestLong(LE *a_field, double a_user, int a_days)
Carry out a harvest on a_field.
Definition: farmfuncs.cpp:1821
biocide
Definition: treatment.h:104
Farm::SleepAllDay
virtual bool SleepAllDay(LE *a_field, double a_user, int a_days)
Nothing to to today on a_field.
Definition: farmfuncs.cpp:241
LE::SetStubble
void SetStubble(bool a_flag)
Sets the in stubble flag.
Definition: elements.h:390
fa_calcium
Definition: treatment.h:70
CFG_CUSTOM
Definition: configurator.h:60
fa_manure
Definition: treatment.h:66
fp_npks
Definition: treatment.h:48
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:1510
row_cultivation
Definition: treatment.h:76
trial_insecticidetreat
Definition: treatment.h:96
LE
Definition: elements.h:81
Farm::Water
virtual bool Water(LE *a_field, double a_user, int a_days)
Carry out a watering on a_field.
Definition: farmfuncs.cpp:1717
LE::SetBirdMaize
void SetBirdMaize(double a_forage)
Definition: elements.h:213
Farm::AutumnPlough
virtual bool AutumnPlough(LE *a_field, double a_user, int a_days)
Carry out a ploughing event in the autumn on a_field.
Definition: farmfuncs.cpp:132
Farm::SpringSow
virtual bool SpringSow(LE *a_field, double a_user, int a_days)
Carry out a sowing event in the spring on a_field.
Definition: farmfuncs.cpp:546
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:261
cfg_WW_isecticide_prop3
CfgFloat cfg_WW_isecticide_prop3("PEST_WWINSECTTHREEPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing third insecticide spray in...
Farm::FA_AmmoniumSulphate
virtual bool FA_AmmoniumSulphate(LE *a_field, double a_user, int a_days)
Apply ammonium sulphate to a_field owned by an stock farmer.
Definition: farmfuncs.cpp:990
LE::SetLastTreatment
void SetLastTreatment(int a_treatment)
Definition: elements.cpp:490
VegElement::Set_harvested
void Set_harvested()
Definition: elements.h:644
LE::GrazeVegetation
virtual void GrazeVegetation(double, bool)
Definition: elements.h:231
fp_ammoniumsulphate
Definition: treatment.h:54
CfgInt
Integer configurator entry class.
Definition: configurator.h:87
stubble_cultivator_heavy
Definition: treatment.h:36
Farm::FP_LiquidNH3
virtual bool FP_LiquidNH3(LE *a_field, double a_user, int a_days)
Apply liquid ammonia fertilizer to a_field owned by an arable farmer.
Definition: farmfuncs.cpp:677
VegElement::Set_biomass_at_harvest
void Set_biomass_at_harvest(double a_biomass, int index)
Definition: elements.h:642
DO_IT_PROB_LONG
#define DO_IT_PROB_LONG
Definition: farmfuncs.cpp:57
Farm::StriglingSow
virtual bool StriglingSow(LE *a_field, double a_user, int a_days)
Carry out a mechanical weeding followed by sowing on a_field.
Definition: farmfuncs.cpp:1597
spring_plough
Definition: treatment.h:44
l_pest_productapplic_startdate
CfgInt l_pest_productapplic_startdate
fa_greenmanure
Definition: treatment.h:67
g_landscape_p
Landscape * g_landscape_p
Definition: Landscape.cpp:258
l_farm_cattle_veg_reduce2
static CfgFloat l_farm_cattle_veg_reduce2("FARM_CATTLE_VEG_REDUCE_LOW", CFG_CUSTOM, 1.00)
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:417
Farm::StrawCovering
virtual bool StrawCovering(LE *a_field, double a_user, int a_days)
Straw covering applied on a_field.
Definition: farmfuncs.cpp:2502
cfg_pest_product_1_amount
CfgFloat cfg_pest_product_1_amount
fp_calcium
Definition: treatment.h:59
CfgFloat
Double configurator entry class.
Definition: configurator.h:106
Farm::FP_RSM
virtual bool FP_RSM(LE *a_field, double a_user, int a_days)
RSM (ammonium nitrate solution) applied on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:847
spring_roll
Definition: treatment.h:46
fa_manganesesulphate
Definition: treatment.h:64
LE::SetBirdSeed
void SetBirdSeed(double a_forage)
Definition: elements.h:201
Farm::WinterPlough
virtual bool WinterPlough(LE *a_field, double a_user, int a_days)
Carry out a ploughing event in the winter on a_field.
Definition: farmfuncs.cpp:392
bed_forming
Definition: treatment.h:106
CFG_PRIVATE
Definition: configurator.h:62
cut_weeds
Definition: treatment.h:94
CfgInt::value
int value(void)
Definition: configurator.h:98
LE::SetGrowthPhase
virtual void SetGrowthPhase(int)
Definition: elements.h:170
Farm::BulbHarvest
virtual bool BulbHarvest(LE *a_field, double a_user, int a_days)
Carry out a bulb harvest on a_field.
Definition: farmfuncs.cpp:2465
fp_manganesesulphate
Definition: treatment.h:53
herbicide_treat
Definition: treatment.h:71
Farm::FP_GreenManure
virtual bool FP_GreenManure(LE *a_field, double a_user, int a_days)
Spread green manure on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:798
Farm::GrowthRegulator
virtual bool GrowthRegulator(LE *a_field, double a_user, int a_days)
Apply growth regulator to a_field.
Definition: farmfuncs.cpp:1250
LE::GetUnsprayedMarginPolyRef
int GetUnsprayedMarginPolyRef(void)
Definition: elements.h:319
growth_regulator
Definition: treatment.h:72
Calendar::DayInYear
int DayInYear(void)
Definition: calendar.h:58
cut_to_silage
Definition: treatment.h:86
LE::ZeroVeg
virtual void ZeroVeg(void)
Definition: elements.h:174
product_treat
Definition: treatment.h:101
LE::SetHerbicideDelay
void SetHerbicideDelay(int a_decaytime_days)
Definition: elements.h:312
g_date
class Calendar * g_date
Definition: calendar.cpp:38
pigs_out
Definition: treatment.h:84
Farm::FA_PK
virtual bool FA_PK(LE *a_field, double a_user, int a_days)
Apply PK fertilizer to a_field owned by an stock farmer.
Definition: farmfuncs.cpp:941
Farm::BurnStrawStubble
virtual bool BurnStrawStubble(LE *a_field, double a_user, int a_days)
Burn stubble on a_field.
Definition: farmfuncs.cpp:2236
cut_to_hay
Definition: treatment.h:85
LE::Insecticide
virtual void Insecticide(double)
Definition: elements.h:158
spring_sow
Definition: treatment.h:47
cfg_WW_conv_tillage_prop1
CfgFloat cfg_WW_conv_tillage_prop1("TILLAGE_WWCONVONEPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing first conventional tillage...
LE_SIG_NO_MOLLUSC
#define LE_SIG_NO_MOLLUSC
Definition: elements.h:46
Farm::Swathing
virtual bool Swathing(LE *a_field, double a_user, int a_days)
Cut the crop on a_field and leave it lying (probably rape)
Definition: farmfuncs.cpp:1744
cfg_WW_conv_tillage_prop2
CfgFloat cfg_WW_conv_tillage_prop2("TILLAGE_WWCONVTWOPROP", CFG_CUSTOM, 1.0)
Provided to allow configuration control of the proportion of farmers doing second conventional tillag...
sleep_all_day
Definition: treatment.h:33
cfg_OSR_InsecticideMonth
CfgInt cfg_OSR_InsecticideMonth("PEST_OSRINSECTONEMONTH", CFG_CUSTOM, 4)
Provided to allow configuration control of the first insecticide spray in OSR - this changes the mont...
CfgBool::value
bool value(void)
Definition: configurator.h:135
cfg_OSR_InsecticideDay
CfgInt cfg_OSR_InsecticideDay("PEST_OSRINSECTONEDAY", CFG_CUSTOM, 30)
Provided to allow configuration control of the first insecticide spray in OSR - this changes the day ...
l_farm_event_do_it_prob_long
static CfgInt l_farm_event_do_it_prob_long("FARM_EVENT_DO_IT_PROB_LONG", CFG_PRIVATE, 5)
Farm::PigsOut
virtual bool PigsOut(LE *a_field, double a_user, int a_days)
Generate a 'pigs_out' event for every day the cattle are on a_field.
Definition: farmfuncs.cpp:2062
Farm::HayTurning
virtual bool HayTurning(LE *a_field, double a_user, int a_days)
Carry out hay turning on a_field.
Definition: farmfuncs.cpp:2159
Farm::CattleOut
virtual bool CattleOut(LE *a_field, double a_user, int a_days)
Start a grazing event on a_field today.
Definition: farmfuncs.cpp:1910
strigling_hill
Definition: treatment.h:105
g_weather
class Weather * g_weather
Definition: weather.cpp:41
Farm::HeavyCultivatorAggregate
virtual bool HeavyCultivatorAggregate(LE *a_field, double a_user, int a_days)
Carry out a heavy cultivation event on a_field. This is non-inversion type of cultivation which can b...
Definition: farmfuncs.cpp:217
fa_slurry
Definition: treatment.h:63
swathing
Definition: treatment.h:81
LE_SIG_NO_HERBICIDE
#define LE_SIG_NO_HERBICIDE
Definition: elements.h:47
LE::SetVegParameters
virtual void SetVegParameters(double, double, double, double)
Definition: elements.h:166
Weather::GetRainPeriod
double GetRainPeriod(long a_date, unsigned int a_period)
Definition: weather.cpp:253
Farm::StubbleHarrowing
virtual bool StubbleHarrowing(LE *a_field, double a_user, int a_days)
Carry out stubble harrowing on a_field.
Definition: farmfuncs.cpp:2209
Farm::SpringHarrow
virtual bool SpringHarrow(LE *a_field, double a_user, int a_days)
Carry out a harrow event in the spring on a_field.
Definition: farmfuncs.cpp:471
EL_HERBICIDE_DELAYTIME
#define EL_HERBICIDE_DELAYTIME
Definition: elements.h:60
sow
Definition: plants.h:53
Farm::FP_NPKS
virtual bool FP_NPKS(LE *a_field, double a_user, int a_days)
Apply NPKS fertilizer, on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:602
Farm::CutWeeds
virtual bool CutWeeds(LE *a_field, double a_user, int a_days)
Carry out weed topping on a_field.
Definition: farmfuncs.cpp:2303