PopulationManager.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.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
//
#include <vector>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string.h>
#include <list>

#include "../Landscape/ls.h"
#include "../BatchALMaSS/PopulationManager.h"
#include "../GooseManagement/GooseMemoryMap.h"
#include "../GooseManagement/Goose_Base.h"
#include "../BatchALMaSS/CurveClasses.h"
#include "../Hunters/Hunters_all.h"
#include "../GooseManagement/Goose_Population_Manager.h"
#ifdef __ALMASS_VISUAL
#include "wx/wx.h"
#include "wx/spinctrl.h"
#include "../GUI/ALMaSS_GUI.h"
#endif
#include "../BatchALMaSS/BoostRandomGenerators.h"

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

using namespace std;

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


/* Species code
#ifdef StartAnimal
  #include "../Skylark/Skylarks_All.h"
#endif
#ifdef PartridgeModel
  #include "../Partridge/Partridge_All.h"
#endif
#ifdef SkylarkModel
  #include "../Skylark/Skylarks_All.h"
#endif
#ifdef YellowhammerModel
  #include "../Yellowhammer/Yellowhammer_All.h"
#endif
#ifdef SpiderModel
  #include "../Spider/Spider_all.h"
#endif
#ifdef BembidionModel
  #include "../Bembidion/Bembidion_all.h"
#endif
#ifdef RoeDeerModel
  #include "../RoeDeer/Roe_all.h"
#endif
#ifdef FieldVoleModel
  #include "../Vole/GeneticMaterial.h"
  #include "../Vole/Predators.h"
  #include "../Vole/Vole_all.h"
#endif
*/
#define _CRTDBG_MAP_ALLOC

static CfgStr cfg_RipleysOutput_filename( "G_RIPLEYSOUTPUT_FILENAME", CFG_CUSTOM, "RipleysOutput.txt" );
static CfgStr cfg_ReallyBigOutput_filename( "G_REALLYBIGOUTPUT_FILENAME", CFG_CUSTOM, "ReallyBigOutput.txt" );
CfgBool cfg_RipleysOutputMonthly_used( "G_RIPLEYSOUTPUTMONTHLY_USED", CFG_CUSTOM, false );
CfgBool cfg_RipleysOutput_used( "G_RIPLEYSOUTPUT_USED", CFG_CUSTOM, true );
CfgBool cfg_ReallyBigOutput_used( "G_REALLYBIGOUTPUT_USED", CFG_CUSTOM, false );
CfgBool cfg_fixed_random_sequence("G_FIXEDRANDOMSEQUENCE",CFG_CUSTOM,false);
static CfgInt cfg_RipleysOutput_interval( "G_RIPLEYSOUTPUT_INTERVAL", CFG_CUSTOM, 1 );
static CfgInt cfg_RipleysOutput_day( "G_RIPLEYSOUTPUT_DAY", CFG_CUSTOM, 60 );
static CfgInt cfg_RipleysOutputFirstYear("G_RIPLEYSOUTPUT_FIRSTYEAR",CFG_CUSTOM,1);
static CfgInt cfg_ReallyBigOutput_interval( "G_REALLYBIGOUTPUT_INTERVAL", CFG_CUSTOM, 1 );
static CfgInt cfg_ReallyBigOutput_day1( "G_REALLYBIGOUTPUT_DAY_ONE", CFG_CUSTOM, 1 );
static CfgInt cfg_ReallyBigOutput_day2( "G_REALLYBIGOUTPUT_DAY_TWO", CFG_CUSTOM, 91 );
static CfgInt cfg_ReallyBigOutput_day3( "G_REALLYBIGOUTPUT_DAY_THREE", CFG_CUSTOM, 182 );
static CfgInt cfg_ReallyBigOutput_day4( "G_REALLYBIGOUTPUT_DAY_FOUR", CFG_CUSTOM, 274 );
static CfgInt cfg_ReallyBigOutputFirstYear("G_REALLYBIGOUTPUT_FIRSTYEAR",CFG_CUSTOM,1);
static CfgInt cfg_CipeGridSize("G_CIPEGRIDSIZE",CFG_CUSTOM,500);
CfgStr cfg_CIPEGridOutput_filename( "G_CIPEGRIDOUTPUT_FILENAME", CFG_CUSTOM, "CIPEGridOutput.txt" );
CfgStr cfg_CIPEGridOutput_filenameB( "G_CIPEGRIDOUTPUT_FILENAME_B", CFG_CUSTOM, "CIPEGridOutputB.txt" );
CfgBool cfg_CIPEGridOutput_used( "G_CIPEGRIDOUTPUT_USED", CFG_CUSTOM, false );
CfgInt cfg_CIPEGridOutput_Interval( "G_CIPEGRIDOUTPUT_INTERVAL", CFG_CUSTOM, 1 );
CfgInt cfg_CIPEGridOutput_day( "G_CIPEGRIDOUTPUT_DAY", CFG_CUSTOM, 1 );
CfgInt cfg_CIPEGridOutput_day_b( "G_CIPEGRIDOUTPUT_DAY_B", CFG_CUSTOM, 270 );
// Catastrophe config variables
CfgInt cfg_CatastropheEventStartYear("PM_CATASTROPHEEVENTSTARTYEAR",CFG_CUSTOM,99999); // this means unless this is altered it events will not happen
CfgInt cfg_pm_eventfrequency( "PM_EVENTFREQUENCY", CFG_CUSTOM, 0 ); // every X years
CfgInt cfg_pm_eventsize( "PM_EVENTSIZE", CFG_CUSTOM, 100 ); // The percentage change in population size, 100=no change
static CfgInt cfg_DayInMonth( "PRB_DAYINMONTH", CFG_CUSTOM, 1 );
static CfgBool cfg_VoleCatastrophe_on( "VOLE_CATASTROPHE_ON", CFG_CUSTOM, false );
static CfgInt cfg_VoleCatastrophe_interval( "VOLE_CATASTROPHE_I", CFG_CUSTOM, 365 * 5 );
static CfgInt cfg_VoleCatastrophe_mortality( "VOLE_CATASTROPHE_M", CFG_CUSTOM, 90 );

char g_str[255];

//---------------------------------------------------------------------------
//                        Population Manager
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void probe_data::CloseFile() {
  if ( m_MyFile != NULL ) {
      if (m_MyFile->is_open()) m_MyFile->close();
      delete m_MyFile;
  }
};

class CompareX {
public:
  bool operator() ( TAnimal * A1, TAnimal * A2 ) const {
    return (A1->Supply_m_Location_x() < A2->Supply_m_Location_x());
  }
};

class CompareY {
public:
  bool operator() ( TAnimal * A1, TAnimal * A2 ) const {
    return (A1->Supply_m_Location_y() < A2->Supply_m_Location_y());
  }
};

class CompareState {
public:
  bool operator() ( TAnimal * A1, TAnimal * A2 ) const {
    return (A1->WhatState() < A2->WhatState());
  }
};


class CompareStateR {
public:
    bool operator() (TAnimal * A1, TAnimal * A2) const {
        return (A1->GetCurrentStateNo() > A2->GetCurrentStateNo());
    }
};

class CompareStateDead {
public:
    bool operator() (TAnimal * A1) const {
        return (A1->GetCurrentStateNo() == -1);
    }
};

class CompareStateAlive {
public:
    bool operator() (TAnimal * A1) const {
        return (A1->GetCurrentStateNo() != -1);
    }
};



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


Population_Manager::Population_Manager( Landscape * L ) {
    // Keep a pointer to the landscape this population is in
    m_TheLandscape = L;
    // create 10 empty arrays as default, excess can be removed in descendent classes
    TListOfAnimals alist;
    TheArray.insert( TheArray.end(), 10, alist );
    // Set the simulation bounds
    SimH = m_TheLandscape->SupplySimAreaHeight();
    SimW = m_TheLandscape->SupplySimAreaWidth();
    SimHH = m_TheLandscape->SupplySimAreaHeight()/2;
    SimWH = m_TheLandscape->SupplySimAreaWidth()/2;
    for (int i = 0; i < 10; i++) {
        // Set default BeforeStepActions
        BeforeStepActions[ i ] = 0;
        m_ListNames[ i ] = "Unknown";
        m_LiveArraySize.push_back( 0 );
    }
    // modify this if they need to in descendent classes
    StateNamesLength = 0; // initialise this variable.
    m_catastrophestartyear=-1; // Default is don't do this
#ifdef __LAMBDA_RECORD
    ofstream fout("LambdaGridOuput.txt", ios_base::out);  // open for writing
    fout.close();
    LamdaClear();
#endif
  if ( cfg_RipleysOutputMonthly_used.value() ) {
    OpenTheMonthlyRipleysOutputProbe();
  }
    m_cipegridsize = cfg_CipeGridSize.value();
    m_cgridcountwidth = SimW/m_cipegridsize;
    m_cgridcount = new int[ m_cgridcountwidth * m_cgridcountwidth ];
    m_gridcountsize[0] = 50;
    m_gridcountsize[1] = 100;
    m_gridcountsize[2] = 200;
    m_gridcountsize[3] = 500;
    m_gridcountwidth[0] = SimW/50;
    m_gridcountwidth[1] = SimW/100;
    m_gridcountwidth[2] = SimW/200;
    m_gridcountwidth[3] = SimW/500;
    m_gridcount[0] = new int[ m_gridcountwidth[0] * m_gridcountwidth[0] ];
    m_gridcount[1] = new int[ m_gridcountwidth[1] * m_gridcountwidth[1] ];
    m_gridcount[2] = new int[ m_gridcountwidth[2] * m_gridcountwidth[2] ];
    m_gridcount[3] = new int[ m_gridcountwidth[3] * m_gridcountwidth[3] ];
    // Ensure the GUI pointer is NULL in case we are not in GUI mode
#ifdef __ALMASS_VISUAL
    m_MainForm = NULL;
#endif
    m_SeasonNumber = 0;  // Ensure that we start in season number 0. Season number is incremented at day in year 183
}
//---------------------------------------------------------------------------

Population_Manager::~Population_Manager( void ) {
  // clean-up
  for ( unsigned i = 0; i < TheArray.size(); i++ ) {
    // if objects in the list need to be deleted:
    for ( unsigned j = 0; j < (unsigned) GetLiveArraySize(i); j++ ) {
      delete TheArray[ i ] [ j ];
    }
    // empty the array
    TheArray[ i ].clear();
    // --
  }
  if ( cfg_RipleysOutput_used.value() ) {
    CloseTheRipleysOutputProbe();
    fclose( NWordOutputPrb );
  }
 if ( cfg_RipleysOutputMonthly_used.value() ) {
    CloseTheMonthlyRipleysOutputProbe();
  }
  if ( cfg_ReallyBigOutput_used.value() ) {
    CloseTheReallyBigOutputProbe();
  }
  for (int d=0; d<4; d++) delete [] m_gridcount[d];
  delete [] m_cgridcount;
}

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

void Population_Manager::LOG( const char* fname ) {
  FILE * PFile = fopen(fname, "w" );
  if (PFile) {
      m_TheLandscape->Warn("PopulationManager::LOG - Could not open file ",fname);
      exit(0);
  }
  AnimalPosition AP;
  for ( unsigned listindex = 0; listindex < TheArray.size(); listindex++ ) {
#ifndef __BCB__
    fprintf( PFile, "%s :\n", m_ListNames[ listindex ] );
#else
    fprintf( PFile, "%s :\n", m_ListNames[ listindex ].c_str() );
#endif
    for ( unsigned j = 0; j < (unsigned) m_LiveArraySize[listindex]; j++ ) {
      AP = TheArray[ listindex ] [ j ]->SupplyPosition();
      fprintf( PFile, "%i %i %i\n", j, AP.m_x, AP.m_y );
    }
  }
  fclose( PFile );
}

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

void Population_Manager::DoFirst() {
}

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

void Population_Manager::DoBefore() {
}

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

void Population_Manager::Run( int NoTSteps ) {
  for ( int TSteps = 0; TSteps < NoTSteps; TSteps++ )
  {
      unsigned size2;
      unsigned size1 =  (unsigned) TheArray.size();
      for ( unsigned listindex = 0; listindex < size1; listindex++ )
      {
          // Must check each object in the list for m_CurrentStateNo==-1
          m_LiveArraySize[listindex] = PartitionLiveDead(listindex);
      }
#ifdef __ALMASS_VISUAL
      if (m_MainForm!=NULL)
      {
          int n = 0;
          for ( unsigned listindex = 0; listindex < size1; listindex++ ) n += (int) m_LiveArraySize[ listindex ];
          //if (n>0) DisplayLocations();
      }
#endif
      // begin step actions ...
      // set all stepdone to false.... is this really necessary??
      for ( unsigned listindex = 0; listindex < size1; listindex++ )
      {
          size2 = (unsigned) GetLiveArraySize(listindex);
          for ( unsigned j = 0; j < size2; j++ )
          {
              TheArray[ listindex ] [ j ]->SetStepDone( false );
          }
      }

      for ( unsigned listindex = 0; listindex < size1; listindex++ ) {
          // Call the Shuffle/Sort procedures
          Shuffle_or_Sort( listindex );
      }
      // Need to check if Ripleys Statistic needs to be saved
      if ( cfg_RipleysOutput_used.value() ) {
          int Year = m_TheLandscape->SupplyYearNumber();
          if (Year>=cfg_RipleysOutputFirstYear.value()) {
              if ( Year % cfg_RipleysOutput_interval.value() == 0 ) {
                  int day = m_TheLandscape->SupplyDayInYear();
                  if ( cfg_RipleysOutput_day.value() == day ) {
                      // Do the Ripley Probe
                      TheRipleysOutputProbe( RipleysOutputPrb );
                      TheNWordOutputProbe(); // These two go hand in hand.
                  }
              }
          }
      }
    // Need to check if Monthly Ripleys Statistic needs to be saved
    if ( cfg_RipleysOutputMonthly_used.value() ) {
        if (m_TheLandscape->SupplyDayInMonth()==1) {
            int Year = m_TheLandscape->SupplyYearNumber();
            if (Year>=cfg_RipleysOutputFirstYear.value()) {
                if ( Year % cfg_RipleysOutput_interval.value() == 0 ) {
                    int month = m_TheLandscape->SupplyMonth();
                    // Do the Ripley Probe
                    switch (month) {
                        case 1: TheRipleysOutputProbe( RipleysOutputPrb1 );
                            break;
                        case 2: TheRipleysOutputProbe( RipleysOutputPrb2 );
                            break;
                        case 3: TheRipleysOutputProbe( RipleysOutputPrb3 );
                            break;
                        case 4: TheRipleysOutputProbe( RipleysOutputPrb4 );
                            break;
                        case 5: TheRipleysOutputProbe( RipleysOutputPrb5 );
                            break;
                        case 6: TheRipleysOutputProbe( RipleysOutputPrb6 );
                            break;
                        case 7: TheRipleysOutputProbe( RipleysOutputPrb7 );
                            break;
                        case 8: TheRipleysOutputProbe( RipleysOutputPrb8 );
                            break;
                        case 9: TheRipleysOutputProbe( RipleysOutputPrb9 );
                            break;
                        case 10: TheRipleysOutputProbe( RipleysOutputPrb10 );
                            break;
                        case 11: TheRipleysOutputProbe( RipleysOutputPrb11 );
                            break;
                        case 12: TheRipleysOutputProbe( RipleysOutputPrb12 );
                            break;
                    }
                }
            }
        }
    }
    // Need to check if Really Big Probe needs to be saved
    if ( cfg_ReallyBigOutput_used.value() ) {
      int Year = m_TheLandscape->SupplyYearNumber();
      if (Year>=cfg_ReallyBigOutputFirstYear.value()) {
          if ( Year % cfg_ReallyBigOutput_interval.value() == 0 ) {
            int day = m_TheLandscape->SupplyDayInYear();
            if (( cfg_ReallyBigOutput_day1.value() == day )|| ( cfg_ReallyBigOutput_day2.value() == day )|| ( cfg_ReallyBigOutput_day3.value() == day )|| ( cfg_ReallyBigOutput_day4.value() == day )||( cfg_ReallyBigOutput_day1.value() == -1 ))
            {
              // Do the Ripley Probe
              TheReallyBigOutputProbe();
            }
          }
        }
    }
    // Need to check if CIPEGrid Statistic needs to be saved
    if ( cfg_CIPEGridOutput_used.value() ) {
      int Year = m_TheLandscape->SupplyYearNumber();
      if ( Year % cfg_CIPEGridOutput_Interval.value() == 0 ) {
        int day = m_TheLandscape->SupplyDayInYear();
        if ( cfg_CIPEGridOutput_day.value() == day ) {
          // Do the Ripley Probe
          TheCIPEGridOutputProbe();
        }
      }
    }
    int yr=m_TheLandscape->SupplyYearNumber();
    if ( yr > cfg_CatastropheEventStartYear.value() ) {
        if (m_catastrophestartyear==-1) m_catastrophestartyear=yr;
        Catastrophe(); // This method must be overidden in descendent classes
    }
    DoFirst();
    // call the begin-step-method of all objects
    for ( unsigned listindex = 0; listindex < size1; listindex++ ) {
        size2 = (unsigned)GetLiveArraySize( listindex );
        for (unsigned j = 0; j < size2; j++)
        TheArray[ listindex ] [ j ]->BeginStep();
    }
    DoBefore();
    // call the step-method of all objects
    do {
      for ( unsigned listindex = 0; listindex < size1; listindex++ ) {
          size2 = (unsigned)GetLiveArraySize( listindex );
          for (unsigned j = 0; j < size2; j++) {
          TheArray[ listindex ] [ j ]->Step();
        }
      } // for listindex
    } while ( !StepFinished() );
    DoAfter();
    // call the end-step-method of all objects
    for ( unsigned listindex = 0; listindex < size1; listindex++ ) {
        size2 = (unsigned)GetLiveArraySize( listindex );
        for (unsigned j = 0; j < size2; j++) {
        TheArray[ listindex ] [ j ]->EndStep();
      }
    }
    // ----------------
    // end of this step actions
    // For each animal list
    DoAlmostLast();

DoLast();
  } // End of time step loop
}

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

bool Population_Manager::StepFinished( void ) {
  for ( unsigned listindex = 0; listindex < TheArray.size(); listindex++ ) {
      for (unsigned j = 0; j < (unsigned)GetLiveArraySize( listindex ); j++) {
      if ( TheArray[ listindex ] [ j ]->GetStepDone() == false ) {
        return false;
      }
    }
  }
  return true;
}
//---------------------------------------------------------------------------

void Population_Manager::DoAfter() {
  //TODO: Add your source code here
}

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

void Population_Manager::DoAlmostLast() {
  //TODO: Add your source code here
}

//---------------------------------------------------------------------------
void Population_Manager::DoLast() {

/*
#ifdef __UNIX__
  for ( unsigned i = 0; i < 100; i++ ) {
    StateList.n[ i ] = 0;
  }
#else
  // Zero results
  for ( unsigned listindex = 0; listindex < m_ListNameLength; listindex++ ) {
    for ( unsigned i = 0; i < 100; i++ ) {
      Counts[ listindex ] [ i ] = 0;
    }
  }
#endif
  // How many animals in each state?
  for ( unsigned listindex = 0; listindex < TheArray.size(); listindex++ ) {
    unsigned size = (unsigned) TheArray[ listindex ].size();
    for ( unsigned j = 0; j < size; j++ ) {
#ifdef __UNIX__
      StateList.n[ TheArray[ listindex ] [ j ]->WhatState() ] ++;
#else
      Counts[ listindex ] [ TheArray[ listindex ] [ j ]->WhatState() ] ++;
#endif
    }
  }
*/
}
//---------------------------------------------------------------------------

void Population_Manager::DisplayLocations()
{
#ifdef __ALMASS_VISUAL
    m_MainForm->UpdateGraphics();
#endif
}
//---------------------------------------------------------------------------

int Population_Manager::ProbeFileInput( char * p_Filename, int p_ProbeNo ) {
  FILE * PFile;
  int data = 0;
  int data2 = 0;
  char S[ 255 ];
  PFile = fopen(p_Filename, "r" );
  if ( !PFile ) {
    m_TheLandscape->Warn( "Population Manager - cannot open Probe File ", p_Filename );
    exit( 0 );
  }
  fgets( S, 255, PFile ); // dummy line
  fgets( S, 255, PFile ); // dummy line
  fscanf( PFile, "%d\n", & data ); // Reporting interval
  TheProbe[ p_ProbeNo ]->m_ReportInterval = data;
  fgets( S, 255, PFile ); // dummy line
  fscanf( PFile, "%d\n", & data ); // Write to file
  if ( data == 0 ) TheProbe[ p_ProbeNo ]->m_FileRecord = false; else
    TheProbe[ p_ProbeNo ]->m_FileRecord = true;
  fgets( S, 255, PFile ); // dummy line
  for ( int i = 0; i < 10; i++ ) {
    fscanf( PFile, "%d", & data );
    if ( data > 0 ) TheProbe[ p_ProbeNo ]->m_TargetTypes[ i ] = true; else
      TheProbe[ p_ProbeNo ]->m_TargetTypes[ i ] = false;
  }

  fgets( S, 255, PFile ); // dummy line
  fgets( S, 255, PFile ); // dummy line
  fscanf( PFile, "%d", & data );
  TheProbe[ p_ProbeNo ]->m_NoAreas = data;
  fgets( S, 255, PFile ); // dummy line
  fgets( S, 255, PFile ); // dummy line
  fscanf( PFile, "%d", & data2 ); // No References areas
  fgets( S, 255, PFile ); // dummy line
  fgets( S, 255, PFile ); // dummy line
  fscanf( PFile, "%d", & data ); // Type reference for probe
  if ( data == 1 ) TheProbe[ p_ProbeNo ]->m_NoEleTypes = data2; else
    TheProbe[ p_ProbeNo ]->m_NoEleTypes = 0;
  if ( data == 2 ) TheProbe[ p_ProbeNo ]->m_NoVegTypes = data2; else
    TheProbe[ p_ProbeNo ]->m_NoVegTypes = 0;
  if ( data == 3 ) TheProbe[ p_ProbeNo ]->m_NoFarms = data2; else
    TheProbe[ p_ProbeNo ]->m_NoFarms = 0;
  fgets( S, 255, PFile ); // dummy line
  fgets( S, 255, PFile ); // dummy line
  // Now read in the areas data
  for ( int i = 0; i < 10; i++ ) {
    fscanf( PFile, "%d", & data );
    TheProbe[ p_ProbeNo ]->m_Rect[ i ].m_x1 = data;
    fscanf( PFile, "%d", & data );
    TheProbe[ p_ProbeNo ]->m_Rect[ i ].m_y1 = data;
    fscanf( PFile, "%d", & data );
    TheProbe[ p_ProbeNo ]->m_Rect[ i ].m_x2 = data;
    fscanf( PFile, "%d", & data );
    TheProbe[ p_ProbeNo ]->m_Rect[ i ].m_y2 = data;
  }
  fgets( S, 255, PFile ); // dummy line
  fgets( S, 255, PFile ); // dummy line
  if ( TheProbe[ p_ProbeNo ]->m_NoVegTypes > 0 ) {
    for ( int i = 0; i < 25; i++ ) {
      fscanf( PFile, "%d", & data );
      if ( data != 999 )
        TheProbe[ p_ProbeNo ]->m_RefVeg[ i ] = m_TheLandscape->TranslateVegTypes( data );
    }
  } else if ( TheProbe[ p_ProbeNo ]->m_NoFarms > 0 ) {
    for ( int i = 0; i < 25; i++ ) {
      fscanf( PFile, "%d", & data );
      if ( data != 999 )
        TheProbe[ p_ProbeNo ]->m_RefFarms[ i ] = data;
    }
  } else {
    for ( int i = 0; i < 25; i++ ) {
      fscanf( PFile, "%d", & data );
      if ( data != 999 ) TheProbe[ p_ProbeNo ]->m_RefEle[ i ] = m_TheLandscape->TranslateEleTypes( data );
    }
  }
  fclose( PFile );
  return data2; // number of data references
}

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

void Population_Manager::LamdaDumpOutput() {
   ofstream fout("LambdaGridOuput.txt", ios_base::app);  // open for writing
   for (int i=0; i<257; i++ ) {
       for (int j=0; j<257; j++) {
           fout << lamdagrid[0][i][j] << "\t" << lamdagrid[1][i][j] << endl;
       }
   }
   //fout << "NEXT" << endl;
   fout.close();
}
//-----------------------------------------------------------------------------

void Population_Manager::ImpactedProbe( ) {

}
//-----------------------------------------------------------------------------

float Population_Manager::Probe( int ListIndex, probe_data * p_TheProbe ) {
    // Counts through the list and goes through each area to see if the animal
    // is standing there and if the farm, veg or element conditions are met
    AnimalPosition Sp;
    float NumberSk = 0;
    // Four possibilites
    // either NoVegTypes or NoElementTypes or NoFarmTypes is >0 or all==0
    if ( p_TheProbe->m_NoFarms != 0 ) {
        for (unsigned j = 0; j < (unsigned)GetLiveArraySize( ListIndex ); j++) {
            Sp = TheArray[ ListIndex ] [ j ]->SupplyPosition();
            unsigned Farm = TheArray[ ListIndex ] [ j ]->SupplyFarmOwnerRef();
            for ( unsigned i = 0; i < p_TheProbe->m_NoAreas; i++ ) {
                if ( ( Sp.m_x >= p_TheProbe->m_Rect[ i ].m_x1 ) && ( Sp.m_y >= p_TheProbe->m_Rect[ i ].m_y1 )
                        && ( Sp.m_x <= p_TheProbe->m_Rect[ i ].m_x2 ) && ( Sp.m_y <= p_TheProbe->m_Rect[ i ].m_y2 ) )
                for ( unsigned k = 0; k < p_TheProbe->m_NoFarms; k++ ) {
                    if ( p_TheProbe->m_RefFarms[ k ] == Farm )
                    NumberSk++; // it is in the square so increment number
                }

            }
    }
    } else if ( p_TheProbe->m_NoEleTypes != 0 ) {
        for (unsigned j = 0; j < (unsigned)GetLiveArraySize( ListIndex ); j++) {
      Sp = TheArray[ ListIndex ] [ j ]->SupplyPosition();
      for ( unsigned i = 0; i < p_TheProbe->m_NoAreas; i++ ) {
        if ( ( Sp.m_x >= p_TheProbe->m_Rect[ i ].m_x1 ) && ( Sp.m_y >= p_TheProbe->m_Rect[ i ].m_y1 )
             && ( Sp.m_x <= p_TheProbe->m_Rect[ i ].m_x2 ) && ( Sp.m_y <= p_TheProbe->m_Rect[ i ].m_y2 ) )
               for ( unsigned k = 0; k < p_TheProbe->m_NoEleTypes; k++ ) {
                 if ( p_TheProbe->m_RefEle[ k ] == Sp.m_EleType )
                   NumberSk++; // it is in the square so increment number
               }
      }
    }
    } else {
    if ( p_TheProbe->m_NoVegTypes != 0 ) {
        for (unsigned j = 0; j < (unsigned)GetLiveArraySize( ListIndex ); j++) {
        Sp = TheArray[ ListIndex ] [ j ]->SupplyPosition();

        for ( unsigned i = 0; i < p_TheProbe->m_NoAreas; i++ ) {
          if ( ( Sp.m_x >= p_TheProbe->m_Rect[ i ].m_x1 ) && ( Sp.m_y >= p_TheProbe->m_Rect[ i ].m_y1 )
               && ( Sp.m_x <= p_TheProbe->m_Rect[ i ].m_x2 ) && ( Sp.m_y <= p_TheProbe->m_Rect[ i ].m_y2 ) ) {
                 for ( unsigned k = 0; k < p_TheProbe->m_NoVegTypes; k++ ) {
                   if ( p_TheProbe->m_RefVeg[ k ] == Sp.m_VegType )
                     NumberSk++; // it is in the square so increment number
                 }
          }
        }
      }
    } else // both must be zero
    {
        unsigned sz = (unsigned)GetLiveArraySize( ListIndex );
        // It is worth checking whether we have a total dump of all individuals
        // if so don't bother with asking each where it is
        if (p_TheProbe->m_NoAreas==1) {
            if ((p_TheProbe->m_Rect[0].m_x1==0) && (p_TheProbe->m_Rect[0].m_y1==0) && (p_TheProbe->m_Rect[0].m_x2==(unsigned)SimW) &&
                (p_TheProbe->m_Rect[0].m_y2==(unsigned)SimH)) {
                    return (float) sz;
            }
        }
        // Asking for a subset - need to test them all
        for ( unsigned j = 0; j < sz; j++ ) {
            Sp = TheArray[ ListIndex ] [ j ]->SupplyPosition();
            for ( unsigned i = 0; i < p_TheProbe->m_NoAreas; i++ ) {
                if ( ( Sp.m_x >= p_TheProbe->m_Rect[ i ].m_x1 ) && ( Sp.m_y >= p_TheProbe->m_Rect[ i ].m_y1 )
                       && ( Sp.m_x <= p_TheProbe->m_Rect[ i ].m_x2 ) && ( Sp.m_y <= p_TheProbe->m_Rect[ i ].m_y2 ) )
                        NumberSk++; // it is in the square so increment number
            }
        }
    }
    }
    return NumberSk;
}

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

bool Population_Manager::OpenTheCIPEGridOutputProbe() {
  CIPEGridOutputPrb = fopen(cfg_CIPEGridOutput_filename.value(), "w" );
  if ( !CIPEGridOutputPrb ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheCIPEGridOutputProbe(): ""Unable to open probe file",
         cfg_CIPEGridOutput_filename.value() );
    exit( 1 );
  }
  CIPEGridOutputPrbB = fopen(cfg_CIPEGridOutput_filenameB.value(), "w" );
  if ( !CIPEGridOutputPrbB ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheCIPEGridOutputProbe(): ""Unable to open probe file",
         cfg_CIPEGridOutput_filenameB.value() );
    exit( 1 );
  }
  return true;
}

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

void Population_Manager::CloseTheCIPEGridOutputProbe() {
  if ( CIPEGridOutputPrb != NULL )
    fclose( CIPEGridOutputPrb );
    fclose( CIPEGridOutputPrbB );
}

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

void Population_Manager::TheCIPEGridOutputProbe() {
}

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

void Population_Manager::NWordOutput() {
    int Counted[4];
    int totalcells[4];
    int OccupiedCells[4];
    for (int cellwidth=0; cellwidth<4; cellwidth++) {
        Counted[cellwidth] = 0;
        totalcells[cellwidth] = m_gridcountwidth[cellwidth] * m_gridcountwidth[cellwidth];
        OccupiedCells[cellwidth] = 0;
        for (int i=0; i<m_gridcountwidth[cellwidth]; i++) {
          for (int j=0; j<m_gridcountwidth[cellwidth]; j++) {
            int res=m_gridcount[cellwidth][i+j*m_gridcountwidth[cellwidth]];
            Counted[cellwidth] += res;
            if (res>0) OccupiedCells[cellwidth]++;
          }
        }
    }
    fprintf(NWordOutputPrb,"%d\t%d\t%d\t", m_TheLandscape->SupplyYearNumber() ,(int)m_TheLandscape->SupplyDayInYear(), Counted[0] );
    for (int c=0; c<4; c++) {
        fprintf(NWordOutputPrb,"%d\t%d\t", totalcells[c], OccupiedCells[c]);
    }
    fprintf(NWordOutputPrb,"\n");
    fflush(NWordOutputPrb);
}
//---------------------------------------------------------------------------

bool Population_Manager::OpenTheRipleysOutputProbe() {
  RipleysOutputPrb = fopen(cfg_RipleysOutput_filename.value(), "w" );
  if ( !RipleysOutputPrb ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  NWordOutputPrb = fopen("NWordOutputPrb.txt", "w" );
  if ( !NWordOutputPrb ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheCIPEGridOutputProbe(): ""Unable to open NWord probe file", "" );
    exit( 1 );
  }
  fprintf(NWordOutputPrb,"%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t\n","Year","Day","Total no.","Cells50","Occupied50","Cells100","Occupied100","Cells200","Occupied200","Cells400","Occupied400");
  return true;
}

//-----------------------------------------------------------------------------
bool Population_Manager::OpenTheMonthlyRipleysOutputProbe() {
  RipleysOutputPrb1 = fopen("RipleyOutput_Jan.txt", "w" );
  if ( !RipleysOutputPrb1 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb2 = fopen("RipleyOutput_Feb.txt", "w" );
  if ( !RipleysOutputPrb2 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb3 = fopen("RipleyOutput_Mar.txt", "w" );
  if ( !RipleysOutputPrb3 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb4 = fopen("RipleyOutput_Apr.txt", "w" );
  if ( !RipleysOutputPrb4 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb5 = fopen("RipleyOutput_May.txt", "w" );
  if ( !RipleysOutputPrb5 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb6 = fopen("RipleyOutput_Jun.txt", "w" );
  if ( !RipleysOutputPrb6 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb7 = fopen("RipleyOutput_Jul.txt", "w" );
  if ( !RipleysOutputPrb7 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb8 = fopen("RipleyOutput_Aug.txt", "w" );
  if ( !RipleysOutputPrb8 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb9 = fopen("RipleyOutput_Sep.txt", "w" );
  if ( !RipleysOutputPrb9 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb10 = fopen("RipleyOutput_Oct.txt", "w" );
  if ( !RipleysOutputPrb10 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb11 = fopen("RipleyOutput_Nov.txt", "w" );
  if ( !RipleysOutputPrb11 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  RipleysOutputPrb12 = fopen("RipleyOutput_Dec.txt", "w" );
  if ( !RipleysOutputPrb12 ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_RipleysOutput_filename.value() );
    exit( 1 );
  }
  return true;
}

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

bool Population_Manager::OpenTheReallyBigProbe() {
  ReallyBigOutputPrb = fopen(cfg_ReallyBigOutput_filename.value(), "w" );
  if ( !ReallyBigOutputPrb ) {
    g_msg->Warn( WARN_FILE, "Population_Manager::OpenTheRipleysOutputProbe(): ""Unable to open probe file",
         cfg_ReallyBigOutput_filename.value() );
    exit( 1 );
  }
  return true;
}

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

void Population_Manager::CloseTheRipleysOutputProbe() {
  if ( cfg_RipleysOutputMonthly_used.value() )
    fclose( RipleysOutputPrb );
  RipleysOutputPrb=NULL;
}

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

void Population_Manager::CloseTheMonthlyRipleysOutputProbe() {
  fclose( RipleysOutputPrb1 );
  fclose( RipleysOutputPrb2 );
  fclose( RipleysOutputPrb3 );
  fclose( RipleysOutputPrb4 );
  fclose( RipleysOutputPrb5 );
  fclose( RipleysOutputPrb6 );
  fclose( RipleysOutputPrb7 );
  fclose( RipleysOutputPrb8 );
  fclose( RipleysOutputPrb9 );
  fclose( RipleysOutputPrb10 );
  fclose( RipleysOutputPrb11 );
  fclose( RipleysOutputPrb12 );
}

//-----------------------------------------------------------------------------
void Population_Manager::CloseTheReallyBigOutputProbe() {
  if ( ReallyBigOutputPrb != 0 )
    fclose( ReallyBigOutputPrb );
  ReallyBigOutputPrb=0;
}

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

void Population_Manager::TheReallyBigOutputProbe() {
}
//-----------------------------------------------------------------------------

void Population_Manager::TheRipleysOutputProbe(FILE* /* a_Prob */ ) {
}

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


//-----------------------------------------------------------------------------
//                    TheArray handling functions
//----------------------

TAnimal * Population_Manager::FindClosest( int x, int y, unsigned Type ) {
  int distance = 100000000;
  TAnimal * TA = NULL;
  int dx, dy, d;
  for (unsigned j = 0; j < (unsigned)GetLiveArraySize( Type ); j++) {
    dx = TheArray[ Type ] [ j ]->Supply_m_Location_x();
    dy = TheArray[ Type ] [ j ]->Supply_m_Location_y();
    dx = ( dx - x );
    dx *= dx;
    dy = ( dy - y );

    dy *= dy;
    d = dx + dy;
    if ( d < distance ) {
      distance = d;
      TA = TheArray[ Type ] [ j ];
    }
  }
  return TA;
}

//------------------------------------------------------------------------------
void Population_Manager::EmptyTheArray()
{
    for ( unsigned i = 0; i < TheArray.size(); i++ )
    {
        // if objects in the list need to be deleted:
        for (unsigned j = 0; j < (unsigned) TheArray[i].size(); j++)
        {
            delete TheArray[ i ] [ j ];
        }
        // empty the array
        TheArray[ i ].clear();
    }
}

void Population_Manager::SortX( unsigned Type ) {
    vector<TAnimal*>::iterator nth = TheArray[Type].begin() + m_LiveArraySize[Type];
    sort( TheArray[ Type ].begin(), nth, CompareX() );
}

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

void Population_Manager::SortY( unsigned Type ) {
    vector<TAnimal*>::iterator nth = TheArray[Type].begin() + m_LiveArraySize[Type];
    sort(TheArray[Type].begin(), nth, CompareY());
}

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

void Population_Manager::SortState( unsigned Type ) {
  sort( TheArray[ Type ].begin(), TheArray[ Type ].end(), CompareState() );
}

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

void Population_Manager::SortStateR(unsigned Type) {
    sort(TheArray[Type].begin(), TheArray[Type].begin()+m_LiveArraySize[Type], CompareStateR());
}

unsigned Population_Manager::PartitionLiveDead(unsigned Type) {
    auto it = partition(TheArray[Type].begin(), TheArray[Type].begin() + m_LiveArraySize[Type], CompareStateAlive());
    // it now points at the first dead element
    // the number of live ones before it is it-TheArray[Type].begin(). This is the new vector size for live animals.
    return unsigned(it - TheArray[Type].begin());
}

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

void Population_Manager::SortXIndex( unsigned Type ) {
    vector<TAnimal*>::iterator nth = TheArray[Type].begin() + m_LiveArraySize[Type];
    sort(TheArray[Type].begin(), nth, CompareX());
  unsigned s = (unsigned)GetLiveArraySize( Type );
  // Now make the index array to X;
  int counter = 0;
  int x;
  // for each individual
  for ( unsigned i = 0; i < s; i++ ) {
    // Get Next co-ordiated
    x = TheArray[ Type ] [ i ]->Supply_m_Location_x();
    // fill gaps up to x
    while ( counter < x ) IndexArrayX[ Type ] [ counter++ ] = -1;
    if ( x == counter ) {
      IndexArrayX[ Type ] [ counter++ ] = i;
    }
  }
  // Fill up the rest of the array with -1;
  for ( int c = counter; c < 10000; c++ ) {
    IndexArrayX[ Type ] [ c ] = -1;
  }
}

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

void Population_Manager::Shuffle( unsigned Type ) {
    unsigned s = (unsigned)GetLiveArraySize( Type );
  for ( unsigned i = 0; i < s; i++ ) {
    TAnimal * temp;
    unsigned a = random( s );
    unsigned b = random( s );
    temp = TheArray[ Type ] [ a ];
    TheArray[ Type ] [ a ] = TheArray[ Type ] [ b ];
    TheArray[ Type ] [ b ] = temp;
  }
}

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

void Population_Manager::Shuffle_or_Sort( unsigned Type ) {
  switch ( BeforeStepActions[ Type ] ) {
    case 0:
      Shuffle( Type );
      break;
    case 1:
      SortX( Type );
      break;
    case 2:
      SortY( Type );
      break;
    case 3:
      SortXIndex( Type );
      break;
    case 4: // Do nothing
      break;
    case 5: 
      if (g_rand_uni() < double (1/500)) Shuffle( Type );
      break;
    default:
      m_TheLandscape->Warn( "Population_Manager::Shuffle_or_Sort- BeforeStepAction Unknown", NULL );
      exit( 1 );
  }
}

//-----------------------------------------------------------------------------
bool Population_Manager::BeginningOfMonth() {
  if ( m_TheLandscape->SupplyDayInMonth() == cfg_DayInMonth.value() ) return true;
  return false;
}

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

void Population_Manager::Catastrophe() {
    return;
}
//---------------------------------------------------------------------------

char* Population_Manager::SpeciesSpecificReporting(int a_species, int a_time) {
  strcpy(g_str,"");
// Vole Model
  if ( a_species == 1 ) {
/*
// The next lines are obselete code from genetic simulations
float MeanNoAlleles;
    float MeanHO;
    float MeanHE;
    unsigned size;

    if ( m_time % ( 365 * 24 * 60 ) == 0 ) // End of year
    {

      // empty the GenStruc data
      for ( int ProbeNo = 0; ProbeNo < ( int )m_NoProbes; ProbeNo++ ) {
        fprintf( m_GeneticsFile, "%d ", m_time );
        int TotalSize = 0;
        m_AManager->AlFreq->Flush();
        for ( unsigned listindex = 0; listindex <= 1; listindex++ ) {
          size = 0;
          m_AManager->TheGeneticProbe( listindex, ProbeNo, size );
          TotalSize += size;
        }
        if ( TotalSize > 0 ) {
          m_AManager->AlFreq->CalcAF();
          m_AManager->AlFreq->CalcNoAlleles();
          m_AManager->AlFreq->CalcHE();
          m_AManager->AlFreq->CalcHO( TotalSize );
        }
        // Get the means
        // For N alleles
        int NA = 0;
        float NHO = 0;
        float NHE = 0;
        for ( int l = 0; l < 16; l++ ) {
          NA += m_AManager->AlFreq->SupplyNoAlleles( l );
        }
        MeanNoAlleles = ( float )NA / 16.0;
        for ( int l = 0; l < 16; l++ ) {
          NHO += m_AManager->AlFreq->SupplyHO( l );
        }
        MeanHO = NHO / 16.0;
        for ( int l = 0; l < 16; l++ ) {
          NHE += m_AManager->AlFreq->SupplyHE( l );
        }
        MeanHE = NHE / 16.0;

        // Do some output
        // Output is to two files, the genetics file and the AllelerequencyFile
        fprintf( m_GeneticsFile, "%2.2f ", MeanNoAlleles );
        fprintf( m_GeneticsFile, "%1.3f ", MeanHO );
        fprintf( m_GeneticsFile, "%1.3f ", MeanHE );
        for ( int l = 0; l < 16; l++ ) {
          fprintf( m_GeneticsFile, "%04i ", m_AManager->AlFreq->SupplyNoAlleles( l ) );
        }
        for ( int l = 0; l < 16; l++ ) {
          fprintf( m_GeneticsFile, "%1.3f ", m_AManager->AlFreq->SupplyHO( l ) );
        }
        for ( int l = 0; l < 16; l++ ) {
          fprintf( m_GeneticsFile, "%1.3f ", m_AManager->AlFreq->SupplyHE( l ) );
        }
        fprintf( m_GeneticsFile, "\n" );
        fprintf( m_AlleleFreqsFile, "%d ", m_time );
        for ( int l = 0; l < 16; l++ ) {
          for ( int al = 0; al < 4; al++ ) {
            fprintf( m_AlleleFreqsFile, "%1.3f ", m_AManager->AlFreq->SupplyAF( l, al ) );
          }
        }
        fprintf( m_AlleleFreqsFile, "\n" );
      }
      // make sure progress reaches the disk
      fflush( m_GeneticsFile );
      fflush( m_AlleleFreqsFile );
    }

    if ( cfg_UseEasyPop.value()) {
      int targettime=a_time % ( 365 * 100 );
      if ( (  targettime == 59 ) ||(targettime == 181)||(targettime ==304)||(targettime ==59+365)||(targettime ==181+365)||(targettime ==304+365)) {
          for ( unsigned listindex = 0; listindex <= 1; listindex++ ) {
            GeneticsResultsOutput( m_EasyPopRes, listindex);
        }
        fflush( m_EasyPopRes );
      }
    }
*/
    /* Three times a year reporting
    if ( m_time % 365 == 60 ) ProbeReportNow( m_time );
    if ( m_time % 365 == 152 ) ProbeReportNow( m_time );
    if ( m_time % 365 == 273 ) ProbeReportNow( m_time ); */
    ProbeReport( a_time );
#ifdef __SpecificPesticideEffectsVinclozolinLike__
    ImpactProbeReport( a_time );
#endif
#ifdef __WithinOrchardPesticideSim__
    ImpactProbeReport( a_time );
#endif

  }
  // Skylark Model
  else if ( a_species == 0 ) {
    int No;
    int a_day = a_time % 365;
    if ( a_time % 365 == 364 )
    {
      //Write the Breeding Attempts Probe
      int BreedingFemales, YoungOfTheYear, TotalPop, TotalFemales, TotalMales, BreedingAttempts;
      int No = TheBreedingSuccessProbe( BreedingFemales, YoungOfTheYear, TotalPop, TotalFemales, TotalMales, BreedingAttempts );
      float bs = 0;
      if ( BreedingFemales > 0 ) {
        bs = No / ( float )BreedingFemales; //bs = successful breeding attempt per attempting to breed female
      }
      BreedingSuccessProbeOutput( bs, BreedingFemales, YoungOfTheYear, TotalPop,
           TotalFemales, TotalMales, a_time, BreedingAttempts );
    }
    if ( a_day == 152 ) {
      // Need to fill in the landscape from 1st June, it will change before
      // the count of fledgelings is needed
      m_TheLandscape->FillVegAreaData();
    }
    if ( a_day == 197 ) {
      for ( int ProbeNo = 0; ProbeNo < m_NoProbes; ProbeNo++ ) {
        No = TheFledgelingProbe();
        // Do some output
        FledgelingProbeOutput( No, a_time );
      }
    }
#ifdef __SKPOM
    // This is clunky but for purposes of validation we want probes throughout the year
    // First get the breeding pairs data.
    BreedingPairsOutput(a_day);
#else
    ProbeReport( a_time );
#endif
  }
  else return ProbeReport( a_time );
  return g_str;
}
//-----------------------------------------------------------------------------

unsigned int Population_Manager::FarmAnimalCensus(unsigned int a_farm, unsigned int a_typeofanimal)
{
    unsigned int No = 0;
    unsigned sz = (unsigned)GetLiveArraySize( a_typeofanimal );
    for ( unsigned j = 0; j < sz; j++ ) 
    {
        if (a_farm == TheArray[ a_typeofanimal ] [ j ]->SupplyFarmOwnerRef()) No++;
    }
    return No;
}
//-----------------------------------------------------------------------------
    
char* Population_Manager::ProbeReport( int Time ) {

  int No;
  char str[100]; // 100 out to be enough!!
  strcpy(g_str,"");
  for ( int ProbeNo = 0; ProbeNo < m_NoProbes; ProbeNo++ ) {
    No = 0;
    // See if we need to record/update this one
    // if time/months/years ==0 or every time
    if ( ( TheProbe[ ProbeNo ]->m_ReportInterval == 3 )
         || ( ( TheProbe[ ProbeNo ]->m_ReportInterval == 2 ) && ( BeginningOfMonth() ) )
         || ( ( TheProbe[ ProbeNo ]->m_ReportInterval == 1 ) && ( Time % 365 == 0 ) ) ) {
           // Goes through each area and sends a value to OutputForm
           unsigned Index = SupplyListIndexSize();
           for ( unsigned listindex = 0; listindex < Index; listindex++ ) {
             if ( TheProbe[ ProbeNo ]->m_TargetTypes[ listindex ] )
               No += (int) Probe( listindex, TheProbe[ ProbeNo ] );
           }
           TheProbe[ ProbeNo ]->FileOutput( No, Time, ProbeNo );
            sprintf(str," %d ", No );
            strcat(g_str,str);
    }
  }
  return g_str;
}
//-----------------------------------------------------------------------------

char* Population_Manager::ProbeReportTimed( int Time) {
    int No;
    char str[100]; // 100 ought to be enough!!
    strcpy(g_str,"");
    for ( int ProbeNo = 0; ProbeNo < m_NoProbes; ProbeNo++ ) {
    No = 0;
    unsigned Index = SupplyListIndexSize();
    for ( unsigned listindex = 0; listindex < Index; listindex++ ) {
        if ( TheProbe[ ProbeNo ]->m_TargetTypes[ listindex ] ) No += (int) Probe( listindex, TheProbe[ ProbeNo ] );
    }
    TheProbe[ ProbeNo ]->FileOutput( No, Time, ProbeNo );
    sprintf(str," %d ", No );
    strcat(g_str,str);
  }
  return g_str;
}
//-----------------------------------------------------------------------------

void Population_Manager::ImpactProbeReport( int a_Time ) {

  for ( int ProbeNo = 0; ProbeNo < 1; ProbeNo++ ) {
    // See if we need to record/update this one
    // if time/months/years ==0 or every time
    if ( ( TheProbe[ ProbeNo ]->m_ReportInterval == 3 )
         || ( ( TheProbe[ ProbeNo ]->m_ReportInterval == 2 ) && ( BeginningOfMonth() ) )
         || ( ( TheProbe[ ProbeNo ]->m_ReportInterval == 1 ) && ( a_Time % 365 == 0 ) ) ) {
             ImpactedProbe();
    }
  }
}

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

//-----------------End of TheArray handling functions

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


AnimalPosition TAnimal::SupplyPosition() {
  AnimalPosition SkP;
  SkP.m_x = m_Location_x;
  SkP.m_y = m_Location_y;
  SkP.m_EleType = m_OurLandscape->SupplyElementType( m_Location_x, m_Location_y );
  SkP.m_VegType = m_OurLandscape->SupplyVegType( m_Location_x, m_Location_y );
  return SkP;
}

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

unsigned TAnimal::SupplyFarmOwnerRef() {
  return m_OurLandscape->SupplyFarmOwner( m_Location_x, m_Location_y );
}

//-----------------------------------------------------------------------------
TAnimal::TAnimal( int x, int y, Landscape * L ) {
  m_OurLandscape = L;
  m_Location_x = x;
  m_Location_y = y;
}

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

TALMaSSObject::TALMaSSObject() {
#ifdef __CJTDebug_5
  AmAlive = 0xDEADC0DE;
#endif
  m_StepDone = false;
  m_CurrentStateNo = 0;
}

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


TALMaSSObject::~TALMaSSObject() {
#ifdef __CJTDebug_5
  AmAlive = 0;
#endif
}

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

void TAnimal::CheckManagement( void ) {
  FarmToDo event;
  int i = 0;
  while ( ( event = ( FarmToDo )m_OurLandscape->SupplyLastTreatment( m_Location_x, m_Location_y, & i ) ) != sleep_all_day ) {
    if ( OnFarmEvent( event ) ) break;
  }
}

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

void TAnimal::CheckManagementXY( int x, int y ) {
  FarmToDo event;
  int i = 0;
  while ( ( event = ( FarmToDo )m_OurLandscape->SupplyLastTreatment( x, y, & i ) ) != sleep_all_day ) {
    OnFarmEvent( event );
  }
}

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

void TALMaSSObject::OnArrayBoundsError() {
  exit( 1 );
}

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

#ifdef __CJTDebug_5
void TALMaSSObject::DEADCODEError() {
  exit( 0 );
}

#endif
//-----------------------------------------------------------------------------
//           probe_data
//-----------------------------------------------------------------------------

void probe_data::FileOutput( int No, int time, int ProbeNo ) {
  if ( m_FileRecord ) {

    if ( ProbeNo == 0 ) {
      // First probe so write the time and a new line
      (*m_MyFile) << endl;
      (*m_MyFile) << time << '\t' << No;
    } else
      (*m_MyFile) << '\t' << No ;
  }
  (*m_MyFile).flush();
}

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

void probe_data::FileAppendOutput( int No, int time ) {
  m_MyFile->open(m_MyFileName,ios::app);
  if ( !m_MyFile->is_open() ) {
    g_msg->Warn( (MapErrorState)0,"Cannot open file for append: ", m_MyFileName );
    exit( 0 );
  }
  if ( m_FileRecord ) {
   (*m_MyFile)<< time << '\t' << No << endl;
  }
  m_MyFile->close();
}

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

probe_data::probe_data() {
  m_Time = 0;
  m_FileRecord = false;
  m_MyFile = NULL;
}

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

ofstream * probe_data::OpenFile( char * Nme ) {
  m_MyFile = new ofstream( Nme );
  if ( !m_MyFile->is_open() ) {
    g_msg->Warn( (MapErrorState)0,"probe_data::OpenFile - Cannot open file: ", Nme );
    exit( 0 );
  }
  strcpy( m_MyFileName, Nme );
  return m_MyFile;
}
//-----------------------------------------------------------------------------

void probe_data::SetFile( ofstream * F ) {
  m_MyFile = F;
}

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

probe_data::~probe_data() {
}
//-----------------------------------------------------------------------------


bool Population_Manager::CheckXY(int l, int i)
{
    if (TheArray[l][i]->Supply_m_Location_x() > 10000) return true;
    if (TheArray[l][i]->Supply_m_Location_y() > 10000) return true;
    if (TheArray[l][i]->Supply_m_Location_x() < 0) return true;
    if (TheArray[l][i]->Supply_m_Location_y() < 0) return true;
    return false;
}