#include <RodenticidePredators.h>

Public Member Functions
int	HowManyTerritoriesHere (int a_x, int a_y)

void	PreCachePoly (int a_poly)

	RodenticidePredators_Population_Manager (Landscape *L)

vector< RP_Territory > *	SupplyTerritories ()

void	Tick ()
	Updates the rodenticide exposure for all predator territories. More...

virtual	~RodenticidePredators_Population_Manager ()

Public Member Functions inherited from Population_Manager
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)

Protected Member Functions
void	CreateTerritories ()
	Populates the landscape with predatory territories. More...

void	CreatHabitatQualGrid (void)
	Evaluate the landscape and create the habitat quality grid. More...

double	EvaluateHabitat (int a_x, int a_y, int a_range)
	Gets the total habitat score for a square UL x,y diameter of range. More...

double	EvaluatePoly (int a_poly)
	Get the habitat quality based on polygon type. More...

bool	IsGridPositionValid (int &x, int &y, int range)
	Tests whether a square has any occupied cells. More...

void	NewTerritory (int a_x, int a_y, int a_range, double a_qual)
	Create a new territory and claim the grid. More...

void	PredatorTerritoryInput ()
	Output functions for predator territories. More...

void	PredatorTerritoryOutput (bool a_initial)
	Output functions for predator territories. More...

void	ReadHabitatValues (int a_type)
	Read in specific predator type habitat scores. More...

Protected Member Functions inherited from Population_Manager
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
double	m_habquals [tole_Foobar]

int	m_hash_size

int	m_NoTerritories

bool *	m_occupancy_grid

int	m_predator_maxHR

int	m_predator_minHR

double	m_predator_targetQual

double *	m_qual_cache

double *	m_qual_grid

int	m_sim_h

int	m_sim_h_div_10

int	m_sim_w

int	m_sim_w_div_10

double	m_summeddays
	Keeps track of the number of days we have rodenticide exposure summation for. More...

vector< RP_Territory >	m_Territories

Protected Attributes inherited from Population_Manager
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

Additional Inherited Members
Public Attributes inherited from Population_Manager
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]

Constructor & Destructor Documentation

RodenticidePredators_Population_Manager::~RodenticidePredators_Population_Manager ( )

virtual

When the manager is destroyed call the output functions for predator territories

References m_occupancy_grid, m_qual_cache, m_qual_grid, and PredatorTerritoryOutput().

 {
         PredatorTerritoryOutput(false);
         delete m_qual_cache;
     delete m_qual_grid;
         delete m_occupancy_grid;
 }

RodenticidePredators_Population_Manager::RodenticidePredators_Population_Manager ( Landscape * L )

On construction the first thing to do is to read the quality scores in from the correct predator input file. This depends on a config variable being correctly set: cfg_RodenticidePredatoryType

Create the habitat quality grid ready for predatory habitat assessment

Now populate the landscape with predatory territories

References cfg_rodenticide_read_predators(), cfg_RodenticidePredatoryMaxTerr(), cfg_RodenticidePredatoryMinTerr(), cfg_RodenticidePredatoryTargetQual(), cfg_RodenticidePredatoryType(), CreateTerritories(), CreatHabitatQualGrid(), m_predator_maxHR, m_predator_minHR, m_predator_targetQual, m_summeddays, PredatorTerritoryInput(), PredatorTerritoryOutput(), and ReadHabitatValues().

                                                                                                 : Population_Manager(a_L)
 {
         m_predator_minHR = cfg_RodenticidePredatoryMinTerr.value() / 10; // Need divind by 10 for the grid (it is in 10 x 10m grids)
         m_predator_maxHR = cfg_RodenticidePredatoryMaxTerr.value() / 10;
         m_predator_targetQual = cfg_RodenticidePredatoryTargetQual.value();
         m_summeddays = 0.0;
         ReadHabitatValues(cfg_RodenticidePredatoryType.value());
         CreatHabitatQualGrid();
         if (cfg_rodenticide_read_predators.value()) PredatorTerritoryInput(); 
         else 
         {
                 CreateTerritories(); 
                 PredatorTerritoryOutput(true);
         }
 
 }

Member Function Documentation

void RodenticidePredators_Population_Manager::CreateTerritories ( )

protected

Populates the landscape with predatory territories.

Starts with a minimum territory size territory and then increases the size until either a occupied square is found or max size is reached, or the quality level has been met.

Referenced by RodenticidePredators_Population_Manager().

 {
         m_NoTerritories = 0;
         int x0 = m_predator_maxHR / 2; // Our starting point x
         int x = (int) (x0+g_rand_uni()*(m_sim_w_div_10 - x0));
         int y = x0;  // Our starting point y
         int starty = y;
         int x1 = m_sim_w_div_10 - x0;   // End point x
         int y1 = m_sim_h_div_10 - x0;   // End point y
         //bool toggle = false;
         double qual;
         int range; 
         int tries = m_sim_w_div_10 * m_sim_h_div_10; // the number of grid points in the grid
         while ( tries-- > 0)
         {
                 //if (toggle) if (y>=starty) break;
                 range = m_predator_minHR; 
                 bool found = false;
             while ( ( range <= m_predator_maxHR ) && ( !found ))
             {
                         if ( !IsGridPositionValid( x, y, range ) ) 
                         {
                                 if ( ++x >= x1 ) 
                                 {
                                         x = 0; //random( 3 );
                                         if ( ++y >= y1 ) 
                                         {
                                                 tries = 0; // Gone all the way round so stop
                                                 range = m_predator_maxHR +1;
                                                 //toggle = true;
                                         }
                                 }
                                 continue;
                         }
                         // Location was OK, ie. not occupied.
                         // Try the smallest possible territory located right at our starting
                         // position.
                         qual = EvaluateHabitat( x, y, range );
                         // Is it suitable?
                         if ( qual >= m_predator_targetQual ) 
                         {
                                 // If so create it and claim the area on the grid
                                 // Is OK so create a territory
                                 NewTerritory( x, y, range, 0.0 );
                                 found = true;
                         }
                         else range++;
                 }
                 // Take a step and try again
                 if (++x >= x1) 
                 {
                         x = x0;
                         if (++y >= y1)
                         {
                                 tries = 0; // Gone all the way round so stop
                                 range = m_predator_maxHR + 1;
                                 //toggle = true;
                         }
                 }
         }
 }

void RodenticidePredators_Population_Manager::CreatHabitatQualGrid ( void )

protected

Evaluate the landscape and create the habitat quality grid.

Need to do the basic read and quality assessment for the landscape, before creating and allocating the predatory territories. The first step is to get the map dimensions saved to local attributes.

Following that all the polygons in the landscape are pre-cached for their quality score - this is important for speed because it only needs to be done once per polygon.

Finally go through the whole landscape in 10x10m blocks and fill in the quality grid scoresas a the mean of 100m2 i.e. 10 x 10 m squares

References m_hash_size, m_occupancy_grid, m_qual_cache, m_qual_grid, m_sim_h, m_sim_h_div_10, m_sim_w, m_sim_w_div_10, Population_Manager::m_TheLandscape, Landscape::RodenticidePredatorsEvaluation(), Landscape::SupplyLargestPolyNumUsed(), Landscape::SupplyPolyRef(), Landscape::SupplySimAreaHeight(), and Landscape::SupplySimAreaWidth().

Referenced by RodenticidePredators_Population_Manager().

 {
         m_sim_w = m_TheLandscape->SupplySimAreaWidth();
         m_sim_h = m_TheLandscape->SupplySimAreaHeight();
         m_sim_w_div_10 = m_sim_w / 10;
         m_sim_h_div_10 = m_sim_h / 10;
         m_hash_size = m_TheLandscape->SupplyLargestPolyNumUsed() + 1;
         m_qual_cache = new double[m_hash_size];
         m_TheLandscape->RodenticidePredatorsEvaluation( this );
         /*
         * Next the memory required for operations is reserved for the quality grid and occupancy grid that we need for the territory finding operations. 
         * The occupancy grid also needs all elements set to false.
         */
         int totalgrids = m_sim_w_div_10 * m_sim_h_div_10;
         m_qual_grid = new double[ totalgrids ];
         m_occupancy_grid = new bool [ totalgrids ];
         for (int i=0; i<totalgrids; i++)
         {
                 m_occupancy_grid[ i ] = false;
         }
         for (int x=0; x< m_sim_w_div_10; x++)
         {
                 for (int y = 0; y < m_sim_h_div_10; y++)
                 {
                         int cx = x*10;
                         int cy = y*10;
                         double qual = 0.0;
                         for (int xx = cx; xx < cx+10; xx++)
                         {
                                 for (int yy = cy; yy < cy+10; yy++)
                                 {
                                         int poly = m_TheLandscape->SupplyPolyRef(xx,yy);
                                         qual += m_qual_cache[poly];
                                 }
                         }
                         m_qual_grid[x + (y * m_sim_w_div_10)] = qual/=100.0;
                 }
         }
 }

double RodenticidePredators_Population_Manager::EvaluateHabitat	(	int	a_x,
		int	a_y,
		int	a_range
	)

protected

Gets the total habitat score for a square UL x,y diameter of range.

Looks through the area summing all scores.

 {
         double l_qual = 0.0;
         int r2 = a_range / 2;
         int l_min_x = a_x - r2;
         int l_min_y = a_y - r2;
         int l_max_x = a_x + r2;
         int l_max_y = a_y + r2;
         for (int x = l_min_x; x < l_max_x; x++)
         {
                 for ( int y = l_min_y; y < l_max_y; y++ ) 
                 {
                         l_qual += m_qual_grid[ x + y * m_sim_w_div_10 ];
                 }
         }
         return l_qual;
 }

double RodenticidePredators_Population_Manager::EvaluatePoly ( int a_poly )

protected

Get the habitat quality based on polygon type.

Returns the specific score for this polygon based on the polygon type and the score stored in m_habquals

References m_habquals, Population_Manager::m_TheLandscape, and Landscape::SupplyElementType().

 {
         TTypesOfLandscapeElement l_type = m_TheLandscape->SupplyElementType( a_poly );
         return m_habquals[(int) l_type];
 }

int RodenticidePredators_Population_Manager::HowManyTerritoriesHere	(	int	a_x,
		int	a_y
	)

 {
         int sum = 0;
         int sz =  (int) m_Territories.size();
         for (int t=0; t< sz; t++)
         {
                 int r = m_Territories[t].m_range;
                 int x = m_Territories[t].m_x - (r / 2);
                 int y = m_Territories[t].m_y - (r / 2);
                 if ((a_x>=x) && (a_x<x+r) && (a_y>=y) &&(a_y<=y+r)) sum++;
         }
         return sum;
 }

bool RodenticidePredators_Population_Manager::IsGridPositionValid	(	int &	x,
		int &	y,
		int	range
	)

protected

Tests whether a square has any occupied cells.

Returns: false if any occupied grid cell is found If we are too near the edge then do not evaluate,

otherwise test each potential location to see if they are occupied - if so return false

 {
         int r2 = a_range / 2;
         int l_min_x = a_x - r2;
         int l_min_y = a_y - r2;
         int l_max_x = a_x + r2;
         int l_max_y = a_y + r2;
         for (int i = l_min_x; i < l_max_x; i++)
         {
                 for (int j = l_min_y; j < l_max_y; j++)
                 {
                         if ( m_occupancy_grid[ i + j * m_sim_w_div_10 ]  ) 
                         {
                                 return false;
                         }
                 }
         }
         // No occupied squares found so return true
         return true;
 }

void RodenticidePredators_Population_Manager::NewTerritory	(	int	a_x,
		int	a_y,
		int	a_range,
		double	a_qual
	)

protected

Create a new territory and claim the grid.

 {
         RP_Territory rpt;
         rpt.m_exposure = a_exposure;
         rpt.m_range = (int) floor(0.5+(a_range * 10 * cfg_RodenticidePredatoryTerrOverlap.value()));
         rpt.m_x = a_x * 10;
         rpt.m_y = a_y * 10;
         m_Territories.push_back(rpt);
         // Claim the territory in the grid
         int r2 = a_range / 2;
         int l_min_x = a_x - r2;
         int l_min_y = a_y - r2;
         int l_max_x = a_x + r2;
         int l_max_y = a_y + r2;
         
         for (int i = l_min_x; i < l_max_x; i++)
         {
                 for (int j = l_min_y; j < l_max_y; j++)
                 {
                         m_occupancy_grid[ i + j * m_sim_w_div_10 ] = true;
                 }
         }
 }

void RodenticidePredators_Population_Manager::PreCachePoly ( int a_poly )

inline

Referenced by Landscape::RodenticidePredatorsEvaluation().

         {
                 m_qual_cache[a_poly] = EvaluatePoly(a_poly);
         }

void RodenticidePredators_Population_Manager::PredatorTerritoryInput ( )

protected

Output functions for predator territories.

Opens a standard output tab-delimited text file and reads all predatory territory information in the format:
Number of entries
Entry 1 x, Entry 1 y, Entry 1 size, Entry 1 exposure
Entry 2 x, Entry 2 y, Entry 2 size, Entry 2 exposure
Entry 3 x etc....

Referenced by RodenticidePredators_Population_Manager().

 {
         ifstream ifile("PredatorTerritoryOutputInfo.txt",ios::in);
         int sz;
         ifile >> sz;
         double skip;
         int x,y,range;
         m_Territories.resize(0);
         for (int i=0; i< sz; i++)
         {
                 ifile >> x >> y  >> range >> skip;
                 RP_Territory rpt;
                 rpt.m_exposure = 0.0;
                 rpt.m_range = range;
                 rpt.m_x = x;
                 rpt.m_y = y;
                 m_Territories.push_back(rpt);
         }
         ifile.close();
 }

void RodenticidePredators_Population_Manager::PredatorTerritoryOutput ( bool a_initial )

protected

Output functions for predator territories.

Opens a standard output tab-delimited text file and dumps all predatory territory information in the format:
Number of entries
Entry 1 x, Entry 1 y, Entry 1 size, Entry 1 exposure
Entry 2 x, Entry 2 y, Entry 2 size, Entry 2 exposure
Entry 3 x etc....

Referenced by RodenticidePredators_Population_Manager(), and ~RodenticidePredators_Population_Manager().

 {
         ofstream ofile("PredatorTerritoryOutputInfo.txt",ios::out);
         int sz =  (int) m_Territories.size();
         ofile << sz << endl;
         double asum=0.0;
         for (int i=0; i< sz; i++) asum+=m_Territories[i].m_exposure;
         if ((asum==0.0) || (m_summeddays<1)) a_initial = true;
         for (int i=0; i< sz; i++)
         {
                 ofile << m_Territories[i].m_x << '\t';
                 ofile << m_Territories[i].m_y << '\t';
                 ofile << m_Territories[i].m_range << '\t';
                 if (a_initial) ofile << 0.0 << endl; else ofile << m_Territories[i].m_exposure/m_summeddays << endl;
         }
         ofile.close();
 }

void RodenticidePredators_Population_Manager::ReadHabitatValues ( int a_type )

protected

Read in specific predator type habitat scores.

This method picks the input file based on the parameter a_type and reads in the scores for each habitat for that predator type. These are stored in m_habquals for later use in habitat evaluation.

References m_habquals, Population_Manager::m_TheLandscape, and Landscape::Warn().

Referenced by RodenticidePredators_Population_Manager().

 {
         fstream ifile;
         switch (a_type)
         {
         case 0:
                 ifile.open("RodenticidePredator0_HabitatScores.txt",ios::in);
                 break;
         default:
                 ifile.open("RodenticidePredatorNone_HabitatScores.txt",ios::in);
         }
         if (!ifile)
         {
                         m_TheLandscape->Warn("RodenticidePredators_Population_Manager::ReadHabitatValues","Could Not Open Predator Habitat Scores File");
                         exit(0);
         }
         int n_values;
         ifile >> n_values;
         if (n_values != tole_Foobar)
         {
                         m_TheLandscape->Warn("RodenticidePredators_Population_Manager::ReadHabitatValues"," - wrong number of habitat scores in RodenticidePredator_HabitatScores.txt");
                         exit(0);
         }
         for (int i = 0; i< tole_Foobar; i++) ifile >> m_habquals[i];
         ifile.close();
 }

vector<RP_Territory>* RodenticidePredators_Population_Manager::SupplyTerritories ( )

inline

62 { return &m_Territories; }

RodenticidePredators_Population_Manager::m_Territories

vector< RP_Territory > m_Territories

Definition: RodenticidePredators.h:78

void RodenticidePredators_Population_Manager::Tick ( void )

Updates the rodenticide exposure for all predator territories.

Runs through all the territories and sums up the rodenticide exposure and accumulates this in each territory

 {
         int sz =  (int) m_Territories.size();
         for (int t=0; t< sz; t++)
         {
                 int x = m_Territories[t].m_x;
                 int y = m_Territories[t].m_y;
                 int r = m_Territories[t].m_range;
                 int xr = x+r;
                 int yr = y+r;
                 if (xr >= m_sim_w ) xr = m_sim_w-1;
                 if (yr >= m_sim_h ) yr = m_sim_h-1;
                 for (int i=x; i<xr; i++)
                         for (int j=y; j< yr; j++)
                         {
                                 m_Territories[t].m_exposure += m_TheLandscape->SupplyRodenticide(i,j);
                         }
         }
         m_summeddays++;
 }