Population_Manager Class Reference

Base class for all population managers. More...

#include <PopulationManager.h>

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

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

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

Protected Attributes
unsigned	BeforeStepActions [10]
FILE *	CIPEGridOutputPrb
FILE *	CIPEGridOutputPrbB
long int	lamdagrid [2][257][257]
FILE *	m_AlleleFreqsFile
int	m_catastrophestartyear
int *	m_cgridcount
int	m_cgridcountwidth
int	m_cipegridsize
FILE *	m_EasyPopRes
FILE *	m_GeneticsFile
int *	m_gridcount [4]
int	m_gridcountsize [4]
int	m_gridcountwidth [4]
unsigned	m_ListNameLength
const char *	m_ListNames [10]
vector< unsigned >	m_LiveArraySize
int	m_NoProbes
TTypesOfPopulation	m_population_type
int	m_SeasonNumber
	Holds the season number. Used when running goose and hunter sims. More...
int	m_StepSize
FILE *	NWordOutputPrb
FILE *	ReallyBigOutputPrb
FILE *	RipleysOutputPrb
FILE *	RipleysOutputPrb1
FILE *	RipleysOutputPrb10
FILE *	RipleysOutputPrb11
FILE *	RipleysOutputPrb12
FILE *	RipleysOutputPrb2
FILE *	RipleysOutputPrb3
FILE *	RipleysOutputPrb4
FILE *	RipleysOutputPrb5
FILE *	RipleysOutputPrb6
FILE *	RipleysOutputPrb7
FILE *	RipleysOutputPrb8
FILE *	RipleysOutputPrb9
const char *	StateNames [100]
unsigned	StateNamesLength
FILE *	TestFile
FILE *	TestFile2
vector< TListOfAnimals >	TheArray

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

(

Landscape *

L

)

Constructor for the Population_Manager class

References cfg_CipeGridSize(), and cfg_RipleysOutputMonthly_used().

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

Population_Manager::~Population_Manager ( void  )

virtual

Destructor for the Population_Manager class

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

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

Member Function Documentation

bool Population_Manager::BeginningOfMonth

(

)

Is it the first day of the month?

References cfg_DayInMonth().

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

virtual void Population_Manager::BreedingPairsOutput ( int  )

inlinevirtual

                                           {
  }

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

inlinevirtual

                                                                                        {
  }

virtual void Population_Manager::Catastrophe ( int  )

inlinevirtual

References BeginningOfMonth(), ImpactProbeReport(), ProbeReport(), and SpeciesSpecificReporting().

                                        {
        }

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

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

void Population_Manager::CloseTheCIPEGridOutputProbe

(

)

close the probe

                                                     {
  if ( CIPEGridOutputPrb != NULL )
    fclose( CIPEGridOutputPrb );
    fclose( CIPEGridOutputPrbB );
}

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

void Population_Manager::CloseTheReallyBigOutputProbe

(

)

close the probe

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

void Population_Manager::CloseTheRipleysOutputProbe

(

)

close the probe

References cfg_RipleysOutputMonthly_used().

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

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
}

void Population_Manager::DoAfter ( )

protectedvirtual

Can be used in descendent classes

                                 {
  //TODO: Add your source code here
}

void Population_Manager::DoAlmostLast ( )

protectedvirtual

Can be used in descendent classes

                                      {
  //TODO: Add your source code here
}

void Population_Manager::DoBefore ( )

protectedvirtual

Can be used in descendent classes

                                  {
}

void Population_Manager::DoFirst ( )

protectedvirtual

Can be used in descendent classes

                                 {
}

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

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

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

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

virtual void Population_Manager::FledgelingProbeOutput ( int  , int    )

inlinevirtual

                                                 {
  }

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

inlinevirtual

                                                           {
  }

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

TTypesOfPopulation Population_Manager::GetPopulationType ( )

inline

{ return m_population_type; }

int Population_Manager::GetSeasonNumber ( )

inline

Get the season number.

{return m_SeasonNumber;}

void Population_Manager::ImpactedProbe ( )

virtual

Special pesticide related probe. Overidden in descendent classes

                                        {

}

void Population_Manager::ImpactProbeReport

(

int

a_Time

)

Special probe

References BeginningOfMonth().

                                                       {

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

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

bool Population_Manager::IsLast ( unsigned  listindex )

inline

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

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

inline

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

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

inline

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

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

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

inline

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

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

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

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

                                                {
  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::NWordOutput ( )

protected

The output section for the NWord probe.
.

A common output stub for the NWord output probe. Specialist counting for each species occurs as part of the CIPE grid probe, then this method deals with the final output.

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

virtual bool Population_Manager::OpenTheBreedingPairsProbe ( )

inlinevirtual

Referenced by CreatePopulationManager().

                                           {
    return false;
  }

virtual bool Population_Manager::OpenTheBreedingSuccessProbe ( )

inlinevirtual

Referenced by CreatePopulationManager().

                                             {
    return false;
  }

bool Population_Manager::OpenTheCIPEGridOutputProbe

(

)

open the probe

References cfg_CIPEGridOutput_filename(), and cfg_CIPEGridOutput_filenameB().

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

virtual bool Population_Manager::OpenTheFledgelingProbe ( )

inlinevirtual

Referenced by CreatePopulationManager().

                                        {
    return false;
  }

bool Population_Manager::OpenTheMonthlyRipleysOutputProbe

(

)

open 12 ripley output probles, one for each month

References cfg_RipleysOutput_filename().

                                                          {
  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

(

)

open the probe

References cfg_ReallyBigOutput_filename().

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

bool Population_Manager::OpenTheRipleysOutputProbe

(

)

open the probe

References cfg_RipleysOutput_filename().

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

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

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

virtual

Default data probe. Rarely used in actuality but always available

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.

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

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

Default probe file input

Referenced by GetProbeInput_ini().

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

char * Population_Manager::ProbeReport

(

int

a_time

)

References BeginningOfMonth(), and g_str.

                                                {

  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

a_time

)

References g_str.

                                                    {
        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::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.

References cfg_CatastropheEventStartYear(), cfg_CIPEGridOutput_day(), cfg_CIPEGridOutput_Interval(), cfg_CIPEGridOutput_used(), 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().

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

void Population_Manager::SetNoProbes ( int  a_pn )

inline

Referenced by CreatePopulationManager().

{ m_NoProbes=a_pn; }

void Population_Manager::Shuffle ( unsigned  Type )

protected

Run once through the list swapping randomly chosen elements

References random().

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

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

References g_rand_uni.

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

void Population_Manager::SortState ( unsigned  Type )

protected

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

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

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

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

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

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

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

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

Referenced by RunTheSim().

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

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

virtual int Population_Manager::SupplyCovPosx ( int  )

inlinevirtual

                                   {
    return 0;
  }

virtual int Population_Manager::SupplyCovPosy ( int  )

inlinevirtual

                                   {
    return 0;
  }

unsigned Population_Manager::SupplyListIndexSize ( )

inline

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

const char* Population_Manager::SupplyListName ( int  i )

inline

                                      {
    return m_ListNames[ i ];
  }

int Population_Manager::SupplyListNameLength ( )

inline

                             {
    return m_ListNameLength;
  }

unsigned Population_Manager::SupplyListSize ( unsigned  listindex )

inline

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

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

virtual int Population_Manager::SupplyPegPosx ( int  )

inlinevirtual

                                   {
    return 0;
  }

virtual int Population_Manager::SupplyPegPosy ( int  )

inlinevirtual

                                   {
    return 0;
  }

int Population_Manager::SupplySimH ( )

inline

                   {
    return SimH;
  }

int Population_Manager::SupplySimW ( )

inline

                   {
    return SimW;
  }

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

inline

IntArray100 * SupplyStateList() { return & StateList; }

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

const char* Population_Manager::SupplyStateNames ( int  i )

inline

                                        {
    return StateNames[ i ];
  }

unsigned Population_Manager::SupplyStateNamesLength ( )

inline

                                    {
    return StateNamesLength;
  }

int Population_Manager::SupplyStepSize ( )

inline

                       {
    return m_StepSize;
  }

virtual int Population_Manager::TheBreedingFemalesProbe ( int  )

inlinevirtual

                                             {
        return 0;
  }

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

inlinevirtual

                                                                                       {
         return 0;
  }

void Population_Manager::TheCIPEGridOutputProbe ( )

virtual

This method MUST be overridden in descendent classes, if you want it to work

                                                {
}

virtual int Population_Manager::TheFledgelingProbe ( )

inlinevirtual

                                   {
    return 0;
  }

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

inlinevirtual

                                                               {
  }

virtual void Population_Manager::TheNWordOutputProbe ( )

inlinevirtual

{};

void Population_Manager::TheReallyBigOutputProbe ( )

virtual

This method must be overridden in descendent classes

                                                 {
}

void Population_Manager::TheRipleysOutputProbe ( FILE *  a_prb )

virtual

This method must be overridden in descendent classes

                                                       {
}

Member Data Documentation

unsigned Population_Manager::BeforeStepActions[10]

protected

FILE* Population_Manager::CIPEGridOutputPrb

protected

FILE* Population_Manager::CIPEGridOutputPrbB

protected

int Population_Manager::IndexArrayX[5][10000]

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

protected

FILE* Population_Manager::m_AlleleFreqsFile

protected

int Population_Manager::m_catastrophestartyear

protected

int* Population_Manager::m_cgridcount

protected

int Population_Manager::m_cgridcountwidth

protected

int Population_Manager::m_cipegridsize

protected

FILE* Population_Manager::m_EasyPopRes

protected

FILE* Population_Manager::m_GeneticsFile

protected

int* Population_Manager::m_gridcount[4]

protected

int Population_Manager::m_gridcountsize[4]

protected

int Population_Manager::m_gridcountwidth[4]

protected

unsigned Population_Manager::m_ListNameLength

protected

const char* Population_Manager::m_ListNames[10]

protected

vector<unsigned> Population_Manager::m_LiveArraySize

protected

int Population_Manager::m_NoProbes

protected

TTypesOfPopulation Population_Manager::m_population_type

protected

int Population_Manager::m_SeasonNumber

protected

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

char Population_Manager::m_SimulationName[255]

int Population_Manager::m_StepSize

protected

Landscape* Population_Manager::m_TheLandscape

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

FILE* Population_Manager::NWordOutputPrb

protected

bool Population_Manager::ProbesSet

FILE* Population_Manager::ReallyBigOutputPrb

protected

FILE* Population_Manager::RipleysOutputPrb

protected

FILE* Population_Manager::RipleysOutputPrb1

protected

FILE* Population_Manager::RipleysOutputPrb10

protected

FILE* Population_Manager::RipleysOutputPrb11

protected

FILE* Population_Manager::RipleysOutputPrb12

protected

FILE* Population_Manager::RipleysOutputPrb2

protected

FILE* Population_Manager::RipleysOutputPrb3

protected

FILE* Population_Manager::RipleysOutputPrb4

protected

FILE* Population_Manager::RipleysOutputPrb5

protected

FILE* Population_Manager::RipleysOutputPrb6

protected

FILE* Population_Manager::RipleysOutputPrb7

protected

FILE* Population_Manager::RipleysOutputPrb8

protected

FILE* Population_Manager::RipleysOutputPrb9

protected

int Population_Manager::SimH

unsigned Population_Manager::SimHH

int Population_Manager::SimW

unsigned Population_Manager::SimWH

const char* Population_Manager::StateNames[100]

protected

unsigned Population_Manager::StateNamesLength

protected

FILE* Population_Manager::TestFile

protected

FILE* Population_Manager::TestFile2

protected

vector< TListOfAnimals > Population_Manager::TheArray

protected

probe_data* Population_Manager::TheProbe[100]

Referenced by CloseDownSim(), and GetProbeInput_ini().

---

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

• PopulationManager.h
• PopulationManager.cpp