farmfuncs.cpp

Go to the documentation of this file.

//
// farmfuncs.cpp
//
/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, University of Aarhus
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
#define UNREFERENCED_PARAMETER(P) (P)

#include "ls.h"


using namespace std;

extern Landscape* g_landscape_p;
extern CfgFloat l_pest_insecticide_amount;
extern CfgFloat l_pest_product_1_amount;
extern CfgFloat l_pest_product_0_amount;
extern CfgInt l_pest_productapplic_startdate;
extern CfgInt l_pest_productapplic_enddate;
extern CfgInt l_pest_productapplic_period;
extern CfgBool cfg_OptimiseBedriftsmodelCrops;
extern CfgInt cfg_productapplicstartyear;
extern CfgInt cfg_productapplicendyear;

#define DO_IT_PROB (l_farm_event_do_it_prob.value())
#define DO_IT_PROB_LONG (l_farm_event_do_it_prob_long.value())

static CfgInt l_farm_event_do_it_prob("FARM_EVENT_DO_IT_PROB", CFG_PRIVATE, 50);
static CfgInt l_farm_event_do_it_prob_long("FARM_EVENT_DO_IT_PROB_LONG", CFG_PRIVATE, 5);
static CfgFloat l_farm_cattle_veg_reduce("FARM_CATTLE_VEG_REDUCE", CFG_CUSTOM, 1.5);
static CfgFloat l_farm_cattle_veg_reduce2("FARM_CATTLE_VEG_REDUCE_LOW", CFG_CUSTOM, 1.00 );
static CfgFloat l_farm_pig_veg_reduce("FARM_PIG_VEG_REDUCE", CFG_CUSTOM, 0.98 );


// Determine whether insecticide and herbicide actually
// influences the insect population. By default they *do*
// kill off some of the little critters.
static CfgBool l_farm_insecticide_kills("FARM_INSECTICIDE_KILLS",
                                       CFG_CUSTOM, true );
static CfgBool l_farm_herbicide_kills("FARM_PESTICIDE_KILLS",
                                        CFG_CUSTOM, true );

CfgInt cfg_WW_InsecticideDay("PEST_WWINSECTONEDAY", CFG_CUSTOM, 1);
CfgInt cfg_WW_InsecticideMonth("PEST_WWINSECTONEMONTH", CFG_CUSTOM, 5);
CfgInt cfg_SB_InsecticideDay("PEST_SBINSECTONEDAY", CFG_CUSTOM, 15);
CfgInt cfg_SB_InsecticideMonth("PEST_SBINSECTONEMONTH", CFG_CUSTOM, 5);
CfgInt cfg_OSR_InsecticideDay("PEST_OSRINSECTONEDAY", CFG_CUSTOM, 30);
CfgInt cfg_OSR_InsecticideMonth("PEST_OSRINSECTONEMONTH", CFG_CUSTOM, 4);


//declared in elements.cpp
extern CfgFloat l_el_o_cut_height;
extern CfgFloat l_el_o_cut_green;
extern CfgFloat l_el_o_cut_total;


bool Farm::AutumnPlough( LE *a_field, double /*a_user*/, int a_days )
{

    // LE is a pointer to the field element
    // a_user is a pointer to the farm
    // a_days is the end of the operation time - today
    // if a_days <0 then the time to do it is passed
    // the line below reads 'plough if last day possible OR if not raining and pass a probability test
    if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
        // this bit sets up the events to occur when ploughing occurs
        // The trace below is for debugging checks
        a_field->Trace( autumn_plough );
        // Record the event for this field, so other objects can find out it has happened
        a_field->SetLastTreatment( autumn_plough );
        // 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.
        a_field->InsectMortality( 0.1 );
        // Reduce the vegetation, in this case to zero
        a_field->ZeroVeg();
        // 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.
        int pref=a_field->GetUnsprayedMarginPolyRef();
        if (pref!=-1){
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um=g_landscape_p->SupplyLEPointer(pref);
            um->SetLastTreatment( autumn_plough );
            um->InsectMortality( 0.1 );
            um->ZeroVeg();
        }
        return true;      // completed
    }
    return false;       // not completed
}

bool Farm::SleepAllDay( LE *a_field, double /*a_user*/, int /*a_days */)
{

  a_field->Trace( sleep_all_day );
  a_field->SetLastTreatment( sleep_all_day );
  int pref=a_field->GetUnsprayedMarginPolyRef();
  if (pref!=-1){
    // Must have an unsprayed margin so need to pass the information on to it
    LE* um=g_landscape_p->SupplyLEPointer(pref);
    um->SetLastTreatment(sleep_all_day);
  }
  return true;
}

bool Farm::AutumnHarrow( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( autumn_harrow );
    a_field->SetLastTreatment( autumn_harrow );
   // Apply 90% mortality to the insects
    a_field->InsectMortality( 0.1 );
   // Reduce the vegetation to zero
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( autumn_harrow );
      um->InsectMortality( 0.1 );
      um->ZeroVeg();
    }
    return true;
  }
  return false;
}

bool Farm::AutumnRoll( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( autumn_roll );
    a_field->SetLastTreatment( autumn_roll );
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( autumn_roll );
      um->ZeroVeg();
    }
    return true;
  }
  return false;
}

bool Farm::AutumnSow( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( autumn_sow );
    a_field->SetLastTreatment( autumn_sow );
    a_field->SetGrowthPhase( sow );
    a_field->SetLastSownVeg(a_field->GetVegType());
    // Reduce the vegetation to zero
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( autumn_sow );
      um->SetGrowthPhase( sow );
      um->ZeroVeg();
      um->SetLastSownVeg(um->GetVegType());
    }
    return true;
  }
  return false;
}

bool Farm::WinterPlough( LE *a_field, double /*a_user*/, int a_days )
{

    if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( winter_plough );
    a_field->SetLastTreatment( winter_plough );
    a_field->InsectMortality( 0.1 );
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( winter_plough );
      um->InsectMortality( 0.1 );
      um->ZeroVeg();
    }
    return true;
  }
  return false;
}

bool Farm::DeepPlough( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( deep_ploughing );
    a_field->SetLastTreatment( deep_ploughing );
   // Apply 90% mortality to the insects
    a_field->InsectMortality( 0.1 );
   // Reduce the vegetation to zero
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( deep_ploughing );
      um->InsectMortality( 0.1 );
      um->ZeroVeg();
    }
    return true;
  }
  return false;
}

bool Farm::SpringPlough( LE *a_field, double /*a_user*/, int a_days )
{

    if ((a_days <= 0) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( spring_plough );
    a_field->SetLastTreatment( spring_plough );
   // Apply 90% mortality to the insects
    a_field->InsectMortality( 0.1 );
   // Reduce the vegetation to zero
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( spring_plough );
      um->InsectMortality( 0.1);
      um->ZeroVeg();
    }
    return true;
  }
  return false;
}

bool Farm::SpringHarrow( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( spring_harrow );
    a_field->SetLastTreatment( spring_harrow );
    // 30% insect mortality
       a_field->InsectMortality( 0.7 );
    // remove all vegetation
       a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( spring_harrow );
      um->InsectMortality( 0.7 );
      um->ZeroVeg();
    }
    return true;
  }
  return false;
}

bool Farm::SpringRoll( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( spring_roll );
    a_field->SetLastTreatment( spring_roll );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( spring_roll );
    }
    return true;
  }
  return false;
}

bool Farm::SpringSow( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( spring_sow );
    a_field->SetLastTreatment( spring_sow );
    a_field->SetGrowthPhase( sow );
    a_field->SetLastSownVeg(a_field->GetVegType());
   // Reduce the  vegetation to zero - should not strictly be necessary, but prevents any false starts in the crop growth.
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
   if (pref!=-1){
     // Must have an unsprayed margin so need to pass the information on to it
     LE* um=g_landscape_p->SupplyLEPointer(pref);
     um->SetLastTreatment( spring_sow );
     um->SetGrowthPhase( sow );
     um->ZeroVeg();
     um->SetLastSownVeg(um->GetVegType());
   }
   return true;
  }
  return false;
}

bool Farm::FP_NPKS( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_npks );
    a_field->SetLastTreatment( fp_npks );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
if (pref!=-1){
  // Must have an unsprayed margin so need to pass the information on to it
  LE* um=g_landscape_p->SupplyLEPointer(pref);
  um->SetLastTreatment(sleep_all_day);
  um->SetGrowthPhase( harvest1 );
  um->InsectMortality( 0.4 );
  um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
}

    return true;
  }
  return false;
}


bool Farm::FP_NPK( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_npk );
    a_field->SetLastTreatment( fp_npk );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment(fp_npk);
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_PK( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_pk );
    a_field->SetLastTreatment( fp_pk );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment(fp_pk);
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_LiquidNH3( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_liquidNH3 );
    a_field->SetLastTreatment( fp_liquidNH3 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment(fp_liquidNH3);
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_Slurry( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
                                 !g_weather->Raining() && DoIt(DO_IT_PROB)))
{
    a_field->Trace( fp_slurry );
    a_field->SetLastTreatment( fp_slurry );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment(fp_slurry);
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_ManganeseSulphate( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_manganesesulphate );
    a_field->SetLastTreatment( fp_manganesesulphate );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fp_manganesesulphate );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_Manure( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
                        !g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_manure );
    a_field->SetLastTreatment( fp_manure );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fp_manure );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_GreenManure( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fp_greenmanure );
    a_field->SetLastTreatment( fp_greenmanure );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fp_greenmanure );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FP_Sludge( LE *a_field, double /*a_user*/, int a_days )
{
  //
  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
                                 !g_weather->Raining() && DoIt(DO_IT_PROB)))
{
    a_field->Trace( fp_sludge );
    a_field->SetLastTreatment( fp_sludge );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fp_sludge );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FA_NPK( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fa_npk );
    a_field->SetLastTreatment( fa_npk );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_npk );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FA_PK( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fa_pk );
    a_field->SetLastTreatment( fa_pk );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_pk );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::FA_Slurry( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
                        !g_weather->Raining() && DoIt(DO_IT_PROB)))
{
    a_field->Trace( fa_slurry );
    a_field->SetLastTreatment( fa_slurry );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_slurry );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::FA_AmmoniumSulphate( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fa_ammoniumsulphate );
    a_field->SetLastTreatment( fa_ammoniumsulphate );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_ammoniumsulphate );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FA_Manure( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
                                 !g_weather->Raining() && DoIt(DO_IT_PROB)))
{
    a_field->Trace( fa_manure );
    a_field->SetLastTreatment( fa_manure );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_manure );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FA_GreenManure( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( fa_greenmanure );
    a_field->SetLastTreatment( fa_greenmanure );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_greenmanure );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::FA_Sludge( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || ((g_weather->GetTemp()>0)&&
                                 !g_weather->Raining() && DoIt(DO_IT_PROB)))
{
    a_field->Trace( fa_sludge );
    a_field->SetLastTreatment( fa_sludge );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( fa_sludge );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool Farm::HerbicideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days) // Must do this
  {
    if (((a_field->GetSignal() & LE_SIG_NO_HERBICIDE)==0 )) 
    {
      a_field->Trace( herbicide_treat );
      a_field->SetLastTreatment( herbicide_treat );
        if ( l_farm_herbicide_kills.value()) 
        {
        a_field->ReduceWeedBiomass( 0.05 );
      }
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
    }
    return true;
  }
  else if ((g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) 
  {
      if ( !(a_field->GetSignal() & LE_SIG_NO_HERBICIDE) ) 
      {
      a_field->Trace( herbicide_treat );
      a_field->SetLastTreatment( herbicide_treat );
          if ( l_farm_herbicide_kills.value()) 
          {
        a_field->ReduceWeedBiomass( 0.05 );
      }
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
    }
  return true;
  }
  return false;
}


bool OptimisingFarm::HerbicideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days) // Must do this
  {
    if (((a_field->GetSignal() & LE_SIG_NO_HERBICIDE)==0 )) 
    {
        a_field->Trace( herbicide_treat );
        a_field->SetLastTreatment( herbicide_treat );
        if ( l_farm_herbicide_kills.value()) {
            a_field->ReduceWeedBiomass( 0.05 );
        }
        a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
        a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
        
        
        if(!cfg_OptimiseBedriftsmodelCrops.value()){
            Field * pf =  dynamic_cast<Field*>(a_field); 
            pf->Add_no_herb_app();
        }

     }
     return true;
  }
  else if ((g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) 
  {
    if ( !(a_field->GetSignal() & LE_SIG_NO_HERBICIDE) ) 
    {
        a_field->Trace( herbicide_treat );
        a_field->SetLastTreatment( herbicide_treat );
        if ( l_farm_herbicide_kills.value()) {
            a_field->ReduceWeedBiomass( 0.05 );
        }
        a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
        a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
        
        if(!cfg_OptimiseBedriftsmodelCrops.value()){
            Field * pf =  dynamic_cast<Field*>(a_field); 
            pf->Add_no_herb_app();
        }
    }
    return true;
  }
  return false;
}



bool Farm::GrowthRegulator( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days)
  {
    if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5) &&
        (!(a_field->GetSignal() & LE_SIG_NO_GROWTH_REG) )) {
      a_field->Trace( growth_regulator );
      a_field->SetLastTreatment( growth_regulator );
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  else if ( (g_weather->GetWind()<4.5) &&
           (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_GROWTH_REG) ) {
      a_field->Trace( growth_regulator );
      a_field->SetLastTreatment( growth_regulator );
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::FungicideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days)
  {
        if ( ( ! a_field->GetSignal() & LE_SIG_NO_FUNGICIDE )) 
        {
      a_field->Trace( fungicide_treat );
      a_field->SetLastTreatment( fungicide_treat );
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  else if ( (g_weather->GetWind()<4.5) &&
            (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_FUNGICIDE) ) {
      a_field->Trace( fungicide_treat );
      a_field->SetLastTreatment( fungicide_treat );
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool OptimisingFarm::FungicideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days)
  {
    if ( ( ! a_field->GetSignal() & LE_SIG_NO_FUNGICIDE )) {
        a_field->Trace( fungicide_treat );
        a_field->SetLastTreatment( fungicide_treat );
        a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
        
        if(!cfg_OptimiseBedriftsmodelCrops.value()){
            Field * pf =  dynamic_cast<Field*>(a_field); 
            pf->Add_no_fi_app();
        }
    }
    return true;
  }
  else if ( (g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_FUNGICIDE) ) {
        a_field->Trace( fungicide_treat );
        a_field->SetLastTreatment( fungicide_treat );
        a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
        
        if(!cfg_OptimiseBedriftsmodelCrops.value()){
            Field * pf =  dynamic_cast<Field*>(a_field); 
            pf->Add_no_fi_app();
        }
    }   
    return true;
  }
  return false;
}



bool Farm::InsecticideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days) 
  {
      if (( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE) )) 
      {
          // **CJT** Turn this code on to use the pesticide engine with insecticides
          //      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
          //
      a_field->Trace( insecticide_treat );
      a_field->SetLastTreatment( insecticide_treat );
          if ( l_farm_insecticide_kills.value()) 
          {
       a_field->Insecticide( 0.36 );
      }
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  else if ( (g_weather->GetWind()<4.5) &&
            (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE )) {
// **CJT** Turn this code on to use the pesticide engine with insecticides
//      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
//
      a_field->Trace( insecticide_treat );
      a_field->SetLastTreatment( insecticide_treat );
      if ( l_farm_insecticide_kills.value()) {
       a_field->Insecticide( 0.36 );
      }
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}


bool OptimisingFarm::InsecticideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  if (0 >= a_days) 
  {
    if (( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE) )) 
    {
        // **CJT** Turn this code on to use the pesticide engine with insecticides
        //      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
        //
        a_field->Trace( insecticide_treat );
        a_field->SetLastTreatment( insecticide_treat );
        if ( l_farm_insecticide_kills.value()) {
            a_field->Insecticide( 0.36 );
        }
        a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
        
        if(!cfg_OptimiseBedriftsmodelCrops.value()){
            Field * pf =  dynamic_cast<Field*>(a_field); 
            pf->Add_no_fi_app();
        }

    }   
    return true;
  }
  else if ( (g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) 
  {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE )) {
        // **CJT** Turn this code on to use the pesticide engine with insecticides
        //      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
        //
        a_field->Trace( insecticide_treat );
        a_field->SetLastTreatment( insecticide_treat );
        if ( l_farm_insecticide_kills.value()) {
            a_field->Insecticide( 0.36 );
        }
        a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    
        if(!cfg_OptimiseBedriftsmodelCrops.value()){
            Field * pf =  dynamic_cast<Field*>(a_field); 
            pf->Add_no_fi_app();
        }
    }
    
    return true;
  }
  return false;
}



bool Farm::SynInsecticideTreat( LE *a_field, double /*a_user*/, int a_days )
{

  // NOTE Differs from normal insecticide in that it will be done on the last
  // day if not managed before
  if (0 >= a_days) {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_SYNG_INSECT )) {
      a_field->Trace( syninsecticide_treat );
      a_field->SetLastTreatment( syninsecticide_treat );
      if ( l_farm_insecticide_kills.value()) {
       a_field->Insecticide( 0.2 );
      }
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
//    double p=l_pest_insecticide_amount.value();
//    g_pest->DailyQueueAdd( a_field,p );
    return true;
  } else {
    if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5)) {
      if ( ! (a_field->GetSignal() & LE_SIG_NO_SYNG_INSECT ) ) {
       a_field->Trace( syninsecticide_treat );
       a_field->SetLastTreatment( syninsecticide_treat );
       if ( l_farm_insecticide_kills.value()) {
         a_field->Insecticide( 0.2 );
       }
       a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      }
//      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
      return true;
    }
  }
  return false;
}

bool Farm::ProductApplication0( LE *a_field, double /*a_user*/, int a_days )
{

  // NOTE Differs from normal pesticide in that it will be done on the last
  // day if not managed before
  if (0 >= a_days) {
    a_field->Trace( product_treat );
    a_field->SetLastTreatment( product_treat );
    if ( l_farm_insecticide_kills.value()) {
        a_field->Insecticide( 0.2 );     }
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    double p=l_pest_product_0_amount.value();
    g_pest->DailyQueueAdd( a_field,p );
    return true;
  } else {
    if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5)) {
    a_field->Trace( product_treat );
    a_field->SetLastTreatment( product_treat );
    if ( l_farm_insecticide_kills.value()) {
         a_field->Insecticide( 0.2 );     }
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    double p=l_pest_product_0_amount.value();
    g_pest->DailyQueueAdd( a_field,p );
      return true;
         }
  }
  return false;
}

bool Farm::ProductApplication1( LE *a_field, double /*a_user*/, int a_days )
{

  // NOTE Differs from normal pesticide in that it will be done on the last
  // day if not managed before
  if (0 >= a_days) {
    a_field->Trace( product_treat );
    a_field->SetLastTreatment( product_treat );
    if ( l_farm_insecticide_kills.value()) 
    {
        a_field->Insecticide( 0.2 );     
    }
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    double p=l_pest_product_1_amount.value();
    g_pest->DailyQueueAdd( a_field,p );
    return true;
  } else {
    if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5)) {
    a_field->Trace( product_treat );
    a_field->SetLastTreatment( product_treat );
    if ( l_farm_insecticide_kills.value()) {
         a_field->Insecticide( 0.2 );     }
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    double p=l_pest_product_1_amount.value();
    g_pest->DailyQueueAdd( a_field,p );
      return true;
         }
  }
  return false;
}

bool Farm::Molluscicide( LE *a_field, double /*a_user*/, int a_days )
{

       if (0 >= a_days) {
    if ( (!g_weather->Raining()) && (g_weather->GetWind()<4.5) &&
        (! (a_field->GetSignal() & LE_SIG_NO_MOLLUSC ))) {
      a_field->Trace( molluscicide );
      a_field->SetLastTreatment( molluscicide );
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  else if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    if ( ! (a_field->GetSignal() & LE_SIG_NO_MOLLUSC) ) {
      a_field->Trace( molluscicide );
      a_field->SetLastTreatment( molluscicide );
      a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::RowCultivation( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) && (g_weather->GetRainPeriod(g_date->Date(),3)<0.1) )
  {
    // Too much rain, just give up and claim we did it.
    return true;
  }

  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( row_cultivation );
    a_field->SetLastTreatment( row_cultivation );
    a_field->ReduceWeedBiomass( 0.5 );
    a_field->InsectMortality( 0.25 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( row_cultivation );
      um->InsectMortality( 0.25 );
      um->ReduceWeedBiomass( 0.5 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::Strigling( LE *a_field, double /*a_user*/, int a_days )
{

  // Force strigling if it has not been done already!!!  This happens regardless of weather as of 26/10/2005
  if ( (0 >= a_days) )// && (g_weather->GetRainPeriod(g_date->Date(),3)>0.1) )
  {
    a_field->Trace( strigling );
    a_field->SetLastTreatment( strigling );
    a_field->ReduceWeedBiomass( 0.05 );
    a_field->InsectMortality( 0.7 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    a_field->SetHerbicideDelay( EL_STRIGLING_DELAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( strigling );
      um->ReduceWeedBiomass( 0.05 );
      um->InsectMortality( 0.7 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      um->SetHerbicideDelay( EL_STRIGLING_DELAYTIME );
    return true;
  }
  }
  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( strigling );
    a_field->SetLastTreatment( strigling );
    a_field->ReduceWeedBiomass( 0.05 );
    a_field->InsectMortality( 0.7 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    a_field->SetHerbicideDelay( EL_STRIGLING_DELAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( strigling );
      um->ReduceWeedBiomass( 0.05 );
      um->InsectMortality( 0.7 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      um->SetHerbicideDelay( EL_STRIGLING_DELAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::StriglingSow( LE *a_field, double /*a_user*/, int a_days )
{

  //2 days good weather afterwards
  if ( (0 >= a_days) && (g_weather->GetRainPeriod(g_date->Date(),3)<0.1) )
  {
    return true;
  }

  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( strigling_sow );
    a_field->SetLastTreatment( strigling_sow );
    a_field->ReduceWeedBiomass( 0.05 );
    a_field->InsectMortality( 0.7 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    a_field->SetHerbicideDelay( EL_STRIGLING_DELAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( strigling_sow );
      um->ReduceWeedBiomass( 0.05 );
      um->InsectMortality( 0.7 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      um->SetHerbicideDelay( EL_STRIGLING_DELAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::HillingUp( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( hilling_up );
    a_field->SetLastTreatment( hilling_up );
    a_field->InsectMortality( 0.75 );
    a_field->ReduceWeedBiomass( 0.25 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( hilling_up );
      um->ReduceWeedBiomass( 0.25 );
      um->InsectMortality( 0.75 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::Water( LE *a_field, double /*a_user*/, int a_days )
{


  /* Turn on this code to avoid watering on heavy soils
  int soiltype = a_field->GetSoilType();
  if ( soiltype < 1 || soiltype > 4 )
    return true;
*/
  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( water );
    a_field->SetLastTreatment( water );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( water );
    }
    return true;
  }
  return false;
}

bool Farm::Swathing( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( swathing );
    a_field->SetLastTreatment( swathing );
    a_field->InsectMortality( 0.5 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( swathing );
      um->InsectMortality( 0.5 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::Harvest(LE *a_field, double /*a_user*/, int a_days)
{
    //5 days good weather before
    if ((0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(), 5) < 0.1) && DoIt(DO_IT_PROB))) {
        a_field->Trace(harvest);
        a_field->SetLastTreatment(harvest);
        a_field->SetGrowthPhase(harvest1);
        // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
        a_field->InsectMortality(0.4);
        double insects = a_field->GetInsectPop();
        a_field->ResetDigestability();
        a_field->RecalculateBugsNStuff();
        a_field->SetInsectPop(insects);
        a_field->SetTramlinesDecay(EL_TRAMLINE_DECAYTIME);
        int pref = a_field->GetUnsprayedMarginPolyRef();
        // Are we a cereal crop? If so we need to have some spilled grain
        double someseed = 0.0;
        double somemaize = 0.0;
        if (dynamic_cast<VegElement*>(a_field)->IsMatureCereal()) {
            someseed = m_OurManager->GetSpilledGrain();
        }
        else if (dynamic_cast<VegElement*>(a_field)->IsMaize()) {
            somemaize = m_OurManager->GetSpilledMaize();
        }
        else {
            someseed = 0.0;
            somemaize = 0.0;
        }
        a_field->SetBirdSeed( someseed );
        a_field->SetBirdMaize( somemaize ); 
        if (pref != -1){
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um = g_landscape_p->SupplyLEPointer(pref);
            um->SetLastTreatment(harvest);
            um->SetGrowthPhase(harvest1);
            um->InsectMortality(0.4);
            um->SetTramlinesDecay(EL_TRAMLINE_DECAYTIME);
            um->ResetDigestability();
            um->RecalculateBugsNStuff();
            um->SetBirdSeed( someseed ); 
            um->SetBirdMaize( somemaize );
        }
        return true;
    }
    return false;
}


bool Farm::HarvestLong(LE *a_field, double /*a_user*/, int a_days)
{

    //5 days good weather before
    if ((0 >= a_days) ||
        ((g_weather->GetRainPeriod(g_date->Date(), 5)<0.1) && DoIt(DO_IT_PROB_LONG))
        ) {
        a_field->Trace(harvest);
        a_field->SetLastTreatment(harvest);
        a_field->SetGrowthPhase(harvest1);
        // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
        a_field->InsectMortality(0.4);
        double insects = a_field->GetInsectPop();
        a_field->ResetDigestability();
        a_field->RecalculateBugsNStuff();
        a_field->SetInsectPop(insects);
        a_field->SetTramlinesDecay(EL_TRAMLINE_DECAYTIME);
        int pref = a_field->GetUnsprayedMarginPolyRef();
        double someseed = 0.0;  //No bird seed or maize forage on sugar beet (which is currently (March 2015) the only crop using HarvestLong.
        a_field->SetBirdSeed( someseed );
        a_field->SetBirdMaize( someseed );
        if (pref != -1){
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um = g_landscape_p->SupplyLEPointer(pref);
            um->SetLastTreatment(harvest);
            um->SetGrowthPhase(harvest1);
            um->InsectMortality(0.4);
            um->SetTramlinesDecay(EL_TRAMLINE_DECAYTIME);
            um->ResetDigestability();
            um->RecalculateBugsNStuff();
            um->SetBirdSeed( someseed );
            um->SetBirdMaize( someseed );
        }
        return true;
    }
    return false;
}

bool OptimisingFarm::Harvest(LE *a_field, double /*a_user*/, int a_days)
{

  //5 days good weather before
  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))) 
  {

    //05.03.13 need to get the info on biomass
    if(!cfg_OptimiseBedriftsmodelCrops.value()){
        Field * pf =  dynamic_cast<Field*>(a_field); //ok????? - maybe should be VegElement instead of field!
        if(pf->GetVegType()!=tov_Potatoes && pf->GetVegType()!=tov_PotatoesIndustry){ //do not save biomass for potatoes! 
            double biomass_at_harvest = a_field->GetVegBiomass();
            pf->Set_biomass_at_harvest(biomass_at_harvest, 0);  //sets the biomass of a current crop; the current crop is at the index 0
            pf->Set_harvested(); //mark this crop as harvested
        }
    }
    //05.03.13 end 

    a_field->Trace( harvest );
    a_field->SetLastTreatment( harvest );
    a_field->SetGrowthPhase( harvest1 );
    // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
    a_field->InsectMortality( 0.4 );
    double insects=a_field->GetInsectPop();
    a_field->RecalculateBugsNStuff();
    a_field->SetInsectPop(insects);
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    a_field->ResetDigestability();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment(harvest);
      um->SetGrowthPhase( harvest1 );
      um->InsectMortality( 0.4 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      um->ResetDigestability();
      um->RecalculateBugsNStuff();
    }
    return true;
  }
  return false;
}



bool Farm::CattleOut( LE *a_field, double /*a_user*/, int a_days )
{
    if ((0 >= a_days) || DoIt( DO_IT_PROB ))
    {
        a_field->ToggleCattleGrazing();
        a_field->Trace( cattle_out );
        a_field->SetLastTreatment( cattle_out );
        // Reduce the vegetation because of grazing
        //double h=a_field->GetVegHeight();
        //double reduc = 1-(l_farm_cattle_veg_reduce.value()*((h-15)/15));
        //a_field->ReduceVeg_Extended( reduc );
        a_field->GrazeVegetation( l_farm_cattle_veg_reduce.value(), false );
        int pref = a_field->GetUnsprayedMarginPolyRef();
        if (pref != -1)
        {
            // Must have an unsprayed margin so need to pass the information on to it
            // This happens if all arable fields are given unsprayed margins - they have no effect on grass unless it is sprayed with pesticides
            LE* um = g_landscape_p->SupplyLEPointer( pref );
            um->ToggleCattleGrazing();
            um->SetLastTreatment( cattle_out );
            um->GrazeVegetation( l_farm_cattle_veg_reduce.value( ), false );
        }
        return true;
    }
    return false;
}

bool Farm::CattleOutLowGrazing( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days)||  DoIt(DO_IT_PROB)) {
          a_field->ToggleCattleGrazing();
    a_field->Trace( cattle_out_low );
    a_field->SetLastTreatment( cattle_out_low );
    // Reduce the vegetation because of grazing
    //double h=a_field->GetVegHeight();
    //double reduc = 1-(l_farm_cattle_veg_reduce.value()*((h-15)/15));
    //a_field->ReduceVeg_Extended( reduc );
    a_field->GrazeVegetation( l_farm_cattle_veg_reduce2.value( ), false );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
         // This happens if all arable fields are given unsprayed margins - they have no effect on grass unless it is sprayed with pesticides
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->ToggleCattleGrazing();
      um->SetLastTreatment( cattle_out_low );
      um->GrazeVegetation( l_farm_cattle_veg_reduce2.value( ), false );
    }
    return true;
  }
  return false;
}

bool Farm::CattleIsOut(LE *a_field, double /*a_user*/, int a_days, int a_max)
{
    double biomass = a_field->GetVegBiomass();
    if (biomass > 100.0)
    {
        a_field->SetLastTreatment(cattle_out);
        a_field->Trace(cattle_out);
        // Reduce the vegetation because of grazing
        //double h=a_field->GetVegHeight();
        //double reduc = 1-(l_farm_cattle_veg_reduce.value()*((h-15)/15));
        //a_field->ReduceVeg_Extended( reduc );
        a_field->GrazeVegetation( l_farm_cattle_veg_reduce.value( ), false );
        int pref = a_field->GetUnsprayedMarginPolyRef();
        if (pref != -1)
        {
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um = g_landscape_p->SupplyLEPointer(pref);
            um->SetLastTreatment(cattle_out);
            um->GrazeVegetation( l_farm_cattle_veg_reduce.value( ), false );
        }
    }
    int d1 = g_date->DayInYear(10, 9);
    if (d1 > a_max) d1 = a_max;
    if ((((g_date->DayInYear() > d1) && (10 >= a_days)) && DoIt(10)) || (0 >= a_days))
    {
        a_field->ToggleCattleGrazing();
        int pref = a_field->GetUnsprayedMarginPolyRef();
        if (pref != -1){
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um = g_landscape_p->SupplyLEPointer(pref);
            um->ToggleCattleGrazing();
        }
        return true;
    }
    return false;
}

bool Farm::CattleIsOutLow(LE *a_field, double /*a_user*/, int a_days, int a_max)
{

    // Generate a 'cattle_in_out' event for every day the cattle is on the
    // field.
    double biomass = a_field->GetVegBiomass();
    if (biomass > 100.0)
    {
        a_field->SetLastTreatment(cattle_out_low);
        a_field->Trace(cattle_out_low);
        // Reduce the vegetation because of grazing
        //double h=a_field->GetVegHeight();
        //double reduc = 1-(l_farm_cattle_veg_reduce2.value()*((h-15)/15));
        //a_field->ReduceVeg_Extended( reduc );
        a_field->GrazeVegetation( l_farm_cattle_veg_reduce2.value( ), false );
        int pref = a_field->GetUnsprayedMarginPolyRef();
        if (pref != -1)
        {
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um = g_landscape_p->SupplyLEPointer(pref);
            um->SetLastTreatment(cattle_out_low);
            um->GrazeVegetation( l_farm_cattle_veg_reduce2.value( ), false );
        }
    }
    int d1 = g_date->DayInYear(10, 9);
    if (d1 > a_max) d1 = a_max;
    if ((((g_date->DayInYear() > d1) && (10 >= a_days)) && DoIt(10)) || (0 >= a_days))
    {
        a_field->ToggleCattleGrazing();
        int pref = a_field->GetUnsprayedMarginPolyRef();
        if (pref != -1){
            // Must have an unsprayed margin so need to pass the information on to it
            LE* um = g_landscape_p->SupplyLEPointer(pref);
            um->ToggleCattleGrazing();
        }
        return true;
    }
    return false;
}

bool Farm::PigsOut( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days)||  DoIt(DO_IT_PROB))
 {
    a_field->TogglePigGrazing();
    a_field->Trace( pigs_out );
    a_field->SetLastTreatment( pigs_out );
    // Reduce the vegetation because of grazing
    a_field->ReduceVeg_Extended( l_farm_pig_veg_reduce.value());
                                 // make this a function of grazing pressure
                                 //and field size - perhaps in a later life
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( pigs_out );
      um->ReduceVeg_Extended( l_farm_pig_veg_reduce.value() );
    }
    return true;
 }
  return false;
}

bool Farm::PigsAreOutForced( LE *a_field, double /*a_user*/, int /*a_days*/)
{
  a_field->SetLastTreatment( pigs_out );
  a_field->Trace( pigs_out );
  // Reduce the vegetation because of grazing
  a_field->ReduceVeg_Extended( l_farm_pig_veg_reduce.value() );
  // make this a function of grazing pressure
  //and field size - perhaps in a later life
  int pref=a_field->GetUnsprayedMarginPolyRef();
  if (pref!=-1){
    // Must have an unsprayed margin so need to pass the information on to it
    LE* um=g_landscape_p->SupplyLEPointer(pref);
    um->SetLastTreatment( pigs_out );
    um->ReduceVeg_Extended( l_farm_pig_veg_reduce.value() );
  }
  return false;
}

bool Farm::PigsAreOut( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days)||  DoIt(50/a_days)) {
    a_field->TogglePigGrazing();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->TogglePigGrazing();
    }
    return true;
  }
  return false;
}

bool Farm::StrawChopping( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( straw_chopping );
    a_field->SetLastTreatment( straw_chopping );
    a_field->InsectMortality( 0.4 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( straw_chopping );
      um->InsectMortality( 0.4 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::HayTurning( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( hay_turning );
    a_field->SetLastTreatment( hay_turning );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( hay_turning );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::HayBailing( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( hay_bailing );
    a_field->SetLastTreatment( hay_bailing );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( hay_bailing );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::StubbleHarrowing( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) ||
       ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1) && DoIt(DO_IT_PROB))
  ) {
    a_field->Trace( stubble_harrowing );
    a_field->SetLastTreatment( stubble_harrowing );
    a_field->InsectMortality( 0.25 );
    a_field->ZeroVeg();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( stubble_harrowing );
      um->ZeroVeg();
      um->InsectMortality( 0.25 );
    }
    return true;
  }
  return false;
}

bool Farm::BurnStrawStubble( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) && (g_weather->GetRainPeriod(g_date->Date(),3)>0.1))
  {
    return true;
  }
  if ( (0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(),3)<0.1)
          && DoIt(DO_IT_PROB)))
  {
    a_field->Trace( burn_straw_stubble );
    a_field->SetLastTreatment( burn_straw_stubble );
    a_field->InsectMortality( 0.4 );
    a_field->ReduceVeg( 0.2 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( burn_straw_stubble );
      um->ReduceVeg( 0.2 );
      um->InsectMortality( 0.4 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::CutToHay( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1)
          && DoIt(DO_IT_PROB)))
  {
    a_field->Trace( cut_to_hay );
    a_field->SetLastTreatment( cut_to_hay );
    a_field->SetGrowthPhase(harvest1);
    a_field->InsectMortality(0.4);
    a_field->ReduceVeg_Extended( 0.2 );
    a_field->SetVegHeight(10);
    //a_field->ResetDigestability();
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( cut_to_hay );
      um->SetGrowthPhase(harvest1);
      um->InsectMortality(0.4);
      um->ReduceVeg_Extended( 0.2 );
      um->SetVegHeight( 10);
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::CutWeeds( LE *a_field, double /*a_user*/, int a_days )
{

  if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB)))
  {
    a_field->Trace( cut_weeds );
    a_field->SetLastTreatment( cut_weeds );
    a_field->ReduceVeg( 0.8 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( cut_weeds );
      um->ReduceVeg( 0.8 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    }
    return true;
  }
  return false;
}

bool Farm::CutToSilage( LE *a_field, double /*a_user*/, int a_days )
{

    if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( cut_to_silage );
    a_field->SetLastTreatment( cut_to_silage );
    a_field->ReduceVeg_Extended( 0.2 );
    a_field->InsectMortality( 0.4 );
    a_field->SetVegHeight( 10 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    //a_field->ResetDigestability();
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( cut_to_silage );
      um->ReduceVeg_Extended( 0.2 );
      um->InsectMortality( 0.4 );
      um->SetVegHeight( 10 );
      um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
      um->ResetDigestability();
    }
    return true;
  }
  return false;
}

bool Farm::CutOrch( LE *a_field, double /* a_user */, int a_days )
{

    if ( (0 >= a_days) || (!g_weather->Raining() && DoIt(DO_IT_PROB))) {
    a_field->Trace( mow ); //? tried to do=mow...
    a_field->SetLastTreatment( mow );
    a_field->SetMownDecay( 12 ); // 12 days of not suitable
    //ReduceVeg_Extended( 0.2 );
    //a_field->InsectMortality( 0.4 );
    a_field->SetGrowthPhase( harvest1 );
    //m_DateCut = a_today; ?? what to substitute it with?

    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
  
    int pref=a_field->GetUnsprayedMarginPolyRef();
    if (pref!=-1){
      // Must have an unsprayed margin so need to pass the information on to it
      LE* um=g_landscape_p->SupplyLEPointer(pref);
      um->SetLastTreatment( mow );
      um->ReduceVeg_Extended( 0.2 ); //are these values ok?
      um->InsectMortality( 0.4 );
      um->SetVegParameters( l_el_o_cut_height.value(), l_el_o_cut_total.value(), l_el_o_cut_green.value(), 0 );
    }
    return true;
  }
  return false;
}


// Pesticide Trial Farm Function Code
bool Farm::Trial_PesticideTreat_DateLimited(LE *a_field, double /*a_user*/, int /*a_days*/)
{
    int year = g_landscape_p->SupplyYearNumber();
    if (year < cfg_productapplicstartyear.value()) return false;
    if (year > cfg_productapplicendyear.value()) return false;
    a_field->Trace(trial_insecticidetreat); // Debug function only
    a_field->SetLastTreatment(trial_insecticidetreat);
    a_field->InsectMortality(0.36);  // Change this manually if it is really a herbicide
    a_field->SetTramlinesDecay(EL_TRAMLINE_DECAYTIME);
    a_field->SetSprayedToday(true);
    g_pest->DailyQueueAdd(a_field, l_pest_insecticide_amount.value());
    return true;
}



// Pesticide Trial Farm Function Code
bool Farm::Trial_PesticideTreat( LE *a_field, double /*a_user*/, int /*a_days*/ )
{
    a_field->Trace( trial_insecticidetreat );
    a_field->SetLastTreatment( trial_insecticidetreat );
    a_field->InsectMortality( 0.1 );  // Change this manually if it is really a herbicide
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    return true;
}

// Pesticide Trial Farm Function Code
bool Farm::Trial_PesticideTreat_GS( LE *a_field, double /*a_user*/, int /*a_days*/ )
{
    // Can spray between two certain heights only, but we have to hope that we get called in time for the first so
    // right now we only care if we are above a certain height (timing is also important, so must not call this until
    // after a ploughing and sowing event
    if (a_field->GetVegHeight() < 3.0) return false;
    // All OK so here goes:
    a_field->Trace( trial_insecticidetreat );
    a_field->SetLastTreatment( trial_insecticidetreat );
    //a_field->InsectMortality( 0.1 );  // Change this manually if it is really a herbicide
    a_field->ReduceWeedBiomass( 0.05 );
    a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    return true;
}

bool Farm::Trial_ToxicControl( LE *a_field, double /*a_user*/, int /*a_days*/ )
{
    a_field->Trace( trial_toxiccontrol );
    a_field->SetLastTreatment( trial_toxiccontrol );
    a_field->InsectMortality( 0.001 );
    a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
    return true;
}


bool Farm::Trial_Control( LE *a_field, double /*a_user*/, int /*a_days*/ )
{
  // Will always do this at the first chance
  a_field->Trace( trial_control );
  a_field->SetLastTreatment( trial_control );
  a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
  return true;
}

bool Farm::Glyphosate( LE *a_field, double /* a_user */, int /* a_days */)
{
  // Will always do this at the first chance
  a_field->Trace( glyphosate );
  a_field->SetLastTreatment( glyphosate );
  a_field->InsectMortality( 0.5 );
  a_field->ReduceVeg_Extended( 0.05 );
  return true;
}