Vole_all.cpp

Go to the documentation of this file.

 
/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, Aarhus University
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
 
#include <iostream>
#include <fstream>
#include "../Landscape/ls.h"
#include "../BatchALMaSS/PopulationManager.h"
#include "../BatchALMaSS/BinaryMapBase.h"
#include "../BatchALMaSS/MovementMap.h"
#include "../Vole/vole_all.h"
#include "../Vole/VolePopulationManager.h"
#include "../Vole/GeneticMaterial.h"
#include "../Vole/Predators.h"
#include "../BatchALMaSS/BoostRandomGenerators.h"
 
extern boost::variate_generator<base_generator_type&, boost::uniform_real<> > g_rand_uni;
extern CfgBool cfg_RecordVoleMort;
extern CfgFloat l_pest_daily_mort;
extern const int Vector_x[8];
extern const int Vector_y[8];
 
 
#ifdef __VOLEPESTICIDEON
int Vole_Female::m_EndoCrineDisruptionGestationLength = 5; // Default value - will be altered by Vole_Female constructor
#endif
 
CfgFloat cfg_extradispmort("VOLEDISPMORT",CFG_CUSTOM,0.055);
CfgFloat cfg_VoleResourceRegrowth("VOLE_RESOURCEREGROWTH",CFG_CUSTOM, 0.5);
 
static CfgFloat cfg_volepcidebiodegredrate("VOLE_PCIDE_BIODEGREDATIONRATE",CFG_CUSTOM, 0.0 ); // 1.0 = no degradation, 0 = 100%
static CfgFloat cfg_InfanticideRangeRelToTerRange("VOLE_IINFANTICIDERANGE_RELTO_TERRANGE",CFG_CUSTOM,0.5);
static CfgBool cfg_VoleMortalityDataUsed("VOLE_MORTALITY_DATA_USED",CFG_CUSTOM, false);
static CfgInt cfg_VoleEndoCrineDisruptionGestationLength("VOLE_ENDOCRINEDISPRUPTORGESTATION", CFG_CUSTOM,21);
static CfgFloat cfg_InfanticideProbability("INFANTI_PROBA",CFG_CUSTOM,0.01);
static CfgFloat cfg_vole_habqualscaler("VOLE_HABQUALSCALER",CFG_CUSTOM,2.1);
CfgInt cfg_MinFemaleTerritorySize("VOLE_MINFEMALETERRITORYSIZE",CFG_CUSTOM,8);
static CfgInt cfg_MaxFemaleTerrSize("VOLE_MAXFEMALETERRITORYSIZE",CFG_CUSTOM,8);
CfgInt cfg_MinMaleTerritorySize("VOLE_MINMALETERRITORYSIZE",CFG_CUSTOM,9);
static CfgInt cfg_MaxMaleTerrSize("VOLE_MAXMALETERRITORYSIZE",CFG_CUSTOM,23);
static CfgInt cfg_vole_LifeMonths("VOLE_LIFEMONTHS",CFG_CUSTOM,3);
 
static CfgInt cfg_MaxStarvationDays("VOLE_MAXSTARVATIONDAYS",CFG_CUSTOM,29);
extern double MoveToLessFavourable;
extern double g_SpeedyDivides[2001];
extern CfgInt cfg_productapplicstartyear;
static CfgFloat cfg_PesticideAccumulationThreshold("VOLE_PESTICDEACCUMULATIONTHRESHOLD",CFG_CUSTOM,20.0); //mg/kg
static CfgFloat cfg_PesticideAccumulationThresholdModelink2("VOLE_PESTICDEACCUMULATIONTHRESHOLD_MODELINKTWO",CFG_CUSTOM,20.0); //mg/kg
static CfgFloat cfg_PesticideAccumulationThreshold2("VOLE_PESTICDEACCUMULATIONTHRESHOLDTWO",CFG_CUSTOM,44.1); //mg/kg
static CfgFloat cfg_PesticideFemaleMaturityDelay("VOLE_PCIDE_FEMALEMATURITYDELAY",CFG_CUSTOM,0.0192);
static CfgFloat cfg_PesticideLitterSizeReduction("VOLE_PCIDE_LITTERSIZEREDUCTION",CFG_CUSTOM,0.0038);
static CfgFloat cfg_PesticideWeaningReduction("VOLE_PCIDE_WEANINGREDUCTION",CFG_CUSTOM,0.0017);
CfgBool cfg_ResistanceDominant("VOLE_RESISTANCEDOMINANT",CFG_CUSTOM,false);
 
 
extern CfgInt cfg_productapplicendyear;
extern CfgBool cfg_ReallyBigOutputMonthly_used;
extern CfgBool cfg_RipleysOutput_used;
extern CfgBool cfg_AOROutput_used;
extern CfgBool l_pest_enable_pesticide_engine;
extern CfgBool cfg_pest_residue_or_rate; // true if residue, otherwise it is rate per m2
CfgInt cfg_VoleDDepConst("VOLE_DDEPCONST",CFG_CUSTOM,4);
CfgInt cfg_MinReproAgeM("VOLE_MINREPROAGEM",CFG_CUSTOM,30);
CfgInt cfg_MinReproAgeF("VOLE_MINREPROAGEF",CFG_CUSTOM,23);
 
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
// Constants
//---------------------------------------------------------------------------
 
 
const int FemNoMature = September;
//const double MaturationChance [5] = {0.020,0.100,0.200,0.500,1.000};
const unsigned TheGestationPeriod = 21;
const unsigned WeanedAge = 13;
// Growth curve data for weight of voles
const int WeanedWeight=5;
const double MaxWeightM=60; // is 'double' to make MaleTerritoryRangeSlope a double
const double MaxWeightF=55; // is 'double' to make FemaleTerritoryRangeSlope a double
const double DaysAtMaxGrowth=90.0;
const double growthperdayM=(MaxWeightM-WeanedWeight)/DaysAtMaxGrowth;
const double growthperdayF=(MaxWeightF-WeanedWeight)/DaysAtMaxGrowth;
const int GrowStopDate = August;
int MinReproAgeM;
int MinReproAgeF;
const unsigned MinReproWeightM=40; //The smallest a male can be reproductive at.
const int MinReproWeightF=20; //The smallest a female can be reproductive at.
int g_sigAgeDiff = 30;
const double FemaleResourceReq [13]=
                  {
                  0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0,
                  1.0
                  };
 
const unsigned FemaleMovement  = 50;    //50
const unsigned MinFemaleMovement = 5;
const unsigned VoleMoveInterval = 30; // will have max movement after 120 days
const unsigned MaleMovement [4] = {10,40,70,110};
const unsigned MinMaleMovement  = 5;
int g_MaleReproductFinish = 0;
const double InfanticideChanceByAge[9]= {0.97,0.86,0.75,0.64,0.54,0.43,0.32,0.21,0.11};
 
// Mortality Data TODO - make these config variables
double g_DailyMortChance = 0.003;
double g_DailyMortChanceMaleTerr = 0.003;
const double VoleHarvestMort=0.20;
const double VoleStriglingMort=0.50;
const double VoleSoilCultivationMort=0.75;
const double VolePigGrazingMort=0.25;
const double VoleHerbicicideMort = 0.0;
const double VoleInsecticideMort = 0.0;
 
double g_extradispmort;
double g_NoFemalesMove = 0.01;
//---------------------------------------------------------------------------
//                          Vole_Base
//---------------------------------------------------------------------------
 
    unsigned int Vole_Base::m_MaxMaleTerritorySize = 0;
    unsigned int Vole_Base::m_MaxFemaleTerritorySize = 0;
    unsigned int Vole_Base::m_MinMaleTerritorySize = 0;
    unsigned int Vole_Base::m_MinFemaleTerritorySize = 0;
    double Vole_Base::m_MinFVoleHabQual = 0;
    double Vole_Base::m_MinJMVoleHabQual = 0;
    double Vole_Base::m_MinMVoleHabQual = 0;
    double Vole_Base::m_MaleTerritoryRangeSlope = 0;
    double Vole_Base::m_FemaleTerritoryRangeSlope = 0;
    bool Vole_Base::m_BreedingSeason = false;
#ifdef __VoleStarvationDays
    int Vole_Base::m_MaxStarvationDays = 21;
#endif
 
    Vole_Base::Vole_Base(struct_Vole_Adult * p_aVoleStruct) : TAnimal(p_aVoleStruct->x, p_aVoleStruct->y, p_aVoleStruct->L)
    {
        Init(p_aVoleStruct);
    }
    //---------------------------------------------------------------------------
 
 
    void Vole_Base::ReInit(struct_Vole_Adult * p_aVoleStruct) {
        Init(p_aVoleStruct);
    }
    //---------------------------------------------------------------------------
 
    void Vole_Base::Init(struct_Vole_Adult * p_aVoleStruct)
    {
        m_Location_x = p_aVoleStruct->x;
        m_Location_y = p_aVoleStruct->y;
        m_OurLandscape = p_aVoleStruct->L;
        m_CurrentStateNo = 0;
        m_OurPopulation = p_aVoleStruct->VPM;
        m_Mature = false;
        m_Age = 0;
        m_Weight = 0.5;
        m_NoOfYoungTotal = 0;
        m_DispVector = -1;
        m_Have_Territory = false;
        m_TerrRange = 0;  // The size of the territory
        m_MinTerrRange = 0;
        m_Reserves = 3;
        m_LifeSpan = (365 + 60) + int(g_rand_uni()*(30 * cfg_vole_LifeMonths.value())); //
        CurrentVState = tovs_InitialState;
        m_intrappos.m_inAtrap = false;
        m_BornLastYear = false;
 
        m_MyGenes = p_aVoleStruct->Genes;
        SimH = m_OurPopulation->SimH;
        SimW = m_OurPopulation->SimW;
        IDNo = m_OurPopulation->IDNumber++;
 
        unsigned FatherIdNo = p_aVoleStruct->FatherId;
        Set_FatherId(FatherIdNo);
        unsigned MotherIdNo = p_aVoleStruct->MotherId;
        Set_MotherId(MotherIdNo);
        Set_XBorn(m_Location_x);
        Set_YBorn(m_Location_y);
        Set_PolyRefBorn(m_Location_x, m_Location_y);
        Set_VegBorn(m_Location_x, m_Location_y);
        Set_ElemBorn(m_Location_x, m_Location_y);
        Set_BirthYear(p_aVoleStruct->BirthYear);
 
        m_MinMaleTerritorySize = cfg_MinMaleTerritorySize.value();
        m_MaxMaleTerritorySize = cfg_MaxMaleTerrSize.value();
        if (m_MaxMaleTerritorySize < m_MinMaleTerritorySize) m_MaxMaleTerritorySize = m_MinMaleTerritorySize; // Corrects a bug caused by incorrect input settings
        m_MinFemaleTerritorySize = cfg_MinFemaleTerritorySize.value();
        m_MaxFemaleTerritorySize = cfg_MaxFemaleTerrSize.value();
        if (m_MaxFemaleTerritorySize < m_MinFemaleTerritorySize) m_MaxFemaleTerritorySize = m_MinFemaleTerritorySize; // Corrects a bug caused by incorrect input settings
        m_MinFVoleHabQual = cfg_vole_habqualscaler.value() * (4 * m_MinFemaleTerritorySize * m_MinFemaleTerritorySize);
        m_MinMVoleHabQual = cfg_vole_habqualscaler.value() * (4 * m_MinMaleTerritorySize * m_MinMaleTerritorySize);
        m_MinJMVoleHabQual = cfg_vole_habqualscaler.value() * (4 * m_MinFemaleTerritorySize * m_MinFemaleTerritorySize); // Yes this should be female
        m_MaleTerritoryRangeSlope = (m_MaxMaleTerritorySize - m_MinMaleTerritorySize) / (MaxWeightM - MinReproWeightM);
        m_FemaleTerritoryRangeSlope = (m_MaxFemaleTerritorySize - m_MinFemaleTerritorySize) / (MaxWeightF - MinReproWeightF);
#ifdef __VoleStarvationDays
        m_StarvationDays = 0;
        m_MaxStarvationDays = cfg_MaxStarvationDays.value();
#endif
#ifdef __VOLEPESTICIDEON
        ClearPesticidLoad();
        m_pesticideBioDegradeRate = cfg_volepcidebiodegredrate.value();
        SetPesticideInfluenced1(false);
        SetPesticideInfluenced2(false);
        m_pesticideInfluenced3 = 0.0;
#endif
        m_fertile = true;
    }
//---------------------------------------------------------------------------
 
 
Vole_Base::~Vole_Base()
{
}
//---------------------------------------------------------------------------
void Vole_Base::CopyMyself(VoleObject a_vtype) {
      struct_Vole_Adult* av;
      av = new struct_Vole_Adult;
      av->VPM = m_OurPopulation;
      av->L = m_OurLandscape;
      av->m_flag=true; // Used to signal pesticide effect to CreateObjects
      av->PolyRefBorn = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
      av->ElemBorn = m_OurLandscape->SupplyElementType(av->PolyRefBorn);
      av->VegBorn = m_OurLandscape->SupplyVegType(m_Location_x, m_Location_y);
      av->x = ((m_Location_x+1)%m_OurPopulation->SimW);
      av->y = ((m_Location_y)%m_OurPopulation->SimH);
      // Do the genetics
      av->Genes.Recombine(&m_MyGenes,&m_MyGenes);
      m_OurPopulation->CreateObjects(a_vtype,this,av,1);
      // object will be destroyed by death state
      // but must let Dad know anyway
      delete av;
}
//-----------------------------------------------------------------------------
void Vole_Base::EndStep()
{
    m_Age++; // Once a day increment m_Age
}
//---------------------------------------------------------------------------
void Vole_Base::st_Dying()
{
   FreeLocation();
   m_CurrentStateNo=-1;
}
//---------------------------------------------------------------------------
 
bool Vole_Base::MortalityTest()
{
    // returns true if the vole should die
    if (g_rand_uni() < g_DailyMortChance) {
        return true;
    }
    // returns true if the vole should die
    return false;
}
//---------------------------------------------------------------------------
 
double Vole_Base::CalculateCarryingCapacity (int p_x, int p_y, int a_ddep )
{
  int NoPolygons = 0;
  int PolyRefData[500][2];
  // First convert centre co-rdinates to square co-ordinates
  double quality = 0;
  int x=p_x - m_MinTerrRange;
  if (x<0) x+=SimW;
  int y=p_y - m_MinTerrRange;
  if (y<0) y+=SimH;
  int range_x=m_MinTerrRange+m_MinTerrRange;
  int range_y=m_MinTerrRange+m_MinTerrRange;
  // Stage 1 make a list of polygons
  // create the extent variables
  int xextent0 = x+range_x;
  int yextent0 = y+range_y;
  int xextent1 = (x+range_x)-SimW;
  int yextent1 = (y+range_y)-SimH;
  // Create the looping variables needed
  int Dfinx=xextent0;
  int Dfiny=yextent0;
  int Afinx=0;  // unless the finx values for A-C are changed
  int Bfinx=0;  // the value of zero will stop the A-C loops from executing
  int Cfinx=0;
  int Afiny=0; // this one assigned 0 to stop compiler complaints
  // Now create the loop values;
  if (x+range_x<=SimW)
  {
    // Type B & D (overlap bottom, no overlap)
    if (yextent0>SimH)
    {
      // Type B (overlap bottom only)
      Dfiny=SimH;
      Bfinx=x+range_x;
    }
  }
  else
  {
    // Type A & C overlap left edge or bottom & left
    if (yextent0>SimH)
    {
      // Type C overlap bottom and left
      Afinx=xextent1;
      Afiny=SimH;
      Bfinx=SimW;
      Cfinx=xextent1;
      Dfinx=SimW;
      Dfiny=SimH;
    }
    else
    {
      // Type A overlap left edge
      Afinx=xextent1;
      Afiny=yextent0;
      Dfinx=SimW;
    }
  }
  // the default is:
  // Type D no overlap
 
 
  // A Loop
  for (int i=0; i<Afinx; i++)
  {
    for (int j=y; j<Afiny; j++)
    {
      // Get the polyref
      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
      // check if we have had this one already
            bool found=false;
            for (int k=0; k<NoPolygons; k++)
            {
                if (PolyRefData[k][0]==PRef)
                {
                  PolyRefData[k][1]++;
                  found = true;
                  break;
                }
            }
            if (!found)
//*/
      {
        // don't have this one so get the height & type to the PolyDatas arrays
        PolyRefData[NoPolygons][0]=PRef;
        PolyRefData[NoPolygons][1]=1;
        NoPolygons++;
      }
    }
  }
  // B Loop
  for (int i=x; i<Bfinx; i++)
  {
    for (int j=0; j<yextent1; j++)
    {
      // Get the polyref
      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
      // check if we have had this one already
/*
    int index=-1;
      for (int k=0; k<NoPolygons; k++)
      {
        if (PolyRefData[k][0]==PRef)
        {
          index=k;
          break;
        }
      }
      if (index!=-1)
      {
        PolyRefData[index][1]++;
      }
      else
*/
            bool found=false;
            for (int k=0; k<NoPolygons; k++)
            {
                if (PolyRefData[k][0]==PRef)
                {
                  PolyRefData[k][1]++;
                  found = true;
                  break;
                }
            }
            if (!found)
//*/
      {
        // don't have this one so get the height & type to the PolyDatas arrays
        PolyRefData[NoPolygons][0]=PRef;
        PolyRefData[NoPolygons][1]=1;
        NoPolygons++;
      }
    }
  }
  // C Loop
  for (int i=0; i<Cfinx; i++)
  {
    for (int j=0; j<yextent1; j++)
    {
      // Get the polyref
      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
      // check if we have had this one already
/*
    int index=-1;
      for (int k=0; k<NoPolygons; k++)
      {
        if (PolyRefData[k][0]==PRef)
        {
          index=k;
          break;
        }
      }
      if (index!=-1)
      {
        PolyRefData[index][1]++;
      }
      else
*/
            bool found=false;
            for (int k=0; k<NoPolygons; k++)
            {
                if (PolyRefData[k][0]==PRef)
                {
                  PolyRefData[k][1]++;
                  found = true;
                  break;
                }
            }
            if (!found)
//*/
      {
        // Don't have this one so get the height & type to the PolyDatas arrays
        PolyRefData[NoPolygons][0]=PRef;
        PolyRefData[NoPolygons][1]=1;
        NoPolygons++;
      }
    }
  }
  // D Loop
  int last=-99999;
  int k_index=-1;
  for (int i=x; i<Dfinx; i++)
  {
    for (int j=y; j<Dfiny; j++)
    {
      // Get the polyref
      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
      // check if we have had this one already
      if (last==PRef)
      {
          PolyRefData[k_index][1]++;
      }
      else
      {
 
            bool found=false;
            for (int k=0; k<NoPolygons; k++)
            {
                if (PolyRefData[k][0]==PRef)
                {
                  PolyRefData[k][1]++;
                  found = true;
                  last = PRef;
                  k_index = k;
                  break;
                }
            }
            if (!found)
            {
                // don't have this one so get the height & type to the PolyDatas arrays
                PolyRefData[NoPolygons][0]=PRef;
                PolyRefData[NoPolygons][1]=1;
                NoPolygons++;
            }
      }
    }
  }
  // End of search algorithm
    /* for each polygon get the quality and multiply by amount of that polygon in the territory sum this to get overall quality */
    for ( int i=0; i<NoPolygons; i++)
    {
       quality+= PolyRefData[i][1]*m_OurPopulation->GetHabitatQuality(PolyRefData[i][0]);
    }
//    return quality;
 
    int Voles = m_OurPopulation->SupplyHowManyVoles(m_Location_x,m_Location_y, m_TerrRange);
    if (Voles > a_ddep) quality /= (Voles-a_ddep);
    // return the total quality
    return quality;
}
//---------------------------------------------------------------------------
 
 
//double Vole_Base::CalculateCarryingCapacity(int p_x, int p_y,
//                                              int & p_stand_x, int & p_stand_y)
//{
//  int NoPolygons = 0;
//  int PolyRefData[200][2];
//  // First convert centre co-rdinates to square co-ordinates
//  double quality = 0;
//  int x=p_x - m_MinTerrRange;
//  if (x<0) x+=SimW;
//  int y=p_y - m_MinTerrRange;
//  if (y<0) y+=SimH;
//  int range_x=m_MinTerrRange+m_MinTerrRange;
//  int range_y=m_MinTerrRange+m_MinTerrRange;
//  // Stage 1 make a list of polygons
//  // create the extent variables
//  int xextent0 = x+range_x;
//  int yextent0 = y+range_y;
//  int xextent1 = (x+range_x)-SimW;
//  int yextent1 = (y+range_y)-SimH;
//  // Create the looping variables needed
//  int Dfinx=xextent0;
//  int Dfiny=yextent0;
//  int Afinx=0;  // unless the finx values for A-C are changed
//  int Bfinx=0;  // the value of zero will stop the A-C loops from executing
//  int Cfinx=0;
//  int Afiny=0; // this one is only assigned as 0 to stop compiler complaints
//  // Now create the loop values;
//  if (x+range_x<=SimW)
//  {
//    // Type B & D (overlap bottom, no overlap)
//    if (yextent0>SimH)
//    {
//      // Type B (overlap bottom only)
//      Dfiny=SimH;
//      Bfinx=x+range_x;
//    }
//  }
//  else
//  {
//    // Type A & C overlap left edge or bottom & left
//    if (yextent0>SimH)
//    {
//      // Type C overlap bottom and left
//      Afinx=xextent1;
//      Afiny=m_OurPopulation->SimH;
//      Bfinx=m_OurPopulation->SimW;
//      Cfinx=xextent1;
//      Dfinx=m_OurPopulation->SimW;
//      Dfiny=m_OurPopulation->SimH;
//    }
//    else
//    {
//      // Type A overlap left edge
//      Afinx=xextent1;
//      Afiny=yextent0;
//      Dfinx=SimW;
//    }
//  }
//  // the default is:
//  // Type D no overlap
//
//
//  // A Loop
//  for (int i=0; i<Afinx; i++)
//  {
//    for (int j=y; j<Afiny; j++)
//    {
//      // Get the polyref
//      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
//      // check if we have had this one already
//      int index=-1;
//      for (int k=0; k<NoPolygons; k++)
//      {
//        if (PolyRefData[k][0]==PRef)
//        {
//          index=k;
//          break;
//        }
//      }
//      if (index!=-1)
//      {
//        PolyRefData[index][1]++;
//      }
//      else
//      {
//        // don't have this one so get the height & type to the PolyDatas arrays
//        PolyRefData[NoPolygons][0]=PRef;
//        PolyRefData[NoPolygons][1]=1;
//        NoPolygons++;
//      }
//    }
//  }
//  // B Loop
//  for (int i=x; i<Bfinx; i++)
//  {
//    for (int j=0; j<yextent1; j++)
//    {
//      // Get the polyref
//      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
//      // check if we have had this one already
//      int index=-1;
//      for (int k=0; k<NoPolygons; k++)
//      {
//        if (PolyRefData[k][0]==PRef)
//        {
//          index=k;
//          break;
//        }
//      }
//      if (index!=-1)
//      {
//        PolyRefData[index][1]++;
//      }
//      else
//      {
//        // don't have this one so get the height & type to the PolyDatas arrays
//        PolyRefData[NoPolygons][0]=PRef;
//        PolyRefData[NoPolygons][1]=1;
//        NoPolygons++;
//      }
//    }
//  }
//  // C Loop
//  for (int i=0; i<Cfinx; i++)
//  {
//    for (int j=0; j<yextent1; j++)
//    {
//      // Get the polyref
//      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
//      // check if we have had this one already
//      int index=-1;
//      for (int k=0; k<NoPolygons; k++)
//      {
//        if (PolyRefData[k][0]==PRef)
//        {
//          index=k;
//          break;
//        }
//      }
//      if (index!=-1)
//      {
//        PolyRefData[index][1]++;
//      }
//      else
//      {
//        // Don't have this one so get the height & type to the PolyDatas arrays
//        PolyRefData[NoPolygons][0]=PRef;
//        PolyRefData[NoPolygons][1]=1;
//        NoPolygons++;
//      }
//    }
//  }
//  // D Loop
//  for (int i=x; i<Dfinx; i++)
//  {
//    for (int j=y; j<Dfiny; j++)
//    {
//      // Get the polyref
//      int PRef = m_OurLandscape->SupplyPolyRefIndex(i,j);
//      // check if we have had this one already
//      int index=-1;
//      for (int k=0; k<NoPolygons; k++)
//      {
//        if (PolyRefData[k][0]==PRef)
//        {
//          index=k;
//          break;
//        }
//      }
//      if (index!=-1)
//      {
//        PolyRefData[index][1]++;
//      }
//      else
//      {
//        // don't have this one so get the height & type to the PolyDatas arrays
//        PolyRefData[NoPolygons][0]=PRef;
//        PolyRefData[NoPolygons][1]=1;
//        NoPolygons++;
//      }
//    }
//  }
//  // End of search algorithm
//    // for each polygon get the quality and multiply by amount of
//    // that polygon in the territory
//    // sum this to get overall quality
//    double bestqual=-2;
//    unsigned found=0;
//    for ( int i=0; i<NoPolygons; i++)
//    {
//      double qual = m_OurPopulation->GetHabitatQuality(PolyRefData[i][0]);
//       if (bestqual<qual)
//       {
//         bestqual=qual;
//         found = i;
//       }
//       quality+=PolyRefData[i][1]*qual;
//    }
//    // now find a location in polygon i
//  // D Loop
//  for (int i=x; i<Dfinx; i++)
//  {
//    for (int j=y; j<Dfiny; j++)
//    {
//      // Get the polyref
//       if (m_OurLandscape->SupplyPolyRefIndex(i,j)==PolyRefData[found][0])
//      {
//        p_stand_x = p_x;
//        p_stand_y = p_y;
//        return quality;
//      }
//    }
//  }
//  // A Loop
//  for (int i=0; i<Afinx; i++)
//  {
//    for (int j=y; j<Afiny; j++)
//    {
//      // Get the polyref
//      if (m_OurLandscape->SupplyPolyRefIndex(i,j)==PolyRefData[found][0])
//      {
//        p_stand_x = p_x;
//        p_stand_y = p_y;
//        return quality;
//      }
//    }
//  }
//  // B Loop
//  for (int i=x; i<Bfinx; i++)
//  {
//    for (int j=0; j<yextent1; j++)
//    {
//      // Get the polyref
//      if (m_OurLandscape->SupplyPolyRefIndex(i,j)==PolyRefData[found][0])
//      {
//        p_stand_x = p_x;
//        p_stand_y = p_y;
//        return quality;
//      }
//    }
//  }
//  // C Loop
//  for (int i=0; i<Cfinx; i++)
//  {
//    for (int j=0; j<yextent1; j++)
//    {
//      if (m_OurLandscape->SupplyPolyRefIndex(i,j)==PolyRefData[found][0])
//      {
//        p_stand_x = p_x;
//        p_stand_y = p_y;
//        return quality;
//      }
//    }
//  }
//  m_OurLandscape->Warn("Vole_Base::CalculateCarryingCapacity - error",NULL);
//  exit(1);
//}
//---------------------------------------------------------------------------
 
void Vole_Base::MoveTo(int p_Vector,int p_Distance, int p_iterations)
{
  int offset=p_Distance*p_iterations;
  if ((m_Location_x-offset < 0) ||(m_Location_x+offset >= SimW) || (m_Location_y-offset < 0) ||(m_Location_y+offset >= SimH))
  {
    // Need correct coords
    // Make sure that the coords can't become -ve
    int vx = m_Location_x+SimW;
    int vy = m_Location_y+SimH;
    do
    {
      DoWalkingCorrect(p_Distance,p_Vector,vx,vy);
      p_Distance=1;
    } while ((GetLocation(vx%SimW,vy%SimH)) && (p_iterations-->0));
    // alter the voles location (& correct coords)
    FreeLocation();
    m_Location_x=vx%SimW;
    m_Location_y=vy%SimH;
    SetLocation();
  }
  else
  {
    // Don't need correct coords
    int vx = m_Location_x;
    int vy = m_Location_y;
    do
    {
      DoWalking(p_Distance,p_Vector,vx,vy);
      p_Distance=1;
    } while ((GetLocation(vx,vy)) && (p_iterations-->0));
    // alter the voles location (& correct coords)
    FreeLocation();
    m_Location_x=vx;
    m_Location_y=vy;
    SetLocation();
  }
}
//---------------------------------------------------------------------------
 
void Vole_Base::DoWalking(int p_Distance,int &p_Vector, int &vx, int &vy)
{
    int t[5], q[5];
    t[0] = p_Vector;
    t[1] = (p_Vector+1) & 0x07;
    t[2] = (p_Vector+7) & 0x07;
    t[3] = (p_Vector+2) & 0x07;
    t[4] = (p_Vector+6) & 0x07;
//*/
    for (int i=0; i<p_Distance; i++)
    {
        // test the squares at Vector, Vector+1+2, Vector-1-2
        // They have either a quality or are inaccessible (water,buildings)
        // if can go to one of these squares then pick the best one
        // if all or some are equal then take a random pick.
        // if all are 'bad' then add or subtract one from vector and try again
 
/*  t[0] = p_Vector;
    t[1] = (p_Vector+1) & 0x07;
    t[2] = (p_Vector+7) & 0x07;
    t[3] = (p_Vector+2) & 0x07;
    t[4] = (p_Vector+6) & 0x07; */
 
        q[0] = MoveQuality((vx+Vector_x[t[0]]),(vy+Vector_y[t[0]]));
        q[1] = MoveQuality((vx+Vector_x[t[1]]),(vy+Vector_y[t[1]]));
        q[2] = MoveQuality((vx+Vector_x[t[2]]),(vy+Vector_y[t[2]]));
        q[3] = MoveQuality((vx+Vector_x[t[3]]),(vy+Vector_y[t[3]]));
        q[4] = MoveQuality((vx+Vector_x[t[4]]),(vy+Vector_y[t[4]]));
        if (g_rand_uni() < MoveToLessFavourable)
        {
          // allow a mistake once in a while
          for (int j=1; j<5; j++) q[j]=-1;
        }
        // Now pick the best of these
        int best = q[0];
        int score=1;
        for (int ii=1; ii<5; ii++)
        {
            if (q[ii]>best)
            {
              best=q[ii];
              score=1;
            }
            else if (q[ii]==best) score++;
        }
        if (best==-1)
        {
            // can't go anywhere so change the vector
            if (random(2)) ++p_Vector; else (--p_Vector);
            p_Vector&=0x07;
            t[0] = p_Vector;
            t[1] = (p_Vector+1) & 0x07;
            t[2] = (p_Vector+7) & 0x07;
            t[3] = (p_Vector+2) & 0x07;
            t[4] = (p_Vector+6) & 0x07;
//*/
        }
        else
        {
            // Can go to one of score squares
            int scored=random(score); // pick one
            int loop=0;
            for (int ii=0; ii<5; ii++)
            {
              if (best==q[ii]) loop++; // count the squares with 'best' quality
              if (loop>scored)
              {
                loop=ii; // go to i-square
                break;
              }
            }
            // change co-ordinates
            vx+=Vector_x[t[loop]];
            vy+=Vector_y[t[loop]];
        }
    }
}
//------------------------------------------------------------------------------
void Vole_Base::DoWalkingCorrect(int p_Distance,int &p_Vector, int &vx, int &vy)
{
    int t[5], q[5];
    t[0] = p_Vector;
    t[1] = (p_Vector+1) & 0x07;
    t[2] = (p_Vector+7) & 0x07;
    t[3] = (p_Vector+2) & 0x07;
    t[4] = (p_Vector+6) & 0x07;
    //*/
    for (int i=0; i<p_Distance; i++)
    {
      // test the squares at Vector, Vector+1+2, Vector-1-2
      // They have either a quality or are inaccessible (water,buildings)
      // if can go to one of these squares then pick the best one
      // if all or some are equal then take a random pick.
      // if all are 'bad' then add or subtract one from vector and try again
     /* t[0] = p_Vector;
      t[1] = (p_Vector+1) & 0x07;
      t[2] = (p_Vector+7) & 0x07;
      t[3] = (p_Vector+2) & 0x07;
      t[4] = (p_Vector+6) & 0x07; */
      q[0] = MoveQuality((vx+Vector_x[t[0]])%SimW, (vy+Vector_y[t[0]])%SimH);
      q[1] = MoveQuality((vx+Vector_x[t[1]])%SimW,(vy+Vector_y[t[1]])%SimH);
      q[2] = MoveQuality((vx+Vector_x[t[2]])%SimW,(vy+Vector_y[t[2]])%SimH);
      q[3] = MoveQuality((vx+Vector_x[t[3]])%SimW,(vy+Vector_y[t[3]])%SimH);
      q[4] = MoveQuality((vx+Vector_x[t[4]])%SimW,(vy+Vector_y[t[4]])%SimH);
      if (g_rand_uni()<MoveToLessFavourable)
      {
        // allow a mistake once in a while
        for (int j=1; j<5; j++) q[j]=-1;
      }
      // Now pick the best of these
      int best = q[0];
      int score=1;
      for (int ii=1; ii<5; ii++)
      {
        if (q[ii]>best)
        {
          best=q[ii];
          score=1;
        }
        else
        if (q[ii]==best) score++;
      }
      if (best==-1)
      {
        // can't go anywhere so change the vector
        if (random(2)) ++p_Vector; else (--p_Vector);
        p_Vector&=0x07;
       // /*
        t[0] = p_Vector;
        t[1] = (p_Vector+1) & 0x07;
        t[2] = (p_Vector+7) & 0x07;
        t[3] = (p_Vector+2) & 0x07;
        t[4] = (p_Vector+6) & 0x07; //*/
      }
      else
      {
        // Can go to one of score squares
        int scored=random(score); // pick one
        int loop=0;
        for (int ii=0; ii<5; ii++)
        {
          if (best==q[ii]) loop++; // count the squares with 'best' quality
          if (loop>scored)
          {
            loop=ii; // go to i-square
            break;
          }
        }
        // change co-ordinates
        vx+=Vector_x[t[loop]];
        vy+=Vector_y[t[loop]];
      }
    }
}
//------------------------------------------------------------------------------
 
void Vole_Base::Escape(int p_Vector,int p_Distance)
{
    // This will alter m_Location_x & m_Location_y
    // it will give a very directed movement towards p_Vector
 
    // p_Vector gives the preferred direction (0-7)
    // p_Distance is the number of steps
    int vx = m_Location_x+SimW;
    int vy = m_Location_y+SimH;
//    int counter = 0;
    for (int i=0; i<p_Distance; i++)
    {
      // test the squares at Vector, Vector+1+2, Vector-1-2
      // They have either a quality or are inaccessible (water,buildings)
      // if can go to one of these squares then pick the best one
      // if all or some are equal then take a random pick.
      // if all are 'bad' then add or subtract one from p_Vector and try again
//      counter ++;
      int t[3], q[3];
      t[0] = p_Vector;
      t[1] = (p_Vector+1) & 0x07;
      t[2] = (p_Vector+7) & 0x07;
      q[0] = MoveQuality((vx+Vector_x[t[0]])%SimW,(vy+Vector_y[t[0]])%SimH);
      q[1] = MoveQuality((vx+Vector_x[t[1]])%SimW,(vy+Vector_y[t[1]])%SimH);
      q[2] = MoveQuality((vx+Vector_x[t[2]])%SimW,(vy+Vector_y[t[2]])%SimH);
      // Now pick the best of these
      int noscore=0;
      for (int ii=0; ii<3; ii++)
      {
        if (q[ii]==-1)
        {
          noscore++;
        }
      }
      if (noscore==3)
      {
        // can't go anywhere so change the vector
        if (random(2)) p_Vector++; else p_Vector--;
      }
      else
      {
        // Can go to at least one of score squares
        // try the middle first
        int loop=0;
        if (q[0]==-1)
        {
          // otherwise randomly try one side or other
          // it must be possible to go to one of these
          int which=random(2);
          if (which==1)
          {
            if (q[1]!=-1) loop=1; else loop=2;
          }
          else
          {
            if (q[2]!=-1) loop=2; else loop=1;
          }
        }
        // change co-ordinates
        vx+=Vector_x[t[loop]];
        vy+=Vector_y[t[loop]];
      }
    }
  // alter the voles location
  FreeLocation();
  m_Location_x=vx%SimW;
  m_Location_y=vy%SimH;
  SetLocation();
}
//---------------------------------------------------------------------------
 
 
int Vole_Base::MoveQuality(int p_x, int p_y)
{
    if (m_OurPopulation->m_VoleMap->GetMapValue(p_x,p_y)!=NULL) return -1;
    // Nobody there so carry on
    int poly_index=m_OurLandscape->SupplyPolyRefIndex(p_x,p_y);
    int score = -9999;
    TTypesOfLandscapeElement tole = m_OurLandscape->SupplyElementTypeFromVector(poly_index);
    switch (tole)
    {
    case tole_NaturalGrassDry: // 110
    case tole_NaturalGrassWet: // 110
    case tole_BeetleBank:
        score=4;
        break;
    case tole_PermPasture: // 35
        if (m_OurLandscape->SupplyGrazingPressureVector(poly_index) > 0 ) score=1; else score=4;
        break;
    case tole_PermPastureLowYield: // 35
        if (m_OurLandscape->SupplyGrazingPressureVector(poly_index) > 0 ) score = 1; else score = 4;
        break;
    case tole_PermPastureTussocky:
        if (m_OurLandscape->SupplyGrazingPressureVector(poly_index) > 0 ) score = 2; else score = 4;
        break;
    case tole_Orchard: // 56
        // Quality depends on when it was mown
        if (m_OurLandscape->SupplyJustMownVector(poly_index)) score=0; else
        {
            if (m_OurLandscape->SupplyVegCoverVector(poly_index)<0.8) score = 4;
                else if (m_OurLandscape->SupplyVegHeightVector(poly_index)<=40) score = 4;
                    else score = 4;
        }
 
        break;
    case tole_MownGrass: // 58
        // Quality depends on when it was mown
        if (m_OurLandscape->SupplyJustMownVector(poly_index)) score=1; else score=4;
        break;
    case tole_OrchardBand: // 57
        score = 4 - (int) (0.6*m_OurLandscape->SupplyJustSprayedVector(poly_index));
        break;
    case tole_RoadsideSlope:
    case tole_Railway: // 118
    case tole_FieldBoundary: // 160
    case tole_RoadsideVerge: // 13
    case tole_HedgeBank:
    case tole_PermanentSetaside:
    case tole_YoungForest: // 60
    case tole_Vildtager:
    case tole_Wasteland:
        score = 4;
        break;
    case tole_Saltmarsh: // 95
    case tole_Marsh: // 95
    case tole_Scrub: // 70
    case tole_Heath:
    case tole_Hedges: // 130 (internal ALMaSS representation for Hedges)
    case tole_RiversidePlants: // 98
    case tole_PitDisused: // 75
    case tole_MixedForest: // 60
    case tole_DeciduousForest: // 40
    case tole_Copse:
        score=3;
        break;
    case tole_RiversideTrees: // 97
    case tole_ConiferousForest: // 50
    case tole_BuiltUpWithParkland:
    case tole_Parkland:
    case tole_AmenityGrass:
    case tole_WoodyEnergyCrop:
    case tole_IndividualTree:
        score=2;
        break;
    case tole_Garden: //11
    case tole_Track: // 123
    case tole_SmallRoad: // 122
    case tole_LargeRoad: // 121
    case tole_BareRock:
    case tole_UrbanNoVeg:
    case tole_UrbanPark:
    case tole_SandDune:
    case tole_Churchyard:  //204
        score=1;
        break;
    case tole_MetalledPath:
    case tole_Carpark:
    case tole_Stream:
    case tole_HeritageSite:
    case tole_Building: // 5
    case tole_ActivePit: // 115
    case tole_Freshwater: // 90
    case tole_FishFarm:
    case tole_Pond:
    case tole_River: // 96
    case tole_Saltwater: // 80
    case tole_Coast: // 100
    case tole_StoneWall: // 15
    case tole_Fence: //225
    case tole_WindTurbine:
    case tole_Pylon:
        score=-1;
        break;
    case tole_Field: // 20 & 30
    case tole_UnsprayedFieldMargin:
      {
       TTypesOfVegetation  VType=m_OurLandscape->SupplyVegTypeVector(poly_index);
       switch (VType) {
       case tov_OCloverGrassSilage1:
       case tov_CloverGrassGrazed1:
       case tov_CloverGrassGrazed2:
       case tov_OCloverGrassGrazed1:
       case tov_OCloverGrassGrazed2:
       case tov_OPermanentGrassGrazed:
       case tov_PermanentGrassGrazed:
           score = 3 - m_OurLandscape->SupplyGrazingPressureVector(poly_index);
        break;
       default:
        double cover = m_OurLandscape->SupplyVegCoverVector(poly_index);
        double height = m_OurLandscape->SupplyVegHeightVector(poly_index);
        if ((cover>0.80) && (height>40)) score = 3;
        if ((cover<0.50) || (height<10)) score = 0;
            else score = 2;
        }
      }
      break;
    case tole_Foobar: // 999 !! type unknown - should not happen
    default:
     static char errornum[20];
     sprintf(errornum, "%d", m_OurLandscape->SupplyElementTypeFromVector(poly_index));
     m_OurLandscape->Warn("Vole_Base:MoveQuality: Unknown tole_type",
     errornum);
     exit(1);
  }
  return score;
}
//---------------------------------------------------------------------------
//                           Vole_JuvenileFemale
//---------------------------------------------------------------------------
 
Vole_JuvenileFemale::Vole_JuvenileFemale(struct_Vole_Adult *p_aVoleStruct):Vole_Base(p_aVoleStruct)
{
  m_Sex=false;
  m_TerrRange=m_MinFemaleTerritorySize;
  m_MinTerrRange=m_MinFemaleTerritorySize;
  m_BornLastYear= false;
  m_Weight=WeanedWeight;
  m_Age=14;
#ifdef __VOLEPESTICIDEON
  m_maturitydelay = 0.0;
#endif
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileFemale::ReInit(struct_Vole_Adult * p_aVoleStruct) {
    Init(p_aVoleStruct);
    m_Sex = false;
    m_TerrRange = m_MinFemaleTerritorySize;
    m_MinTerrRange = m_MinFemaleTerritorySize;
    m_BornLastYear = false;
    m_Weight = WeanedWeight;
    m_Age = 14;
#ifdef __VOLEPESTICIDEON
    m_maturitydelay = 0.0;
#endif
}
//---------------------------------------------------------------------------
 
 
Vole_JuvenileFemale::~Vole_JuvenileFemale()
{
  // Nothing to do
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileFemale::BeginStep()
{
  if (MortalityTest())
  {
    CurrentVState=tovs_FDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FBck,1);
  }
  else
  {
      if (--m_LifeSpan<1)
      {
          if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FLife,1);
          CurrentVState=tovs_FDying;
          m_StepDone=true;
      }
  }
#ifdef __VOLEPESTICIDEON
    PesticideIngestion();
    ActOnPesticideDose();
#endif
 }
//---------------------------------------------------------------------------
 
void Vole_JuvenileFemale::Step()
{
  if (m_StepDone) return;
  switch (CurrentVState)
  {
   case 0: // Initial state
    CurrentVState=tovs_FEvaluateExplore;
    break;
   case tovs_FEvaluateExplore: // Evaluate & Explore
    switch(st_Evaluate_n_Explore())
    {
      case 1: // Dead from dispersal mortality
          CurrentVState=tovs_FDying; // Die
          break;
      case 2: // Starved
          if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FStarve,1);
          CurrentVState=tovs_FDying; // Die
          break;
      default:
          ; // Do nothing
    }
#ifdef __VOLEPESTICIDEON
        if (m_Age >= MinReproAgeF+ m_maturitydelay ) st_BecomeSubAdult();
#else
        if (m_Age == MinReproAgeF ) st_BecomeSubAdult();
#endif
    m_StepDone=true;
    break;
   case tovs_FDying: // Die
    FreeLocation();
    m_StepDone=true;
    break;
   default:
       m_OurLandscape->Warn("Vole_Female::Step - unknown state",NULL);
       exit(9);
  }
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileFemale::EndStep()
{
#ifdef __VoleStarvationDays
  if ( m_StarvationDays > m_MaxStarvationDays)
  {
      st_Dying();
      if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FStarve,1);
  }
#endif
  CheckManagement();
  if (CurrentVState==tovs_FDying) {
      st_Dying();
  }
 
  else
  {
    m_Age++;
    /*              FEMALE GROWTH NOTES
 
     Female vole grows until 20g.
     After that she will only grow if he has matured
     Growth continues up to 55g.
 
     Reproduction cannot occur below 20g or 20 days
 
     Growth only occurs between 1 March and 1st August
 
     taken from Hanson L, 1977, Oikos 29.
    */
    int today=m_OurLandscape->SupplyDayInYear();
    if ((today<GrowStopDate) && (today>
                               m_OurPopulation->SupplyGrowthStartDate()))
    {
       if (m_Weight<20)
       {
         m_Weight+=growthperdayF;
       }
       else if ((m_Mature==true) && (m_Weight<MaxWeightF))
       {
           m_Weight+=growthperdayF;
           m_TerrRange= (int) (m_MinFemaleTerritorySize+(m_FemaleTerritoryRangeSlope*(m_Weight-MinReproWeightF)));
       }
    }
    else  if (today==1) m_BornLastYear=true; // must be true if alive on 1st Jan.
  }
}
//---------------------------------------------------------------------------
 
bool Vole_JuvenileFemale::OnFarmEvent(FarmToDo event)
{
 switch(event)
 {
case  sleep_all_day:
  break;
case  autumn_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  autumn_harrow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  autumn_roll:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  autumn_sow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  winter_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  deep_ploughing:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  spring_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  spring_harrow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  spring_roll:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  spring_sow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  fp_npks:
  break;
case  fp_npk:
  break;
case  fp_pk:
  break;
case  fp_liquidNH3:
  break;
case  fp_slurry:
  break;
case  fp_manganesesulphate:
  break;
case  fp_manure:
  break;
case  fp_greenmanure:
  break;
case  fp_sludge:
  break;
case  fa_npk:
  break;
case  fa_pk:
  break;
case  fa_slurry:
  break;
case  fa_ammoniumsulphate:
  break;
case  fa_manure:
  break;
case  fa_greenmanure:
  break;
case  fa_sludge:
  break;
case  herbicide_treat:
  break;
case  growth_regulator:
  break;
case  fungicide_treat:
  break;
case  insecticide_treat:
  break;
case  molluscicide:
  break;
case glyphosate:
  break;
case  row_cultivation:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  strigling:
  if (g_rand_uni()<VoleStriglingMort)
     CurrentVState=tovs_FDying;
  break;
case  hilling_up:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  water:
  break;
case  swathing:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  harvest:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  cattle_out:
case cattle_out_low:
  break;
case  cut_to_hay:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  cut_to_silage:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  straw_chopping:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  hay_turning:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  hay_bailing:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case  stubble_harrowing:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  autumn_or_spring_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case  burn_straw_stubble:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case mow:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case cut_weeds:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_FDying;
  break;
case pigs_out:
  if (g_rand_uni()<VolePigGrazingMort)
     CurrentVState=tovs_FDying;
  break;
case strigling_sow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_FDying;
  break;
case trial_insecticidetreat:
case trial_toxiccontrol:
case trial_control:
  break;
default:
  g_msg->Warn( WARN_FILE, "Vole_Female::OnFarmEvent(): Unknown event type:",
          m_OurLandscape->EventtypeToString(event) );
  exit( 1 );
 }
 if (CurrentVState==tovs_FDying)
 {
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FFarm,1);
   return true;
 }
 else
 return false;
}
//----------------------------------------------------------------------------
 
void Vole_JuvenileFemale::OnKilled()
{
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FPred,1);
    CurrentVState=tovs_FDying;
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileFemale::st_BecomeSubAdult()
{
      struct_Vole_Adult* av;
      av = new struct_Vole_Adult;
      av->VPM = m_OurPopulation;
      av->L = m_OurLandscape;
      av->m_flag=true; // Used to signal pesticide effect to CreateObjects
      // Create the new voles (50% chance of male/female)
      av->PolyRefBorn = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
      av->ElemBorn = m_OurLandscape->SupplyElementType(m_Location_x, m_Location_y);
      av->VegBorn = m_OurLandscape->SupplyVegType(m_Location_x, m_Location_y);
      av->FatherId = m_FatherId;
      av->MotherId = m_MotherId;
      av->x = m_Location_x;
      av->y = m_Location_y;
      av->weight = m_Weight;
      // Do the genetics
      av->Genes = m_MyGenes;
      av->age = m_Age;
      m_OurPopulation->CreateObjects(vob_Female,this,av,1);
      // Remove the current object
      CurrentVState = tovs_FDying;
      FreeLocation();
      m_CurrentStateNo = -1;
      m_StepDone = true;
}
//---------------------------------------------------------------------------
 
int Vole_JuvenileFemale::st_Evaluate_n_Explore()
{
#ifdef __USINGTRAPLINES
    CheckTraps();
#endif
    double Qual = CalculateCarryingCapacity(m_Location_x, m_Location_y, cfg_VoleDDepConst.value());
    // This function determines whether he must leave and whether he does
    // an explore. He will do this if he is not in optimal conditions
 
    if (Qual < m_MinFVoleHabQual)
    {
        // check an area MinFemaleMovement to FemaleMovement metres away
        m_DispVector = random(8);
        // Not quality dependent dispersal, very directed
        return Dispersal(-1, random(FemaleMovement) + 1);
    }
    else return (Dispersal(Qual, 1 + random(FemaleMovement) + 1)); // returns 1 if it has died of extra dispersal mortality or starvation
}
//---------------------------------------------------------------------------
 
 
inline void Vole_JuvenileFemale::SetLocation() {
     m_OurPopulation->m_VoleMap->SetMapValue(m_Location_x,m_Location_y,this);
    };
inline void Vole_JuvenileFemale::FreeLocation() {
     m_OurPopulation->m_VoleMap->ClearMapValue(m_Location_x,m_Location_y);
    };
inline bool Vole_JuvenileFemale::GetLocation(int px, int py) {
     if( m_OurPopulation->m_VoleMap->GetMapValue(px,py)!=NULL) return true;
     return false;
    };
//---------------------------------------------------------------------------
 
 
//---------------------------------------------------------------------------
//                           Vole_Female
//---------------------------------------------------------------------------
int Vole_JuvenileFemale::Dispersal(double p_OldQual, int p_Distance)
{
    // Returns 1 for die, 0 for carry on
    if (m_DispVector == -1) m_DispVector = random(8); // Choose direction 0-7
    // Go that far in that direction (assuming it is possible to do that)
    int oldx = m_Location_x;
    int oldy = m_Location_y;
    MoveTo(m_DispVector, p_Distance,10);
    //  Now we are there so what is the new quality
    // 1. Get the carrying capacity
    double CC = CalculateCarryingCapacity(m_Location_x,m_Location_y,cfg_VoleDDepConst.value());
    if ( CC <= p_OldQual )
    {
        // Don't want to move
        FreeLocation();
        m_Location_x=oldx;
        m_Location_y=oldy;
        SetLocation();
    }
    else
    {
        if (g_rand_uni() < g_extradispmort )
        {
            if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FDisp,1);
            return 1;
        }
    }
    return 0;
}
//---------------------------------------------------------------------------
 
Vole_Female::Vole_Female(struct_Vole_Adult *p_aVoleStruct) :Vole_JuvenileFemale(p_aVoleStruct)
{
    m_NoOfYoung = 0;
    m_Pregnant = false;
    m_TerrRange = m_MinFemaleTerritorySize;
    m_MinTerrRange = m_MinFemaleTerritorySize;
    m_MatesIdNo = -1;
    m_Weight = WeanedWeight;
    m_Age = MinReproAgeF + 1;
    m_DaysUntilBirth = 0;
#ifdef __VOLEPESTICIDEON
    Vole_Female::m_EndoCrineDisruptionGestationLength = cfg_VoleEndoCrineDisruptionGestationLength.value();
    m_pesticideloadindex = 0;
    for (int i = 0; i<21; i++) m_pesticideloadarray[i] = 0;
#endif
 
}
//---------------------------------------------------------------------------
void Vole_Female::ReInit(struct_Vole_Adult *p_aVoleStruct)
{
    Init(p_aVoleStruct);
    m_NoOfYoung = 0;
    m_Pregnant = false;
    m_TerrRange = m_MinFemaleTerritorySize;
    m_MinTerrRange = m_MinFemaleTerritorySize;
    m_MatesIdNo = -1;
    m_Weight = WeanedWeight;
    m_Age = MinReproAgeF + 1;
    m_DaysUntilBirth = 0;
#ifdef __VOLEPESTICIDEON
    Vole_Female::m_EndoCrineDisruptionGestationLength = cfg_VoleEndoCrineDisruptionGestationLength.value();
    m_pesticideloadindex = 0;
    for (int i = 0; i<21; i++) m_pesticideloadarray[i] = 0;
#endif
 
}
//---------------------------------------------------------------------------
 
 
Vole_Female::~Vole_Female()
{
  // Nothing to do
}
//---------------------------------------------------------------------------
 
void Vole_Female::Step()
{
  if (m_StepDone) return;
  switch (CurrentVState)
  {
   case 0: // Initial state
    CurrentVState=tovs_FEvaluateExplore;
    break;
   case tovs_FEvaluateExplore: // Evaluate & Explore
    switch(st_Evaluate_n_Explore())
    {
      case 1:
          CurrentVState=tovs_FDying; // Die
          break;
      case 2:
          if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FStarve,1);
          CurrentVState=tovs_FDying; // Die
          break;
      default:
       CurrentVState=tovs_ReproBehaviour; // repro behaviour
    }
    m_StepDone=true;
    break;
   case tovs_ReproBehaviour: // ReproBehaviour
    CurrentVState = st_ReproBehaviour();
    break;
   case tovs_Lactating: // Lactating
    CurrentVState = st_Lactating();
    m_StepDone=true;
    break;
   case tovs_GiveBirth:
       CurrentVState = st_GiveBirth();
       m_StepDone=true;  // wait until next day
       break;
   case tovs_FMaturation: // Maturation
    CurrentVState = st_BecomeReproductive(); // only returns Eval n Explore
    break;
   case tovs_Mating: // Mating
    CurrentVState = st_Mating(); // only returns Eval n Explore
    break;
   case tovs_UpdateGestation: // Update Gestation
    CurrentVState = st_UpdateGestation();
    break;
   case tovs_SpecialExplore: // Special Explore
    st_Special_Explore();
    CurrentVState = tovs_ReproBehaviour;  // Repro behaviour
    m_StepDone=true;
    break;
   case tovs_FDying: // Die
    FreeLocation();
    m_StepDone=true;
    break;
   default:
       m_OurLandscape->Warn("Vole_Female::Step - unknown state",NULL);
       exit(9);
  }
}
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_Female::st_ReproBehaviour()
{
   if (!m_Mature) return tovs_FMaturation; // Go to BecomeReproductive;
     else if (m_NoOfYoung>0) return tovs_Lactating;  //Go to lactating
       else if ((!m_Pregnant) && (m_DaysUntilBirth==0)) return tovs_Mating; // Go to Mating;
         else return tovs_UpdateGestation; // Go to UpdateGestation;
}
//---------------------------------------------------------------------------
 
 
TTypeOfVoleState Vole_Female::st_UpdateGestation()
{
    m_DaysUntilBirth--;
    if (m_DaysUntilBirth == 0) return tovs_GiveBirth; else return tovs_FEvaluateExplore;
}
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_Female::st_BecomeReproductive()
{
    if ( m_BreedingSeason && m_Have_Territory )
    {
        if ( m_Age>= MinReproAgeF) {
            Setm_Mature();
        }
    }
    return tovs_FEvaluateExplore;
}
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_Female::st_GiveBirth()
{
    // TODO must locate the nest position if this is considered important - currently it is set as the centre of the territory
    if (m_Have_Territory && m_Pregnant)
    {
        // Must produce young
        int yr = 0;
        if (m_BornLastYear) yr = 1;
        m_NoOfYoung = m_OurPopulation->ReproTable[yr][m_OurLandscape->SupplyDayInYear() / 30];
        m_Pregnant = false;
#ifdef __VOLEPESTICIDEON
        if ((m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide) || (m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide21TWA))
        {
            double dose = 0.0;
            double survive = 1.0;
            if (m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide21TWA)
            {
                for (int i = 0; i < 21; i++) dose += m_pesticideloadarray[i];
                dose /= 21;
                dose -= cfg_PesticideAccumulationThresholdModelink2.value();
            }
            else
            {
                dose = m_pesticideInfluenced3 - cfg_PesticideAccumulationThreshold.value();
                m_pesticideInfluenced3 = 0;
            }
            if (dose > 0) // this has the maximum dose received
            {
                // Calc dose response in terms of chance of death for individual offspring
                survive = 1 - (cfg_PesticideLitterSizeReduction.value() * dose);
            }
            // This applies the survival probability to each individual - why do we not do this to the litter as a whole
            // - this is because the probability may be too small to get a % response from e.g. 4 young
            int ny = 0;
            for (int y = 0; y < m_NoOfYoung; y++) if (g_rand_uni() < survive)
            {
                ny++;
                m_OurPopulation->AddToNotImpacted();
            }
            else m_OurPopulation->AddToImpacted();
            m_NoOfYoung = ny;
        }
        if (m_NoOfYoung > 0) m_OurPopulation->incLittersProduced(); else m_OurPopulation->incLittersLost();
#endif
        // Must age young
        m_YoungAge = 0;
        // Update the YoungProduced Today Counter
        m_OurPopulation->AddToYoung(m_NoOfYoung);
        m_NoOfYoungTotal += m_NoOfYoung;
        return tovs_ReproBehaviour; //NB if m_NoOfYoung is zero due to pesticide effects this will quietly be dealt with by the repro switch
    }
    else
    {
        m_NoOfYoung = 0;
    }
    m_Pregnant = false;
    return tovs_FEvaluateExplore;
}
//---------------------------------------------------------------------------
TTypeOfVoleState Vole_Female::st_Lactating()
{
    if( m_YoungAge++ >= WeanedAge )
    {
      struct_Vole_Adult* av;
      av = new struct_Vole_Adult;
      av->VPM = m_OurPopulation;
      av->L = m_OurLandscape;
      av->m_flag = true; // Used to signal pesticide effect to CreateObjects
#ifdef __VOLEPESTICIDEON
      double mdelay = 0;
      if ((m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide)|| (m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide21TWA))
      {
          double dose = 0.0;
          double survive = 1.0;
          if (m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide21TWA)
          {
              for (int i=0; i<21; i++) dose+=m_pesticideloadarray[i];
              dose /=21;
              dose -= cfg_PesticideAccumulationThresholdModelink2.value();
          } else
          {
            dose = m_pesticideInfluenced3-cfg_PesticideAccumulationThreshold.value();
            m_pesticideInfluenced3=0;
          }
          if ( dose > 0 ) // this has the maximum dose received
          {
              // Calc dose response in terms of chance of death for individual offspring
              survive = 1-(cfg_PesticideWeaningReduction.value() * dose);
              mdelay = cfg_PesticideFemaleMaturityDelay.value() * dose;
          }
          // This applies the survival probability to each individual - why do we not do this to the litter as a whole
          // - this is because the probability may be too small to get a % response from e.g. 4 young
          int ny=0;
          for (int y=0; y<m_NoOfYoung; y++) if (g_rand_uni()<survive) ny++;
          m_NoOfYoung = ny;
      }
#endif
      unsigned MotherIdNo = SupplyIDNo();
      unsigned FatherIdNo = SupplyMateId();
 
      // Create the new voles (50% chance of male/female)
      for (int i=0; i<m_NoOfYoung; i++)
      {
          av->PolyRefBorn = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
          av->ElemBorn = m_OurLandscape->SupplyElementType(m_Location_x, m_Location_y);
          av->VegBorn = m_OurLandscape->SupplyVegType(m_Location_x, m_Location_y);
          av->FatherId = FatherIdNo;
          av->MotherId = MotherIdNo;
          av->x = ((m_Location_x+random(10))%m_OurPopulation->SimW);
          av->y = ((m_Location_y+random(10))%m_OurPopulation->SimH);
          // Do the genetics
          av->Genes.Recombine(&m_MyGenes,&m_MatesGenes);
          av->Genes.Mutation_4();
#ifdef __Mutation
        //av->Genes256_16.Mutation_3(); // This is only one of a number of mutation types we can use
#endif
        if (random(2)==1) // Even sex ratio
        {
            // Males
#ifdef __VOLEPESTICIDEON
            if (m_OurLandscape->SupplyPesticideType() == ttop_Vinclozolin)
            {
            // If her mate was pesticide influenced then ensure all male offspring are also
            // by setting the gene on if we are useing Vinclozolin
            // If either the male was directly affected, or the female directly during gestation
            if ( m_pesticideInfluenced1 )
            {
                av->m_dflag = true;
                av->m_gflag = true;
                m_OurPopulation->AddToImpacted();
            }
            // Otherwise if the male was genetically affected
            else if (MatesGenes.GetGeneticFlag())
            {
                av->m_gflag = true;
                av->m_dflag=false;
                m_OurPopulation->AddToGeneticImpacted();
            }
            else
            {
                av->m_gflag=false;
                av->m_dflag=false;
                m_OurPopulation->AddToNotImpacted();
            }
        }
        else if (m_OurLandscape->SupplyPesticideType() == ttop_ReproductiveEffects )
        {
            // If either the male was directly affected, or the female directly during gestation
            if ( m_pesticideInfluenced1 )
            {
                av->m_dflag = true;
                av->m_gflag = false;
                m_OurPopulation->AddToImpacted();
            }
            else
            {
                av->m_gflag=false;
                av->m_dflag=false;
                m_OurPopulation->AddToNotImpacted();
            }
        }
        else
        {
            av->m_gflag=false;
            av->m_dflag=false;
        }
#endif
          m_OurPopulation->CreateObjects(vob_JuvenileMale,this,av,1);
        }
        else {
#ifdef __VOLEPESTICIDEON
            if ((m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide)|| (m_OurLandscape->SupplyPesticideType() == ttop_ModelinkPesticide21TWA))
            {
                av->misc_use = mdelay;
            }
            else av->misc_use = 0.0;
#endif
            m_OurPopulation->CreateObjects(vob_JuvenileFemale,this,av,1);
        }
      }
      m_OurPopulation->AddToJuvs(m_NoOfYoung);
      m_Reserves=0; // all reserves used up
      m_NoOfYoung=0; // No more young to feed
      delete av; // clean up
      return tovs_SpecialExplore; //  CurrentVState=14 Special Explore
    }
    else return tovs_Lactating; // carry on feeding young
}
//---------------------------------------------------------------------------
 
int Vole_Female::st_Evaluate_n_Explore()
{
#ifdef __USINGTRAPLINES
    CheckTraps();
#endif
/*
    unsigned MovementIndex;
    if (m_Age>90) MovementIndex=3;
     else if (m_Age>60) MovementIndex=2;
       else if (m_Age>30) MovementIndex=1;
         else MovementIndex=0;
*/
    double Qual = CalculateCarryingCapacity(m_Location_x, m_Location_y,cfg_VoleDDepConst.value());
    // This function determines whether he must leave and whether he does
    // an explore. Will do this if he is not in optimal conditions
   if ( Qual <= m_MinFVoleHabQual )
   {
 
#ifdef __VoleStarvationDays
       ++m_StarvationDays;
#endif
       m_Have_Territory = false;
       // check an area MinFemaleMovement to FemaleMovement metres away
       m_DispVector = random(8);
       // Not quality dependent dispersal, very directed
       return Dispersal(-1,random(FemaleMovement)+ MinFemaleMovement);
   }
   else
   {
       m_Have_Territory = true;
#ifdef __VoleStarvationDays
       m_StarvationDays = 0;
#endif
       return (Dispersal(Qual,random(FemaleMovement)+ MinFemaleMovement)); // returns 1 if it has died of extra dispersal mortality or starvation
   }
}
//---------------------------------------------------------------------------
 
int Vole_Female::st_Special_Explore()
{
  //The vole must now find a good territory
  // She will explore in all 8 directions from the nest and pick the best
  // from these and here present position
  unsigned coords[9][2];
  double qualities[9];
  // Check the quality here
  coords[8][0]=m_Location_x;
  coords[8][1]=m_Location_y;
  if (!m_OurPopulation->SupplyOlderFemales(m_Location_x,m_Location_y,m_Age,m_TerrRange))
     qualities[8]=-1;
  else
  {
    qualities[8]=CalculateCarryingCapacity(m_Location_x,m_Location_y,cfg_VoleDDepConst.value());
  }
  // Now check the quality in all 8 directions
  unsigned steps = 2 * FemaleMovement+MinFemaleMovement;
  for (unsigned i=0; i<8; i++)
  {
    MoveTo(i,steps,10); // changes m_Location_x & y
    coords[i][0]=m_Location_x;
    coords[i][1]=m_Location_y;
    if (!m_OurPopulation->SupplyOlderFemales(m_Location_x,m_Location_y,m_Age,
                                                                   m_TerrRange))
       qualities[i]=-1;
    else
    {
      qualities[i]=CalculateCarryingCapacity(m_Location_x,m_Location_y,cfg_VoleDDepConst.value());
    }
  }
  // find the best out of the nine qualities
  double best =qualities[8]; // here
  unsigned found=8; // default stay here
  for (unsigned i=0; i<8; i++)
  {
    if (qualities[i]>best)
    {
      best=qualities[i];
      found=i;
    }
    if (best>1)
    {
      if (m_Mature)
      {
        m_Have_Territory=true;
      }
    }
    else
    {
      m_Have_Territory=false;
    }
    FreeLocation();
    m_Location_x=coords[found][0];
    m_Location_y=coords[found][1];
    SetLocation();
  }
  return 0;
}
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_Female::st_Mating()
{
  //if it is the breeding season
  if ( m_BreedingSeason )
  {
    // Find a male if there is one
 
    Vole_Male* Mate=m_OurPopulation->FindClosestMale(m_Location_x, m_Location_y, m_MaxMaleTerritorySize); // Changed from a constant of 20 to her Territory range **//TD 090519
    // Get his genes if we found a mate
    if (Mate)
    {
        m_MatesGenes=Mate->SupplyGenes();
        m_MatesIdNo=Mate->SupplyIDNo();
#ifdef __VOLEPESTICIDEON
        if (!Mate->GetFertile())
        {
            m_Pregnant = false;
        }
        else m_Pregnant = true;
#else
        m_Pregnant = true;
#endif
        m_DaysUntilBirth = TheGestationPeriod;
    }
  }
  return tovs_FEvaluateExplore;
}
//---------------------------------------------------------------------------
 
void Vole_Female::OnInfanticideAttempt()
{
   //try this if she has kids
   if (m_NoOfYoung)
   {
     if (m_YoungAge<9)
     {
       double mortchance=g_rand_uni();
       if (mortchance<=InfanticideChanceByAge[m_YoungAge])
       {
           m_OurPopulation->AddToNoYoungInfanticideCount (m_NoOfYoung, m_YoungAge);
 
         // Young are killed
         m_NoOfYoung=0;    // will cause the vole to be mated
         m_Pregnant=false;
      }
     }
   }
}
//---------------------------------------------------------------------------
 
 
//---------------------------------------------------------------------------
//                           Vole_Male
//---------------------------------------------------------------------------
 
Vole_Male::Vole_Male(struct_Vole_Adult *p_aVoleStruct) :Vole_JuvenileMale(p_aVoleStruct)
{
    m_Age = p_aVoleStruct->age;
    m_Weight = p_aVoleStruct->weight;
    m_BirthYear = p_aVoleStruct->BirthYear;
    m_Sex = true;
    m_TerrRange = m_MinMaleTerritorySize;
    m_MinTerrRange = m_MinMaleTerritorySize;
}
//---------------------------------------------------------------------------
 
void Vole_Male::ReInit(struct_Vole_Adult * p_aVoleStruct) {
    Init(p_aVoleStruct);
    m_Age = p_aVoleStruct->age;
    m_Weight = p_aVoleStruct->weight;
    m_BirthYear = p_aVoleStruct->BirthYear;
    m_Sex = true;
    m_TerrRange = m_MinMaleTerritorySize;
    m_MinTerrRange = m_MinMaleTerritorySize;
}
//---------------------------------------------------------------------------
 
Vole_Male::~Vole_Male()
{
  // Nothing to do
}
//---------------------------------------------------------------------------
 
void Vole_Male::Step()
{
  if (m_StepDone || m_CurrentStateNo == -1) return;
  switch (CurrentVState)
  {
   case tovs_InitialState:  //initial state
       CurrentVState=tovs_MEvaluateExplore;
       break;
   case tovs_MMaturation: // Maturation
       if (st_Maturation()) Setm_Mature();
       CurrentVState=tovs_MEvaluateExplore; // Eval and Explore
       break;
   case tovs_MEvaluateExplore: // Eval&Explore
       CurrentVState = st_Eval_n_Explore();
       m_StepDone = true;
       break;
   case tovs_Infanticide: // Infanticide
       st_Infanticide();
       CurrentVState=tovs_MEvaluateExplore;
       break;
   case tovs_MDying:
       FreeLocation();
       m_StepDone=true;
       break;
   default:
       m_OurLandscape->Warn("Vole_Male::Step - unknown return error",NULL);
       exit(1);
  }
}
//---------------------------------------------------------------------------
 
void Vole_Male::EndStep()
{
#ifdef __VoleStarvationDays
  if (m_Have_Territory) m_StarvationDays = 0;
  if ( m_StarvationDays > m_MaxStarvationDays)
  {
      st_Dying();
      if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MStarve,1);
  }
  else
#endif
  {
      CheckManagement();
      if (CurrentVState==tovs_MDying)
      {
          st_Dying();
      }
      else
      {
          m_Age++;
            /*              MALE GROWTH NOTES
 
             Male vole grows until 20g. After that he will only grow if he has matured
             Growth continues up to 60g.
 
             Reproduction cannot occur below 40g or 40 days
 
             Growth only occurs between 1 March and 1st August
             taken from Hanson L, 1977, Oikos 29.
            */
          int today = m_OurLandscape->SupplyDayInYear();
          if ((today < GrowStopDate) && (today > m_OurPopulation->SupplyGrowthStartDate()))
          {
              if (m_Weight<20)
              {
                m_Weight+=growthperdayM;
              }
              else if ((m_Mature==true) && (m_Weight<MaxWeightM))
              {
                  m_Weight+=growthperdayM;
              }
          }
           else if ((today == 1)) {
               m_BornLastYear = true; 
               m_Mature = true; 
           }// must be true if alive on 1st Jan.
          DetermineTerritorySize();
      }
  }
}
//---------------------------------------------------------------------------
 
int Vole_Male::st_Maturation(void)
{
        if (m_OurLandscape->SupplyDayInYear()<
              m_OurPopulation->SupplyGrowthStartDate()) return 0;// don't mature
        else return 1; // matures
}
//---------------------------------------------------------------------------
 
void Vole_Male::st_Infanticide(void)
{
    if (g_rand_uni() < cfg_InfanticideProbability.value() ) {
    // int SearchInf =(int) m_TerrRange*cfg_InfanticideRangeRelToTerRange.value();
     m_OurPopulation->SendMessage(tovm_Infanticide,m_Location_x,m_Location_y,m_MinTerrRange,false,m_Weight);
    }
}
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_Male::st_Eval_n_Explore(void)
{
    VoleDispersalReturns retval = vdisp_CarryOn;
 
    unsigned MovementIndex;
    if (m_Age>90) MovementIndex=3;
     else if (m_Age>60) MovementIndex=2;
       else if (m_Age>30) MovementIndex=1;
         else MovementIndex=0;
    int OldMales = m_OurPopulation->SupplyInOlderTerr(m_Location_x,m_Location_y,m_Age,m_TerrRange); // returns -1 if a male has p_x,p_y in his territory and is older than p_Age else returns the number of females present
    int NoFemales = OldMales;
    double Qual = CalculateCarryingCapacity(m_Location_x, m_Location_y,10000);
    //if (OldMales>1) Qual/=OldMales; // Share resources with the females, but no-one else
    if ( m_BreedingSeason )
    {
        if( m_Have_Territory ) // Must be mature
        {
        #ifdef __USINGTRAPLINES
            CheckTraps();
        #endif
            if (!m_Mature)
            {
                return tovs_MMaturation; // Special case, immature male in breeding season with territory will mature
            }
            // If he his mature then he must move if in an older males territory
            bool NoMates = false;
            if (NoFemales<1)
            {
                if ((g_rand_uni() < g_NoFemalesMove))
                {
                    Vole_Female* af = m_OurPopulation->FindClosestFemale(m_Location_x, m_Location_y,MaleMovement[MovementIndex]);
                    if (af!=NULL)
                    {
                        AnimalPosition ap = af->SupplyPosition();
                        int tx=(SimW+ap.m_x+(random(2)-1))%SimW;
                        int ty=(SimH+ap.m_y+(random(2)-1))%SimH;
                        while ((GetLocation(tx,ty)) && (MoveQuality(tx,ty)<1))
                        {
                            tx=(SimW+tx+(random(2)-1))%SimW;
                            ty=(SimH+ty+(random(2)-1))%SimH;
                        }
                        FreeLocation();
                        m_Location_x=tx;
                        m_Location_y=ty;
                        SetLocation();
                    } else NoMates = true;
                }
            } else
            if (((OldMales<1)|| (Qual<m_MinFVoleHabQual) || (NoMates)) && !m_BornLastYear) // In larger males territory, must move or are no females
            {
                m_Have_Territory = false;
                m_DispVector = random(8);
                retval = (Dispersal(Qual,MaleMovement[MovementIndex]));
            }
        }
        else
        {
            // No territory & Breeding season
            #ifdef __USINGTRAPLINES
            CheckTraps();
            #endif
            // Not quality dependent dispersal, very directed
            retval = (Dispersal(-1, MaleMovement[MovementIndex]));
        }
    }
    else  // Not breeding season
    {
    #ifdef __USINGTRAPLINES
        CheckTraps();
    #endif
        if  ( (OldMales<1) || (Qual < m_MinFVoleHabQual ))
        {
            #ifdef __VoleStarvationDays
                m_StarvationDays++;
            #endif
            retval = (Dispersal(-1,1+random(MaleMovement[MovementIndex])));
        }
    }
    // retval now holds the answer to the returning state
    switch (retval)
    {
        case vdisp_Mature:
            Setm_Mature();
            return tovs_Infanticide;
        case vdisp_Infanticide:
            return tovs_Infanticide;
        case vdisp_Die:
            return tovs_MDying;
        case vdisp_CarryOn:
        default:
            return CurrentVState;
    }
}
//---------------------------------------------------------------------------
 
VoleDispersalReturns Vole_Male::Dispersal(double p_OldQual, int p_Distance)
{
 
    // int retval = 0;
    // p_OldQuatells whether dispersal is conditional on quality or not
    // p_OldQual is set to old habitat quality or -1
    // p_Distance is the p_Distance used by the move function
    // aim is to move in a directed way traversing the landscape using the best
    // habitats
    // remember the old co-ordinates in case infanticide needs to be triggered
    int oldx = m_Location_x;
    int oldy = m_Location_y;
#ifdef __VOLE_SMALL_LANDSCAPE
    m_DispVector = random(8); // Choose direction 0-7
#else
    if (m_DispVector == -1) m_DispVector = random(8); // Choose direction 0-7
#endif
    // Go that far in that direction (assuming it is possible to do that)
    MoveTo(m_DispVector, p_Distance, 10);
    //  Now we are there so what is the new quality
    // 1. Get the carrying capacity
    int OldMales = 1;
    int NoFemales = 1;
    if (m_BreedingSeason)
    {
        OldMales = m_OurPopulation->SupplyInOlderTerr(m_Location_x, m_Location_y, m_Age, m_TerrRange);
        NoFemales = OldMales; // If can be 0 or >0 if OldMales does not return 1
    }
    double CC = CalculateCarryingCapacity(m_Location_x, m_Location_y, cfg_VoleDDepConst.value());
    if (p_OldQual == -1)
    {
        // Do an extra mortality test if we are forced to disperse
        if (g_rand_uni() < g_extradispmort)
        {
            if (cfg_RecordVoleMort.value()) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MDisp, 1);
            return vdisp_Die;
        }
    }
 
    if ((CC < p_OldQual) || (OldMales < 1) || (NoFemales < 1))
    {
        // Don't want to move
        FreeLocation();
        m_Location_x = oldx;
        m_Location_y = oldy;
        SetLocation();
        return vdisp_CarryOn;
    }
    else if (CC > m_MinMVoleHabQual)
    {
        m_Have_Territory = true;
        if (m_BreedingSeason)
        {
            if (!m_Mature)
            {
                return  vdisp_Mature; // Will also trigger infanticde
            }
            if ((abs(oldx - m_Location_x) > (2 * m_TerrRange)) || (abs(oldy - m_Location_y) > (2 * m_TerrRange)))
            {
                // Have we moved more than _TerrRange from old home
                return vdisp_Infanticide; // This will result in an infanticide attempt if females in the new territory have young and the male has moved outside his old terr range.
            }
        }
    }
    return vdisp_CarryOn;
}
//---------------------------------------------------------------------------
bool Vole_Male::MortalityTest()
{
    // returns true if the vole should die
    if ( m_Have_Territory )
    {
        if (g_rand_uni() < g_DailyMortChanceMaleTerr) return true;
    }
    else if (g_rand_uni() < g_DailyMortChance) return true;
    return false;
}
//---------------------------------------------------------------------------
inline void Vole_Male::DetermineTerritorySize()
{
    if (m_Weight < MinReproWeightM) return;
    m_TerrRange = (int)(m_MinMaleTerritorySize + (m_MaleTerritoryRangeSlope*(m_Weight - MinReproWeightM)));
}
//---------------------------------------------------------------------------
 
inline bool Vole_Male::CanFeed()
{
    if (CalculateCarryingCapacity(m_Location_x, m_Location_y,cfg_VoleDDepConst.value())>= double(m_MinMVoleHabQual))  return true;
        else return false;
}
//---------------------------------------------------------------------------
 
void Vole_Base::CheckTraps()
{
    if (m_OurLandscape->SupplyYearNumber() < 10 ) return; // Don't sample until the population has stabilised
        int r = m_TerrRange;
        int vx = m_Location_x;
        int vy = m_Location_y;
        for (int rad = 0; rad <r; rad++) {
            // Two Loops
            for (int x = vx-rad; x<=vx+rad; x++) {
                int y = vy + rad;
                if (m_OurPopulation->IsTrap( x, y ) ) {
                    if (random(1) == 0) {
                        m_intrappos.m_x = x;
                        m_intrappos.m_y = y;
                        m_intrappos.m_EleType = m_OurLandscape->SupplyElementType(x, y);
                        m_intrappos.m_VegType = m_OurLandscape->SupplyVegType(x, y);
                        m_intrappos.m_inAtrap = true;
                        return;
                    }
                }
                y = vy - rad;
                if (m_OurPopulation->IsTrap( x, y ) ) {
                    if (random(1) == 0) {
                        m_intrappos.m_x = x;
                        m_intrappos.m_y = y;
                        m_intrappos.m_EleType = m_OurLandscape->SupplyElementType(x, y);
                        m_intrappos.m_VegType = m_OurLandscape->SupplyVegType(x, y);
                        m_intrappos.m_inAtrap = true;
                        return;
                    }
                }
            }
            for (int y = vy-(rad-1); y<=vy+(rad-1); y++) {
                int x = vx + rad;
                if (m_OurPopulation->IsTrap( x, y ) ) {
                    if (random(1) == 0) {
                        m_intrappos.m_x = x;
                        m_intrappos.m_y = y;
                        m_intrappos.m_EleType = m_OurLandscape->SupplyElementType(x, y);
                        m_intrappos.m_VegType = m_OurLandscape->SupplyVegType(x, y);
                        m_intrappos.m_inAtrap = true;
                        return;
                    }
                }
                x = vx - rad;
                if (m_OurPopulation->IsTrap( x, y ) ) {
                    if (random(1) == 0) {
                        m_intrappos.m_x = x;
                        m_intrappos.m_y = y;
                        m_intrappos.m_EleType = m_OurLandscape->SupplyElementType(x, y);
                        m_intrappos.m_VegType = m_OurLandscape->SupplyVegType(x, y);
                        m_intrappos.m_inAtrap = true;
                        return;
                    }
                }
            }
        }
}
 
/*
*****************************************************************************************
******************************** Juvenile Male Code *************************************
*****************************************************************************************
*/
 
void Vole_JuvenileMale::st_JuvenileExplore(void)
{
    // Just do some movement at first
    MoveTo(random(8),MinMaleMovement,20);
}
//---------------------------------------------------------------------------
bool Vole_JuvenileMale::OnFarmEvent(FarmToDo event)
{
 switch(event)
 {
case  sleep_all_day:
  break;
case  autumn_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  autumn_harrow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  autumn_roll:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  autumn_sow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  winter_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  deep_ploughing:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  spring_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  spring_harrow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  spring_roll:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  spring_sow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  fp_npks:
  break;
case  fp_npk:
  break;
case  fp_pk:
  break;
case  fp_liquidNH3:
  break;
case  fp_slurry:
  break;
case  fp_manganesesulphate:
  break;
case  fp_manure:
  break;
case  fp_greenmanure:
  break;
case  fp_sludge:
  break;
case  fa_npk:
  break;
case  fa_pk:
  break;
case  fa_slurry:
  break;
case  fa_ammoniumsulphate:
  break;
case  fa_manure:
  break;
case  fa_greenmanure:
  break;
case  fa_sludge:
  break;
case glyphosate:
  break;
case  herbicide_treat:
  if (g_rand_uni()<VoleHerbicicideMort)
     CurrentVState=tovs_MDying;
  break;
case  growth_regulator:
  break;
case  fungicide_treat:
  break;
case  insecticide_treat:
  if (g_rand_uni()<VoleInsecticideMort)
     CurrentVState=tovs_MDying;
  break;
case  molluscicide:
  break;
case  row_cultivation:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  strigling:
  if (g_rand_uni()<VoleStriglingMort)
     CurrentVState=tovs_MDying;
  break;
case  hilling_up:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  water:
  break;
case  swathing:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  harvest:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  cattle_out:
case  cattle_out_low:
  break;
case  cut_to_hay:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  cut_to_silage:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  straw_chopping:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  hay_turning:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  hay_bailing:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case  stubble_harrowing:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  autumn_or_spring_plough:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case  burn_straw_stubble:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case mow:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case cut_weeds:
  if (g_rand_uni()<VoleHarvestMort)
     CurrentVState=tovs_MDying;
  break;
case pigs_out:
  if (g_rand_uni()<VolePigGrazingMort)
     CurrentVState=tovs_MDying;
  break;
case strigling_sow:
  if (g_rand_uni()<VoleSoilCultivationMort)
     CurrentVState=tovs_MDying;
  break;
case trial_insecticidetreat:
case trial_toxiccontrol:
case trial_control:
  break;
default:
  g_msg->Warn( WARN_FILE, "Vole_JuvenileMale::OnFarmEvent(): Unknown event type:",
          m_OurLandscape->EventtypeToString(event) );
  exit( 1 );
 }
 if (CurrentVState==tovs_MDying) {
     if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MFarm,1);
     return true;
 }
 else
 return false;
}
//----------------------------------------------------------------------------
 
inline void Vole_JuvenileMale::SetLocation() {
     m_OurPopulation->m_VoleMap->SetMapValue(m_Location_x,m_Location_y,this);
    };
//----------------------------------------------------------------------------
 
inline void Vole_JuvenileMale::FreeLocation() {
     m_OurPopulation->m_VoleMap->ClearMapValue(m_Location_x,m_Location_y);
    };
//----------------------------------------------------------------------------
 
inline bool Vole_JuvenileMale::GetLocation(int px, int py) {
     if( m_OurPopulation->m_VoleMap->GetMapValue(px,py)!=NULL) return true;
     return false;
    };
//---------------------------------------------------------------------------
 
void Vole_JuvenileMale::BeginStep()
{
        if (MortalityTest())
        {
            if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MBck,1);
            CurrentVState=tovs_MDying;
            m_StepDone=true;
        }
        else
        {
            if (--m_LifeSpan<1)
            {
                if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MLife,1);
                CurrentVState=tovs_MDying;
                m_StepDone=true;
            }
        }
#ifdef __VOLEPESTICIDEON
    PesticideIngestion();
    ActOnPesticideDose();
#endif
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileMale::Step()
{
  if (m_StepDone || m_CurrentStateNo == -1) return;
  switch (CurrentVState)
  {
   case tovs_InitialState:  //initial state
     CurrentVState=tovs_JuvenileExploration;
     break;
   case tovs_JuvenileExploration: // Juvenile Exploration
    st_JuvenileExplore();
    CurrentVState=tovs_MEvaluateExplore;
    m_StepDone=true;
    break;
   case tovs_MEvaluateExplore: // Eval&Explore
       CurrentVState = st_Eval_n_Explore();
       m_StepDone=true;
       break;
   case tovs_MMaturation:
       st_BecomeSubAdult();
       break;
   case tovs_MDying:
       FreeLocation();
       m_StepDone=true;
       break;
   default:
       m_OurLandscape->Warn("Vole_JuvenileMale::Step - unknown return error",NULL);
       exit(1);
  }
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileMale::EndStep()
{
  CheckManagement();
  if (CurrentVState==tovs_MDying)
  {
      st_Dying();
  }
  else
  {
    m_Age++;
    m_Weight+=growthperdayM;
    if (m_Age >= MinReproAgeM) CurrentVState = tovs_MMaturation;
    if (m_OurLandscape->SupplyDayInYear() == 1) {
        m_BornLastYear = true; // must be true if alive on 1st Jan.
    }
  }
}
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_JuvenileMale::st_Eval_n_Explore(void)
{
#ifdef __USINGTRAPLINES
    CheckTraps();
#endif
    double Qual = CalculateCarryingCapacity(m_Location_x, m_Location_y, cfg_VoleDDepConst.value());
    int NoFemales = m_OurPopulation->SupplyCountFemales(m_Location_x, m_Location_y, m_TerrRange);
    bool NoMates = false;
    if (NoFemales<1) if ((g_rand_uni() < g_NoFemalesMove)) NoMates = true;
    //if (NoFemales<1) NoMates = true;
    int OldMales = 1;
    OldMales = m_OurPopulation->SupplyInOlderTerr(m_Location_x, m_Location_y, m_Age, m_TerrRange); // returns -1 if a male has p_x,p_y in his territory and is older than p_Age else returns the number of females present
    if ((Qual < m_MinJMVoleHabQual) || (OldMales<1) || NoMates)
    //if ((Qual < m_MinJMVoleHabQual) || (OldMales < 1))
    {
        m_DispVector = random(8);
        // Not quality dependent dispersal, very directed
        return Dispersal(-1, random(MaleMovement[0]) + 1);
    }
    else return (Dispersal(Qual, 1 + random(MaleMovement[0]) + 1));
}
 
//---------------------------------------------------------------------------
 
TTypeOfVoleState Vole_JuvenileMale::Dispersal(double p_OldQual, int p_Distance)
{
    if (g_rand_uni() < g_extradispmort )
    {
        if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MDisp,1);
        return tovs_MDying;
    }
    // Returns 1 for die, 0 for carry on
    if (m_DispVector == -1) m_DispVector = random(8); // Choose direction 0-7
    // Go that far in that direction (assuming it is possible to do that)
    int oldx = m_Location_x;
    int oldy = m_Location_y;
    MoveTo(m_DispVector, p_Distance,10);
    //  Now we are there so what is the new quality
    // 1. Get the carrying capacity
    double CC = CalculateCarryingCapacity(m_Location_x,m_Location_y,cfg_VoleDDepConst.value());
    if ( CC <= p_OldQual )
    {
        // Don't want to move
        FreeLocation();
        m_Location_x=oldx;
        m_Location_y=oldy;
        SetLocation();
    }
    return tovs_MEvaluateExplore;
}
//---------------------------------------------------------------------------
void Vole_JuvenileMale::st_BecomeSubAdult()
{
      struct_Vole_Adult* av;
      av = new struct_Vole_Adult;
      av->VPM = m_OurPopulation;
      av->L = m_OurLandscape;
      if (m_MyGenes.GetDirectFlag() == 0) av->m_dflag = false; else av->m_flag = true;
      if (m_MyGenes.GetGeneticFlag() == 0) av->m_gflag = false; else av->m_gflag = true;
      av->m_flag=true; // Used to signal pesticide effect to CreateObjects
      // Create the new voles (50% chance of male/female)
      av->PolyRefBorn = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
      av->ElemBorn = m_OurLandscape->SupplyElementType(m_Location_x, m_Location_y);
      av->VegBorn = m_OurLandscape->SupplyVegType(m_Location_x, m_Location_y);
      av->FatherId = m_FatherId;
      av->MotherId = m_MotherId;
      av->x = m_Location_x;
      av->y = m_Location_y;
      av->weight = m_Weight;
      // Do the genetics
      av->Genes = m_MyGenes;
      av->age = m_Age;
      m_OurPopulation->CreateObjects(vob_Male,this,av,1);
      // Remove the current object
      CurrentVState = tovs_MDying;
      FreeLocation();
      m_CurrentStateNo = -1;
      m_StepDone = true;
 
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileMale::OnKilled()
{
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MPred,1);
    CurrentVState=tovs_MDying;
}
//---------------------------------------------------------------------------
 
Vole_JuvenileMale::Vole_JuvenileMale(struct_Vole_Adult *p_aVoleStruct):Vole_Base(p_aVoleStruct)
{
    m_Age = 14;
    m_Weight=WeanedWeight;
    m_Sex=true;
    m_TerrRange=m_MinMaleTerritorySize;
    m_MinTerrRange=m_MinMaleTerritorySize;
}
//---------------------------------------------------------------------------
 
void Vole_JuvenileMale::ReInit(struct_Vole_Adult * p_aVoleStruct) {
    Init(p_aVoleStruct);
    m_Age = 14;
    m_Weight = WeanedWeight;
    m_Sex = true;
    m_TerrRange = m_MinMaleTerritorySize;
    m_MinTerrRange = m_MinMaleTerritorySize;
}
//---------------------------------------------------------------------------
 
Vole_JuvenileMale::~Vole_JuvenileMale()
{
  // Nothing to do
}
//---------------------------------------------------------------------------
#ifdef __VOLERODENTICIDEON
//#####################################################################################
//############################# RODENTICIDE HANDLING CODE ###############################
//#####################################################################################
 
void Vole_Base::RodenticideIngestion(void)
{
    double rodenticide = m_OurLandscape->SupplyRodenticide(m_Location_x, m_Location_y);
    if (rodenticide>0)  { 
 
        // Todo effects
    }
    else return;
}
#endif
 
#ifdef __VOLEPESTICIDEON
//#####################################################################################
//############################# PESTICIDE HANDLING CODE ###############################
//#####################################################################################
 
void Vole_Base::PesticideIngestion( void )
{
    // If we are not running the pesticide module, then do nothing
    if ( !l_pest_enable_pesticide_engine.value()) return;
    BioDegradePesticide(); 
    double pest=0;
    pest =m_OurLandscape->SupplyPesticide( m_Location_x,m_Location_y, ppp_1); // ppp_1 is assumed. Units are mg/kg vegetation or mg/m2
    if (!cfg_pest_residue_or_rate.value())
    {
        /*
        // pest is is mg/m2 (corrected for wetweight)
        // veg is in g/m2
        // we need this in mg/kg body weight
        // mg/g veg = pest/veg
        // ingested mg (X) = pest/veg * 0.010425 * 1000
        // mg/kg = X/0.025  (vole weight in kg)
        pest*=g_SpeedyDivides[veg]; // assuming 70% is water
        */
        double veg= 1 + m_OurLandscape->SupplyVegBiomass( m_Location_x,m_Location_y );  // Units are g dw/m2, 1 added to avoid divide by zero
        veg *= 3.33333; // assuming 70% water
        pest *= g_SpeedyDivides[(int)veg]; // mg/kg ww
    }
    //pest *= 0.010425; // mg ingested
    //pest *= 40; // = 1/0.025 // mg/kg bw ingested
    m_pesticideload += pest; // add this to the current body burden
}
 
void Vole_Base::ActOnPesticideDose()
{
    TTypesOfPesticide tp = m_OurLandscape->SupplyPesticideType();
    if ( tp == ttop_ModelinkPesticide21TWA ) ModelinkPesticide21TWA(m_pesticideload);
    else if (m_pesticideload > cfg_PesticideAccumulationThreshold.value()) 
    {
        switch (tp)
        {
        case ttop_NoPesticide:
            break;
        case ttop_ReproductiveEffects:
            GeneralEndocrineDisruptor(m_pesticideload);
            break;
        case ttop_AcuteEffects:
            GeneralOrganophosphate(m_pesticideload); 
            break;
        case ttop_Vinclozolin:
            Vinclozolin(m_pesticideload);
            break;
        case ttop_ModelinkPesticide:
            ModelinkPesticide();
            break;
        case ttop_GeneticDemo:
            GeneticDemoPesticide(m_pesticideload); 
            break;
        default:
            exit(47);
        }
    }
}
 
//*************************************************************************************
//************************** PESTICIDE SPECIFIC EFFECT CODE ***************************
//*************************************************************************************
 
//-------------------------------------------------------------------------------------
//------------------------------ MODELINKPESTICIDE EFFECT CODE ------------------------
//-------------------------------------------------------------------------------------
void Vole_JuvenileMale::ModelinkPesticide()
{
    ; // No impact
}
 
void Vole_JuvenileMale::ModelinkPesticide21TWA(double /* a_dose */)
{
    ; // No impact
}
 
void Vole_JuvenileFemale::ModelinkPesticide()
{
    ; // No impact
}
 
void Vole_JuvenileFemale::ModelinkPesticide21TWA(double /* a_dose */)
{
    ; // No impact
}
 
void Vole_Male::ModelinkPesticide()
{
    ; // No impact
}
 
void Vole_Male::ModelinkPesticide21TWA(double /* a_dose */)
{
    ; // No impact
}
 
void Vole_Female::ModelinkPesticide()
{
    // Specify certain gestation days for the effects here
    if (((m_DaysUntilBirth>0) && (m_DaysUntilBirth<m_EndoCrineDisruptionGestationLength)) || (CurrentVState==tovs_Lactating) )
    {
        if (m_pesticideload > m_pesticideInfluenced3)
        {
            m_pesticideInfluenced3=m_pesticideload;
        }
    }
}
 
void Vole_Female::ModelinkPesticide21TWA(double /* a_dose */)
{
    m_pesticideloadarray[m_pesticideloadindex++]=m_pesticideload;
    if (m_pesticideloadindex==21) m_pesticideloadindex=0;
}
 
//-------------------------------------------------------------------------------------
//------------------------------ VINCLOZALIN EFFECT CODE ------------------------------
//-------------------------------------------------------------------------------------
void Vole_JuvenileMale::Vinclozolin(double /* a_dose */ )
{
    ; // No impact
}
 
void Vole_JuvenileFemale::Vinclozolin(double /* a_dose */ )
{
    ; // No impact
}
 
void Vole_Male::Vinclozolin(double /* a_dose */ )
{
    ; // No impact
}
 
void Vole_Female::Vinclozolin(double /* a_dose */ )
{
    // May also wish to specify certain gestation days for the effects here
    if ((m_DaysUntilBirth>0) && (m_DaysUntilBirth<m_EndoCrineDisruptionGestationLength))
    {
        m_pesticideInfluenced1 = true;
    }
}
 
//-------------------------------------------------------------------------------------
//-------------------- GENERAL ENDOCRINE DISRUPTOR EFFECT CODE ------------------------
//-------------------------------------------------------------------------------------
 
void Vole_Female::GeneralEndocrineDisruptor(double /* a_dose */ )
{
    // May also wish to specify certain gestation days for the effects here
    if ((m_DaysUntilBirth>0) && (m_DaysUntilBirth< m_EndoCrineDisruptionGestationLength))
    {
        m_pesticideInfluenced1 = true;
    }
}
 
void Vole_Male::GeneralEndocrineDisruptor(double /* a_dose */ )
{
    ; // No effect
}
 
void Vole_JuvenileMale::GeneralEndocrineDisruptor(double /* a_dose */ )
{
    ; // No effect
}
 
void Vole_JuvenileFemale::GeneralEndocrineDisruptor(double /* a_dose */ )
{
    ; // No effect
}
 
 
 
//-------------------------------------------------------------------------------------
//------------------------ GENERAL ORGANOPHOSPHATE EFFECT CODE ------------------------
//-------------------------------------------------------------------------------------
void Vole_JuvenileMale::GeneralOrganophosphate(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return;
    CurrentVState=tovs_MDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MPest,1);
    return;
}
 
void Vole_JuvenileFemale::GeneralOrganophosphate(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return;
    CurrentVState=tovs_FDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FPest,1);
    return;
}
 
void Vole_Male::GeneralOrganophosphate(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return;
    CurrentVState=tovs_MDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MPest,1);
    return;
}
 
void Vole_Female::GeneralOrganophosphate(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return;
    CurrentVState=tovs_FDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FPest,1);
    return;
}
 
void Vole_JuvenileMale::GeneticDemoPesticide(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return;
    if ( cfg_ResistanceDominant.value()){ if ((SupplyMyAllele(3,0) == 1) || (SupplyMyAllele(3,1) == 1)) return; }
      else
 
      {
          if ((SupplyMyAllele(3,0) == 1) && (SupplyMyAllele(3,1) == 1))
    {
            return;
    }
      }
    CurrentVState=tovs_MDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MPest,1);
    return;
}
 
void Vole_JuvenileFemale::GeneticDemoPesticide(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return;
    if ( cfg_ResistanceDominant.value()) { if ((SupplyMyAllele(3,0) == 1) || (SupplyMyAllele(3,1) == 1)) return; }
      else if ((SupplyMyAllele(3,0) == 1) && (SupplyMyAllele(3,1) == 1))
    {
            return;
    }
    CurrentVState=tovs_FDying;
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FPest,1);
    return;
}
 
void Vole_Male::GeneticDemoPesticide(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return; // No effect triggered due probability
    if ( cfg_ResistanceDominant.value()) { if ((SupplyMyAllele(3,0) == 1) || (SupplyMyAllele(3,1) == 1)) return; } // If we assume a dominant resistant allele then if either are set there is no effect
      else if ((SupplyMyAllele(3,0) == 1) && (SupplyMyAllele(3,1) == 1))
    {
            return;
    }
    CurrentVState=tovs_MDying; // No save due to resistance so the vole dies
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_MPest,1);
    return;
}
 
void Vole_Female::GeneticDemoPesticide(double /* a_dose */)
{
    if ( g_rand_uni() > l_pest_daily_mort.value() ) return; // No effect triggered due probability
    if ( cfg_ResistanceDominant.value()) { if ((SupplyMyAllele(3,0) == 1) || (SupplyMyAllele(3,1) == 1)) return; } // If we assume a dominant resistant allele then if either are set there is no effect
      else if ((SupplyMyAllele(3,0) == 1) && (SupplyMyAllele(3,1) == 1))
    {
            return;
    }
    CurrentVState=tovs_FDying; // No save due to resistance so the vole dies
    m_StepDone=true;
    if (cfg_RecordVoleMort.value() ) m_OurPopulation->m_VoleRecordMort->ChangeData(tovmort_FPest,1);
    return;
}
 
//#####################################################################################
//########################### END PESTICIDE HANDLING CODE #############################
//#####################################################################################
 
#endif