elements.cpp

Go to the documentation of this file.

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

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

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

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

#define _CRT_SECURE_NO_DEPRECATE



#define __WEED_CURVE 99 //99  // 99 is the weed curve

// The default no better information values (Mean of the four crop values)
#define EL_BUG_PERCENT_A 0.0
#define EL_BUG_PERCENT_B 0.2975
#define EL_BUG_PERCENT_C 0.095916647275
#define EL_BUG_PERCENT_D 0

// SBarley
#define EL_BUG_PERCENT_SB_A 0
#define EL_BUG_PERCENT_SB_B 0.380763296
#define EL_BUG_PERCENT_SB_C 0
#define EL_BUG_PERCENT_D 0

// WWheat
#define EL_BUG_PERCENT_WW_A 0.0
#define EL_BUG_PERCENT_WW_B 0.1283
#define EL_BUG_PERCENT_WW_C 0.0
#define EL_BUG_PERCENT_D 0

// WRye
#define EL_BUG_PERCENT_WRy_A 0.0
#define EL_BUG_PERCENT_WRy_B 0.395651915
#define EL_BUG_PERCENT_WRy_C 0.0
#define EL_BUG_PERCENT_D 0

//WRape
#define EL_BUG_PERCENT_WR_A 0.0
#define EL_BUG_PERCENT_WR_B 0.028271643
#define EL_BUG_PERCENT_WR_C 0.0
#define EL_BUG_PERCENT_D 0

//Cropped/Grazed Grass
#define EL_BUG_PERCENT_G_A 4.123817127
#define EL_BUG_PERCENT_G_B 0.151015629
#define EL_BUG_PERCENT_G_C -0.228228353
#define EL_BUG_PERCENT_D 0

//Edges
#define EL_BUG_PERCENT_Edges_A 10.72459109
#define EL_BUG_PERCENT_Edges_B 0.4
#define EL_BUG_PERCENT_Edges_C 2.529631141
#define EL_BUG_PERCENT_D 0


#include <math.h>
#include "../Landscape/ls.h"
#include "../BatchALMaSS/BoostRandomGenerators.h"

extern boost::variate_generator<base_generator_type&, boost::uniform_real<> > g_rand_uni;

extern void FloatToDouble(double &, float);
extern CfgInt cfg_pest_productapplic_startdate;
extern CfgInt cfg_pest_productapplic_period;
using namespace std;

CfgBool cfg_calc_pond_pesticide("POND_PEST_CALC_ON", CFG_CUSTOM, false);
CfgFloat cfg_pondpesticiderunoff("POND_PEST_RUNOFFFACTOR", CFG_CUSTOM, 10.0);

CfgInt cfg_goosecountperiod("GOOSE_GOOSECOUNTPERIOD",CFG_CUSTOM,1);

const double c_SolarConversion[ 2 ] [ 81 ] = {
   {
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0.28,
     0.56,0.84,1.12,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,1.4,
     1.4,1.4,1.26,1.12,0.98,0.84,0.7,0.56,0.42,0.28,0.14,0,0,0,0,0,0,0,0,0,0,0,
     0,0,0,0,0
   },
   {
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
     0,0.242857,0.485714,0.728571,0.971429,1.214286,1.457143,1.7,1.7,1.7,1.7,
     1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7,
     1.53,1.36,1.19,1.02,0.85,0.68,0.51,0.34,0.17,0,0,0,0,0,0
   }
  };

extern CfgFloat l_pest_insecticide_amount;
static CfgFloat l_pest_productOrchard_amount( "PEST_PRODUCTORCHARD_AMOUNT", CFG_CUSTOM, 0.0 );
extern CfgInt cfg_pest_productapplic_startdate;
extern CfgInt cfg_pest_productapplic_startdate2;
extern CfgInt cfg_pest_productapplic_startdate3;
extern CfgInt cfg_pest_productapplic_period;
extern CfgFloat cfg_goose_GrainDecayRate;


static CfgFloat cfg_beetlebankinsectscaler("ELE_BBINSECTSCALER",CFG_CUSTOM,1.0); // 1.0 means beetlebank is the same as hedgebank
static double g_biomass_scale[ tov_Undefined ];
static double g_weed_percent[ tov_Undefined ];
static double g_bug_percent_a[ tov_Undefined ];
static double g_bug_percent_b[ tov_Undefined ];
static double g_bug_percent_c[ tov_Undefined ];
static double g_bug_percent_d[ tov_Undefined ];
static CfgInt cfg_OrchardSprayDay( "TOX_ORCHARDSPRAYDAY", CFG_CUSTOM, 150 );
static CfgInt cfg_OrchardSprayDay2( "TOX_ORCHARDSPRAYDAYTWO", CFG_CUSTOM, 200000 );
CfgInt cfg_OrchardNoCutsDay( "TOX_ORCHARDNOCUTS", CFG_CUSTOM, -1 );
static CfgInt cfg_MownGrassNoCutsDay( "ELE_MOWNGRASSNOCUTS", CFG_CUSTOM, -1 );
static CfgInt cfg_UMPatchyChance( "UMPATCHYCHANCE", CFG_CUSTOM, 0 );
static CfgFloat cfg_BBPatchyChance( "BEETLEBANKBPATCHYCHANCE", CFG_CUSTOM, 0.5 );
static CfgFloat cfg_MGPatchyChance( "MOWNGRASSPATCHYCHANCE", CFG_CUSTOM, 0.5 );
static CfgFloat cfg_SetAsidePatchyChance("SETASIDEPATCHYCHANCE", CFG_CUSTOM, 1.0);
static CfgFloat cfg_ele_weedscaling( "ELE_WEEDSCALING", CFG_CUSTOM, 1.0 );
CfgFloat cfg_PondLarvalFoodBiomassConst("POND_LARVALFOODBIOMASSCONST", CFG_CUSTOM, 255.0);
CfgFloat cfg_PondLarvalFoodR("POND_LARVALFOODFOODR", CFG_CUSTOM, 0.04);
// Docs in elements.h
CfgInt g_el_tramline_decaytime_days( "ELEM_TRAMLINE_DECAYTIME_DAYS", CFG_PRIVATE, 21 );
CfgInt g_el_herbicide_delaytime_days( "ELEM_HERBICIDE_DELAYTIME_DAYS", CFG_PRIVATE, 35 );
CfgInt g_el_strigling_delaytime_days( "ELEM_STRIGLING_DELAYTIME_DAYS", CFG_PRIVATE, 28 );

// Daydegree sum set on an element by ReduceVeg().
#define EL_GROWTH_DAYDEG_MAGIC l_el_growth_daydeg_magic.value()
static CfgInt l_el_growth_daydeg_magic( "ELEM_GROWTH_DAYDEG_MAGIC", CFG_PRIVATE, 100 );

// Date after which ReduceVeg() automatically sets the growth phase
// to harvest1. Cannot become a global configuration variable as it
// is calculated at runtime.
#define EL_GROWTH_DATE_MAGIC   (g_date->DayInYear(1,9))

// If the fraction used in the call to ReduceVeg() is *below* this
// value, then a phase transition to harvest1 is considered if
// there has been no previous 'forced' phase transition before this
// year.
#define EL_GROWTH_PHASE_SHIFT_LEVEL (l_el_growth_phase_shift_level.value())
static CfgFloat l_el_growth_phase_shift_level( "ELEM_GROWTH_PHASE_SHIFT_LEVEL", CFG_PRIVATE, 0.5 );


// Types of landscape elements. Default is 'unknown'.
// The conversion arrays are at the top in 'elements.cpp'!
// Change when adding or deleting element types.
// Outdated, not used anywhere in the landscape. *FN*
//#define EL_MAX_ELEM_TYPES 18

// Constant of proportionality between leaf area total and plant
// biomass.
#define EL_PLANT_BIOMASS  (l_el_plant_biomass_proport.value())  // Scaled to dry matter on Spring Barley for 2001 & 2002
// All other values are scaled relative to this as of 29/03/05
static CfgFloat l_el_plant_biomass_proport( "ELEM_PLANT_BIOMASS_PROPORT", CFG_PRIVATE, 41.45 );

// Default starting LAI Total. (NB LAIGreen=LAITotal/4)
#define EL_VEG_START_LAIT (l_el_veg_start_lait.value())
static CfgFloat l_el_veg_start_lait( "ELEM_VEG_START_LAIT", CFG_PRIVATE, 1.08 );

// Constant * biomass to get height
#define EL_VEG_HEIGHTSCALE  (l_el_veg_heightscale.value())
static CfgInt l_el_veg_heightscale( "ELEM_VEG_HEIGHTSCALE", CFG_PRIVATE, 16 );
//May+21
#define RV_CUT_MAY (l_el_rv_cut_may.value())
static CfgInt l_el_rv_cut_may( "ELEM_RV_CUT_MAY", CFG_PRIVATE, 142 );

#define RV_CUT_JUN (l_el_rv_cut_jun.value())
static CfgInt l_el_rv_cut_jun( "ELEM_RV_CUT_JUN", CFG_PRIVATE, 28 );

#define RV_CUT_JUL (l_el_rv_cut_jul.value())
static CfgInt l_el_rv_cut_jul( "ELEM_RV_CUT_JUL", CFG_PRIVATE, 35 );

#define RV_CUT_AUG (l_el_rv_cut_aug.value())
static CfgInt l_el_rv_cut_aug( "ELEM_RV_CUT_AUG", CFG_PRIVATE, 42 );

#define RV_CUT_SEP (l_el_rv_cut_sep.value())
static CfgInt l_el_rv_cut_sep( "ELEM_RV_CUT_SEP", CFG_PRIVATE, 49 );

#define RV_CUT_OCT (l_el_rv_cut_oct.value())
static CfgInt l_el_rv_cut_oct( "ELEM_RV_CUT_OCT", CFG_PRIVATE, 49 );

#define RV_MAY_1ST (l_el_rv_may_1st.value())
static CfgInt l_el_rv_may_1st( "ELEM_RV_MAY_1ST", CFG_PRIVATE, 121 );

#define RV_CUT_HEIGHT (l_el_rv_cut_height.value())
static CfgFloat l_el_rv_cut_height( "ELEM_RV_CUT_HEIGHT", CFG_PRIVATE, 10.0 );
#define RV_CUT_GREEN (l_el_rv_cut_green.value())
static CfgFloat l_el_rv_cut_green( "ELEM_RV_CUT_GREEN", CFG_PRIVATE, 1.5 );
#define RV_CUT_TOTAL (l_el_rv_cut_total.value())
static CfgFloat l_el_rv_cut_total( "ELEM_RV_CUT_TOTAL", CFG_PRIVATE, 2.0 );

CfgFloat l_el_o_cut_height( "ELEM_RV_CUT_HEIGHT", CFG_PRIVATE, 10.0 );
CfgFloat l_el_o_cut_green( "ELEM_RV_CUT_GREEN", CFG_PRIVATE, 1.5 );
CfgFloat l_el_o_cut_total( "ELEM_RV_CUT_TOTAL", CFG_PRIVATE, 2.0 );

// Default fraction between crop and weed biomasses.
#define EL_WEED_PERCENT (l_el_weed_percent.value())
static CfgFloat l_el_weed_percent( "ELEM_WEED_PERCENT", CFG_PRIVATE, 0.1 );

// Weed biomass regrowth slope after herbacide application.
#define EL_WEED_SLOPE (l_el_weed_slope.value())
static CfgFloat l_el_weed_slope( "ELEM_WEED_SLOPE", CFG_PRIVATE, 0.15 );

// Bug biomass regrowth slope after insecticide application.
#define EL_BUG_SLOPE (l_el_bug_slope.value())
static CfgFloat l_el_bug_slope( "ELEM_BUG_SLOPE", CFG_PRIVATE, 0.2 );

// Fraction of the weed biomass below which we are in pesticide
// regrowth phase, above we are in proportionality mode.
// CANNOT be 1.00!
#define EL_WEED_GLUE (l_el_weed_glue.value())
static CfgFloat l_el_weed_glue( "ELEM_WEED_GLUE", CFG_PRIVATE, 0.99 );

// Same as for weed, but bugs this time.
#define EL_BUG_GLUE (l_el_bug_glue.value())
static CfgFloat l_el_bug_glue( "ELEM_BUG_GLUE", CFG_PRIVATE, 0.50 );

// This is inversed prior to use. A multiplication is very much less
// expensive compared to a division.
//
// The original array supplied is:
// {1.11,1.06,1.01,0.99,0.96,0.92,0.92,0.93,0.97,0.99,1.02,1.06}
double LE::m_monthly_traffic[ 12 ] =
  {0.9009, 0.9434, 0.9901, 1.0101, 1.0417, 1.0870,
 1.0870, 1.0753, 1.0753, 1.0101, 0.9804,  0.9434};

double LE::m_largeroad_load[ 24 ] =
  {15,9,4,5,14,54,332,381,252,206,204,215,
 231,256,335,470,384,270,191,130,91,100,99,60};

double LE::m_smallroad_load[ 24 ] =
  {4,3,1,1,4,15,94,108,71,58,58,61,
 65,73,95,133,109,76,54,37,26,28,28,17};

class LE_TypeClass * g_letype;

LE::LE(void) {

    m_signal_mask = 0;
    m_lasttreat.resize(1);
    m_lasttreat[0] = sleep_all_day;
    m_lastindex = 0;
    m_running = 0;
    m_poison = false;
    m_owner_file = -1;
    m_owner_index = -1;
    m_high = false;
    m_cattle_grazing = 0;
    m_default_grazing_level = 0; // this means any grazed elements must set this in their constructor.
    m_pig_grazing = false;
    m_yddegs = 0.0;
    m_vegddegs = -1.0;
    m_olddays = 0;
    m_days_since_insecticide_spray = 0;
    m_tramlinesdecay = 0;
    m_mowndecay = 0;
    m_herbicidedelay = 0;
    m_border = NULL;
    m_unsprayedmarginpolyref = -1;
    m_valid_x = -1;
    m_valid_y = -1;
    m_is_in_map = false;
    m_squares_in_map = 0;
    m_management_loop_detect_date = 0;
    m_management_loop_detect_count = 0;
    m_repeat_start = false;
    m_skylarkscrapes = false;
    m_type = tole_Foobar;
    SetALMaSSEleType(-1);
    m_ddegs = 0.0;
    m_maxx = -1; // a very small number
    m_maxy = -1;
    m_minx = 9999999; // a very big number
    m_miny = 9999999;
    m_countrydesignation = -1; // default not set
    m_soiltype = -1;
    m_area = 0;
    m_centroidx = -1;
    m_centroidy = -1;
    m_vege_danger_store = -1;
    m_PesticideGridCell = -1;
    m_subtype = -1;
    m_owner = NULL;
    m_rot_index = -1;
    m_poly = -1;
    m_map_index = -1;
    m_almass_le_type = -1;
    m_farmfunc_tried_to_do = -1;
    m_birdseedforage = -1;
    m_birdmaizeforage = -1;
    m_openness = -1;
    m_vegage = -1;
    for (int i = 0; i<10; i++) SetMConstants(i, 1);
    for (int i = 0; i < 366; i++)
    {
        m_gooseNos[i] = 0;
        m_gooseNosTimed[i] = 0;
        for (int l = 0; l < gs_foobar; l++)
        {
            m_gooseSpNos[i][l] = 0;
            m_gooseSpNosTimed[i][l] = 0;
        }
    }
    for (int l = 0; l < gs_foobar; l++)
    {
        m_goosegrazingforage[l] = 0;
    }
    for (int i = 0; i < 25; i++)
    {
        MDates[0][i] = -1;
        MDates[1][i] = -1;
    }
    SetLastSownVeg(tov_Undefined);
#ifdef FMDEBUG
    m_pindex = 0;
    for ( int i = 0; i < 256; i++ ) {
        m_pdates[ i ] = 0;
        m_ptrace[ i ] = 0;
    }
#endif
}

void LE::DoCopy(const LE* a_LE) {

    m_signal_mask = a_LE->m_signal_mask;
    m_lasttreat = a_LE->m_lasttreat;
    m_lastindex = a_LE->m_lastindex;
    m_running = a_LE->m_running;
    m_poison = a_LE->m_poison;
    m_owner_file = a_LE->m_owner_file;
    m_owner_index = a_LE->m_owner_index;
    m_high = a_LE->m_high;
    m_cattle_grazing = a_LE->m_cattle_grazing;
    m_default_grazing_level = a_LE->m_default_grazing_level; // this means any grazed elements must set this in their constructor.
    m_pig_grazing = a_LE->m_pig_grazing;
    m_yddegs = a_LE->m_yddegs;
    m_olddays = a_LE->m_olddays;
    m_vegddegs = a_LE->m_vegddegs;
    m_days_since_insecticide_spray = a_LE->m_days_since_insecticide_spray;
    m_tramlinesdecay = a_LE->m_tramlinesdecay;
    m_mowndecay = a_LE->m_mowndecay;
    m_herbicidedelay = a_LE->m_herbicidedelay;
    m_border = a_LE->m_border;
    m_unsprayedmarginpolyref = a_LE->m_unsprayedmarginpolyref;
    m_valid_x = a_LE->m_valid_x;
    m_valid_y = a_LE->m_valid_y;
    m_is_in_map = a_LE->m_is_in_map;
    m_squares_in_map = a_LE->m_squares_in_map;
    m_management_loop_detect_date = a_LE->m_management_loop_detect_date;
    m_management_loop_detect_count = a_LE->m_management_loop_detect_count;
    m_repeat_start = a_LE->m_repeat_start;
    m_skylarkscrapes = a_LE->m_skylarkscrapes;
    m_type = a_LE->m_type;
    m_birdseedforage = a_LE->m_birdseedforage;
    m_birdmaizeforage = a_LE->m_birdmaizeforage; 
    m_ddegs = a_LE->m_ddegs;
    m_maxx = a_LE->m_maxy; // a very small number
    m_maxy = a_LE->m_maxx;
    m_minx = a_LE->m_minx; // a very big number
    m_miny = a_LE->m_miny;
    m_countrydesignation = a_LE->m_countrydesignation; // default not set
    m_soiltype = a_LE->m_soiltype;
    m_area = a_LE->m_area;
    m_centroidx = a_LE->m_centroidx;
    m_centroidy = a_LE->m_centroidy;
    m_vege_danger_store = a_LE->m_vege_danger_store;
    m_PesticideGridCell = a_LE->m_PesticideGridCell;
    m_subtype = a_LE->m_subtype;
    m_owner = a_LE->m_owner;
    m_rot_index = a_LE->m_rot_index;
    m_poly = a_LE->m_poly;
    m_map_index = a_LE->m_map_index;
    m_almass_le_type = a_LE->m_almass_le_type;
    m_farmfunc_tried_to_do = a_LE->m_farmfunc_tried_to_do;
    m_openness = a_LE->m_openness;
    m_vegage = a_LE->m_vegage;
    for (int i = 0; i < 366; i++)
    {
        m_gooseNos[i] = a_LE->m_gooseNos[i];
        m_gooseNosTimed[i] = a_LE->m_gooseNosTimed[i];
        for (int l = 0; l < gs_foobar; l++)
        {
            m_gooseSpNos[i][l] = a_LE->m_gooseSpNos[i][l];
            m_gooseSpNosTimed[i][l] = a_LE->m_gooseSpNosTimed[i][l];
        }
    }
    for (int l = 0; l < gs_foobar; l++)
    {
        m_goosegrazingforage[l] = a_LE->m_goosegrazingforage[l];
    }
    for (int i = 0; i < 25; i++)
    {
        MDates[0][i] = a_LE->MDates[0][i];
        MDates[1][i] = a_LE->MDates[1][i];
    }
    for (int i = 0; i<10; i++) SetMConstants(i, a_LE->MConsts[i]);
}


LE::~LE( void ) {
}


#ifdef FMDEBUG
void LE::Trace( int a_value ) {
  m_farmfunc_tried_to_do = a_value;

  m_pdates[ m_pindex ] = g_date->DayInYear();
  m_ptrace[ m_pindex++ ] = a_value;
  m_pindex &= 0xff; // Circular buffer if need be.
}

void LE::ResetTrace( void ) {
  m_pindex = 0;
  for ( int i = 0; i < 256; i++ ) {
    m_pdates[ i ] = 0;
    m_ptrace[ i ] = 0;
  }
}

#else
// Compiles into nothing if FMDEBUG is #undef.
void LE::Trace( int a_value ) {
  m_farmfunc_tried_to_do = a_value;
}

void LE::ResetTrace( void ) {
}

#endif

void LE::SetCopyTreatment( int a_treatment ) {
  SetLastTreatment( a_treatment );
}

void LE::SetLastTreatment( int a_treatment ) {
  unsigned sz = (int) m_lasttreat.size();
  if ( m_lastindex == sz )
    m_lasttreat.resize( m_lastindex + 1 );

  m_lasttreat[ m_lastindex++ ] = a_treatment;

  // Count this treatment in the grand scope of things.
  g_landscape_p->IncTreatCounter( a_treatment );
  // If we have a field margin then we need to tell it about this
  // but not if it is an insecticide spray etc..
  /* if (m_unsprayedmarginpolyref!=-1) { switch (a_treatment) { case  herbicide_treat: case  growth_regulator:
  case  fungicide_treat: case  insecticide_treat: case trial_insecticidetreat: case syninsecticide_treat: case  molluscicide:
  break; // Do not add sprayings default: LE* le=g_landscape_p->SupplyLEPointer(m_unsprayedmarginpolyref);
  le->SetCopyTreatment(a_treatment); // Now we also need to do something with the treatment

  break; }

  } */
}

int LE::GetLastTreatment( int * a_index ) {
  if ( * a_index == ( int )m_lastindex )
    return sleep_all_day;
  int i = ( * a_index ) ++;
  int treat = m_lasttreat[ i ];
  return treat;
}

void LE::Tick( void ) {
  m_lastindex = 0;
  m_lasttreat[ 0 ] = sleep_all_day;
  if ( m_tramlinesdecay > 0 )
    m_tramlinesdecay--;
  if ( m_mowndecay > 0 )
    m_mowndecay--;
  if ( m_herbicidedelay > 0 ) m_herbicidedelay--;
}



void LE::DoDevelopment( void ) {
}

APoint LE::GetCentroid()
{
    APoint p;
    p.m_x=m_centroidx;
    p.m_y=m_centroidy;
    return p;
}

int LE::GetGooseNos( ) {
    int geese = 0;
    for (unsigned i = 1; i <= (unsigned)cfg_goosecountperiod.value( ); i++) {
        unsigned ind = ((unsigned)g_date->DayInYear( ) - i) % 365;
        geese += m_gooseNos[ ind ];
    }
    return geese;
}

int LE::GetGooseNosToday() {
    int geese = 0;
    for (unsigned i = 0; i < (unsigned)gs_foobar; i++) {
        geese += m_gooseSpNos[g_date->DayInYear()][i];
    }
    return geese;
}

int LE::GetGooseNosTodayTimed() {
    int geese = 0;
    for (unsigned i = 0; i < (unsigned)gs_foobar; i++) {
        geese += m_gooseSpNosTimed[g_date->DayInYear()][i];
    }
    return geese;
}

int LE::GetGooseSpNosToday(GooseSpecies a_goose) {
    return m_gooseSpNos[g_date->DayInYear()][a_goose];
}

int LE::GetGooseSpNosTodayTimed(GooseSpecies a_goose) {
    return m_gooseSpNosTimed[g_date->DayInYear()][a_goose];
}


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

VegElement::VegElement(void) : LE() {
    SetVegPatchy(false);
    m_nutrient_status = 0; // default
    m_veg_biomass = 0.0;
    m_weed_biomass = 0.0;
    m_veg_height = 0.0;
    m_veg_cover = 0.0;
    m_insect_pop = 1.0;
    m_vege_type = tov_NoGrowth;
    m_curve_num = g_crops->VegTypeToCurveNum(m_vege_type);
    m_weed_curve_num = 99; // 99 used as zero growth curve
    m_yddegs = 0.0;
    m_vegddegs = -1.0;
    m_ddegs = 0.0;
    m_LAgreen = 0.0;
    m_LAtotal = 0.0;
    m_digestability = 1.0;
    for (int i = 0; i < 32; i++) m_oldnewgrowth[i] = 0.5;
    m_newoldgrowthindex = 0;
    m_newgrowthsum = 8.0;
    m_forced_phase_shift = false;
    m_force_growth = false;
    SetGrowthPhase(janfirst);
    m_total_biomass = 0.0;
    m_total_biomass_old = 0.0;



    g_biomass_scale[tov_Carrots] = 0.7857;
    g_biomass_scale[tov_CloverGrassGrazed1] = 1.2;
    g_biomass_scale[tov_CloverGrassGrazed2] = 1.2;
    g_biomass_scale[tov_FodderGrass] = 1.2;
    g_biomass_scale[ tov_BroadBeans ] = 0.857;
    g_biomass_scale[ tov_FieldPeas ] = 0.857;
    g_biomass_scale[ tov_FieldPeasSilage ] = 0.857;
    g_biomass_scale[tov_FodderBeet] = 0.857;
    g_biomass_scale[tov_SugarBeet] = 0.857;
    g_biomass_scale[tov_OFodderBeet] = 0.857;
    g_biomass_scale[tov_Maize] = 1.00;
    g_biomass_scale[tov_MaizeSilage] = 1.00;
    g_biomass_scale[tov_OMaizeSilage] = 1.00;
    g_biomass_scale[tov_NaturalGrass] = 0.567; //0.567 is scaled for actual yield
    g_biomass_scale[tov_Heath] = 0.567; //0.567 is scaled for actual yield
    g_biomass_scale[tov_NoGrowth] = 0.0;
    g_biomass_scale[tov_None] = 0.0;
    g_biomass_scale[tov_OrchardCrop] = 0.7857;
    g_biomass_scale[tov_Oats] = 0.857;
    g_biomass_scale[tov_OBarleyPeaCloverGrass] = 0.857;
    g_biomass_scale[tov_OSBarleySilage] = 0.857 * 0.8;
    g_biomass_scale[tov_OCarrots] = 0.7857 * 0.8;
    g_biomass_scale[tov_OCloverGrassGrazed1] = 1.1;
    g_biomass_scale[tov_OCloverGrassGrazed2] = 1.1;
    g_biomass_scale[tov_OCloverGrassSilage1] = 1.1;
    g_biomass_scale[tov_OFieldPeas] = 0.857 * 0.8;
    g_biomass_scale[tov_OFieldPeasSilage] = 0.857 * 0.8;
    g_biomass_scale[tov_OFirstYearDanger] = 0.0;
    g_biomass_scale[tov_OGrazingPigs] = 0.7857 * 0.8;
    g_biomass_scale[tov_OOats] = 0.857 * 0.8;
    g_biomass_scale[tov_OPermanentGrassGrazed] = 0.7857;
    g_biomass_scale[tov_OPotatoes] = 0.857 * 0.8;
    g_biomass_scale[tov_OSeedGrass1] = 0.7857;
    g_biomass_scale[tov_OSeedGrass2] = 0.7857;
    g_biomass_scale[tov_OSetaside] = 0.7857;
    g_biomass_scale[tov_OSpringBarley] = 0.857 * 0.8;
    g_biomass_scale[tov_OSpringBarleyExt] = 0.857 * 0.8 * 0.8;
    g_biomass_scale[tov_OSpringBarleyClover] = 0.857 * 0.8;
    g_biomass_scale[tov_OSpringBarleyGrass] = 0.857 * 0.8;
    g_biomass_scale[tov_OSpringBarleyPigs] = 0.857 * 0.8;
    g_biomass_scale[tov_OTriticale] = 1.00 * 0.8;
    g_biomass_scale[tov_OWinterBarley] = 0.857 * 0.8;
    g_biomass_scale[tov_OWinterBarleyExt] = 0.857 * 0.8 * 0.8;
    g_biomass_scale[tov_OWinterRape] = 1.071 * 0.8;
    g_biomass_scale[tov_OWinterRye] = 0.857 * 0.8;
    g_biomass_scale[ tov_OWinterWheat ] = 1.00 * 0.8;
    g_biomass_scale[ tov_OWinterWheatUndersown ] = 1.00 * 0.8;
    g_biomass_scale[ tov_OWinterWheatUndersownExt ] = 1.00 * 0.8 * 0.8;
    g_biomass_scale[tov_PermanentGrassGrazed] = 1.1;
    g_biomass_scale[tov_PermanentGrassLowYield] = 1.0;
    g_biomass_scale[tov_PermanentGrassTussocky] = 0.7857;
    g_biomass_scale[tov_PermanentSetaside] = 0.7857;
    g_biomass_scale[tov_Potatoes] = 0.857;
    g_biomass_scale[tov_PotatoesIndustry] = 0.857;
    g_biomass_scale[tov_SeedGrass1] = 0.7857;
    g_biomass_scale[tov_SeedGrass2] = 0.7857;
    g_biomass_scale[tov_OSeedGrass1] = 0.7857;
    g_biomass_scale[tov_OSeedGrass2] = 0.7857;
    g_biomass_scale[tov_Setaside] = 0.7857;
    g_biomass_scale[tov_SpringBarley] = 0.857;
    g_biomass_scale[tov_SpringBarleySpr] = 0.857;
    g_biomass_scale[tov_SpringBarleyPTreatment] = 0.857;
    g_biomass_scale[tov_SpringBarleySKManagement] = 0.857;
    g_biomass_scale[tov_SpringBarleyCloverGrass] = 0.857;
    g_biomass_scale[tov_SpringBarleyGrass] = 0.857;
    g_biomass_scale[tov_SpringBarleySeed] = 0.857;
    g_biomass_scale[tov_SpringBarleySilage] = 0.857;
    g_biomass_scale[tov_SpringRape] = 1.071;
    g_biomass_scale[tov_SpringWheat] = 1.00;
    g_biomass_scale[tov_Triticale] = 1.00;
    g_biomass_scale[tov_WinterBarley] = 0.857;
    g_biomass_scale[tov_WinterRape] = 1.071;
    g_biomass_scale[tov_WinterRye] = 0.857;
    g_biomass_scale[tov_WinterWheat] = 1.00;  // This gives approx 18 tonnes biomass for WW
    g_biomass_scale[tov_WinterWheatShort] = 1.00;
    g_biomass_scale[tov_AgroChemIndustryCereal] = 1.00;
    g_biomass_scale[tov_WWheatPControl] = 1.00;
    g_biomass_scale[tov_WWheatPToxicControl] = 1.00;
    g_biomass_scale[tov_WWheatPTreatment] = 1.00;
    g_biomass_scale[tov_WinterWheatStrigling] = 1.00;
    g_biomass_scale[tov_WinterWheatStriglingCulm] = 1.00;
    g_biomass_scale[tov_WinterWheatStriglingSingle] = 1.00;
    g_biomass_scale[tov_SpringBarleyCloverGrassStrigling] = 0.857;
    g_biomass_scale[tov_SpringBarleyStrigling] = 0.857;
    g_biomass_scale[tov_SpringBarleyStriglingSingle] = 0.857;
    g_biomass_scale[tov_SpringBarleyStriglingCulm] = 0.857;
    g_biomass_scale[tov_MaizeStrigling] = 0.857;
    g_biomass_scale[tov_WinterRapeStrigling] = 1.071;
    g_biomass_scale[tov_WinterRyeStrigling] = 0.857;
    g_biomass_scale[tov_WinterBarleyStrigling] = 0.857;
    g_biomass_scale[tov_FieldPeasStrigling] = 0.857;
    g_biomass_scale[tov_SpringBarleyPeaCloverGrassStrigling] = 0.857;
    g_biomass_scale[tov_YoungForest] = 0.7857 * 0.67;
    g_biomass_scale[tov_Wasteland] = 0.7857 * 0.67;

    if (l_el_read_bug_percentage_file.value()) {
        //ReadBugPercentageFile();
        return;
    }

    g_weed_percent[tov_Carrots] = 0.1;
    g_weed_percent[ tov_BroadBeans ] = 0.1;
    g_weed_percent[ tov_Maize ] = 0.05;
    g_weed_percent[tov_MaizeSilage] = 0.05;
    g_weed_percent[tov_OMaizeSilage] = 0.05;
    g_weed_percent[tov_OCarrots] = 0.1;
    g_weed_percent[tov_Potatoes] = 0.1;
    g_weed_percent[tov_OPotatoes] = 0.1;
    g_weed_percent[tov_FodderGrass] = 0.1;
    g_weed_percent[tov_CloverGrassGrazed1] = 0.1;
    g_weed_percent[tov_CloverGrassGrazed2] = 0.1;
    g_weed_percent[tov_OCloverGrassGrazed1] = 0.1;
    g_weed_percent[tov_OCloverGrassGrazed2] = 0.1;
    g_weed_percent[tov_SpringBarley] = 0.1;
    g_weed_percent[tov_SpringBarleySpr] = 0.1;
    g_weed_percent[tov_SpringBarleyPTreatment] = 0.1;
    g_weed_percent[tov_SpringBarleySKManagement] = 0.1;
    g_weed_percent[tov_WinterWheat] = 0.1;
    g_weed_percent[tov_WinterWheatShort] = 0.1;
    g_weed_percent[tov_SpringBarleySilage] = 0.1;
    g_weed_percent[tov_SpringBarleySeed] = 0.1;
    g_weed_percent[tov_OGrazingPigs] = 0.1;
    g_weed_percent[tov_OCloverGrassSilage1] = 0.1;
    g_weed_percent[tov_SpringBarleyCloverGrass] = 0.1;
    g_weed_percent[tov_OSpringBarleyPigs] = 0.1;
    g_weed_percent[tov_OBarleyPeaCloverGrass] = 0.1;
    g_weed_percent[tov_OSpringBarley] = 0.1;
    g_weed_percent[tov_OSpringBarleyExt] = 0.1;
    g_weed_percent[tov_OSBarleySilage] = 0.1;
    g_weed_percent[ tov_OWinterWheat ] = 0.1;
    g_weed_percent[ tov_OWinterWheatUndersown ] = 0.1;
    g_weed_percent[ tov_OWinterWheatUndersownExt ] = 0.1;
    g_weed_percent[tov_WinterRape] = 0.05;
    g_weed_percent[tov_OWinterRape] = 0.05;
    g_weed_percent[tov_OWinterRye] = 0.1;
    g_weed_percent[tov_OWinterBarley] = 0.1;
    g_weed_percent[tov_OWinterBarleyExt] = 0.1;
    g_weed_percent[tov_WinterBarley] = 0.1;
    g_weed_percent[tov_WinterRye] = 0.1;
    g_weed_percent[ tov_OFieldPeas ] = 0.1;
    g_weed_percent[tov_OFieldPeas] = 0.1;
    g_weed_percent[ tov_OFieldPeasSilage ] = 0.1;
    g_weed_percent[tov_OOats] = 0.1;
    g_weed_percent[tov_Oats] = 0.1;
    g_weed_percent[tov_Heath] = 0.1;
    g_weed_percent[tov_OrchardCrop] = 0.1;
    g_weed_percent[ tov_FieldPeas ] = 0.1;
    g_weed_percent[ tov_FieldPeasSilage ] = 0.1;
    g_weed_percent[tov_SeedGrass1] = 0.1;
    g_weed_percent[tov_SeedGrass2] = 0.1;
    g_weed_percent[tov_OSeedGrass1] = 0.15;
    g_weed_percent[tov_OSeedGrass2] = 0.15;
    g_weed_percent[tov_OPermanentGrassGrazed] = 0.1;
    g_weed_percent[tov_Setaside] = 0.1;
    g_weed_percent[tov_OSetaside] = 0.1;
    g_weed_percent[tov_PermanentSetaside] = 0.1;
    g_weed_percent[tov_PermanentGrassLowYield] = 0.1;
    g_weed_percent[tov_PermanentGrassGrazed] = 0.1;
    g_weed_percent[tov_PermanentGrassTussocky] = 0.1;
    g_weed_percent[tov_FodderBeet] = 0.1;
    g_weed_percent[tov_SugarBeet] = 0.1;
    g_weed_percent[tov_OFodderBeet] = 0.1;
    g_weed_percent[tov_NaturalGrass] = 0.1;
    g_weed_percent[tov_None] = 0.1;
    g_weed_percent[tov_NoGrowth] = 0.1;
    g_weed_percent[tov_OFirstYearDanger] = 0.1;
    g_weed_percent[tov_Triticale] = 0.1;
    g_weed_percent[tov_OTriticale] = 0.1;
    g_weed_percent[tov_WWheatPControl] = 0.1;
    g_weed_percent[tov_WWheatPToxicControl] = 0.1;
    g_weed_percent[tov_WWheatPTreatment] = 0.1;
    g_weed_percent[tov_AgroChemIndustryCereal] = 0.1;
    g_weed_percent[tov_WinterWheatStrigling] = 0.1;
    g_weed_percent[tov_WinterWheatStriglingSingle] = 0.1;
    g_weed_percent[tov_WinterWheatStriglingCulm] = 0.1;
    g_weed_percent[tov_SpringBarleyCloverGrassStrigling] = 0.1;
    g_weed_percent[tov_SpringBarleyStrigling] = 0.1;
    g_weed_percent[tov_SpringBarleyStriglingSingle] = 0.1;
    g_weed_percent[tov_SpringBarleyStriglingCulm] = 0.1;
    g_weed_percent[tov_MaizeStrigling] = 0.1;
    g_weed_percent[tov_WinterRapeStrigling] = 0.1;
    g_weed_percent[tov_WinterRyeStrigling] = 0.1;
    g_weed_percent[tov_WinterBarleyStrigling] = 0.1;
    g_weed_percent[tov_FieldPeasStrigling] = 0.1;
    g_weed_percent[tov_SpringBarleyPeaCloverGrassStrigling] = 0.1;
    g_weed_percent[tov_YoungForest] = 0.1;
    g_weed_percent[tov_Wasteland] = 0.1;

    g_bug_percent_a[tov_Carrots] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_MaizeSilage] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OMaizeSilage] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_Maize] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OCarrots] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_Potatoes] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OPotatoes] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_FodderGrass] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_CloverGrassGrazed1] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_CloverGrassGrazed2] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_OCloverGrassGrazed1] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_OCloverGrassGrazed2] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_SpringBarley] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleySpr] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleyPTreatment] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleySKManagement] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_WinterWheat] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WinterWheatShort] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_SpringBarleySilage] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleySeed] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_OGrazingPigs] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_OCloverGrassSilage1] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_SpringBarleyCloverGrass] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_OSpringBarleyPigs] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_OBarleyPeaCloverGrass] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_OSpringBarley] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_OSpringBarleyExt] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_OSBarleySilage] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[ tov_OWinterWheat ] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[ tov_OWinterWheatUndersown ] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[ tov_OWinterWheatUndersownExt ] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WinterRape] = EL_BUG_PERCENT_WR_A;
    g_bug_percent_a[tov_SpringRape] = EL_BUG_PERCENT_WR_A;
    g_bug_percent_a[tov_OWinterRape] = EL_BUG_PERCENT_WR_A;
    g_bug_percent_a[tov_OWinterRye] = EL_BUG_PERCENT_WRy_A;
    g_bug_percent_a[tov_OWinterBarley] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OWinterBarleyExt] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_WinterBarley] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_WinterRye] = EL_BUG_PERCENT_WRy_A;
    g_bug_percent_a[tov_OFieldPeas] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OFieldPeasSilage] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OrchardCrop] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_OOats] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_Oats] = EL_BUG_PERCENT_A;
    g_bug_percent_a[ tov_BroadBeans ] = EL_BUG_PERCENT_A;
    g_bug_percent_a[ tov_FieldPeas ] = EL_BUG_PERCENT_A;
    g_bug_percent_a[ tov_FieldPeasSilage ] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OSeedGrass1] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_OSeedGrass2] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_SeedGrass1] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_SeedGrass2] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_OPermanentGrassGrazed] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_Heath] = EL_BUG_PERCENT_Edges_A;
    g_bug_percent_b[tov_Heath] = EL_BUG_PERCENT_Edges_B;
    g_bug_percent_c[tov_Heath] = EL_BUG_PERCENT_Edges_C;
    g_bug_percent_d[tov_Heath] = EL_BUG_PERCENT_D;
    g_bug_percent_a[tov_Setaside] = EL_BUG_PERCENT_Edges_A;
    g_bug_percent_a[tov_OSetaside] = EL_BUG_PERCENT_Edges_A;
    g_bug_percent_a[tov_PermanentSetaside] = EL_BUG_PERCENT_Edges_A;
    g_bug_percent_a[tov_PermanentGrassLowYield] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_PermanentGrassGrazed] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_PermanentGrassTussocky] = EL_BUG_PERCENT_G_A;
    g_bug_percent_a[tov_FodderBeet] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_SugarBeet] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OFodderBeet] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_NaturalGrass] = EL_BUG_PERCENT_Edges_A;
    g_bug_percent_a[tov_None] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_NoGrowth] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OFirstYearDanger] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_Triticale] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_OTriticale] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_WWheatPControl] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WWheatPToxicControl] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WWheatPTreatment] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_AgroChemIndustryCereal] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WinterWheatStrigling] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WinterWheatStriglingCulm] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_WinterWheatStriglingSingle] = EL_BUG_PERCENT_WW_A;
    g_bug_percent_a[tov_SpringBarleyCloverGrassStrigling] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleyStrigling] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleyStriglingSingle] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_SpringBarleyStriglingCulm] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_MaizeStrigling] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_WinterRapeStrigling] = EL_BUG_PERCENT_WR_A;
    g_bug_percent_a[tov_WinterRyeStrigling] = EL_BUG_PERCENT_WRy_A;
    g_bug_percent_a[tov_WinterBarleyStrigling] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_FieldPeasStrigling] = EL_BUG_PERCENT_A;
    g_bug_percent_a[tov_SpringBarleyPeaCloverGrassStrigling] = EL_BUG_PERCENT_SB_A;
    g_bug_percent_a[tov_YoungForest] = EL_BUG_PERCENT_Edges_A;
    g_bug_percent_a[tov_Wasteland] = EL_BUG_PERCENT_Edges_A;

    g_bug_percent_b[tov_Carrots] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_MaizeSilage] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OMaizeSilage] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_Maize] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OCarrots] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_Potatoes] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OPotatoes] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_FodderGrass] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_CloverGrassGrazed1] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_CloverGrassGrazed2] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OCloverGrassGrazed1] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OCloverGrassGrazed2] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_SpringBarley] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleySpr] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleyPTreatment] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleySKManagement] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_WinterWheat] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WinterWheatShort] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_SpringBarleySilage] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleySeed] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_OGrazingPigs] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OCloverGrassSilage1] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_SpringBarleyCloverGrass] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_OSpringBarleyPigs] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_OBarleyPeaCloverGrass] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_OSBarleySilage] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_OSpringBarley] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_OSpringBarleyExt] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[ tov_OWinterWheat ] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[ tov_OWinterWheatUndersown ] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[ tov_OWinterWheatUndersownExt ] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WinterRape] = EL_BUG_PERCENT_WR_B;
    g_bug_percent_b[tov_SpringRape] = EL_BUG_PERCENT_WR_B;
    g_bug_percent_b[tov_OWinterRape] = EL_BUG_PERCENT_WR_B;
    g_bug_percent_b[tov_OWinterRye] = EL_BUG_PERCENT_WRy_B;
    g_bug_percent_b[tov_OWinterBarley] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OWinterBarleyExt] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_WinterBarley] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_WinterRye] = EL_BUG_PERCENT_WRy_B;
    g_bug_percent_b[tov_OFieldPeas] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OFieldPeasSilage] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OrchardCrop] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OOats] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_Oats] = EL_BUG_PERCENT_B;
    g_bug_percent_b[ tov_BroadBeans ] = EL_BUG_PERCENT_B;
    g_bug_percent_b[ tov_FieldPeas ] = EL_BUG_PERCENT_B;
    g_bug_percent_b[ tov_FieldPeasSilage ] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_SeedGrass1] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_SeedGrass2] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OSeedGrass1] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OSeedGrass2] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_OPermanentGrassGrazed] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_Setaside] = EL_BUG_PERCENT_Edges_B;
    g_bug_percent_b[tov_OSetaside] = EL_BUG_PERCENT_Edges_B;
    g_bug_percent_b[tov_PermanentSetaside] = EL_BUG_PERCENT_Edges_B;
    g_bug_percent_b[tov_PermanentGrassGrazed] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_PermanentGrassLowYield] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_PermanentGrassTussocky] = EL_BUG_PERCENT_G_B;
    g_bug_percent_b[tov_FodderBeet] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_SugarBeet] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OFodderBeet] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_NaturalGrass] = EL_BUG_PERCENT_Edges_B;
    g_bug_percent_b[tov_None] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_NoGrowth] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OFirstYearDanger] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_Triticale] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_OTriticale] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_WWheatPControl] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WWheatPToxicControl] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WWheatPTreatment] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_AgroChemIndustryCereal] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WinterWheatStrigling] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WinterWheatStriglingCulm] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_WinterWheatStriglingSingle] = EL_BUG_PERCENT_WW_B;
    g_bug_percent_b[tov_SpringBarleyCloverGrassStrigling] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleyStrigling] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleyStriglingSingle] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_SpringBarleyStriglingCulm] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_MaizeStrigling] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_WinterRapeStrigling] = EL_BUG_PERCENT_WR_B;
    g_bug_percent_b[tov_WinterRyeStrigling] = EL_BUG_PERCENT_WRy_B;
    g_bug_percent_b[tov_WinterBarleyStrigling] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_FieldPeasStrigling] = EL_BUG_PERCENT_B;
    g_bug_percent_b[tov_SpringBarleyPeaCloverGrassStrigling] = EL_BUG_PERCENT_SB_B;
    g_bug_percent_b[tov_YoungForest] = EL_BUG_PERCENT_Edges_B;
    g_bug_percent_b[tov_Wasteland] = EL_BUG_PERCENT_Edges_B;

    g_bug_percent_c[tov_Carrots] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_MaizeSilage] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OMaizeSilage] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_Maize] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OCarrots] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_Potatoes] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OPotatoes] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_FodderGrass] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_CloverGrassGrazed1] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_CloverGrassGrazed2] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OCloverGrassGrazed1] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OCloverGrassGrazed2] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_SpringBarley] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleySpr] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleyPTreatment] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleySKManagement] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_WinterWheat] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WinterWheatShort] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_SpringBarleySilage] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleySeed] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_OGrazingPigs] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OCloverGrassSilage1] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_SpringBarleyCloverGrass] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_OSpringBarleyPigs] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_OBarleyPeaCloverGrass] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_OSBarleySilage] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_OSpringBarley] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_OSpringBarleyExt] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[ tov_OWinterWheat ] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[ tov_OWinterWheatUndersown ] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[ tov_OWinterWheatUndersownExt ] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WinterRape] = EL_BUG_PERCENT_WR_C;
    g_bug_percent_c[tov_SpringRape] = EL_BUG_PERCENT_WR_C;
    g_bug_percent_c[tov_OWinterRape] = EL_BUG_PERCENT_WR_C;
    g_bug_percent_c[tov_OWinterRye] = EL_BUG_PERCENT_WRy_C;
    g_bug_percent_c[tov_OWinterBarley] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OWinterBarleyExt] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_WinterBarley] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_WinterRye] = EL_BUG_PERCENT_WRy_C;
    g_bug_percent_c[tov_OFieldPeas] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OFieldPeasSilage] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OrchardCrop] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OOats] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_Oats] = EL_BUG_PERCENT_C;
    g_bug_percent_c[ tov_FieldPeas ] = EL_BUG_PERCENT_C;
    g_bug_percent_c[ tov_BroadBeans ] = EL_BUG_PERCENT_C;
    g_bug_percent_c[ tov_FieldPeasSilage ] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_SeedGrass1] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_SeedGrass2] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OSeedGrass1] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OSeedGrass2] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_OPermanentGrassGrazed] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_Setaside] = EL_BUG_PERCENT_Edges_C;
    g_bug_percent_c[tov_OSetaside] = EL_BUG_PERCENT_Edges_C;
    g_bug_percent_c[tov_PermanentSetaside] = EL_BUG_PERCENT_Edges_C;
    g_bug_percent_c[tov_PermanentGrassGrazed] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_PermanentGrassLowYield] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_PermanentGrassTussocky] = EL_BUG_PERCENT_G_C;
    g_bug_percent_c[tov_FodderBeet] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_SugarBeet] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OFodderBeet] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_NaturalGrass] = EL_BUG_PERCENT_Edges_C;
    g_bug_percent_c[tov_None] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_NoGrowth] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OFirstYearDanger] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_Triticale] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_OTriticale] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_WWheatPControl] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WWheatPToxicControl] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WWheatPTreatment] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_AgroChemIndustryCereal] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WinterWheatStrigling] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WinterWheatStriglingCulm] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WinterWheatStriglingSingle] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_SpringBarleyCloverGrassStrigling] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleyStrigling] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleyStriglingSingle] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_SpringBarleyStriglingCulm] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_MaizeStrigling] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_WinterRapeStrigling] = EL_BUG_PERCENT_WR_C;
    g_bug_percent_c[tov_WinterRyeStrigling] = EL_BUG_PERCENT_WW_C;
    g_bug_percent_c[tov_WinterBarleyStrigling] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_FieldPeasStrigling] = EL_BUG_PERCENT_C;
    g_bug_percent_c[tov_SpringBarleyPeaCloverGrassStrigling] = EL_BUG_PERCENT_SB_C;
    g_bug_percent_c[tov_YoungForest] = EL_BUG_PERCENT_Edges_C;
    g_bug_percent_c[tov_Wasteland] = EL_BUG_PERCENT_Edges_C;

    g_bug_percent_d[tov_Carrots] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_Maize] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_MaizeSilage] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OMaizeSilage] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OCarrots] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_Potatoes] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OPotatoes] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_FodderGrass] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_CloverGrassGrazed1] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_CloverGrassGrazed2] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OCloverGrassGrazed1] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OCloverGrassGrazed2] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarley] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleySpr] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyPTreatment] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleySKManagement] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterWheat] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterWheatShort] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleySilage] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleySeed] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OGrazingPigs] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OCloverGrassSilage1] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyCloverGrass] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSpringBarleyPigs] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OBarleyPeaCloverGrass] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSBarleySilage] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSpringBarley] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSpringBarleyExt] = EL_BUG_PERCENT_D;
    g_bug_percent_d[ tov_OWinterWheat ] = EL_BUG_PERCENT_D;
    g_bug_percent_d[ tov_OWinterWheatUndersown ] = EL_BUG_PERCENT_D;
    g_bug_percent_d[ tov_OWinterWheatUndersownExt ] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterRape] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OWinterRape] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OWinterRye] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OWinterBarley] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OWinterBarleyExt] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterBarley] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterRye] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OFieldPeas] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OFieldPeasSilage] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OrchardCrop] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OOats] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_Oats] = EL_BUG_PERCENT_D;
    g_bug_percent_d[ tov_BroadBeans ] = EL_BUG_PERCENT_D;
    g_bug_percent_d[ tov_FieldPeas ] = EL_BUG_PERCENT_D;
    g_bug_percent_d[ tov_FieldPeasSilage ] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SeedGrass1] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SeedGrass2] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSeedGrass1] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSeedGrass2] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OPermanentGrassGrazed] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_Setaside] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OSetaside] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_PermanentSetaside] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_PermanentGrassLowYield] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_PermanentGrassGrazed] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_PermanentGrassTussocky] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_FodderBeet] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SugarBeet] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OFodderBeet] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_NaturalGrass] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_None] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_NoGrowth] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OFirstYearDanger] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_Triticale] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_OTriticale] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WWheatPControl] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WWheatPToxicControl] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WWheatPTreatment] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_AgroChemIndustryCereal] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterWheatStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterWheatStriglingCulm] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterWheatStriglingSingle] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyCloverGrassStrigling] = -EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyStriglingSingle] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyStriglingCulm] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_MaizeStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterRapeStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterRyeStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_WinterBarleyStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_FieldPeasStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_SpringBarleyPeaCloverGrassStrigling] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_YoungForest] = EL_BUG_PERCENT_D;
    g_bug_percent_d[tov_Wasteland] = EL_BUG_PERCENT_D;


    //05.03.13 - modifications for farmer decision making, AM
    Clean_CropDataStorage(0);
    Clean_CropDataStorage(1);
    m_crop_index = 0;
}

void VegElement::ReadBugPercentageFile( void ) {
    m_ifile=fopen(l_el_bug_percentage_file.value(), "r" );
  if ( !m_ifile ) {
    g_msg->Warn( WARN_FILE, "CropData::ReadBugPercentageFile(): Unable to open file", l_el_bug_percentage_file.value() );
    exit( 1 );
  }
  for ( int i = 0; i < tov_Undefined; i++ ) {
    int vegnum;
    // **cjt** modified 31/01/2004
    float weedpercent, bugpercent_a, bugpercent_b, bugpercent_c, bugpercent_d;
    if ( 2 != fscanf( m_ifile, "%d %f %f %f %f %f", & vegnum, & weedpercent, & bugpercent_a, & bugpercent_b,
         & bugpercent_c, & bugpercent_d ) ) {
           char vegnums[ 20 ];
           sprintf( vegnums, "%d", tov_Undefined );
           g_msg->Warn( WARN_FILE,
                "VegElement::ReadBugPercentageFile(): Unable to read"
                " sufficient number of int/double pairs from bug percentage file."" Lines expected:", vegnums );
           exit( 1 );
    }
    FloatToDouble( g_weed_percent[ vegnum ], weedpercent);
    FloatToDouble( g_bug_percent_a[ vegnum ] , bugpercent_a);
    FloatToDouble( g_bug_percent_b[ vegnum ] , bugpercent_b);
    FloatToDouble( g_bug_percent_c[ vegnum ] , bugpercent_c);
    FloatToDouble( g_bug_percent_d[ vegnum ] , bugpercent_d);
  }
  fclose( m_ifile );
}

bool VegElement::IsCereal(void)
{
    switch (m_lastsownvegtype)
    {
    case tov_SpringBarley:
    case tov_SpringBarleySpr:
    case tov_WinterBarley:
    case tov_SpringWheat:
    case tov_WinterWheat:
    case tov_WinterRye:
    case tov_Oats:
    case tov_Triticale:
    case tov_SpringBarleySeed:
    case tov_SpringBarleyStrigling:
    case tov_SpringBarleyStriglingSingle:
    case tov_SpringBarleyStriglingCulm:
    case tov_WinterWheatStrigling:
    case tov_WinterWheatStriglingSingle:
    case tov_WinterWheatStriglingCulm:
    case tov_OWinterBarley:
    case tov_OWinterBarleyExt:
    case tov_OWinterRye:
    case tov_SpringBarleyGrass:
    case tov_SpringBarleyCloverGrass:
    case tov_OBarleyPeaCloverGrass:
    case tov_SpringBarleyPeaCloverGrassStrigling:
    case tov_OSpringBarley:
    case tov_OSpringBarleyPigs:
    case tov_OWinterWheatUndersown:
    case tov_OWinterWheat:
    case tov_OOats:
    case tov_OTriticale:
    case tov_WWheatPControl:
    case tov_WWheatPToxicControl:
    case tov_WWheatPTreatment:
    case tov_AgroChemIndustryCereal:
    case tov_SpringBarleyPTreatment:
    case tov_SpringBarleySKManagement:
    case tov_OSpringBarleyExt:
    case tov_OSpringBarleyGrass:
    case tov_OSBarleySilage:
    case tov_OSpringBarleyClover:
        return true;
    default: // No matching code so is should not be cereal
        return false;
    }
}

bool VegElement::IsMatureCereal(void)
{
    switch (m_vege_type)
    {
    case tov_SpringBarley:
    case tov_SpringBarleySpr:
    case tov_WinterBarley:
    case tov_SpringWheat:
    case tov_WinterWheat:
    case tov_WinterRye:
    case tov_Oats:
    case tov_Triticale:
    case tov_SpringBarleySeed:
    case tov_SpringBarleyStrigling:
    case tov_SpringBarleyStriglingSingle:
    case tov_SpringBarleyStriglingCulm:
    case tov_WinterWheatStrigling:
    case tov_WinterWheatStriglingSingle:
    case tov_WinterWheatStriglingCulm:
    case tov_OWinterBarley:
    case tov_OWinterBarleyExt:
    case tov_OWinterRye:
    case tov_SpringBarleyGrass:
    case tov_SpringBarleyCloverGrass:
    case tov_SpringBarleyPeaCloverGrassStrigling:
    case tov_OSpringBarley:
    case tov_OSpringBarleyPigs:
    case tov_OWinterWheatUndersown:
    case tov_OWinterWheat:
    case tov_OOats:
    case tov_OTriticale:
    case tov_WWheatPControl:
    case tov_WWheatPToxicControl:
    case tov_WWheatPTreatment:
    case tov_AgroChemIndustryCereal:
    case tov_SpringBarleyPTreatment:
    case tov_SpringBarleySKManagement:
    case tov_OSpringBarleyExt:
    case tov_OSpringBarleyGrass:
    case tov_OSpringBarleyClover:
        return true;
    default: // No matching code so is should not be mature cereal
        return false;
    }
}

bool VegElement::IsMaize(void)
{
    switch (m_vege_type)
    {
        case tov_Maize:
        case tov_OMaizeSilage:
        case tov_MaizeSilage:
          return true;
        default: // No matching code so is should not be maize
          return false;
      }
}


inline bool VegElement::IsGrass()
{
    switch (m_vege_type)
    {
    case tov_NaturalGrass:
    case tov_PermanentGrassGrazed:
    case tov_PermanentGrassLowYield:
    case tov_PermanentGrassTussocky:
    case tov_PermanentSetaside:
    case tov_Setaside:
    case tov_SeedGrass1:
    case tov_SeedGrass2:
    case tov_OSeedGrass1:
    case tov_OSeedGrass2:
    case tov_CloverGrassGrazed1:
    case tov_CloverGrassGrazed2:
    case tov_OCloverGrassGrazed1:
    case tov_OCloverGrassGrazed2:
    case tov_OrchardCrop:
    case tov_YoungForest:
    case tov_FodderGrass:
    case tov_Heath:
        return true;
    default: return false;
    }
}

inline bool VegElement::IsGooseGrass() {
    switch (m_vege_type) {
        case tov_NaturalGrass:
        case tov_PermanentGrassGrazed:
        case tov_PermanentGrassLowYield:
        case tov_PermanentGrassTussocky:
            return true;
        default: break;
    }
    switch (m_lastsownvegtype) {
        case tov_SeedGrass1:
        case tov_SeedGrass2:
        case tov_OSeedGrass1:
        case tov_OSeedGrass2:
        case tov_CloverGrassGrazed1:
        case tov_CloverGrassGrazed2:
        case tov_OCloverGrassGrazed1:
        case tov_OCloverGrassGrazed2:
        case tov_FodderGrass:
            return true;
        default:
            return false;
    }

}



void VegElement::RecalculateBugsNStuff( void ) {

    double newgrowth=0;
    m_veg_cover = 1.0 - ( exp( m_LAtotal * -0.6 ) ); // Beer's Law to give cover
    double usefull_veg_cover = 1.0 - ( exp( m_LAgreen * -0.4 ) ); // This is used to calc growth rate
    // Need gloabal radiation today
    double glrad = g_landscape_p->SupplyGlobalRadiation();
    // This is different for maize (a C4 plant)
    int ptype;
    if (( m_vege_type == tov_Maize ) || ( m_vege_type == tov_OMaizeSilage ) || (m_vege_type == tov_MaizeSilage) || (m_vege_type == tov_MaizeStrigling)) ptype = 1; else ptype = 0;
    int index = ( int )floor( 0.5 + g_landscape_p->SupplyTemp() ) + 30; // There are 30 negative temps
    double radconv = c_SolarConversion[ ptype ] [ index ];
    if ( m_LAtotal >= m_oldLAtotal ) {
        // we are in positive growth so grow depending on our equation
        newgrowth = usefull_veg_cover * glrad * radconv * g_biomass_scale[ m_vege_type ];
        if (m_owner_index != -1) { // This only works because only crops and similar structures have owners
            int fintensity = g_landscape_p->SupplyFarmIntensity(m_poly);
            if (fintensity==1) {
                // 1 means extensive, so reduce vegetation biomass by 20%
                // NB this cannot be used with extensive crop types otherwise you get an additional 20% reduction
                // This way of doing things provides a quick and dirty general effect.
                m_veg_biomass += newgrowth * 0.8;
            } else m_veg_biomass += newgrowth;
        } else m_veg_biomass += newgrowth;
    } else {
        // Negative growth - so shrink proportional to the loss in LAI Total
        if ( m_oldLAtotal > 0 ) {
            m_veg_biomass *= ( m_LAtotal / m_oldLAtotal );
        }
    }
    m_total_biomass = m_veg_biomass * m_area;
    m_total_biomass_old = m_total_biomass;
    // For geese that eat spilled grain and maize we need to remove some of this daily (loss to other things than geese)
    m_birdseedforage *= cfg_goose_GrainDecayRate.value();  
    if (m_birdseedforage <0.01) m_birdseedforage = 0.0;
    m_birdmaizeforage *= cfg_goose_GrainDecayRate.value();  
    if (m_birdmaizeforage <0.01) m_birdmaizeforage = 0.0;
    // Another thing to do is to calculate mean vegetation digestability
    // This is a 32-day running average of the amount of new growth per day divided by veg biomass
    // With a minimum value of 0.5
    ++m_newoldgrowthindex &= 31;
    if (m_veg_biomass>0 ) {
        switch (m_vege_type) {
        case tov_NoGrowth:
        case tov_None:
        case tov_OFirstYearDanger:
            m_digestability=0.0;
            break;
        case tov_OPotatoes:
        case tov_Maize:
        case tov_MaizeSilage:
        case tov_OMaizeSilage:
        case tov_MaizeStrigling:
        case tov_Potatoes:
        case tov_PotatoesIndustry:
            m_digestability=0.5;
            break;
        default:
            //m_oldnewgrowth[m_newoldgrowthindex]=(newgrowth/m_veg_biomass);
            m_oldnewgrowth[m_newoldgrowthindex]=(newgrowth);
            m_newgrowthsum=0.0;
            for (int i=0; i<32; i++) {
                m_newgrowthsum+=m_oldnewgrowth[i];
            }
            m_digestability = m_newgrowthsum/m_veg_biomass;
            m_digestability+=0.5;
            if (m_digestability>0.8) m_digestability=0.8;
        }
    }
    else {
        m_oldnewgrowth[m_newoldgrowthindex] = 0.0;
        m_digestability = 0.0;
    }
    // We also need to calculate non-grain forage for geese
    if (IsCereal()) {
        if (m_green_biomass > 0.5)  //Testing if this could be a suitable fix for the cereals
        {
            for (unsigned i = 0; i < gs_foobar; i++) {
                //m_goosegrazingforage[ i ] = 0.0;
                m_goosegrazingforage[ i ] = g_landscape_p->SupplyGooseGrazingForageH( m_veg_height, (GooseSpecies)i ) * 1.0325;
            }
        }
        else for (unsigned i = 0; i < gs_foobar; i++) {
            m_goosegrazingforage[i] = 0.0;
        }
    }
    else if (IsGooseGrass()) {
        for (unsigned i = 0; i < gs_foobar; i++) {
            //m_goosegrazingforage[ i ] = 0.0;
            m_goosegrazingforage[ i ] = g_landscape_p->SupplyGooseGrazingForageH( m_veg_height, (GooseSpecies)i );
        }
    }
    else for (unsigned i = 0; i < gs_foobar; i++)   m_goosegrazingforage[ i ] = 0.0;

    // NB The m_weed_biomass is calculated directly from the curve in Curves.pre
    // rather than going through the rigmorole of converting leaf-area index
    // The insect calculation part
    // Bugmass = a + b(biomass) + c(height)
    double temp_bugmass = //g_bug_percent_d[ m_vege_type ] // This was used as a scaler - now not used
    g_bug_percent_a[ m_vege_type ] + ( ( m_veg_biomass + m_weed_biomass ) * g_bug_percent_b[ m_vege_type ] )
    + ( m_veg_height * g_bug_percent_c[ m_vege_type ] );
    // Set a minimum value (regressions will otherwise sometimes give a -ve value
    if ( temp_bugmass < 0.05 ) temp_bugmass = 0.05;
    // Now need to check for deviations caused by management
    // First spot the deviation - this is easy because the only deviation that does
    // not affect the vegetation too is insecticide spraying
    if ( m_days_since_insecticide_spray > 0 ) {
        // Need to change insects still, so grow towards the target, but only when 21 days from zero effect
        if (m_days_since_insecticide_spray<21) m_insect_pop += (temp_bugmass-m_insect_pop)/m_days_since_insecticide_spray;
        m_days_since_insecticide_spray--;
    }
    else {
        m_insect_pop = temp_bugmass;
    }
    m_veg_density = (int) (floor( 0.5 + ( m_veg_biomass / ( 1 + m_veg_height ) ) ));
    if ( m_veg_density > 100 ) m_veg_density = 100; // to stop array bounds problems
    if (m_LAtotal == 0.0) m_green_biomass = 0.0;
    else m_green_biomass = m_veg_biomass * (m_LAgreen / (m_LAtotal));
    m_dead_biomass = m_veg_biomass-m_green_biomass;
    }

void VegElement::RandomVegStartValues( double * a_LAtotal, double * a_LAgreen, double * a_veg_height, double * a_weed_biomass ) {
  * a_LAtotal = EL_VEG_START_LAIT * ( ( ( ( double )( random( 21 ) - 10 ) ) / 100.0 ) + 1.0 ); // +/- 10%
  * a_LAgreen = * a_LAtotal / 4.0;
  * a_veg_height = * a_LAgreen * EL_VEG_HEIGHTSCALE;
  * a_weed_biomass = * a_LAgreen * 0.1; // 10% weeds by biomass
}


void VegElement::SetGrowthPhase(int a_phase) {

    if (a_phase == sow) {
        m_vegddegs = 0.0;
    }
    else if (a_phase == harvest) m_vegddegs = -1;
    if (a_phase == janfirst) {
        m_forced_phase_shift = false;
        if (g_crops->StartValid(m_curve_num, a_phase)) {
            double temp_veg_height = g_crops->GetStartValue(m_curve_num, a_phase, 2);
            if (temp_veg_height < m_veg_height) { // Otherwise we are better off with the numbers we have to start with
                m_LAgreen = g_crops->GetStartValue(m_curve_num, a_phase, 0);
                m_LAtotal = g_crops->GetStartValue(m_curve_num, a_phase, 1);
                m_veg_height = g_crops->GetStartValue(m_curve_num, a_phase, 2);
            }
        }

    }
    else if (g_crops->StartValid(m_curve_num, a_phase)) {
        m_LAgreen = g_crops->GetStartValue(m_curve_num, a_phase, 0);
        m_LAtotal = g_crops->GetStartValue(m_curve_num, a_phase, 1);
        m_veg_height = g_crops->GetStartValue(m_curve_num, a_phase, 2);
    }
    else if (!m_force_growth) {
        // If we are in forced growth mode (which is very likely),
        // then do not choose a new set of starting values, as we have
        // already calculated our way to a reasonable set of values.
        //RandomVegStartValues( & m_LAtotal, & m_LAgreen, & m_veg_height, & m_weed_biomass ); // **CJT** Testing removal 17/02/2015
    }
    m_veg_phase = a_phase;
    m_yddegs = 0.0;
    m_ddegs = g_weather->GetDDDegs(g_date->Date());
    m_force_growth = false;

    if (m_veg_phase == janfirst) {
        // For some growth curves there is no growth in the first
        // two months of the year. This will more likely than
        // not cause a discontinuous jump in the growth curves
        // come March first. ForceGrowthSpringTest() tries
        // to avoid that by checking for positive growth values
        // for the January growth phase. If none are found, then
        // it initializes a forced growth/transition to the March
        // 1st starting values.
        ForceGrowthSpringTest(); // Removal of this causes continuous increase in vegetation growth year on year for any curve that does not have a hard reset (e.g. harvest).
    }
}


void VegElement::ForceGrowthTest( void ) {
  // Called whenever the farmer does something 'destructive' to a
  // field, that reduced the vegetaion.
  if ( g_date->DayInYear() >= g_date->DayInYear( 1, 11 )
       || ( g_date->DayInYear() < g_date->DayInYear( 1, 3 ) && m_force_growth ) ) {
         ForceGrowthInitialize();
  }
}



void VegElement::ForceGrowthSpringTest(void) {
    // Unless we are on the list of special growth curves where we have worked
    // out vegetation declines (grasses), then
    // check if there are any positive growth differentials in the curve
    // for the first two months of the year. Do nothing if there is.
    //if (IsGrass()) return;
    // If we have any positive growth then no need to force either
    if (g_crops->GetLAgreenDiff(90000.0, 0.0, m_curve_num, janfirst) > 0.001
        || g_crops->GetLAtotalDiff(90000.0, 0.0, m_curve_num, janfirst) > 0.001
        || g_crops->GetHeightDiff(90000.0, 0.0, m_curve_num, janfirst) > 0.001) {
        return;
    }

    // No growth, force it.
    ForceGrowthInitialize();
}



void VegElement::ForceGrowthInitialize( void ) {
  double LAgreen_target;
  double Weed_target;
  double LAtotal_target;
  double veg_height_target;
  int next_phase, daysleft;

  // Figure out what our target phase is.
  if ( g_date->DayInYear() < g_date->DayInYear( 3, 1 ) ) {
    daysleft = g_date->DayInYear( 1, 3 ) - g_date->DayInYear();
    next_phase = marchfirst;
  } else if ( g_date->DayInYear() >= g_date->DayInYear( 1, 11 ) ) {
    daysleft = 365 - g_date->DayInYear();
    next_phase = janfirst;
  } else {
    return;
  }
  if ( daysleft <= 0 )
       // Uh! Oh! This really shouldn't happen.
         return;

  if ( !g_crops->StartValid( m_curve_num, next_phase ) ) {
    // If no valid starting values for next phase, then
    // preinitialize the random starting values! Ie. make the
    // choice here and then do not choose another set come
    // next phase transition, but use the values we already
    // got at that point in time.
    RandomVegStartValues( & LAtotal_target, & LAgreen_target, & veg_height_target, & Weed_target );
  } else {
    Weed_target = g_crops->GetStartValue( m_weed_curve_num, next_phase, 0 );
    LAgreen_target = g_crops->GetStartValue( m_curve_num, next_phase, 0 );
    LAtotal_target = g_crops->GetStartValue( m_curve_num, next_phase, 1 );
    veg_height_target = g_crops->GetStartValue( m_curve_num, next_phase, 2 );
  }

  m_force_growth = true;
  m_force_Weed = ( Weed_target - m_weed_biomass ) / ( double )daysleft;
  m_force_LAgreen = ( LAgreen_target - m_LAgreen ) / ( double )daysleft;
  m_force_LAtotal = ( LAtotal_target - m_LAtotal ) / ( double )daysleft;
  m_force_veg_height = ( veg_height_target - m_veg_height ) / ( double )daysleft;
}


void VegElement::ForceGrowthDevelopment( void ) {
  //if ( m_herbicidedelay == 0 ) m_weed_biomass += m_force_Weed; // ***CJT*** 12th Sept 2008 - rather than force growth, weeds might be allowed to grow on their own
  m_LAgreen += m_force_LAgreen;
  m_LAtotal += m_force_LAtotal;
  m_veg_height += m_force_veg_height;
  // RecalculateBugsNStuff();  REMOVED BY CJT 3/2/2015  If no problems occur then we can delete permanantly
}



void VegElement::ZeroVeg( void ) {
  m_LAgreen = 0.0;
  m_LAtotal = 0.0;
  m_veg_height = 0.0;
  m_veg_cover = 0.0;
  m_veg_biomass = 0.0;
  m_weed_biomass = 0.0;
  m_birdseedforage = 0.0;
  m_birdmaizeforage = 0.0;

  ForceGrowthTest();
  RecalculateBugsNStuff();
}


void VegElement::DoDevelopment( void ) {
  if ( m_force_growth ) {
    ForceGrowthDevelopment();
    RecalculateBugsNStuff();
    ResetGeese();
    return;
  }

  m_yddegs = m_ddegs;
  m_ddegs = g_weather->GetDDDegs( g_date->Date() );
  if (m_vegddegs != -1.0) m_vegddegs += m_ddegs; // Sum up the vegetation day degrees since sowing
  m_ddegs += m_yddegs; // and sum up the phase ddegs

  double dLAG = g_crops->GetLAgreenDiff( m_ddegs, m_yddegs, m_curve_num, m_veg_phase );
  double dLAT = g_crops->GetLAtotalDiff( m_ddegs, m_yddegs, m_curve_num, m_veg_phase );
  double dHgt = g_crops->GetHeightDiff( m_ddegs, m_yddegs, m_curve_num, m_veg_phase );

  m_LAgreen += dLAG;
  if ( m_LAgreen < 0.0 )
    m_LAgreen = 0.0;

  m_LAtotal += dLAT;
  if ( m_LAtotal < 0.0 )
    m_LAtotal = 0.0;
  int fintensity = 0;
#ifdef __EXTSHRINKSHEIGHT
  if (this->m_owner_index != -1) { // This only works because only crops and similar structures have owners
      fintensity = g_landscape_p->SupplyFarmIntensity(m_poly);
      if (fintensity==1) {
          // 1 means extensive, so reduce vegetation height by 10%
          dHgt *=0.9;
      }
  }
#endif


  m_veg_height += dHgt;
  if ( m_veg_height < 0.0 )    m_veg_height = 0.0;
  if ( m_herbicidedelay == 0 ) {
    double dWee = g_crops->GetLAtotalDiff( m_ddegs, m_yddegs, m_weed_curve_num, m_veg_phase );
    m_weed_biomass += dWee * cfg_ele_weedscaling.value()* (1+fintensity);
  }
  if ( m_weed_biomass < 0.0 ) m_weed_biomass = 0.0;
  RecalculateBugsNStuff();
  // Here we need to set today's goose numbers to zero in case they are not written by the goose population manager (the normal situation)
  ResetGeese();
}

void VegElement::ResetGeese( void ) {
    m_gooseNos[ g_date->DayInYear() ] = 0;
    for (unsigned i = 0; i < gs_foobar; i++) {
        m_gooseSpNos[ g_date->DayInYear() ][ (GooseSpecies)i ] = 0;
        m_gooseSpNosTimed[ g_date->DayInYear() ][ (GooseSpecies)i ] = 0;
    }
}

void VegElement::GrazeVegetationTotal( double a_grams )
{
    GrazeVegetation( a_grams/m_area, true );
}

void VegElement::GrazeVegetation( double a_reduc, bool a_force )
{
    if (!a_force) a_reduc *= m_default_grazing_level;
    if (a_reduc >= m_veg_biomass) return;
    double propreduc = 1.0 - (a_reduc / m_veg_biomass);
    m_veg_height *= propreduc;
    m_weed_biomass *= propreduc;
    m_veg_biomass -= a_reduc;
    // Need to do something with the LA too - 
    m_LAgreen *= propreduc;
    m_LAtotal *= propreduc;
    m_oldLAtotal = m_LAtotal; // this stops double reduction of biomass later in RecalculateBugsNStuff();
}

void VegElement::ReduceVeg(double a_reduc) {
    m_LAgreen *= a_reduc;
    m_LAtotal *= a_reduc;
    m_veg_height *= a_reduc;
    m_veg_biomass *= a_reduc;
    m_weed_biomass *= a_reduc;

    ForceGrowthTest();
    m_oldLAtotal = m_LAtotal; // this stops double reduction of biomass later in RecalculateBugsNStuff();
}

void VegElement::ReduceVeg_Extended(double a_reduc) {
  m_LAgreen *= a_reduc;
  m_LAtotal *= a_reduc;
  m_veg_height *= a_reduc;
  m_veg_biomass *= a_reduc;
  m_weed_biomass *= a_reduc;

  if ( a_reduc < EL_GROWTH_PHASE_SHIFT_LEVEL ) {
    m_yddegs = 0.0;
    m_ddegs = EL_GROWTH_DAYDEG_MAGIC;
  }

  if ( g_date->DayInYear() >= EL_GROWTH_DATE_MAGIC && a_reduc < EL_GROWTH_PHASE_SHIFT_LEVEL && !m_forced_phase_shift ) {
    SetGrowthPhase( harvest1 );
    m_forced_phase_shift = true;
  }

  ForceGrowthTest();
  m_oldLAtotal = m_LAtotal; // this stops double reduction of biomass later in RecalculateBugsNStuff();
}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------


Field::Field( void ) : VegElement() {
  m_type = tole_Field;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_default_grazing_level = 3;
}



void VegElement::Clean_CropDataStorage(int index){
 //05.03.13 AM

    m_CropDataStorage[index].taken = false;
    m_CropDataStorage[index].tov_type = tov_Undefined;
    m_CropDataStorage[index].biomass_at_harvest = -1;
    m_CropDataStorage[index].harvested = false;
    m_CropDataStorage[index].area = 0;
    m_CropDataStorage[index].no_herb_app = 0;
    m_CropDataStorage[index].missed_herb_app = 0;
    m_CropDataStorage[index].no_fi_app = 0;
    m_CropDataStorage[index].missed_fi_app = 0;
}


void Field::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  SetSprayedToday(false); // Reset the overspray flag in case it is set
  // Now if we have an unsprayed field margin, we need to transfer the crop
  // data to it.
  if ( GetUnsprayedMarginPolyRef() != -1 ) {
    if (( m_type == tole_PermPasture ) || ( m_type == tole_PermPastureTussocky ) || ( m_type == tole_PermPastureLowYield ))
      g_landscape_p->SupplyLEPointer( GetUnsprayedMarginPolyRef() )->SetCropDataAll( m_veg_height,
           ( m_veg_biomass - m_weed_biomass ) * 0.9, m_LAtotal, m_LAgreen, m_vege_type, m_weed_biomass, m_veg_cover,
           m_cattle_grazing, m_insect_pop, m_veg_patchy, m_veg_density );
    else g_landscape_p->SupplyLEPointer( GetUnsprayedMarginPolyRef() )->SetCropData( m_veg_height, m_LAtotal, m_LAgreen,
           m_vege_type, m_veg_cover, m_cattle_grazing );
  }
}


TTypesOfVegetation Field::GetPreviousCrop(int a_index) {
    return m_owner->GetPreviousCrop(a_index); 
}


void VegElement::SetCropData( double a_veg_height, double a_LAtotal, double a_LAgreen, TTypesOfVegetation a_veg,
     double a_cover, int a_grazed ) {
       m_veg_height = a_veg_height;
       m_LAtotal = a_LAtotal;
       m_LAgreen = a_LAgreen;
       m_vege_type = a_veg;
       m_veg_cover = a_cover;
       m_cattle_grazing = a_grazed;
}

void VegElement::SetCropDataAll( double a_veg_height, double a_biomass, double a_LAtotal, double a_LAgreen,
     TTypesOfVegetation a_veg, double a_wb, double a_cover, int a_grazed, double a_ins, bool a_patchy, double a_dens ) {
       m_veg_height = a_veg_height;
       m_veg_biomass = a_biomass;
       m_LAtotal = a_LAtotal;
       m_LAgreen = a_LAgreen;
       m_vege_type = a_veg;
       m_weed_biomass = a_wb;
       m_veg_cover = a_cover;
       m_cattle_grazing = a_grazed;
       m_insect_pop = a_ins;
       m_veg_density = (int) a_dens;
       m_veg_patchy = a_patchy;
}

void VegElement::InsectMortality( double a_fraction ) {
  m_insect_pop *= a_fraction;
}

PermPasture::PermPasture( void ) : VegElement() {
  // Vegetation type set by the farm manager.
  m_type = tole_PermPasture;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = false;
  m_default_grazing_level = 3;
}

PermPastureLowYield::PermPastureLowYield( void ) : VegElement() {
  // Vegetation type set by the farm manager.
  m_type = tole_PermPastureLowYield;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = false;
  m_default_grazing_level = 2;
}


PermPastureTussocky::PermPastureTussocky( void ) : VegElement() {
  // Vegetation type set by the farm manager.
  m_type = tole_PermPastureTussocky;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = true;
  m_digestability+=0.2;
  if (m_digestability>0.8) m_digestability=0.8;
  m_default_grazing_level = 1;
}


PermanentSetaside::PermanentSetaside( void ) : VegElement() {
  m_vege_type = tov_PermanentSetaside;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_PermanentSetaside;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  if (g_rand_uni() < cfg_SetAsidePatchyChance.value()) m_veg_patchy = true; else m_veg_patchy = false;
  m_digestability+=0.2;
  if (m_digestability>0.8) m_digestability=0.8;

}


Hedges::Hedges( void ) : VegElement() {
  LE::SetHigh( true );
  //default to tall - later will depend on height recorded in polygon data
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_Hedges;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  SetSubType(0);
}


HedgeBank::HedgeBank( void ) : VegElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_HedgeBank;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  SetSubType(0);
}


BeetleBank::BeetleBank( void ) : VegElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_BeetleBank;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  if (g_rand_uni() < cfg_BBPatchyChance.value()) m_veg_patchy = true; else m_veg_patchy = false;
}


RoadsideVerge::RoadsideVerge( void ) : VegElement() {
  m_type = tole_RoadsideVerge;
  m_vege_type = tov_NaturalGrass;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = true;
}

void RoadsideVerge::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  // Add cutting functionality when ready.
  long today = g_date->DayInYear();

  if ( g_date->JanFirst() ) {
    // beginning of year so restart the cutting
    m_DateCut = 0;
  }

  if ( today > RV_MAY_1ST ) // No cutting before May 1st
  {
    long SinceCut = today - m_DateCut; // how many days since last cut
    int month = g_date->GetMonth();
    switch ( month ) {
      case 5:
        if ( random( 14 ) + SinceCut > RV_CUT_MAY ) Cutting( today );
      break;
      case 6:
        if ( random( 14 ) + SinceCut > RV_CUT_JUN ) Cutting( today );
      break;
      case 7:
        if ( random( 14 ) + SinceCut > RV_CUT_JUL ) Cutting( today );
      break;
      case 8:
        if ( random( 14 ) + SinceCut > RV_CUT_AUG ) Cutting( today );
      break;
      case 9:
        if ( random( 14 ) + SinceCut > RV_CUT_SEP ) Cutting( today );
      break;
      case 10:
        if ( random( 14 ) + SinceCut > RV_CUT_OCT ) Cutting( today );
      break;
      default:
      break;
    }
  }
}

void RoadsideVerge::Cutting( int a_today )
{
  SetLastTreatment( mow );
  m_DateCut = a_today;
  m_veg_height = RV_CUT_HEIGHT;
  m_LAgreen = RV_CUT_GREEN;
  m_LAtotal = RV_CUT_TOTAL;
  RecalculateBugsNStuff();
}

RoadsideSlope::RoadsideSlope( void ) : RoadsideVerge() {
  m_type = tole_RoadsideSlope;
  m_vege_type = tov_NaturalGrass;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = true;
}

void RoadsideSlope::DoDevelopment( void )
{
    RoadsideVerge::DoDevelopment();
}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

GreenElement::GreenElement( void ) : VegElement() {
  m_veg_patchy = false;
}


void GreenElement::DoDevelopment( void ) {
  VegElement::DoDevelopment();
}


Scrub::Scrub( void ) : GreenElement() {
  LE::SetHigh( true );
  m_type = tole_Scrub;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Marsh::Marsh( void ) : GreenElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_Marsh;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Saltmarsh::Saltmarsh( void ) : Marsh() {
    m_type = tole_Saltmarsh;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Heath::Heath( void ) : GreenElement() {
  m_vege_type = tov_Heath;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_Heath;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = true;
}

Orchard::Orchard( void ) : GreenElement() {
  LE::SetHigh( true );
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_MownGrass;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

MownGrass::MownGrass( void ) : GreenElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( tov_Lawn );
  m_type = tole_MownGrass;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  if (g_rand_uni() < cfg_MGPatchyChance.value()) m_veg_patchy = true; else m_veg_patchy = false;
}

OrchardBand::OrchardBand( void ) : GreenElement() {
  LE::SetHigh( true );
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_OrchardBand;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_LastSprayed = 99999;
}

void Orchard::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  long today = g_date->DayInYear();
  // Spraying
  //int sprayday = cfg_OrchardSprayDay.value();
  int sprayday2 = cfg_pest_productapplic_startdate2.value();
  int sprayday3 = cfg_pest_productapplic_startdate3.value();
  int sprayday=cfg_pest_productapplic_startdate.value();
  //sprayday+=random(cfg_pest_productapplic_period.value());
  if ( ( today == sprayday ) || ( today == sprayday2 ) ||  ( today == sprayday3 ) )
    if ( g_landscape_p->SupplyShouldSpray() ) {
      //g_pest->DailyQueueAdd( this, l_pest_insecticide_amount.value() );
      g_pest->DailyQueueAdd( this, l_pest_productOrchard_amount.value() );
    }
  // Cutting functionality
  if ( g_date->JanFirst() ) {
    // beginning of year so restart the cutting
    m_DateCut = 0;
  }

  switch ( cfg_OrchardNoCutsDay.value() ) {
    case 99:
      if ( today == ( sprayday - 7 ) ) Cutting( today );
    break;
    case 4:
      if ( ( today == 259 ) || ( today == 122 ) || ( today == 92 ) || ( today == 196 ) )
        Cutting( today );
    break;
    case 3:
      if ( ( today == 259 ) || ( today == 122 ) || ( today == 92 ) ) Cutting( today );
    break;
    case 2:
      if ( ( today == 259 ) || ( today == 122 ) ) Cutting( today );
    break;
    case 1:
      if ( ( today == 259 ) ) Cutting( today );
    break;
    default: // No cut
    break;
  }
}

void Orchard::Cutting( int a_today ) {
  SetLastTreatment( mow );
  SetMownDecay( 12 ); // 12 days of not suitable
  SetGrowthPhase( harvest1 );
  m_DateCut = a_today;
  m_veg_height = l_el_o_cut_height.value();
  m_LAgreen = l_el_o_cut_green.value();
  m_LAtotal = l_el_o_cut_total.value();
}

void MownGrass::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  long today = g_date->DayInYear();
  // Cutting functionality
  if ( g_date->JanFirst() ) {
    // beginning of year so restart the cutting
    m_DateCut = 0;
  }
  switch ( cfg_MownGrassNoCutsDay.value() ) {
    case 99:
        // Use to define special cutting behaviour e.g. cutting every 14 days after 1st May
        if (  ( today >= ( March + 15 ) ) && ( today % 42 == 0 )) {
            if (today < October) Cutting( today );
        }
    break;
    case 5:
      if ( ( today == 151 ) ) // 1st June
        Cutting( today );
    break;
    case 4:
      if ( ( today == 259 ) || ( today == 122 ) || ( today == 92 ) || ( today == 196 ) )
        Cutting( today );
    break;
    case 3:
      if ( ( today == 259 ) || ( today == 122 ) || ( today == 92 ) ) Cutting( today );
    break;
    case 2:
      if ( ( today == 259 ) || ( today == 122 ) ) Cutting( today );
    break;
    case 1:
      if ( ( today == 259 ) ) Cutting( today );
    break;
    default: // No cut
    break;
  }
}

void MownGrass::Cutting( int a_today ) {
  SetLastTreatment( mow );
  SetMownDecay( 21 ); // 21 days of not suitable
  SetGrowthPhase( harvest1 );
  m_DateCut = a_today;
  m_veg_height = l_el_o_cut_height.value();
  m_LAgreen = l_el_o_cut_green.value();
  m_LAtotal = l_el_o_cut_total.value();
}


void OrchardBand::DoDevelopment( void ) {
    VegElement::DoDevelopment();
    long today = g_date->DayInYear();
    if (m_LastSprayed<today) {
        m_herbicidedelay = today-m_LastSprayed;
        if (m_herbicidedelay > 5) m_herbicidedelay = 5;
            else if (m_herbicidedelay < 0) m_herbicidedelay = 0;
        this->ReduceVeg(0.9);
        if ((today == 0) || (today-m_LastSprayed > 90)) m_LastSprayed = 999999;
    }
  // Spraying
    int sprayday2 = cfg_pest_productapplic_startdate2.value();
    int sprayday3 = cfg_pest_productapplic_startdate3.value();
    int sprayday=cfg_pest_productapplic_startdate.value();
  //sprayday+=random(cfg_pest_productapplic_period.value());
    if ( ( today == sprayday ) || ( today == sprayday2 ) || ( today == sprayday3 ) ) {
        if ( g_landscape_p->SupplyShouldSpray() ) {
            g_pest->DailyQueueAdd( this, l_pest_productOrchard_amount.value() );
        }
        m_LastSprayed = today; // Regardless of whether we spray our test compound, we want to have the herbicide effect

    }
}

RiversidePlants::RiversidePlants( void ) : GreenElement() {
  m_type = tole_RiversidePlants;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


NaturalGrassDry::NaturalGrassDry( void ) : GreenElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_veg_patchy=true;
  m_type = tole_NaturalGrassDry;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

NaturalGrassWet::NaturalGrassWet( void ) : GreenElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_veg_patchy=true;
  m_type = tole_NaturalGrassWet;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Wasteland::Wasteland(void) : GreenElement() {
    m_vege_type = tov_Wasteland;
    m_curve_num = g_crops->VegTypeToCurveNum(m_vege_type);
    m_veg_patchy = true;
    m_type = tole_Wasteland;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

void NaturalGrassDry::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  // The assumption is that natural grass has a range of species, which means
  // there should be good food all year - but still it should vary with season
  // So we add a constant to the digestability of 0.2
  m_digestability+=0.2;
  if (m_digestability>0.8) m_digestability=0.8;
}

void NaturalGrassWet::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  // The assumption is that natural grass has a range of species, which means
  // there should be good food all year - but still it should vary with season
  // So we add a constant to the digestability of 0.2
  m_digestability+=0.2;
  if (m_digestability>0.8) m_digestability=0.8;
}

void Wasteland::DoDevelopment( void ) {
    // The assumption is that natural grass has a range of species, which means
    // there should be good food all year - but still it should vary with season
    // So we add a constant to the digestability of 0.2
    m_digestability += 0.2;
    VegElement::DoDevelopment();
    if (m_digestability>0.8) m_digestability = 0.8;
}

FieldBoundary::FieldBoundary( void ) : GreenElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_FieldBoundary;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

UnsprayedFieldMargin::UnsprayedFieldMargin( void ) : GreenElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_UnsprayedFieldMargin;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  if (random(100) < cfg_UMPatchyChance.value()) m_veg_patchy = true; else
    m_veg_patchy = false;
}

void UnsprayedFieldMargin::DoDevelopment( void ) {
  m_yddegs = m_ddegs;
  m_ddegs = m_yddegs + g_weather->GetDDDegs( g_date->Date() );
  double dWee = g_crops->GetLAtotalDiff( m_ddegs, m_yddegs, m_weed_curve_num, m_veg_phase );
  m_weed_biomass += dWee;
  if ( m_weed_biomass < 0.0 ) m_weed_biomass = 0.0;
  double temp_biomass = m_LAtotal * EL_PLANT_BIOMASS * 0.9 * g_biomass_scale[ m_vege_type ];
  // Calculate vegdensity here so that excess weeds do not make the density greater
  // They are in the patches which are not calculated in the 0.1 reduc.
  m_veg_density = ( int )floor( 0.5 + ( temp_biomass / ( 1 + m_veg_height ) ) );
  if ( m_veg_density > 100 ) m_veg_density = 100; // to stop array bounds problems
  double temp_bugmass = g_bug_percent_d[ m_vege_type ] * g_bug_percent_a[ m_vege_type ]
       + ( ( temp_biomass + m_weed_biomass ) * g_bug_percent_b[ m_vege_type ] )
       + ( m_veg_height * g_bug_percent_c[ m_vege_type ] );
  // Set a minimum value (regressions will otherwise give a -ve value
  if ( temp_bugmass < 0.05 ) temp_bugmass = 0.05;
  m_veg_biomass = m_weed_biomass + ( temp_biomass * 0.9 );
  m_insect_pop = temp_bugmass;
  m_veg_density = ( int )floor( 0.5 + ( m_veg_biomass / ( 1 + m_veg_height ) ) );
  if ( m_veg_density > 100 ) m_veg_density = 100; // to stop array bounds problems
}


RiversideTrees::RiversideTrees( void ) : GreenElement() {
  LE::SetHigh( true );
  m_type = tole_RiversideTrees;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Railway::Railway( void ) : GreenElement() {
  m_type = tole_Railway;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Vildtager::Vildtager(void) : GreenElement()
{
    m_type = tole_Vildtager;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
    m_vege_type = tov_NaturalGrass;
}


PlantNursery::PlantNursery(void) : GreenElement() {
    LE::SetHigh(true);
    m_type = tole_PlantNursery;
    m_vege_type = tov_PlantNursery;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------


ForestElement::ForestElement( void ) : VegElement() {
  LE::SetHigh( true ); // default to tall
}


Copse::Copse( void ) : ForestElement() {
  m_type = tole_Copse;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


DeciduousForest::DeciduousForest( void ) : ForestElement() {
  m_type = tole_DeciduousForest;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


ConiferousForest::ConiferousForest( void ) : ForestElement() {
  m_type = tole_ConiferousForest;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


MixedForest::MixedForest( void ) : ForestElement() {
  m_type = tole_MixedForest;
}

YoungForest::YoungForest( void ) : ForestElement() {
  m_vege_type = tov_NaturalGrass;
  m_curve_num = g_crops->VegTypeToCurveNum( m_vege_type );
  m_type = tole_YoungForest;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_veg_patchy = true;
  LE::SetHigh( false ); // default to tall
}

WoodlandMargin::WoodlandMargin(void) : ForestElement() {
    m_type = tole_WoodlandMargin;
}

IndividualTree::IndividualTree(void) : ForestElement() {
    m_type = tole_IndividualTree;
}

WoodyEnergyCrop::WoodyEnergyCrop(void) : ForestElement() {
    m_type = tole_WoodyEnergyCrop;
}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

NonVegElement::NonVegElement( void ) : LE() {
  ;
}


ChameleonLE::ChameleonLE(void) : NonVegElement() {
    m_type = tole_Chameleon;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Garden::Garden(void) : NonVegElement() {
    LE::SetHigh(true);
    m_type = tole_Garden;
}


Building::Building( void ) : NonVegElement() {
  LE::SetHigh( true );
  m_type = tole_Building;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
  m_countrydesignation = 0; // default = 0 = town
}


StoneWall::StoneWall( void ) : NonVegElement() {
  LE::SetHigh( true );
  m_type = tole_StoneWall;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


PitDisused::PitDisused( void ) : NonVegElement() {
  LE::SetHigh( true );
  m_type = tole_PitDisused;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Saltwater::Saltwater( void ) : NonVegElement() {
  m_type = tole_Saltwater;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Freshwater::Freshwater(void) : NonVegElement() {
    m_type = tole_Freshwater;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


FishFarm::FishFarm(void) : NonVegElement() {
    m_type = tole_FishFarm;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Pond::Pond( void ) : Freshwater() {
    m_type = tole_Pond;
    SetALMaSSEleType( g_letype->BackTranslateEleTypes( m_type ) );
    m_LarvalFood = 0.01;
    m_MaleNewtPresent = false;
}

void Pond::DoDevelopment()
{
    LE::DoDevelopment();
    CalcPondPesticide();
    CalcLarvalFood();
    m_MaleNewtPresent = false;
}

void Pond::CalcPondPesticide()
{
    m_pondpesticide = 0.0;
    if (!cfg_calc_pond_pesticide.value())
    {
        return;
    }
    for (int x = m_minx; x <= m_maxx; x++)
    for (int y = m_miny; y <= m_maxy; y++)
    {
        if (g_landscape_p->SupplyPolyRef(x, y) == m_poly) m_pondpesticide += g_landscape_p->SupplyPesticide(x, y);
    }
    m_pondpesticide /= m_area;
    m_pondpesticide *= cfg_pondpesticiderunoff.value()/1000.0;
}

void Pond::CalcLarvalFood()
{
    double area = m_area;
    if (m_area > 400) area = 400;
    const double LarvalFoodMonthlyK[12] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
    // Back calculate the scaler
    if (m_LarvalFood < 0.01) m_LarvalFood = 0.01;
    m_LarvalFoodScaler = m_LarvalFood / (cfg_PondLarvalFoodBiomassConst.value() * area);
    // Calculate the new scaler
    m_LarvalFoodScaler = m_LarvalFoodScaler + (m_LarvalFoodScaler*cfg_PondLarvalFoodR.value() * (1 - (m_LarvalFoodScaler / LarvalFoodMonthlyK[g_date->GetMonth() - 1])));
    // Calculate the new food biomass
    m_LarvalFood = m_LarvalFoodScaler * (cfg_PondLarvalFoodBiomassConst.value() * area);
}

bool Pond::SubtractLarvalFood(double a_food)
{
    if (g_rand_uni() > m_LarvalFoodScaler * 2) return false;
    else 
    {
        m_LarvalFood -= a_food;
        return true;
    }
}

River::River( void ) : NonVegElement() {
  m_type = tole_River;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Coast::Coast( void ) : NonVegElement() {
  m_type = tole_Coast;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


BareRock::BareRock( void ) : NonVegElement() {
  m_type = tole_BareRock;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


SandDune::SandDune( void ) : NonVegElement() {
  m_type = tole_SandDune;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


AmenityGrass::AmenityGrass( void ) : NonVegElement() {
  m_type = tole_AmenityGrass;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


Parkland::Parkland( void ) : NonVegElement() {
  m_type = tole_Parkland;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


UrbanNoVeg::UrbanNoVeg( void ) : NonVegElement() {
  LE::SetHigh( true );
  m_type = tole_UrbanNoVeg;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


UrbanPark::UrbanPark( void ) : NonVegElement() {
  m_type = tole_UrbanPark;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


BuiltUpWithParkland::BuiltUpWithParkland( void ) : NonVegElement() {
  LE::SetHigh( true );
  m_type = tole_BuiltUpWithParkland;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


ActivePit::ActivePit( void ) : NonVegElement() {
  LE::SetHigh( true );
  m_type = tole_ActivePit;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


LargeRoad::LargeRoad( void ) : NonVegElement() {
  m_type = tole_LargeRoad;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


double LargeRoad::GetTrafficLoad( void ) {
  return m_largeroad_load[ g_date->GetHour() ] * m_monthly_traffic[ g_date->GetMonth() - 1 ];
}


SmallRoad::SmallRoad( void ) : NonVegElement() {
  m_type = tole_SmallRoad;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


double SmallRoad::GetTrafficLoad( void ) {
  return m_smallroad_load[ g_date->GetHour() ] * m_monthly_traffic[ g_date->GetMonth() - 1 ];
}


Track::Track( void ) : NonVegElement() {
  m_type = tole_Track;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Stream::Stream( void ) : NonVegElement() {
  m_type = tole_Stream;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Churchyard::Churchyard( void ) : NonVegElement() {
  m_type = tole_Churchyard;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Carpark::Carpark( void ) : NonVegElement() {
  m_type = tole_Carpark;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

HeritageSite::HeritageSite( void ) : NonVegElement() {
  m_type = tole_HeritageSite;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

MetalledPath::MetalledPath( void ) : NonVegElement() {
  m_type = tole_MetalledPath;
  SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}

Pylon::Pylon(void) : NonVegElement() {
    LE::SetHigh(true);
    m_type = tole_Pylon;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}


WindTurbine::WindTurbine(void) : NonVegElement() {
    LE::SetHigh(true);
    m_type = tole_Pylon;
    SetALMaSSEleType(g_letype->BackTranslateEleTypes(m_type));
}





//--------------------------------------------------------------------
// created 25/08/00
TTypesOfLandscapeElement LE_TypeClass::TranslateEleTypes( int EleReference ) {
  static char error_num[ 20 ];

  // This returns the vegetation type (or crop type) as applicable
  switch ( EleReference ) {
    case 5:     return tole_Building;
    case 6:
    case 8: // Rural residential
    case 10:    return tole_UrbanNoVeg;
    case 11:    return tole_Garden;
    case 12:    return tole_AmenityGrass;
    case 13:    return tole_RoadsideVerge;
    case 14:    return tole_Parkland;
    case 15:    return tole_StoneWall;
    case 16:    return tole_BuiltUpWithParkland;
    case 17:    return tole_UrbanPark;
    case 20:    return tole_Field;
    case 26:    return tole_PermPastureLowYield;
    case 27:    return tole_PermPastureTussocky;
    case 30:    return tole_Field;
    case 31:    return tole_UnsprayedFieldMargin;
    case 33:    return tole_PermanentSetaside;
    case 35:    return tole_PermPasture;
    case 40:    return tole_DeciduousForest;
    case 41:    return tole_Copse;
    case 50:    return tole_ConiferousForest;
    case 55:    return tole_YoungForest;
    case 56:    return tole_Orchard;
    case 57:    return tole_OrchardBand;
    case 58:    return tole_MownGrass;
    case 69:    return tole_BareRock;
    case 60:    return tole_MixedForest;
    case 70:    return tole_Scrub;
    case 71:    return tole_PlantNursery; 
    case 75:    return tole_PitDisused;
    case 80:    return tole_Saltwater;
    case 90:    return tole_Freshwater;
    case 94:    return tole_Heath;
    case 95:    return tole_Marsh;
    case 99://  This is stream less than 2m
    case 96:    return tole_River;
    case 97:    return tole_RiversideTrees;
    case 98:    return tole_RiversidePlants;
    case 100:   return tole_Coast;
    case 101:   return tole_SandDune;
    case 110:   return tole_NaturalGrassDry;
    case 115:   return tole_ActivePit;
    case 118:   return tole_Railway;
    case 120:
    case 121:   return tole_LargeRoad;
    case 122:   return tole_SmallRoad;
    case 123:   return tole_Track;
    case 130:   return tole_Hedges;
    case 140:   return tole_HedgeBank;
    case 141:   return tole_BeetleBank;
    case 150:   return tole_Chameleon;
    case 160:   return tole_FieldBoundary;
    case 201:   return tole_RoadsideSlope;
    case 202:   return tole_MetalledPath;
    case 203:   return tole_Carpark;
    case 204:   return tole_Churchyard;
    case 205:   return tole_NaturalGrassWet;
    case 206:   return tole_Saltmarsh;
    case 207:   return tole_Stream;
    case 208:   return tole_HeritageSite;
    case 209:   return tole_Wasteland;
    case 210:   return tole_NaturalGrassDry;
    case 211:   return tole_WindTurbine;
    case 212:   return tole_IndividualTree; // TODO This is a windmill
    case 214:   return tole_PlantNursery;
    case 213:   return tole_IndividualTree;
    case 215:   return tole_Vildtager;
    case 216:   return tole_WoodyEnergyCrop;
    case 217:   return tole_WoodlandMargin;
    case 218:   return tole_PermPastureTussockyWet;
    case 219:   return tole_Pond;
    case 220:   return tole_FishFarm;
    case 6000:
    case 2112: 
    case 2300: 
    case 2430: return tole_Missing;

      //  case 999: return tole_Foobar;
      // !! type unknown - should not happen
    default:
      sprintf( error_num, "%d", EleReference );
      g_msg->Warn( WARN_FILE, "LE_TypeClass::TranslateEleTypes(): ""Unknown landscape element type:", error_num );
      exit( 1 );
  }
}



//----------------------------------------------------------------------
// created 24/08/00
TTypesOfVegetation LE_TypeClass::TranslateVegTypes( int VegReference ) {
  char error_num[ 20 ];

  // This returns the vegetation type (or crop type) as applicable
  switch ( VegReference ) {
    case 1:
      return tov_SpringBarley;
    case 2:
      return tov_WinterBarley;
    case 3:
      return tov_SpringWheat;
    case 4:
      return tov_WinterWheat;
    case 5:
      return tov_WinterRye;
    case 6:
      return tov_Oats;
    case 7:
      return tov_Triticale;
    case 8:
      return tov_Maize;
    case 13:
      return tov_SpringBarleySeed;
    case 14: return tov_SpringBarleyStrigling;
    case 15: return tov_SpringBarleyStriglingSingle;
    case 16: return tov_SpringBarleyStriglingCulm;
    case 17: return tov_WinterWheatStrigling;
    case 18: return tov_WinterWheatStriglingSingle;
    case 19: return tov_WinterWheatStriglingCulm;
    case 21:
      return tov_SpringRape;
    case 22:
      return tov_WinterRape;
    case 30:
      return tov_FieldPeas;
    case 31:
        return tov_FieldPeasSilage; //ok?
    case 32:
        return tov_BroadBeans;
    case 50:
      return tov_Setaside;
    case 54:
      return tov_PermanentSetaside;
    case 55:
      return tov_YoungForest;
    case 60:
        return tov_FodderBeet;
    case 61:
        return tov_SugarBeet;
    case 65:
      return tov_CloverGrassGrazed1;
    case 92:
      return tov_PotatoesIndustry;
    case 93:
      return tov_Potatoes;
    case 94:
      return tov_SeedGrass1;
    case 102:
      return tov_OWinterBarley;
    case 611:
      return tov_OWinterBarleyExt;
    case 103:
      return tov_OSBarleySilage;
    case 105:
      return tov_OWinterRye;
    case 106:
      return tov_OFieldPeasSilage;
    case 107:
      return tov_SpringBarleyGrass;
    case 108:
        return tov_SpringBarleyCloverGrass;
    case 109:
        return tov_SpringBarleySpr;
    case 113:
      return tov_OBarleyPeaCloverGrass;
    case 114:
      return tov_SpringBarleyPeaCloverGrassStrigling;
    case 115:
      return tov_SpringBarleySilage;
    case 122:
      return tov_OWinterRape;
    case 140:
      return tov_PermanentGrassGrazed;
    case 141:
      return tov_PermanentGrassLowYield;
    case 142:
      return tov_PermanentGrassTussocky;
    case 165:
      return tov_CloverGrassGrazed2;
    case 194:
      return tov_SeedGrass2;
    case 201:
      return tov_OSpringBarley;
    case 204:
        return tov_OWinterWheatUndersown;
    case 205:
        return tov_OWinterWheat;
    case 206:
      return tov_OOats;
    case 207:
      return tov_OTriticale;
    case 230:
        return tov_OFieldPeas;
    case 26:
        return tov_OFodderBeet;
    case 265:
      return tov_OCloverGrassGrazed1;
    case 270:
      return tov_OCarrots;
    case 271:
      return tov_Carrots;
    case 273:
      return tov_OGrazingPigs;
    case 293:
      return tov_OPotatoes;
    case 294:
      return tov_OSeedGrass1;
    case 306:
        return tov_OSpringBarleyPigs;
    case 307:
      return tov_OSpringBarleyGrass;
    case 308:
      return tov_OSpringBarleyClover;
    case 340:
      return tov_OPermanentGrassGrazed;
    case 365:
      return tov_OCloverGrassGrazed2;
    case 366:
        return tov_OCloverGrassSilage1;
    case 394:
      return tov_OSeedGrass2;
    case 400:
      return tov_NaturalGrass;
    case 401:
      return tov_None;
    case 601:
      return tov_WWheatPControl;
    case 602:
      return tov_WWheatPToxicControl;
    case 603:
      return tov_WWheatPTreatment;
    case 604:
      return tov_AgroChemIndustryCereal;
    case 605:
      return tov_WinterWheatShort;
    case 606:
      return tov_MaizeSilage;
    case 607:
        return tov_FodderGrass;
    case 608:
        return tov_SpringBarleyPTreatment;
    case 609:
      return tov_OSpringBarleyExt;
    case 610:
      return tov_OMaizeSilage;
    case 612:
        return tov_SpringBarleySKManagement;
    case 613:
        return tov_Heath;
    case 700:
      return tov_OrchardCrop;
    case 999:
      return tov_Undefined;
    default: // No matching code so we need an error message of some kind
      sprintf( error_num, "%d", VegReference );
      g_msg->Warn( WARN_FILE, "LE_TypeClass::TranslateVegTypes(): ""Unknown vegetation type:", error_num );
      exit( 1 );
  }
}

//-----------------------------------------------------------------------
// created 25/08/00
int LE_TypeClass::BackTranslateVegTypes( TTypesOfVegetation VegReference ) {
  char error_num[ 20 ];

  // This returns the vegetation type (or crop type) as applicable
  switch ( VegReference ) {
    case tov_SpringBarley:
      return 1;
    case tov_WinterBarley:
      return 2;
    case tov_SpringWheat:
      return 3;
    case tov_WinterWheat:
      return 4;
    case tov_WinterRye:
      return 5;
    case tov_Oats:
      return 6;
    case tov_Triticale:
      return 7;
    case tov_Maize:
      return 8;
    case tov_SpringBarleySeed:
      return 13;
    case tov_SpringBarleyStrigling:
      return 14;
    case tov_SpringBarleyStriglingSingle:
      return 15;
    case tov_SpringBarleyStriglingCulm:
      return 16;
    case tov_WinterWheatStrigling:
        return 17;
    case tov_WinterWheatStriglingSingle:
        return 18;
    case tov_WinterWheatStriglingCulm:
        return 19;
    case tov_SpringRape:
      return 21;
    case tov_WinterRape:
      return 22;
    case tov_FieldPeas:
      return 30;
    case tov_FieldPeasSilage:
        return 31;
    case tov_BroadBeans:
        return 32;
    case tov_Setaside:
      return 50;
    case tov_PermanentSetaside:
      return 54;
    case tov_YoungForest:
      return 55;
    case tov_FodderBeet:
        return 60;
    case tov_SugarBeet:
        return 61;
    case tov_CloverGrassGrazed1:
      return 65;
    case tov_PotatoesIndustry:
      return 92;
    case tov_Potatoes:
      return 93;
    case tov_SeedGrass1:
      return 94;
    case tov_OWinterBarley:
      return 102;
    case tov_OWinterBarleyExt:
      return 611;
    case tov_OWinterRye:
      return 105;
    case tov_SpringBarleyGrass:
      return 107;
    case tov_SpringBarleyCloverGrass:
      return 108;
    case tov_SpringBarleySpr:
        return 109;
    case tov_OSBarleySilage:
        return 103;
    case tov_OBarleyPeaCloverGrass:
      return 113;
    case tov_SpringBarleyPeaCloverGrassStrigling:
      return 114;
    case tov_SpringBarleySilage:
      return 115;
    case tov_OWinterRape:
      return 122;
    case tov_PermanentGrassGrazed:
      return 140;
    case tov_PermanentGrassLowYield:
      return 141;
    case tov_PermanentGrassTussocky:
      return 142;
    case tov_CloverGrassGrazed2:
      return 165;
    case tov_SeedGrass2:
      return 194;
    case tov_OSpringBarley:
      return 201;
    case tov_OWinterWheatUndersown:
        return 204;
    case tov_OWinterWheat:
        return 205;
    case tov_OOats:
      return 206;
    case tov_OTriticale:
      return 207;
    case tov_OFieldPeas:
      return 230;
    case tov_OFieldPeasSilage:
      return 106;
    case tov_OFodderBeet:
        return 260;
    case tov_OCloverGrassGrazed1:
      return 265;
    case tov_OCarrots:
      return 270;
    case tov_Carrots:
      return 271;
    case tov_OPotatoes:
      return 293;
    case tov_OSeedGrass1:
      return 294;
    case tov_OSpringBarleyPigs:
      return 306;
    case tov_OSpringBarleyGrass:
      return 307;
    case tov_OSpringBarleyClover:
      return 308;
    case tov_OPermanentGrassGrazed:
      return 340;
    case tov_OCloverGrassGrazed2:
      return 365;
    case tov_OCloverGrassSilage1:
        return 366;
    case tov_OSeedGrass2:
      return 394;
    case tov_NaturalGrass:
      return 400;
    case tov_None:
      return 401;
    case tov_NoGrowth:
      return 402;
    case tov_WWheatPControl:
      return 601;
    case tov_WWheatPToxicControl:
      return 602;
    case tov_WWheatPTreatment:
      return 603;
    case tov_AgroChemIndustryCereal:
      return 604;
    case tov_WinterWheatShort:
      return 605;
    case tov_MaizeSilage:
      return 606;
    case tov_FodderGrass:
        return 607;
    case tov_SpringBarleyPTreatment:
      return 608;
    case tov_OSpringBarleyExt:
      return 609;
    case tov_OMaizeSilage:
      return 610;
    case tov_SpringBarleySKManagement:
        return 612;
    case tov_Heath:
        return 613;
    case tov_OrchardCrop:
      return 700;
    case tov_Undefined:
      return 999;
    default: // No matching code so we need an error message of some kind
      sprintf( error_num, "%d", VegReference );
      g_msg->Warn( WARN_FILE, "LE_TypeClass::BackTranslateVegTypes(): ""Unknown vegetation type:", error_num );
      exit( 1 );
  }
}

//-----------------------------------------------------------------------
// created 25/08/00
int LE_TypeClass::BackTranslateEleTypes( TTypesOfLandscapeElement EleReference ) {
  static char error_num[ 20 ];

  // This returns the vegetation type (or crop type) as applicable
  switch ( EleReference )
  {
    case tole_Building:             return 5;
    case tole_UrbanNoVeg:           return 6;
    case tole_Garden:               return 11;
    case tole_AmenityGrass:         return 12;
    case tole_RoadsideVerge:        return 13;
    case tole_Parkland:             return 14;
    case tole_StoneWall:            return 15;
    case tole_BuiltUpWithParkland:  return 16;
    case tole_UrbanPark:            return 17;
    case tole_Field:                return 20;
    case tole_PermPastureTussocky:  return 27;
    case tole_PermPastureLowYield:  return 26;
    case tole_UnsprayedFieldMargin: return 31;
    case tole_PermanentSetaside:    return 35;
    case tole_PermPasture:          return 35;
    case tole_DeciduousForest:      return 40;
    case tole_Copse:                return 41;
    case tole_ConiferousForest:     return 50;
    case tole_YoungForest:          return 55;
    case tole_Orchard:              return 56;
    case tole_BareRock:             return 69;
    case tole_OrchardBand:          return 57;
    case tole_MownGrass:            return 58;
    case tole_MixedForest:          return 60;
    case tole_Scrub:                return 70;
    case tole_PitDisused:           return 75;
    case tole_Saltwater:            return 80;
    case tole_Freshwater:           return 90;
    case tole_Heath:                return 94;
    case tole_Marsh:                return 95;
    case tole_River:                return 96;
    case tole_RiversideTrees:       return 97;
    case tole_RiversidePlants:      return 98;
    case tole_Coast:                return 100;
    case tole_SandDune:             return 101;
    case tole_NaturalGrassDry:      return 110;
    case tole_ActivePit:            return 115;
    case tole_Railway:              return 118;
    case tole_LargeRoad:            return 121;
    case tole_SmallRoad:            return 122;
    case tole_Track:                return 123;
    case tole_Hedges:               return 130;
    case tole_HedgeBank:            return 140;
    case tole_BeetleBank:           return 141;
    case tole_Chameleon:            return 150;
    case tole_FieldBoundary:        return 160;
    case tole_RoadsideSlope:        return 201;
    case tole_MetalledPath:         return 202;
    case tole_Carpark:              return 203;
    case tole_Churchyard:           return 204;
    case tole_NaturalGrassWet:      return 205;
    case tole_Saltmarsh:            return 206;
    case tole_Stream:               return 207;
    case tole_HeritageSite:         return 208;
    case tole_Wasteland:            return 209; 
    //case tole_NaturalGrassDry:        return 210; This is a place holder for overdrev
    case tole_WindTurbine:          return 211;
    case tole_Pylon:                return 212;
    case tole_IndividualTree:       return 213;
    case tole_PlantNursery:         return 214;
    case tole_Vildtager:            return 215;
    case tole_WoodyEnergyCrop:      return 216;
    case tole_WoodlandMargin:       return 217;
    case tole_PermPastureTussockyWet:       return 218;
    case tole_Pond:                 return 219;
    case tole_FishFarm:                 return 220;
    case tole_Missing:      return 2112;

    //case tole_Foobar: return 999;
    // !! type unknown - should not happen
    default:
      sprintf( error_num, "%d", EleReference );
      g_msg->Warn( WARN_FILE, "LE_TypeClass::BackTranslateEleTypes(): ""Unknown vegetation type:", error_num );
      exit( 1 );
  }
}

//------------------------------------------------------------------------

void HedgeBank::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  m_insect_pop = m_insect_pop * 3.0;
}

void BeetleBank::DoDevelopment( void ) {
  VegElement::DoDevelopment();
  m_insect_pop = m_insect_pop * cfg_beetlebankinsectscaler.value()*3.0;
}