Population_Manager Class Reference

Base class for all population managers. More...

#include <PopulationManager.h>

Public Member Functions
	Population_Manager (Landscape *L)
virtual	~Population_Manager (void)
void	SetNoProbes (int a_pn)
unsigned	GetLiveArraySize (int a_listindex)
	Gets the number of 'live' objects for a list index in the TheArray. More...
void	IncLiveArraySize (int a_listindex)
	Increments the number of 'live' objects for a list index in the TheArray. More...
virtual void	Catastrophe (int)
unsigned int	FarmAnimalCensus (unsigned int a_farm, unsigned int a_typeofanimal)
char *	SpeciesSpecificReporting (int a_species, int a_time)
char *	ProbeReport (int a_time)
char *	ProbeReportTimed (int a_time)
void	ImpactProbeReport (int a_Time)
bool	BeginningOfMonth ()
void	LOG (const char *fname)
int	SupplyStepSize ()
int	SupplySimW ()
int	SupplySimH ()
virtual void	Run (int NoTSteps)
virtual float	Probe (int ListIndex, probe_data *p_TheProbe)
virtual void	ImpactedProbe ()
int	SupplyListNameLength ()
TAnimal *	SupplyAnimalPtr (int a_index, int a_animal)
	Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK. More...
unsigned	SupplyListIndexSize ()
unsigned	SupplyListSize (unsigned listindex)
bool	CheckXY (int l, int i)
	Debug method to test for out of bounds coordinates. More...
const char *	SupplyListName (int i)
bool	IsLast (unsigned listindex)
int	SupplyState (unsigned listindex, unsigned j)
virtual void	SupplyLocXY (unsigned listindex, unsigned j, int &x, int &y)
const char *	SupplyStateNames (int i)
unsigned	SupplyStateNamesLength ()
virtual void	DisplayLocations ()
int	ProbeFileInput (char *p_Filename, int p_ProbeNo)
TAnimal *	FindClosest (int x, int y, unsigned Type)
bool	OpenTheRipleysOutputProbe (string a_NWordFilename)
void	OpenTheAOROutputProbe (string a_AORFilename)
bool	OpenTheMonthlyRipleysOutputProbe ()
bool	OpenTheReallyBigProbe ()
virtual void	TheAOROutputProbe ()
virtual void	TheRipleysOutputProbe (FILE *a_prb)
virtual void	TheReallyBigOutputProbe ()
void	CloseTheMonthlyRipleysOutputProbe ()
virtual void	CloseTheRipleysOutputProbe ()
virtual void	CloseTheReallyBigOutputProbe ()
TTypesOfPopulation	GetPopulationType ()
int	GetSeasonNumber ()
	Get the season number. More...
void	LamdaDeath (int x, int y)
void	LamdaBirth (int x, int y)
void	LamdaBirth (int x, int y, int z)
void	LamdaClear ()
void	LamdaDumpOutput ()
virtual int	SupplyPegPosx (int)
virtual int	SupplyPegPosy (int)
virtual int	SupplyCovPosx (int)
virtual int	SupplyCovPosy (int)
virtual bool	OpenTheFledgelingProbe ()
virtual bool	OpenTheBreedingPairsProbe ()
virtual bool	OpenTheBreedingSuccessProbe ()
virtual void	BreedingPairsOutput (int)
virtual int	TheBreedingFemalesProbe (int)
virtual int	TheFledgelingProbe ()
virtual void	BreedingSuccessProbeOutput (double, int, int, int, int, int, int, int)
virtual int	TheBreedingSuccessProbe (int &, int &, int &, int &, int &, int &)
virtual void	FledgelingProbeOutput (int, int)
virtual void	TheGeneticProbe (unsigned, int, unsigned &)
virtual void	GeneticsResultsOutput (FILE *, unsigned)

Public Attributes
int	IndexArrayX [5][10000]
probe_data *	TheProbe [100]
int	SimH
int	SimW
unsigned	SimHH
unsigned	SimWH
char	m_SimulationName [255]
bool	ProbesSet
Landscape *	m_TheLandscape

Protected Member Functions
virtual bool	StepFinished ()
	Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour. More...
virtual void	DoFirst ()
virtual void	DoBefore ()
virtual void	DoAfter ()
virtual void	DoAlmostLast ()
virtual void	DoLast ()
void	EmptyTheArray ()
	Removes all objects from the TheArray by deleting them and clearing TheArray. More...
void	SortX (unsigned Type)
void	SortXIndex (unsigned Type)
void	SortY (unsigned Type)
void	SortState (unsigned Type)
void	SortStateR (unsigned Type)
unsigned	PartitionLiveDead (unsigned Type)
void	Shuffle_or_Sort (unsigned Type)
void	Shuffle (unsigned Type)
virtual void	Catastrophe ()

Protected Attributes
vector< unsigned >	m_LiveArraySize
int	m_NoProbes
AOR_Probe *	m_AOR_Probe
FILE *	m_GeneticsFile
FILE *	m_AlleleFreqsFile
FILE *	m_EasyPopRes
const char *	StateNames [100]
int	m_catastrophestartyear
int	m_StepSize
vector< TListOfAnimals >	TheArray
unsigned	StateNamesLength
const char *	m_ListNames [32]
unsigned	m_ListNameLength
FILE *	TestFile
FILE *	TestFile2
unsigned	BeforeStepActions [12]
int	m_SeasonNumber
	Holds the season number. Used when running goose and hunter sims. More...
TTypesOfPopulation	m_population_type
ofstream *	AOROutputPrb
FILE *	RipleysOutputPrb
FILE *	RipleysOutputPrb1
FILE *	RipleysOutputPrb2
FILE *	RipleysOutputPrb3
FILE *	RipleysOutputPrb4
FILE *	RipleysOutputPrb5
FILE *	RipleysOutputPrb6
FILE *	RipleysOutputPrb7
FILE *	RipleysOutputPrb8
FILE *	RipleysOutputPrb9
FILE *	RipleysOutputPrb10
FILE *	RipleysOutputPrb11
FILE *	RipleysOutputPrb12
FILE *	ReallyBigOutputPrb
long int	lamdagrid [2][257][257]

Detailed Description

Base class for all population managers.

The core of the handling of animal populations. All time-step code and most input/output is handled by this class and its descendents. This class effectively implements a state machine to facilitate simulation of animal behaviours and handle potential issues with concurrency. The PopulationManager class is never instantiated but must be used by deriving a descendent class.

Constructor & Destructor Documentation

Population_Manager()

Population_Manager::Population_Manager

(

Landscape *

L

)

Constructor for the Population_Manager class

                                                      {
    // 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(), 12, alist );
    // Set the simulation bounds
    SimH = m_TheLandscape->SupplySimAreaHeight();
    SimW = m_TheLandscape->SupplySimAreaWidth();
    SimHH = m_TheLandscape->SupplySimAreaHeight()/2;
    SimWH = m_TheLandscape->SupplySimAreaWidth()/2;
 
    // dww this is hardcoded limit of 12.
    // Needs fixing
    for (int i = 0; i < 12; 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();
  }
    if (cfg_AOROutput_used.value()) {
        OpenTheAOROutputProbe("AOR_Probe.txt"); 
    }
    // 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
}

References cfg_AOROutput_used(), and cfg_RipleysOutputMonthly_used().

~Population_Manager()

Population_Manager::~Population_Manager ( void  )

virtual

Destructor for the Population_Manager class

                                              {
  // 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();
  }
 if ( cfg_RipleysOutputMonthly_used.value() ) {
    CloseTheMonthlyRipleysOutputProbe();
  }
  if ( cfg_ReallyBigOutput_used.value() ) {
    CloseTheReallyBigOutputProbe();
  }
  if (cfg_AOROutput_used.value()) delete m_AOR_Probe;
}

References cfg_AOROutput_used(), cfg_ReallyBigOutput_used(), cfg_RipleysOutput_used(), and cfg_RipleysOutputMonthly_used().

Member Function Documentation

BeginningOfMonth()

bool Population_Manager::BeginningOfMonth

(

)

Is it the first day of the month?

                                          {
  if ( m_TheLandscape->SupplyDayInMonth() == cfg_DayInMonth.value() ) return true;
  return false;
}

References cfg_DayInMonth().

BreedingPairsOutput()

virtual void Population_Manager::BreedingPairsOutput ( int  )

inlinevirtual

                                          {
    }

BreedingSuccessProbeOutput()

virtual void Population_Manager::BreedingSuccessProbeOutput ( double  , int  , int  , int  , int  , int  , int  , int    )

inlinevirtual

                                                                                       {
    }

Catastrophe() [1/2]

void Population_Manager::Catastrophe ( )

protectedvirtual

This method MUST be overidden in descendent classes if this functionality is does not match with the animals requirements

                                     {
    return;
}

Catastrophe() [2/2]

virtual void Population_Manager::Catastrophe ( int  )

inlinevirtual

                                    {
    }

CheckXY()

bool Population_Manager::CheckXY	(	int	l,
		int	i
	)

Debug method to test for out of bounds coordinates.

{
    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;
}

CloseTheMonthlyRipleysOutputProbe()

void Population_Manager::CloseTheMonthlyRipleysOutputProbe

(

)

close the monthly probes

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

CloseTheReallyBigOutputProbe()

void Population_Manager::CloseTheReallyBigOutputProbe ( )

virtual

close the probe

                                                      {
  if ( ReallyBigOutputPrb != 0 )
    fclose( ReallyBigOutputPrb );
  ReallyBigOutputPrb=0;
}

CloseTheRipleysOutputProbe()

void Population_Manager::CloseTheRipleysOutputProbe ( )

virtual

close the probe

                                                    {
  if ( cfg_RipleysOutputMonthly_used.value() )
    fclose( RipleysOutputPrb );
  RipleysOutputPrb=NULL;
}

References cfg_RipleysOutputMonthly_used().

DisplayLocations()

void Population_Manager::DisplayLocations ( )

virtual

Used to update the graphics when control is not returned to the ALMaSS_GUI between timesteps.

{
#ifdef __ALMASS_VISUAL
    m_MainForm->UpdateGraphics();
#endif
}

DoAfter()

void Population_Manager::DoAfter ( )

protectedvirtual

Can be used in descendent classes

                                 {
  //TODO: Add your source code here
}

DoAlmostLast()

void Population_Manager::DoAlmostLast ( )

protectedvirtual

Can be used in descendent classes

                                      {
  //TODO: Add your source code here
}

DoBefore()

void Population_Manager::DoBefore ( )

protectedvirtual

Can be used in descendent classes

                                  {
}

DoFirst()

void Population_Manager::DoFirst ( )

protectedvirtual

Can be used in descendent classes

                                 {
}

DoLast()

void Population_Manager::DoLast ( )

protectedvirtual

Collects some data to describe the number of animals in each state at the end of the day

                                {
 
/*
#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
    }
  }
*/
}

EmptyTheArray()

void Population_Manager::EmptyTheArray ( )

protected

Removes all objects from the TheArray by deleting them and clearing TheArray.

Sort TheArray w.r.t. the m_Location_x attribute

{
    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();
    }
}

FarmAnimalCensus()

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;
}

FindClosest()

TAnimal * Population_Manager::FindClosest	(	int	x,
		int	y,
		unsigned	Type
	)

Finds the closest individual to an x,y point

                                                                       {
  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;
}

FledgelingProbeOutput()

virtual void Population_Manager::FledgelingProbeOutput ( int  , int    )

inlinevirtual

                                                 {
    }

GeneticsResultsOutput()

virtual void Population_Manager::GeneticsResultsOutput ( FILE *  , unsigned    )

inlinevirtual

                                                         {
    }

GetLiveArraySize()

unsigned Population_Manager::GetLiveArraySize ( int  a_listindex )

inline

Gets the number of 'live' objects for a list index in the TheArray.

                                               {
        return m_LiveArraySize[a_listindex];
    }

References m_LiveArraySize.

GetPopulationType()

TTypesOfPopulation Population_Manager::GetPopulationType ( )

inline

{ return m_population_type; }

References m_population_type.

GetSeasonNumber()

int Population_Manager::GetSeasonNumber ( )

inline

Get the season number.

{ return m_SeasonNumber; }

References m_SeasonNumber.

ImpactedProbe()

void Population_Manager::ImpactedProbe ( )

virtual

Special pesticide related probe. Overidden in descendent classes

                                        {
 
}

ImpactProbeReport()

void Population_Manager::ImpactProbeReport

(

int

a_Time

)

Special probe

                                                       {
 
  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();
    }
  }
}

References BeginningOfMonth().

IncLiveArraySize()

void Population_Manager::IncLiveArraySize ( int  a_listindex )

inline

Increments the number of 'live' objects for a list index in the TheArray.

                                           {
        m_LiveArraySize[a_listindex]++;
    }

References m_LiveArraySize.

IsLast()

bool Population_Manager::IsLast ( unsigned  listindex )

inline

                                    {
        if (TheArray[listindex].size() > 1) return false; else
            return true;
    }

References TheArray.

LamdaBirth() [1/2]

void Population_Manager::LamdaBirth ( int  x, int  y  )

inline

                                  {
        lamdagrid[0][x / __lgridsize][y / __lgridsize]++;
    }

References lamdagrid.

LamdaBirth() [2/2]

void Population_Manager::LamdaBirth ( int  x, int  y, int  z  )

inline

                                         {
        lamdagrid[0][x / __lgridsize][y / __lgridsize] += z;
    }

References lamdagrid.

LamdaClear()

void Population_Manager::LamdaClear ( )

inline

                      {
        for (int i = 0; i < 257; i++) {
            for (int j = 0; j < 257; j++) {
                lamdagrid[0][i][j] = 0;
                lamdagrid[1][i][j] = 0;
            }
        }
    }

References lamdagrid.

LamdaDeath()

void Population_Manager::LamdaDeath ( int  x, int  y  )

inline

                                  {
        // inlined for speed
        lamdagrid[1][x / __lgridsize][y / __lgridsize]++;
    }

References lamdagrid.

LamdaDumpOutput()

void Population_Manager::LamdaDumpOutput

(

)

Special probe

                                         {
   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();
}

LOG()

void Population_Manager::LOG

(

const char *

fname

)

Debug function used to log whatever is needed - this is just a place to write whatever is needed at the time - so contents vary

                                                {
  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 );
}

References AnimalPosition::m_x, and AnimalPosition::m_y.

OpenTheAOROutputProbe()

void Population_Manager::OpenTheAOROutputProbe

(

string

a_AORFilename

)

open the AOR Grid probe

                                                                   {
    m_AOR_Probe = new AOR_Probe(this, m_TheLandscape, a_AORFilename); 
}

OpenTheBreedingPairsProbe()

virtual bool Population_Manager::OpenTheBreedingPairsProbe ( )

inlinevirtual

                                             {
        return false;
    }

Referenced by CreatePopulationManager().

OpenTheBreedingSuccessProbe()

virtual bool Population_Manager::OpenTheBreedingSuccessProbe ( )

inlinevirtual

                                               {
        return false;
    }

Referenced by CreatePopulationManager().

OpenTheFledgelingProbe()

virtual bool Population_Manager::OpenTheFledgelingProbe ( )

inlinevirtual

                                          {
        return false;
    }

Referenced by CreatePopulationManager().

OpenTheMonthlyRipleysOutputProbe()

bool Population_Manager::OpenTheMonthlyRipleysOutputProbe

(

)

open 12 ripley output probles, one for each month

                                                          {
  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;
}

References cfg_RipleysOutput_filename().

OpenTheReallyBigProbe()

bool Population_Manager::OpenTheReallyBigProbe

(

)

open the probe

                                               {
  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;
}

References cfg_ReallyBigOutput_filename().

OpenTheRipleysOutputProbe()

bool Population_Manager::OpenTheRipleysOutputProbe

(

string

a_NWordFilename

)

open the Ripley probe

                                                                         {
    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);
    }
    return true;
}

References cfg_RipleysOutput_filename().

PartitionLiveDead()

unsigned Population_Manager::PartitionLiveDead ( unsigned  Type )

protected

Sort TheArray w.r.t. the current state attribute in reverse order

                                                            {
    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());
}

Probe()

float Population_Manager::Probe ( int  ListIndex, probe_data *  p_TheProbe  )

virtual

Default data probe. Rarely used in actuality but always available

                                                                        {
    // 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;
}

References AnimalPosition::m_EleType, probe_data::m_NoAreas, probe_data::m_NoEleTypes, probe_data::m_NoFarms, probe_data::m_NoVegTypes, probe_data::m_Rect, probe_data::m_RefEle, probe_data::m_RefFarms, probe_data::m_RefVeg, AnimalPosition::m_VegType, AnimalPosition::m_x, rectangle::m_x1, rectangle::m_x2, AnimalPosition::m_y, rectangle::m_y1, and rectangle::m_y2.

ProbeFileInput()

int Population_Manager::ProbeFileInput	(	char *	p_Filename,
		int	p_ProbeNo
	)

Default probe file input

                                                                         {
  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
}

Referenced by GetProbeInput_ini().

ProbeReport()

char * Population_Manager::ProbeReport

(

int

a_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;
}

References BeginningOfMonth(), and g_str.

ProbeReportTimed()

char * Population_Manager::ProbeReportTimed

(

int

a_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;
}

References g_str.

Run()

void Population_Manager::Run ( int  NoTSteps )

virtual

This is the main scheduling method for the population manager.
Note the structure of Shuffle_or_Sort(), DoFirst(), BeginStep, DoBefore(), Step looping until all are finished, DoAfter(), DoAlmostLast(), EndStep, DoLast().

Can do multiple time-steps here inside one landscape time-step (a day). This is used in the roe deer model to provide 10 minute behavioural time-steps.

It is necessary to remove any dead animals before the timestep starts. It is possible that animals are killed after their population manager Run method has been executed. This is the case with geese and hunters. Checking death first prevents this becomming a problem.

                                           {
  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);
                  }
              }
          }
      }
      // Need to check if AOR output needs to be saved
      if (cfg_AOROutput_used.value()) {
          int Year = m_TheLandscape->SupplyYearNumber();
          if (Year >= cfg_AOROutputFirstYear.value()) {
              if (Year % cfg_AOROutput_interval.value() == 0) {
                  int day = m_TheLandscape->SupplyDayInYear();
                  if (cfg_AOROutput_day.value() == day) {
                      // Do the AOR Probe
                      TheAOROutputProbe();
                  }
              }
          }
      }
      // 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();
            }
          }
        }
    }
    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
}

References cfg_AOROutput_day(), cfg_AOROutput_interval(), cfg_AOROutput_used(), cfg_AOROutputFirstYear(), cfg_CatastropheEventStartYear(), cfg_ReallyBigOutput_day1(), cfg_ReallyBigOutput_day2(), cfg_ReallyBigOutput_day3(), cfg_ReallyBigOutput_day4(), cfg_ReallyBigOutput_interval(), cfg_ReallyBigOutput_used(), cfg_ReallyBigOutputFirstYear(), cfg_RipleysOutput_day(), cfg_RipleysOutput_interval(), cfg_RipleysOutput_used(), cfg_RipleysOutputFirstYear(), and cfg_RipleysOutputMonthly_used().

Referenced by RunTheSim().

SetNoProbes()

void Population_Manager::SetNoProbes ( int  a_pn )

inline

{ m_NoProbes = a_pn; }

References m_NoProbes.

Referenced by CreatePopulationManager().

Shuffle()

void Population_Manager::Shuffle ( unsigned  Type )

protected

Run once through the list swapping randomly chosen elements

                                                {
    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;
  }
}

References random().

Shuffle_or_Sort()

void Population_Manager::Shuffle_or_Sort ( unsigned  Type )

protected

This method is used to determine whether the array of animals should be shuffled or sorted.
To do nothing ensure that the BeforeStepActions[] is set appropriately // 0 = Shuffle, 1 = SortX, 2 = SortY, 3 = sortXIndex, 4 = do nothing

                                                        {
  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 );
  }
}

References g_rand_uni.

SortState()

void Population_Manager::SortState ( unsigned  Type )

protected

Sort TheArray w.r.t. the current state attribute

                                                  {
  sort( TheArray[ Type ].begin(), TheArray[ Type ].end(), CompareState() );
}

SortStateR()

void Population_Manager::SortStateR ( unsigned  Type )

protected

Sort TheArray w.r.t. the current state attribute in reverse order

                                                 {
    sort(TheArray[Type].begin(), TheArray[Type].begin()+m_LiveArraySize[Type], CompareStateR());
}

SortX()

void Population_Manager::SortX ( unsigned  Type )

protected

Sort TheArray w.r.t. the m_Location_x attribute

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

SortXIndex()

void Population_Manager::SortXIndex ( unsigned  Type )

protected

Sort TheArray w.r.t. the m_Location_x attribute, and make an indexing array

                                                   {
    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;
  }
}

SortY()

void Population_Manager::SortY ( unsigned  Type )

protected

Sort TheArray w.r.t. the m_Location_y attribute

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

SpeciesSpecificReporting()

char * Population_Manager::SpeciesSpecificReporting	(	int	a_species,
		int	a_time
	)

This method handles species specific outputs. This is one place to do it. More commonly this is done in descendent classes

                                                                            {
  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;
      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;
}

References g_str, ImpactProbeReport(), and ProbeReport().

Referenced by RunTheSim().

StepFinished()

bool Population_Manager::StepFinished ( void  )

protectedvirtual

Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour.

Returns true if and only if all objects have finished the current step

                                            {
  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;
}

SupplyAnimalPtr()

TAnimal* Population_Manager::SupplyAnimalPtr ( int  a_index, int  a_animal  )

inline

Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK.

                                                        {
        return TheArray[a_index][a_animal];
    }

References TheArray.

SupplyCovPosx()

virtual int Population_Manager::SupplyCovPosx ( int  )

inlinevirtual

                                   {
        return 0;
    }

SupplyCovPosy()

virtual int Population_Manager::SupplyCovPosy ( int  )

inlinevirtual

                                   {
        return 0;
    }

SupplyListIndexSize()

unsigned Population_Manager::SupplyListIndexSize ( )

inline

                                   {
        return (unsigned)TheArray.size();
    }

References TheArray.

SupplyListName()

const char* Population_Manager::SupplyListName ( int  i )

inline

                                      {
            return m_ListNames[i];
    }

References m_ListNames.

SupplyListNameLength()

int Population_Manager::SupplyListNameLength ( )

inline

                               {
        return m_ListNameLength;
    }

References m_ListNameLength.

SupplyListSize()

unsigned Population_Manager::SupplyListSize ( unsigned  listindex )

inline

                                                {
        return (unsigned)TheArray[listindex].size();
    }

References TheArray.

SupplyLocXY()

virtual void Population_Manager::SupplyLocXY ( unsigned  listindex, unsigned  j, int &  x, int &  y  )

inlinevirtual

                                                                               {
        x = TheArray[listindex][j]->Supply_m_Location_x();
        y = TheArray[listindex][j]->Supply_m_Location_y();
    }

References TheArray.

SupplyPegPosx()

virtual int Population_Manager::SupplyPegPosx ( int  )

inlinevirtual

                                   {
        return 0;
    }

SupplyPegPosy()

virtual int Population_Manager::SupplyPegPosy ( int  )

inlinevirtual

                                   {
        return 0;
    }

SupplySimH()

int Population_Manager::SupplySimH ( )

inline

                     {
        return SimH;
    }

References SimH.

SupplySimW()

int Population_Manager::SupplySimW ( )

inline

                     {
        return SimW;
    }

References SimW.

SupplyState()

int Population_Manager::SupplyState ( unsigned  listindex, unsigned  j  )

inline

IntArray100 * SupplyStateList() { return & StateList; }

                                                    {
        return TheArray[listindex][j]->WhatState();
    }

References TheArray.

SupplyStateNames()

const char* Population_Manager::SupplyStateNames ( int  i )

inline

                                        {
        return StateNames[i];
    }

References StateNames.

SupplyStateNamesLength()

unsigned Population_Manager::SupplyStateNamesLength ( )

inline

                                      {
        return StateNamesLength;
    }

References StateNamesLength.

SupplyStepSize()

int Population_Manager::SupplyStepSize ( )

inline

                         {
        return m_StepSize;
    }

References m_StepSize.

TheAOROutputProbe()

void Population_Manager::TheAOROutputProbe ( )

virtual

This method must be overridden in descendent classes

                                           {
}

TheBreedingFemalesProbe()

virtual int Population_Manager::TheBreedingFemalesProbe ( int  )

inlinevirtual

                                             {
        return 0;
    }

TheBreedingSuccessProbe()

virtual int Population_Manager::TheBreedingSuccessProbe ( int &  , int &  , int &  , int &  , int &  , int &    )

inlinevirtual

                                                                                  {
        return 0;
    }

TheFledgelingProbe()

virtual int Population_Manager::TheFledgelingProbe ( )

inlinevirtual

                                     {
        return 0;
    }

TheGeneticProbe()

virtual void Population_Manager::TheGeneticProbe ( unsigned  , int  , unsigned &    )

inlinevirtual

                                                            {
    }

TheReallyBigOutputProbe()

void Population_Manager::TheReallyBigOutputProbe ( )

virtual

This method must be overridden in descendent classes

                                                 {
}

TheRipleysOutputProbe()

void Population_Manager::TheRipleysOutputProbe ( FILE *  a_prb )

virtual

This method must be overridden in descendent classes

                                                      {
}

Member Data Documentation

AOROutputPrb

ofstream* Population_Manager::AOROutputPrb

protected

BeforeStepActions

unsigned Population_Manager::BeforeStepActions[12]

protected

IndexArrayX

int Population_Manager::IndexArrayX[5][10000]

lamdagrid

long int Population_Manager::lamdagrid[2][257][257]

protected

Referenced by LamdaBirth(), LamdaClear(), and LamdaDeath().

m_AlleleFreqsFile

FILE* Population_Manager::m_AlleleFreqsFile

protected

m_AOR_Probe

AOR_Probe* Population_Manager::m_AOR_Probe

protected

m_catastrophestartyear

int Population_Manager::m_catastrophestartyear

protected

m_EasyPopRes

FILE* Population_Manager::m_EasyPopRes

protected

m_GeneticsFile

FILE* Population_Manager::m_GeneticsFile

protected

m_ListNameLength

unsigned Population_Manager::m_ListNameLength

protected

Referenced by SupplyListNameLength().

m_ListNames

const char* Population_Manager::m_ListNames[32]

protected

Referenced by SupplyListName().

m_LiveArraySize

vector<unsigned> Population_Manager::m_LiveArraySize

protected

Referenced by GetLiveArraySize(), and IncLiveArraySize().

m_NoProbes

int Population_Manager::m_NoProbes

protected

Referenced by SetNoProbes().

m_population_type

TTypesOfPopulation Population_Manager::m_population_type

protected

Referenced by GetPopulationType().

m_SeasonNumber

int Population_Manager::m_SeasonNumber

protected

Holds the season number. Used when running goose and hunter sims.

Referenced by GetSeasonNumber().

m_SimulationName

char Population_Manager::m_SimulationName[255]

m_StepSize

int Population_Manager::m_StepSize

protected

Referenced by SupplyStepSize().

m_TheLandscape

Landscape* Population_Manager::m_TheLandscape

Referenced by RodenticidePredators_Population_Manager::CreatHabitatQualGrid(), RodenticidePredators_Population_Manager::EvaluatePoly(), RodenticidePredators_Population_Manager::ReadHabitatValues(), and RodenticidePredators_Population_Manager::Tick().

ProbesSet

bool Population_Manager::ProbesSet

ReallyBigOutputPrb

FILE* Population_Manager::ReallyBigOutputPrb

protected

RipleysOutputPrb

FILE* Population_Manager::RipleysOutputPrb

protected

RipleysOutputPrb1

FILE* Population_Manager::RipleysOutputPrb1

protected

RipleysOutputPrb10

FILE* Population_Manager::RipleysOutputPrb10

protected

RipleysOutputPrb11

FILE* Population_Manager::RipleysOutputPrb11

protected

RipleysOutputPrb12

FILE* Population_Manager::RipleysOutputPrb12

protected

RipleysOutputPrb2

FILE* Population_Manager::RipleysOutputPrb2

protected

RipleysOutputPrb3

FILE* Population_Manager::RipleysOutputPrb3

protected

RipleysOutputPrb4

FILE* Population_Manager::RipleysOutputPrb4

protected

RipleysOutputPrb5

FILE* Population_Manager::RipleysOutputPrb5

protected

RipleysOutputPrb6

FILE* Population_Manager::RipleysOutputPrb6

protected

RipleysOutputPrb7

FILE* Population_Manager::RipleysOutputPrb7

protected

RipleysOutputPrb8

FILE* Population_Manager::RipleysOutputPrb8

protected

RipleysOutputPrb9

FILE* Population_Manager::RipleysOutputPrb9

protected

SimH

int Population_Manager::SimH

Referenced by SupplySimH().

SimHH

unsigned Population_Manager::SimHH

SimW

int Population_Manager::SimW

Referenced by SupplySimW().

SimWH

unsigned Population_Manager::SimWH

StateNames

const char* Population_Manager::StateNames[100]

protected

Referenced by SupplyStateNames().

StateNamesLength

unsigned Population_Manager::StateNamesLength

protected

Referenced by SupplyStateNamesLength().

TestFile

FILE* Population_Manager::TestFile

protected

TestFile2

FILE* Population_Manager::TestFile2

protected

TheArray

vector< TListOfAnimals > Population_Manager::TheArray

protected

Referenced by IsLast(), SupplyAnimalPtr(), SupplyListIndexSize(), SupplyListSize(), SupplyLocXY(), and SupplyState().

TheProbe

probe_data* Population_Manager::TheProbe[100]

Referenced by CloseDownSim(), and GetProbeInput_ini().

---

The documentation for this class was generated from the following files:

• C:/Repo/ALMaSS_all/BatchALMaSS/PopulationManager.h
• C:/Repo/ALMaSS_all/BatchALMaSS/PopulationManager.cpp