A class to describe the rabbits warren system. More...

#include <Rabbit.h>

Inheritance diagram for Rabbit_Warren:

Public Member Functions
	Rabbit_Warren (int p_x, int p_y, Landscape p_L, Rabbit_Population_Manager p_NPM, int a_size, int a_soil)
	Rabbit warren constructor. More...

virtual	~Rabbit_Warren ()
	Rabbit warren destructor. More...

virtual void	Step ()
	Warren step code. More...

virtual void	BeginStep ()
	Warren begin step code. More...

int	Get_TL_x ()
	Get m_TL_x. More...

int	Get_TL_y ()
	Get m_TL_x. More...

APoint	GetPointTL ()
	Get the TL coords as a point. More...

int	GetActiveBurrows ()
	Gets the number of occupied burrows. More...

int	GetPopulationSize ()
	Gets the total warren population of rabbits. More...

bool	GetCarryingCapacityFilled ()
	Checks whether all possible burrows are filled with rabbits. More...

double	GetCarryingCapacityRatio ()
	Checks whether all possible burrows are filled with rabbits. This is updated daily by Rabbit_Warren::UpdateForageInformation. More...

int	GetCarryingCapacity ()
	Returns the carrying capacity in burrows. More...

double	GetDiseaseConstant (void)
	Returns the warrens current disease constant. More...

void	RabbitProductionRecord (RabbitObjectTypes YoungType, int kits)
	Stores data about production of rabbits throughout year. More...

int	GetRabbitProductionRecord (RabbitObjectTypes YoungType)
	Get data about production of rabbits throughout year. More...

void	ResetRabbitProductionRecord (RabbitObjectTypes YoungType)
	Reset specific data about production of rabbits throughout year. More...

void	ResetAllRabbitProductionRecord (void)
	Reset data about production of rabbits throughout year. More...

void	AddNetworkConnection (LocalWarrenNewtorkEntry a_LWNE)
	Adds a warren to the local network list. More...

Rabbit_Warren *	GetNetworkWarren (void)
	Chooses a warren to evaluate based on distance. More...

void	NetworkEvaluation (void)
	Calculates and saves distance probabilities. More...

bool	IsMember (Rabbit_Base *a_rabbit)
	Returns true if this rabbit belongs to the warren. More...

bool	IsFreeFemale (void)
	Returns true if there is a female with a burrow and no mate. More...

bool	IsFreeMale (void)
	Returns true if there is a male with a burrow and no mate. More...

void	UpdateDominance (void)
	Checks for a dominant female and promotes one if necessary and possible. More...

void	ChooseNewDominant (void)
	Finds a subdominantfemale and promotes them to dominant. More...

int	IsFreeBurrow (void)
	Is there a vacent burrow? More...

void	Leave (Rabbit_Base *a_rabbit)
	Remove this adult from the warren list. More...

void	Join (Rabbit_Base *a_rabbit)
	Adds this rabbit to the warren list. More...

void	OccupyWarren (Rabbit_Adult *a_rabbit)
	Adds the first rabbit to the warren list. More...

void	JoinNOccupy (Rabbit_Adult *a_rabbit)
	Adds this adult to the warren list and house them in a suitable burrow. More...

void	JoinNMate (Rabbit_Adult *a_mate, RabbitObjectTypes rob_type)
	Adds this rabbit to the warren list and mate him with un-mated female/male with a burrow. More...

void	Mate (Rabbit_Adult *a_mate, RabbitObjectTypes rob_type)
	Mate him with un-mated female/male with a burrow. More...

void	OccupyNewBurrow ()
	a_rabbit occupies a newly dug burrow More...

void	OccupyBurrow ()
	a_rabbit occupies a free burrow More...

int	GetAllBreedingFemaleRabbits ()
	Supplies the number of breeding rabbits currently in the warren. More...

int	GetAllBigFemaleRabbits ()
	Supplies the number of big rabbits currently in the warren. More...

double	GetForagePesticide (void)
	Gets the current mean pesticide concentration per unit forage. More...

int	GetSoilType (void)
	Gets the warren soil type. More...

bool	DEBUG_InternalTest ()

bool	DEBUG_InternalTest2 ()

double	Disease ()
	Supply the current disease mortality constant. More...

void	CalcDisease ()
	Calculate the current disease mortality constant. More...

double	GetAvailableForage (void)
	Returns the available forage realtive to rabbit numbers. More...

double	GetInvAvailableForage (void)
	Returns the inverse of available forage realtive to rabbit numbers. More...

double	GetLitterReabsortionConst (void)
	Returns litter reabsorption chance. More...

int	GetThisYearsBreeders ()
	Returns the number of females breeding this year. More...

double	GetThisYearsBreedersAv ()
	Returns the number of females breeding this year. More...

int	GetThisYears1yrOldFemales ()
	Returns the number of 1yr old females. More...

int	GetLittersThisYear ()
	Returns the number litters produced in the last 12 months. More...

int	GetThisYearsNonBreeders ()
	Returns the number of females not breeding this year but older than 1 year. More...

void	UpdateThisYearsBreeders ()
	Calculates and stores the number of breeders and non-breeders. More...

double	GetDailyMortalityChanceA ()
	Returns the adult daily mortality multiplier. More...

double	GetDailyMortalityChanceJ ()
	Returns the juvenile daily mortality multiplier. More...

double	GetCCRabbitsR ()
	Records the number of big female rabbits for carrying capacity calculations. More...

Public Member Functions inherited from TAnimal
unsigned	SupplyFarmOwnerRef ()

AnimalPosition	SupplyPosition ()

APoint	SupplyPoint ()

int	SupplyPolygonRef ()

int	Supply_m_Location_x ()

int	Supply_m_Location_y ()

virtual void	KillThis ()

virtual void	CopyMyself ()

void	SetX (int a_x)

void	SetY (int a_y)

	TAnimal (int x, int y, Landscape *L)

virtual void	EndStep (void)
	EndStep behaviour - must be implemented in descendent classes. More...

virtual void	ReinitialiseObject (int x, int y, Landscape *L)
	Used to re-use an object - must be implemented in descendent classes. More...

virtual int	WhatState ()

virtual void	Dying ()

void	CheckManagement (void)

void	CheckManagementXY (int x, int y)

virtual bool	OnFarmEvent (FarmToDo)

Public Member Functions inherited from TALMaSSObject
int	GetCurrentStateNo ()
	Returns the current state number. More...

void	SetCurrentStateNo (int a_num)
	Sets the current state number. More...

bool	GetStepDone ()
	Returns the step done indicator flag. More...

void	SetStepDone (bool a_bool)
	Sets the step done indicator flag. More...

virtual void	ReinitialiseObject ()
	Used to re-use an object - must be implemented in descendent classes. More...

	TALMaSSObject ()
	The constructor for TALMaSSObject. More...

virtual	~TALMaSSObject ()
	The destructor for TALMaSSObject. More...

void	OnArrayBoundsError ()
	Used for debugging only, tests basic object properties. More...

Public Attributes
int	m_breedingfemales
	The number of females that bred this year. More...

int	m_1yrOldFemales
	The number of 1 year old females. More...

int	m_littersthisyear
	The number of litters produced this year. More...

int	m_nonbreedingfemales
	The number of females that did not breed this year but are older than 1 year. More...

Static Public Attributes
static double	m_maxForageHeight = cfg_maxForageHeight.value()
	The maximum vegetation height assumed for forage potential. More...

static double	m_minForageDigestability = cfg_minForageDigestability.value()
	The minimum vegetation digestability allowed for foraging. More...

Protected Member Functions
void	st_WarrenBeing (void)
	The only warren behaviour - it just is. More...

void	InitEvaluation (void)
	Intiates the evaluation of the warren area. More...

int	GetForageArea (void)
	Returns the total area of permanent forage. More...

int	CalcForageArea (void)
	Returns the total area of forage. More...

int	CalcPermForageArea (void)
	Returns the total area of permanent forage. More...

int	GetTemporaryForageArea (void)
	Returns the total area of temporary forage. More...

int	GetCoverArea (void)
	Returns the total area of cover. More...

int	GetTempForageAreaVeg (void)
	Returns the total area of temporary forage based on veg height. More...

int	GetCoverAreaVeg (void)
	Returns the total area of cover based on veg height. More...

void	UpdateForageInformation (void)
	Updates the forage information depending upon the vegetation state. More...

void	UpdatePesticide (void)
	Updates the pesticide concentration in forage polygons. More...

void	CalcCarryingCapacityRatio1 ()
	calculates the ratio of rabbits to the carrying capacity More...

double	CalcCarryingCapacityRatio2 ()
	calculates the ratio of rabbits to the carrying capacity for the local area More...

Protected Member Functions inherited from TAnimal
void	CorrectWrapRound ()
	Corrects wrap around co-ordinate problems. More...

Protected Attributes
int	m_size
	Warren core size in m. More...

int	m_foragesize
	Warren forage size in m. More...

int	m_TL_x
	Stores original m_Location_x. More...

int	m_TL_y
	Stores original m_Location_y. More...

int	m_maintenence
	Warren maintenence score - if not max then houseing capacity is reduced. More...

int	m_CarryingCapacity
	Records the max number of rabbit pairs possible here. More...

double	m_CarryingCapacityR
	Records the max number of rabbits possible here. More...

double	m_CarryingCapacityR2
	Records the max number of rabbits possible here divided by 2. More...

double	m_BigFemaleRabbitsR
	Records the number of big female rabbits divided by m_CarryingCapacityR2. More...

double	m_CarryingCapacityRatio
	Records the ratio between carrying capacity and no rabbits in warren. More...

int	m_NoBurrows
	Records the maintenence restricted current carrying capacity (burrow number) More...

int	m_NoOccupiedBurrows
	Records the burrows that are occupied. More...

int	m_BurrowsUnderConstruction
	Records the burrows that are being dug. More...

int	m_soiltype
	Variable holding the soil type, 1 = heavy, 0 = sandy, 3 = unsuitable (never used in warrens) More...

int	m_rabbitdiggingtime
	The time taken for burrow construction. More...

int	m_permforagearea
	Variable holding the total permanent forage area. More...

int	m_foragearea
	Variable holding the total potential forage area. More...

double	m_availableforage
	Records the amount of forage currently available in the warren area as a proportion of what is the potential relative to rabbit numbers possible. More...

double	m_foragearearatio
	Records the amount of forage currently available in the warren area as a proportion of total forage area. More...

double	m_inv_availableforage
	The inverse of m_availableforage, prevents multiple re-calculation. More...

double	m_litterreabosorptionchance
	Chance of litter reaborption based on the m_availableforage. More...

double	m_forageP
	Records the amount of pesticde as a mean concentration per unit area forage. More...

double	m_diseaseconstant
	a measure of disease mortality likelihood More...

double	m_mortalitymultiplierA
	a measure of mortality likelihood - adults More...

double	m_mortalitymultiplierJ
	a measure of mortality likelihood - juveniles More...

int	m_ThisYearsProduction [rob_foobar]
	Storage for rabbit production data. More...

TTypeOfRabbitState	m_CurrentRState
	Variable to record current behavioural state. More...

vector< RabbitWarrenLEInfo >	m_LEList
	List of polygons and the area which is part of the warren. More...

vector< LocalWarrenNewtorkEntry >	m_LocalWarrenNetwork
	List of local warrens and their accessibility from this warren. More...

vector< Rabbit_Base * >	m_InhabitantsList
	List of rabbits that live here - for easy communication purposes. More...

Rabbit_Population_Manager *	m_OurPopulationManager
	This is a time saving pointer to the correct population manager object. More...

int	m_runningavFemales
	Keeps track of the number of breeding females. More...

int	m_runningavCount
	Keeps track of the number of breeding days. More...

Protected Attributes inherited from TAnimal
int	m_Location_x

int	m_Location_y

Landscape *	m_OurLandscape

Protected Attributes inherited from TALMaSSObject
int	m_CurrentStateNo
	The basic state number for all objects - '-1' indicates death. More...

bool	m_StepDone
	Indicates whether the iterative step code is done for this timestep. More...

Detailed Description

A class to describe the rabbits warren system.

Definition at line 518 of file Rabbit.h.

Constructor & Destructor Documentation

Rabbit_Warren::Rabbit_Warren	(	int	p_x,
		int	p_y,
		Landscape *	p_L,
		Rabbit_Population_Manager *	p_NPM,
		int	a_size,
		int	a_soil
	)

Rabbit warren constructor.

To get the warrens to display properly the centre location is needed. Unfortunately to work with display this needs to be m_Location_x & m_Location_y so we need to store TL_x & TL_y too

Must do an evaluation of the warren area and populate our list of polygons and areas. This is done by InitEvaluation

Definition at line 1449 of file Rabbit.cpp.

References cfg_rabbitdiggingtime, InitEvaluation(), m_BigFemaleRabbitsR, m_BurrowsUnderConstruction, m_CarryingCapacity, m_CarryingCapacityRatio, m_CurrentRState, m_diseaseconstant, m_foragesize, m_InhabitantsList, TAnimal::m_Location_x, TAnimal::m_Location_y, m_maintenence, m_NoOccupiedBurrows, m_OurPopulationManager, m_rabbitdiggingtime, m_runningavCount, m_runningavFemales, m_size, m_soiltype, m_TL_x, m_TL_y, ResetAllRabbitProductionRecord(), toRabbits_InitialState, and CfgInt::value().

                                                                                                                       : TAnimal(p_x,p_y,p_L)
 {
     m_CurrentRState = toRabbits_InitialState;
     m_OurPopulationManager = p_NPM;
     m_size = a_size;
     m_maintenence = 0;
     m_NoOccupiedBurrows = 0;
     m_BurrowsUnderConstruction = 0;
     m_CarryingCapacity = 0;
     m_CarryingCapacityRatio = -1; // No effect for the first period until it is properly calculated
     m_InhabitantsList.resize(0);
     m_soiltype = a_soil;
     m_rabbitdiggingtime = cfg_rabbitdiggingtime.value() * (2 - m_soiltype);
     m_diseaseconstant = 0.0;
     ResetAllRabbitProductionRecord();
     m_BigFemaleRabbitsR = 0.0;
     m_runningavCount=0;
     m_runningavFemales = 0; 
     m_Location_x = m_Location_x + (m_size / 2);
     m_Location_y = m_Location_y + (m_size / 2);
     // Now get the forage size.
     m_foragesize = m_size * 2;
     m_TL_x = m_Location_x - (m_foragesize / 2);
     if (m_TL_x < 0) m_TL_x = 0;
     m_TL_y = m_Location_x - (m_foragesize / 2);
     if (m_TL_y < 0) m_TL_y = 0;
     InitEvaluation();
 }

Rabbit_Warren::~Rabbit_Warren ( void )

virtual

Rabbit warren destructor.

Definition at line 1485 of file Rabbit.cpp.

 {
     ;
 }

Member Function Documentation

void Rabbit_Warren::AddNetworkConnection ( LocalWarrenNewtorkEntry a_LWNE )

inline

Adds a warren to the local network list.

Definition at line 590 of file Rabbit.h.

590 { m_LocalWarrenNetwork.push_back( a_LWNE ); }

Rabbit_Warren::m_LocalWarrenNetwork

vector< LocalWarrenNewtorkEntry > m_LocalWarrenNetwork

List of local warrens and their accessibility from this warren.

Definition: Rabbit.h:750

virtual void Rabbit_Warren::BeginStep ( void )

inlinevirtual

Warren begin step code.

Reimplemented from TAnimal.

Definition at line 560 of file Rabbit.h.

                              {
         CalcCarryingCapacityRatio1();
     }

void Rabbit_Warren::CalcCarryingCapacityRatio1 ( )

protected

calculates the ratio of rabbits to the carrying capacity

Definition at line 1682 of file Rabbit.cpp.

References GetAllBigFemaleRabbits(), m_BigFemaleRabbitsR, and m_CarryingCapacityR2.

                                                {
     m_BigFemaleRabbitsR = GetAllBigFemaleRabbits() / (m_CarryingCapacityR2); // m_CarryingCapacityR is (m_CarryingCapacity * cfg_rabbitdendepscaler.value())/2
 }

double Rabbit_Warren::CalcCarryingCapacityRatio2 ( )

protected

calculates the ratio of rabbits to the carrying capacity for the local area

Here the issue can be that the local warren is too small a unit to use for carrying capacity calculations for the POM tests on Bayreuth Therefore we have two options:

1 use the local rabbits for real landscapes
2 a combined area calculation (which takes more time) for enclosure tests

To speed this on each warren creates its own daily stats which can be combined here.

Definition at line 1686 of file Rabbit.cpp.

References m_BigFemaleRabbitsR, and m_LocalWarrenNetwork.

Referenced by UpdateForageInformation().

                                                  {
 #ifdef __EnclosureTest
     double CCRatio = m_BigFemaleRabbitsR;
     int nsz = (int)m_LocalWarrenNetwork.size();
     for (int i = 0; i < nsz; i++) {
         CCRatio += m_LocalWarrenNetwork[i].m_aWarren->GetCCRabbitsR();
     }
     CCRatio /= (nsz + 1);
     return CCRatio;
 #endif
     return m_BigFemaleRabbitsR; // Is the number of big female rabbits / ((m_CarryingCapacity * cfg_rabbitdendepscaler.value())/2)
 }

void Rabbit_Warren::CalcDisease ( void )

Calculate the current disease mortality constant.

To simulate disease we need a globally variying probability with local variations depending upon density This is done by evaluating two levels - the first is the total population density. This is given by the the total number of rabbits divided by the total number of warrens.
The local density is the number of rabbits related to the carrying capacity.
This method is only called at a time period specified as an input variable, so disease will not instantly equilibrate.
The big disease chance is based on global density: prob_density = (totalrabbits / no warren) x (totalrabbits / no warren) * cfg_globaldisease_probability.value(); This is then modified by local density: m_diseaseconstant = prob_density * GetCarryingCapacityRatio

Definition at line 1577 of file Rabbit.cpp.

References cfg_globaldisease_probability, GetCarryingCapacityRatio(), Population_Manager::GetLiveArraySize(), m_diseaseconstant, m_OurPopulationManager, rob_Warren, Rabbit_Population_Manager::SupplyAllBigRabbits(), and CfgFloat::value().

 {
     // Get the numbers we need
     unsigned totalrabbits = m_OurPopulationManager->SupplyAllBigRabbits();
     unsigned warrens = m_OurPopulationManager->GetLiveArraySize(rob_Warren);
     // Some of this should be done by the population managerfor efficiency but it is here to keep it together.
     //The big chance based on global density
     double prob_density = (totalrabbits / (double)warrens) * (totalrabbits / (double)warrens) * cfg_globaldisease_probability.value();
     // Now the local stuff
     m_diseaseconstant = prob_density * GetCarryingCapacityRatio();  
 }

int Rabbit_Warren::CalcForageArea ( void )

protected

Returns the total area of forage.

This returns the forge area calcuated by element type.

Definition at line 1724 of file Rabbit.cpp.

References m_LEList.

Referenced by InitEvaluation(), and UpdateForageInformation().

 {
     int area = 0;
     for (vector<RabbitWarrenLEInfo>::size_type k = 0; k<m_LEList.size(); k++)
     {
         area += m_LEList[k].m_foragearea;
     }
     return area;
 }

int Rabbit_Warren::CalcPermForageArea ( void )

protected

Returns the total area of permanent forage.

This returns the forge area calcuated by element type.

Definition at line 1738 of file Rabbit.cpp.

References m_LEList, and torh_Forage.

Referenced by InitEvaluation().

 {
     int area = 0;
     for (vector<RabbitWarrenLEInfo>::size_type k = 0; k<m_LEList.size(); k++)
     {
         if (m_LEList[k].m_torh == torh_Forage) area += m_LEList[k].m_area;
     }
     return area;
 }

void Rabbit_Warren::ChooseNewDominant ( void )

Finds a subdominantfemale and promotes them to dominant.

Loops through the list to find suitable females who could be dominant. If no fully grown females then the largest one is taken.

Definition at line 1946 of file Rabbit.cpp.

References Rabbit_Adult::GetSocialStatus(), Rabbit_Base::GetweightAge(), m_InhabitantsList, rabbit_socialstatus_dominant, rabbit_socialstatus_subdominant, rob_Female, and Rabbit_Adult::SetSocialStatus().

Referenced by Rabbit_Female::st_Dying(), and UpdateDominance().

                                             {
     Rabbit_Female* rfemale = NULL;
     Rabbit_Female* rfemaleBig = NULL;
     int bigWeight = 0;
     int sz = (int)m_InhabitantsList.size();
     for (int i = 0; i < sz; i++) {
         if (m_InhabitantsList[ i ]->GetRabbitType() == rob_Female) {
             rfemale = dynamic_cast<Rabbit_Female*>(m_InhabitantsList[ i ]);
             if (rfemale->GetSocialStatus() == rabbit_socialstatus_subdominant) {
                 if (rfemale->GetweightAge() >= 300) { // 300 represents max growth
                     rfemale->SetSocialStatus( rabbit_socialstatus_dominant );
                     return;
                 }
                 else if (rfemale->GetweightAge() > bigWeight) {
                     bigWeight = rfemale->GetweightAge();
                     rfemaleBig = rfemale;
                 }
             }
         }
     }
     if (rfemaleBig!=NULL) rfemaleBig->SetSocialStatus( rabbit_socialstatus_dominant );
 }

bool Rabbit_Warren::DEBUG_InternalTest ( )

Definition at line 2292 of file Rabbit.cpp.

References TALMaSSObject::GetCurrentStateNo(), m_InhabitantsList, m_NoBurrows, m_NoOccupiedBurrows, TAnimal::m_OurLandscape, rob_Female, rob_Male, and Landscape::Warn().

Referenced by IsFreeBurrow(), JoinNMate(), JoinNOccupy(), Mate(), Rabbit_Adult::OnMateFinishedDigging(), and st_WarrenBeing().

 {
     int Mburrs = 0;
     int Mmates = 0;
     int MBM = 0;
     int Fburrs = 0;
     int Fmates = 0;
     int FBM = 0;
     int siz = (int) m_InhabitantsList.size();
     int Mdigs = 0;
     int Fdigs = 0;
     for (int i = 0; i<siz; i++)
     {
         if (m_InhabitantsList[i]->GetCurrentStateNo() != -1)
         {
             if (m_InhabitantsList[i]->GetRabbitType() == rob_Male)
             {
                 if (m_InhabitantsList[i]->GetHasBurrow()) Mburrs++; // No males with burrow
                 if (m_InhabitantsList[i]->GetDigging()>-1) Mdigs++;  // No males digging
                 if (dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate() != NULL) Mmates++; // No males with mates
                 if ((dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate() != NULL) && (m_InhabitantsList[i]->GetHasBurrow())) MBM++; // No males with mates and burrows
             }
             if (m_InhabitantsList[i]->GetRabbitType() == rob_Female)
             {
                 if (m_InhabitantsList[i]->GetHasBurrow()) Fburrs++;
                 if (m_InhabitantsList[i]->GetDigging() > -1) Fdigs++;
                 if (dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate() != NULL) Fmates++;
                 if ((dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate() != NULL) && (m_InhabitantsList[i]->GetHasBurrow())) FBM++;
             }
         }
     }
     int alonemales = Mburrs-MBM;
     int alonefemales = Fburrs-FBM;
     if (MBM != FBM) 
     {
         m_OurLandscape->Warn("IsFreeBurrow","Inconsistent mates and burrows MBM != FBM.");
         exit(1);
     }
     if (MBM + alonemales + alonefemales > m_NoBurrows) 
     {
         m_OurLandscape->Warn("IsFreeBurrow","Too many burrows occupied.");
         exit(1);
     }
     if (MBM + alonemales + alonefemales != this->m_NoOccupiedBurrows) 
     {
         m_OurLandscape->Warn("IsFreeBurrow","Too many burrows occupied.");
         exit(1);
     }
     return true;
 }

bool Rabbit_Warren::DEBUG_InternalTest2 ( )

Definition at line 2344 of file Rabbit.cpp.

References m_InhabitantsList, m_NoBurrows, TAnimal::m_OurLandscape, rob_Female, rob_Male, and Landscape::Warn().

Referenced by IsFreeBurrow(), and JoinNOccupy().

 {
     int Mburrs = 0;
     int Mmates = 0;
     int MBM = 0;
     int Fburrs = 0;
     int Fmates = 0;
     int FBM = 0;
     int siz = (int) m_InhabitantsList.size();
     for (int i=0; i<siz; i++)
     {
         if ( m_InhabitantsList[i]->GetRabbitType() == rob_Male)
         {
             if ( m_InhabitantsList[i]->GetHasBurrow()) Mburrs++;
             if ( dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate()!= NULL) Mmates++;
             if (( dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate()!= NULL) && (m_InhabitantsList[i]->GetHasBurrow())) MBM++;
         }
         if ( m_InhabitantsList[i]->GetRabbitType() == rob_Female)
         {
             if ( m_InhabitantsList[i]->GetHasBurrow()) Fburrs++;
             if ( dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate()!= NULL) Fmates++;
             if (( dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i])->GetMate()!= NULL) && (m_InhabitantsList[i]->GetHasBurrow())) FBM++;
         }
     }
     int alonemales = Mburrs-MBM;
     int alonefemales = Fburrs-FBM;
     if (MBM + alonemales + alonefemales >= m_NoBurrows) 
     {
         m_OurLandscape->Warn("IsFreeBurrow","Too many burrows occupied.");
         exit(1);
     }
     return true;
 }

double Rabbit_Warren::Disease ( )

inline

Supply the current disease mortality constant.

Definition at line 638 of file Rabbit.h.

638 { return m_diseaseconstant; }

Rabbit_Warren::m_diseaseconstant

double m_diseaseconstant

a measure of disease mortality likelihood

Definition: Rabbit.h:738

int Rabbit_Warren::Get_TL_x ( )

inline

Get m_TL_x.

Definition at line 564 of file Rabbit.h.

564 { return m_TL_x; }

Rabbit_Warren::m_TL_x

int m_TL_x

Stores original m_Location_x.

Definition: Rabbit.h:698

int Rabbit_Warren::Get_TL_y ( )

inline

Get m_TL_x.

Definition at line 566 of file Rabbit.h.

566 { return m_TL_y; }

Rabbit_Warren::m_TL_y

int m_TL_y

Stores original m_Location_y.

Definition: Rabbit.h:700

int Rabbit_Warren::GetActiveBurrows ( )

inline

Gets the number of occupied burrows.

Definition at line 570 of file Rabbit.h.

570 { return m_NoOccupiedBurrows; }

Rabbit_Warren::m_NoOccupiedBurrows

int m_NoOccupiedBurrows

Records the burrows that are occupied.

Definition: Rabbit.h:716

int Rabbit_Warren::GetAllBigFemaleRabbits ( void )

Supplies the number of big rabbits currently in the warren.

Definition at line 2280 of file Rabbit.cpp.

References m_InhabitantsList, and rob_Female.

Referenced by CalcCarryingCapacityRatio1().

                                                 {
     int biggies = 0;
     int sz = (int)m_InhabitantsList.size();
     for (int i = 0; i < sz; i++) {
         if (m_InhabitantsList[ i ]->GetRabbitType() == rob_Female) {
             if (m_InhabitantsList[ i ]->GetAge()>300) biggies++;
         }
     }
     return biggies;
 }

int Rabbit_Warren::GetAllBreedingFemaleRabbits ( void )

Supplies the number of breeding rabbits currently in the warren.

Definition at line 2268 of file Rabbit.cpp.

References m_InhabitantsList, rabbit_socialstatus_subordinate, and rob_Female.

Referenced by st_WarrenBeing().

                                                      {
     int breeders = 0;
     int sz = (int)m_InhabitantsList.size();
     for (int i = 0; i < sz; i++) {
         if (m_InhabitantsList[ i ]->GetRabbitType() == rob_Female) {
             if (dynamic_cast<Rabbit_Female*>(m_InhabitantsList[ i ])->GetSocialStatus()>rabbit_socialstatus_subordinate) breeders++;
         }
     }
     return breeders;
 }

double Rabbit_Warren::GetAvailableForage ( void )

inline

Returns the available forage realtive to rabbit numbers.

Definition at line 642 of file Rabbit.h.

Referenced by Rabbit_Female::st_EvaluateTerritory().

                                       {
         return m_availableforage;
     }

int Rabbit_Warren::GetCarryingCapacity ( )

inline

Returns the carrying capacity in burrows.

Definition at line 578 of file Rabbit.h.

Referenced by Rabbit_Population_Manager::CreateObjects(), and Rabbit_Male::st_EvaluateTerritory().

578 { return m_CarryingCapacity; }

Rabbit_Warren::m_CarryingCapacity

int m_CarryingCapacity

Records the max number of rabbit pairs possible here.

Definition: Rabbit.h:704

bool Rabbit_Warren::GetCarryingCapacityFilled ( )

inline

Checks whether all possible burrows are filled with rabbits.

Definition at line 574 of file Rabbit.h.

574 { return (m_CarryingCapacity >= m_NoOccupiedBurrows); }

Rabbit_Warren::m_NoOccupiedBurrows

int m_NoOccupiedBurrows

Records the burrows that are occupied.

Definition: Rabbit.h:716

Rabbit_Warren::m_CarryingCapacity

int m_CarryingCapacity

Records the max number of rabbit pairs possible here.

Definition: Rabbit.h:704

double Rabbit_Warren::GetCarryingCapacityRatio ( )

inline

Checks whether all possible burrows are filled with rabbits. This is updated daily by Rabbit_Warren::UpdateForageInformation.

Definition at line 576 of file Rabbit.h.

Referenced by CalcDisease().

576 { return m_CarryingCapacityRatio; }

Rabbit_Warren::m_CarryingCapacityRatio

double m_CarryingCapacityRatio

Records the ratio between carrying capacity and no rabbits in warren.

Definition: Rabbit.h:712

double Rabbit_Warren::GetCCRabbitsR ( )

inline

Records the number of big female rabbits for carrying capacity calculations.

Definition at line 688 of file Rabbit.h.

                            {
         return m_BigFemaleRabbitsR;
     }

int Rabbit_Warren::GetCoverArea ( void )

protected

Returns the total area of cover.

This returns the cover area calcuated by element type. This is probably mis-leading and the GetCoverAreaVeg() is better representative of the cover leves including high vegetation levels.

Definition at line 1766 of file Rabbit.cpp.

References m_LEList, and torh_Cover.

 {
     int area = 0;
     for (vector<RabbitWarrenLEInfo>::size_type k=0; k<m_LEList.size(); k++)
     {
         if (m_LEList[k].m_torh == torh_Cover) area += m_LEList[k].m_area;
     }
     return area;
 }

int Rabbit_Warren::GetCoverAreaVeg ( void )

protected

Returns the total area of cover based on veg height.

This returns the cover area calcuated by element type and vegeation height.

Definition at line 1800 of file Rabbit.cpp.

References m_LEList, m_maxForageHeight, and torh_Other.

                                    {
     int area = 0;
     for (vector<RabbitWarrenLEInfo>::size_type k = 0; k<m_LEList.size(); k++) {
         if (m_LEList[ k ].m_ele->GetVegHeight() >= m_maxForageHeight) {
             if (m_LEList[ k ].m_torh != torh_Other) area += m_LEList[ k ].m_area;
         }
     }
     return area;
 }

double Rabbit_Warren::GetDailyMortalityChanceA ( )

inline

Returns the adult daily mortality multiplier.

Definition at line 680 of file Rabbit.h.

Referenced by Rabbit_Adult::EndStep().

                                       {
         return m_mortalitymultiplierA;
     }

double Rabbit_Warren::GetDailyMortalityChanceJ ( )

inline

Returns the juvenile daily mortality multiplier.

Definition at line 684 of file Rabbit.h.

Referenced by Rabbit_Juvenile::EndStep().

                                       {
         return m_mortalitymultiplierJ;
     }

double Rabbit_Warren::GetDiseaseConstant ( void )

inline

Returns the warrens current disease constant.

Definition at line 580 of file Rabbit.h.

580 { return m_diseaseconstant; }

Rabbit_Warren::m_diseaseconstant

double m_diseaseconstant

a measure of disease mortality likelihood

Definition: Rabbit.h:738

int Rabbit_Warren::GetForageArea ( void )

inlineprotected

Returns the total area of permanent forage.

Definition at line 766 of file Rabbit.h.

766 { return m_permforagearea; }

Rabbit_Warren::m_permforagearea

int m_permforagearea

Variable holding the total permanent forage area.

Definition: Rabbit.h:724

double Rabbit_Warren::GetForagePesticide ( void )

inline

Gets the current mean pesticide concentration per unit forage.

Definition at line 628 of file Rabbit.h.

Referenced by Rabbit_Juvenile::st_Forage(), Rabbit_Male::st_Forage(), and Rabbit_Female::st_Forage().

                                       {
         return m_forageP;
     }

double Rabbit_Warren::GetInvAvailableForage ( void )

inline

Returns the inverse of available forage realtive to rabbit numbers.

Definition at line 646 of file Rabbit.h.

                                          {
         return m_inv_availableforage;
     }

double Rabbit_Warren::GetLitterReabsortionConst ( void )

inline

Returns litter reabsorption chance.

Definition at line 650 of file Rabbit.h.

Referenced by Rabbit_Female::st_GiveBirth().

                                              {
         return m_litterreabosorptionchance;
     }

int Rabbit_Warren::GetLittersThisYear ( )

inline

Returns the number litters produced in the last 12 months.

Definition at line 670 of file Rabbit.h.

Referenced by UpdateThisYearsBreeders().

                             {
         return m_littersthisyear;
     }

Rabbit_Warren * Rabbit_Warren::GetNetworkWarren ( void )

Chooses a warren to evaluate based on distance.

This method chooses a warren from the network with a probability of choice based on the distance from home. However, we need to start at a random point in the list and cycle because otherwise we run the risk of only the first few warrens ever being tested.

Definition at line 1907 of file Rabbit.cpp.

References g_rand_uni, and m_LocalWarrenNetwork.

Referenced by Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
     // Pick a warren
     int nsz = (int) m_LocalWarrenNetwork.size();
     int loopstart = (int) floor(nsz * g_rand_uni());
     for (int i=0; i< nsz; i++ )
     {
         double chance = g_rand_uni();
         int index = (i + loopstart);
         if (index >= nsz) index-=nsz;
         if (chance>m_LocalWarrenNetwork[i].m_visitprob)
         {
             return m_LocalWarrenNetwork[i].m_aWarren;
         }
     }
     return NULL;
 }

APoint Rabbit_Warren::GetPointTL ( )

inline

Get the TL coords as a point.

Definition at line 568 of file Rabbit.h.

568 { APoint TL; TL.m_x=m_TL_x; TL.m_y=m_TL_y; return TL; }

Rabbit_Warren::m_TL_y

int m_TL_y

Stores original m_Location_y.

Definition: Rabbit.h:700

Rabbit_Warren::m_TL_x

int m_TL_x

Stores original m_Location_x.

Definition: Rabbit.h:698

int Rabbit_Warren::GetPopulationSize ( )

inline

Gets the total warren population of rabbits.

Definition at line 572 of file Rabbit.h.

Referenced by Rabbit_Male::st_EvaluateTerritory().

572 { return (int)m_InhabitantsList.size(); }

Rabbit_Warren::m_InhabitantsList

vector< Rabbit_Base * > m_InhabitantsList

List of rabbits that live here - for easy communication purposes.

Definition: Rabbit.h:752

int Rabbit_Warren::GetRabbitProductionRecord ( RabbitObjectTypes YoungType )

inline

Get data about production of rabbits throughout year.

Definition at line 584 of file Rabbit.h.

584 { return m_ThisYearsProduction[YoungType]; }

Rabbit_Warren::m_ThisYearsProduction

int m_ThisYearsProduction[rob_foobar]

Storage for rabbit production data.

Definition: Rabbit.h:744

int Rabbit_Warren::GetSoilType ( void )

inline

Gets the warren soil type.

Definition at line 632 of file Rabbit.h.

632 { return m_soiltype; }

Rabbit_Warren::m_soiltype

int m_soiltype

Variable holding the soil type, 1 = heavy, 0 = sandy, 3 = unsuitable (never used in warrens) ...

Definition: Rabbit.h:720

int Rabbit_Warren::GetTempForageAreaVeg ( void )

protected

Returns the total area of temporary forage based on veg height.

This returns the temporary forge area calcuated by element type and vegetation height.

Definition at line 1780 of file Rabbit.cpp.

References m_LEList, m_maxForageHeight, and torh_TemporaryForage.

 {
     int area = 0;
     for (vector<RabbitWarrenLEInfo>::size_type k=0; k<m_LEList.size(); k++)
     {
         if (m_LEList[k].m_torh == torh_TemporaryForage) 
         {
             if (m_LEList[k].m_ele->GetVegHeight() < m_maxForageHeight )
             {
                 area += m_LEList[k].m_area;
             }
         }
     }
     return area;
 }

int Rabbit_Warren::GetTemporaryForageArea ( void )

protected

Returns the total area of temporary forage.

This returns the forge area calcuated by element type. This is probably mis-leading and the GetTemporaryForageAreaVeg() is better representative of the forage levels.

Definition at line 1752 of file Rabbit.cpp.

References m_LEList, and torh_TemporaryForage.

 {
     int area = 0;
     for (vector<RabbitWarrenLEInfo>::size_type k=0; k<m_LEList.size(); k++)
     {
         if (m_LEList[k].m_torh == torh_TemporaryForage) area += m_LEList[k].m_area;
     }
     return area;
 }

int Rabbit_Warren::GetThisYears1yrOldFemales ( )

inline

Returns the number of 1yr old females.

Definition at line 666 of file Rabbit.h.

                                     {
         return m_1yrOldFemales;
     }

int Rabbit_Warren::GetThisYearsBreeders ( )

inline

Returns the number of females breeding this year.

Definition at line 654 of file Rabbit.h.

                                {
         return m_breedingfemales;
     }

double Rabbit_Warren::GetThisYearsBreedersAv ( )

inline

Returns the number of females breeding this year.

Definition at line 658 of file Rabbit.h.

                                     {
         double av = 0;
         if (m_runningavCount>0) av = m_runningavFemales / static_cast<double>(m_runningavCount);
         m_runningavFemales = 0;
         m_runningavCount = 0;
         return av;
     }

int Rabbit_Warren::GetThisYearsNonBreeders ( )

inline

Returns the number of females not breeding this year but older than 1 year.

Definition at line 674 of file Rabbit.h.

                                   {
         return m_nonbreedingfemales;
     }

void Rabbit_Warren::InitEvaluation ( void )

protected

Intiates the evaluation of the warren area.

This method is called when the warren in initially formed and is repsponsible for making the calcuations of forage and cover areas and then calculating the carrying capacity of the warren if fully occupied.

First fix any wrap-around problems.

Next loop through the area and find all the polygons and areas.

This is done by getting the polygon references and checking if we had this one already. If not save it with an area of 1 otherwise increment the correct record by 1.

Once all polygons are identified and counted then they are classified.

Next the carrying capacity is calculated. This is based on forage area possible and is the number of pairs possible.

We assume that the carrying capacity of sandy soil warrens is halved, unless there is only room for one burrow anyway.

Definition at line 1491 of file Rabbit.cpp.

References CalcForageArea(), CalcPermForageArea(), cfg_rabbitdendepscaler, cfg_rabbitmaxwarrensize, cfg_rabbitminwarrensize, Rabbit_Population_Manager::ClassifyHabitat(), RabbitWarrenLEInfo::m_area, m_CarryingCapacity, m_CarryingCapacityR, m_CarryingCapacityR2, RabbitWarrenLEInfo::m_ele, RabbitWarrenLEInfo::m_forage, RabbitWarrenLEInfo::m_foragearea, m_foragearea, m_foragesize, m_LEList, m_NoBurrows, TAnimal::m_OurLandscape, m_OurPopulationManager, m_permforagearea, RabbitWarrenLEInfo::m_pesticide_conc, RabbitWarrenLEInfo::m_ref, m_size, m_soiltype, m_TL_x, m_TL_y, Landscape::SupplyLEPointer(), Landscape::SupplyPolyRef(), Landscape::SupplySimAreaHeight(), Landscape::SupplySimAreaWidth(), torh_Forage, torh_TemporaryForage, and CfgFloat::value().

Referenced by Rabbit_Warren().

 {
     if (m_TL_x + m_foragesize > m_OurLandscape->SupplySimAreaWidth()) m_foragesize = (m_OurLandscape->SupplySimAreaWidth())-m_TL_x;
     if (m_TL_y + m_foragesize > m_OurLandscape->SupplySimAreaHeight()) m_foragesize = (m_OurLandscape->SupplySimAreaHeight())-m_TL_y;
     for (int i=m_TL_x; i<m_TL_x + m_foragesize; i++)
     {
         for (int j=m_TL_y; j<m_TL_y + m_foragesize; j++)
         {
             int PRef = m_OurLandscape->SupplyPolyRef(i,j);
             bool found=false;
             for (vector<RabbitWarrenLEInfo>::size_type k=0; k<m_LEList.size(); k++)
             {
                 if (m_LEList[k].m_ref == PRef)
                 {
                   m_LEList[k].m_area++;
                   found = true;
                   break;
                 }
             }
             if (!found)
             {
                 RabbitWarrenLEInfo a_ele;
                 a_ele.m_ref = PRef;
                 a_ele.m_area = 1;
                 a_ele.m_ele = m_OurLandscape->SupplyLEPointer(m_OurLandscape->SupplyPolyRef(i,j));
                 a_ele.m_pesticide_conc = 0;
                 a_ele.m_forage = 0;
                 a_ele.m_foragearea = 0;
                 // don't have this one
                 m_LEList.push_back(a_ele);
             }
         }
     }
     for (vector<RabbitWarrenLEInfo>::size_type k=0; k<m_LEList.size(); k++)
     {
         TTypesOfLandscapeElement tole = m_LEList[k].m_ele->GetElementType();
         m_LEList[k].m_torh = m_OurPopulationManager->ClassifyHabitat(tole);
         // Do a little bit of forage managing here
         if (m_LEList[k].m_torh == torh_Forage) m_LEList[k].m_foragearea = m_LEList[k].m_area;
         else if (m_LEList[k].m_torh == torh_TemporaryForage)
         {
             // We assume only 50 m strip of fields is usable
             int fr = 50 * m_size;
             if (m_LEList[k].m_area < fr) fr = m_LEList[k].m_area;
             m_LEList[k].m_foragearea = fr;
         }
         else m_LEList[k].m_foragearea = 0;
     }
     m_permforagearea = CalcPermForageArea();
     m_foragearea = CalcForageArea();
     double minpct = 1.0 / 16.0; // Divide by 16 because the minimum is based on 1/16th of the area used for forage
     double pct = m_foragearea/ (double) (m_foragesize * m_foragesize);
     if (pct<minpct)
     {
         // We have a problem, no rabbits can be here
         m_CarryingCapacity = 0;
         return;
     }
     if (pct > 0.9) pct = 0.9;
     // 1 is the lowest density until soil type is taken into account
     // We use the diff between min and actual pct cover, and then add pro-rata the extra proportion of 12 pairs
     // NB minpct must never be >= 0.9
     m_CarryingCapacity = static_cast<int>(cfg_rabbitminwarrensize.value() + (int)((pct - minpct) / (0.9 - minpct) * cfg_rabbitmaxwarrensize.value())); // e.g. 3 + (0.1 / 0.8 *9) = 3+1.5 for minpct 0.2, pct 0.3
     if (m_soiltype == 0) m_CarryingCapacity /= 2; 
     m_NoBurrows = 0;
     m_CarryingCapacityR = m_CarryingCapacity * cfg_rabbitdendepscaler.value();
     m_CarryingCapacityR2 = m_CarryingCapacityR / 2.0; // Done here once to prevent it being recalculated possibly a lot of times later.
 
 }

int Rabbit_Warren::IsFreeBurrow ( void )

Is there a vacent burrow?

Here we need to determine if there are free burrows, but also what to do about an unoccupied location. If the warren is unoccupied then we need to arrange for the rabbit to slowly make burrow.

Returns: 0 if all burrows are occupied; 1 if there is a free burrow; 2 if the warren is unoccupied and needs a burrow dug or if there is room to make a new burrow

Definition at line 2029 of file Rabbit.cpp.

References DEBUG_InternalTest(), DEBUG_InternalTest2(), m_BurrowsUnderConstruction, m_CarryingCapacity, m_NoBurrows, and m_NoOccupiedBurrows.

Referenced by Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
 
     if (m_NoBurrows > (m_NoOccupiedBurrows + m_BurrowsUnderConstruction))
     {
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest2();
 #endif
             return 1; // There is a free burrow
     }
     if ((m_NoBurrows + m_BurrowsUnderConstruction < m_CarryingCapacity)) return 2;
     return 0;
 }

bool Rabbit_Warren::IsFreeFemale ( void )

Returns true if there is a female with a burrow and no mate.

Returns: false if none, true if unmated female found Checks the list of residents for a female with a burrow and no mate.

Definition at line 1973 of file Rabbit.cpp.

References m_InhabitantsList, and rob_Female.

Referenced by Rabbit_Male::st_EvaluateTerritory().

                                        {
     int sz = (int)m_InhabitantsList.size();
     for (int i = 0; i<sz; i++) {
         if (m_InhabitantsList[ i ]->GetRabbitType() == rob_Female) {
             if (m_InhabitantsList[ i ]->GetMate() == NULL) {
                 if ((m_InhabitantsList[ i ]->GetHasBurrow()) || (m_InhabitantsList[ i ]->GetDigging() > -1)) return true;
             }
         }
     }
     return false;
 }

bool Rabbit_Warren::IsFreeMale ( void )

Returns true if there is a male with a burrow and no mate.

Returns: false if none, true if unmated male found Checks the list of residents for a male with a burrow and no mate.

Definition at line 2008 of file Rabbit.cpp.

References m_InhabitantsList, and rob_Male.

Referenced by Rabbit_Female::st_EvaluateTerritory(), and Rabbit_Female::st_UpdateBreedingStatus().

 {
     int sz = (int) m_InhabitantsList.size();
     for (int i=0; i<sz; i++)
     {
         if  ( m_InhabitantsList[i]->GetRabbitType() == rob_Male )
         {
             if ( m_InhabitantsList[i]->GetMate()==NULL )
             {
                 if ( (m_InhabitantsList[i]->GetHasBurrow() ) || ( m_InhabitantsList[i]->GetDigging() > -1) ) return true;
             }
         }
     }
     return false;
 }

bool Rabbit_Warren::IsMember ( Rabbit_Base * a_rabbit )

Returns true if this rabbit belongs to the warren.

Returns: false if none, true if unmated male found Checks the list of residents for a male with a burrow and no mate.

Definition at line 1990 of file Rabbit.cpp.

References m_InhabitantsList.

Referenced by Rabbit_Female::Rabbit_Female(), and Rabbit_Female::st_EvaluateTerritory().

 {
     int sz = (int) m_InhabitantsList.size();
     for (int i=0; i<sz; i++)
     {
         if (m_InhabitantsList[i] == a_rabbit ) 
         {
             return true;
         }
     }
     return false;
 }

void Rabbit_Warren::Join ( Rabbit_Base * a_rabbit )

Adds this rabbit to the warren list.

Join a warren.

Definition at line 2055 of file Rabbit.cpp.

References m_InhabitantsList, and Rabbit_Base::SetWarren().

Referenced by JoinNMate(), JoinNOccupy(), OccupyWarren(), Rabbit_Base::Rabbit_Base(), Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
     m_InhabitantsList.push_back(a_rabbit);
     a_rabbit->SetWarren(this);
 }

void Rabbit_Warren::JoinNMate	(	Rabbit_Adult *	a_mate,
		RabbitObjectTypes	rob_type
	)

Adds this rabbit to the warren list and mate him with un-mated female/male with a burrow.

Loops through the list of warren inhabitants and looks for the target type rob_type. If found without a mate then ascertain if they have a burrow. Social status will depend on whether one or both is available.

Definition at line 2218 of file Rabbit.cpp.

References DEBUG_InternalTest(), Rabbit_Base::GetDigging(), Rabbit_Base::GetHasBurrow(), Rabbit_Adult::GetMate(), Join(), m_InhabitantsList, rabbit_socialstatus_subdominant, rabbit_socialstatus_subordinate, Rabbit_Base::SetDigging(), Rabbit_Base::SetHasBurrow(), Rabbit_Adult::SetMate(), and Rabbit_Adult::SetSocialStatus().

Referenced by Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
     int sz = (int) m_InhabitantsList.size();
     for (int r=0; r<sz; r++)
     {
         Rabbit_Adult* p_rabAdult = dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[ r ]);
         if ((m_InhabitantsList[r]->GetRabbitType() == rob_type) && (p_rabAdult->GetMate() == NULL) )
         {
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
             if (p_rabAdult->GetHasBurrow())
             {
                 a_mate->SetDigging(-1);
                 a_mate->SetMate(dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[r]));
                 a_mate->SetHasBurrow(true);
                 a_mate->SetSocialStatus( rabbit_socialstatus_subdominant );
                 p_rabAdult->SetSocialStatus( rabbit_socialstatus_subdominant );
                 p_rabAdult->SetMate( a_mate );
                 Join(a_mate);
                 break;
             }
             else
                 if (p_rabAdult->GetDigging() > -1)
             {
                 a_mate->SetMate( p_rabAdult );
                 a_mate->SetSocialStatus( rabbit_socialstatus_subordinate );
                 p_rabAdult->SetSocialStatus( rabbit_socialstatus_subordinate );
                 p_rabAdult->SetMate( a_mate );
                 int digging = p_rabAdult->GetDigging();
                 a_mate->SetDigging(digging);
                 Join(a_mate);
                 break;
             }
 
         }
     }
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
 }

void Rabbit_Warren::JoinNOccupy ( Rabbit_Adult * a_rabbit )

Adds this adult to the warren list and house them in a suitable burrow.

Join a warren and occupy a burrow.

Definition at line 2085 of file Rabbit.cpp.

References DEBUG_InternalTest(), DEBUG_InternalTest2(), Join(), m_NoBurrows, m_NoOccupiedBurrows, TAnimal::m_OurLandscape, OccupyBurrow(), rabbit_socialstatus_subdominant, Rabbit_Base::SetDigging(), Rabbit_Base::SetHasBurrow(), Rabbit_Adult::SetSocialStatus(), and Landscape::Warn().

Referenced by Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
 #ifdef __RABBITDEBUG
             // Do some safety checks here.
             if ((m_NoBurrows <= m_NoOccupiedBurrows) && (m_NoBurrows!=0))
             {
                 m_OurLandscape->Warn("Rabbit_Warren::JoinNOccupy","Attempt to occupy a burrow that is occupied or does not exist.");
                 exit(1);
             }
 #endif
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest2();
 #endif
     Join(a_rabbit);
     OccupyBurrow( );
     a_rabbit->SetDigging(-1);
     a_rabbit->SetSocialStatus( rabbit_socialstatus_subdominant );
     a_rabbit->SetHasBurrow( true );
 
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
 }

void Rabbit_Warren::Leave ( Rabbit_Base * a_rabbit )

Remove this adult from the warren list.

A rabbit is leaving. It may be because they are dead or because they are moving warrens, or just leaving. The rabbit:rabbit interactions are dealt with by the rabbit objects communicating, but burrow occupancy needs to be sorted out here. Both completed and burrows being dug need to be dealt with.

Definition at line 2111 of file Rabbit.cpp.

References Rabbit_Base::GetCurrentRState(), TALMaSSObject::GetCurrentStateNo(), Rabbit_Base::GetDigging(), Rabbit_Base::GetHasBurrow(), Rabbit_Base::GetMate(), Rabbit_Base::GetRabbitType(), m_BurrowsUnderConstruction, m_InhabitantsList, m_NoOccupiedBurrows, TAnimal::m_OurLandscape, rob_Juvenile, rob_Male, Rabbit_Base::SetDigging(), Rabbit_Base::SetHasBurrow(), Rabbit_Base::SetWarren(), toRabbits_Die, and Landscape::Warn().

Referenced by Rabbit_Adult::st_Dying(), Rabbit_Male::st_EvaluateTerritory(), Rabbit_Female::st_EvaluateTerritory(), and Rabbit_Base::~Rabbit_Base().

 {
     int sz = (int) m_InhabitantsList.size();
     for (int i=0; i<sz; i++)
     {
         if (m_InhabitantsList[i]==a_rabbit) 
         {
             // Found the rabbit.
 #ifdef __RABBITDEBUG
             // Do some safety checks here.
             if ( (a_rabbit->GetRabbitType() >= rob_Male ) && (a_rabbit->GetCurrentRState() != toRabbits_Die) )
             {
                 if ((a_rabbit->GetMate()!=NULL) && (a_rabbit->GetCurrentStateNo() != -1))
                 {
                     m_OurLandscape->Warn("Rabbit_Warren::Leave","Attempt to leave a warren with a mate.");
                     exit(1);
                 }
                 // Do some safety checks here.
                 if ((m_InhabitantsList[i]->GetHasBurrow()) && (a_rabbit->GetMate() != NULL) && (a_rabbit->GetCurrentStateNo() != -1))
                 {
                     m_OurLandscape->Warn("Rabbit_Warren::Leave","Attempt to leave a warren with a burrow and mate.");
                     exit(1);
                 }
             }
 #endif
             if (a_rabbit->GetRabbitType() > rob_Juvenile)
             {
                 if ((a_rabbit->GetHasBurrow()) && (a_rabbit->GetMate() == NULL)) {
                     // Single burrow occupier leaving
                     m_NoOccupiedBurrows--;
                     a_rabbit->SetHasBurrow( false );
                 }
                 if ((a_rabbit->GetDigging()!=-1) && (a_rabbit->GetMate() == NULL)) {
                     // Single digger leaving
                     m_BurrowsUnderConstruction--;
                     a_rabbit->SetDigging( -1 );
                 }
             }
             a_rabbit->SetWarren(NULL);
             // remove the rabbit from the warren list
             m_InhabitantsList.erase(m_InhabitantsList.begin() + i);
             break;
         }
     }
 }

void Rabbit_Warren::Mate	(	Rabbit_Adult *	a_mate,
		RabbitObjectTypes	rob_type
	)

Mate him with un-mated female/male with a burrow.

Mates two rabbits and also takes care of deciding whether they need to dig a burrow, and sets the social status.

Definition at line 2163 of file Rabbit.cpp.

References DEBUG_InternalTest(), Rabbit_Base::GetDigging(), Rabbit_Base::GetHasBurrow(), Rabbit_Adult::GetMate(), m_InhabitantsList, m_NoOccupiedBurrows, rabbit_socialstatus_subdominant, rabbit_socialstatus_subordinate, Rabbit_Base::SetDigging(), Rabbit_Base::SetHasBurrow(), Rabbit_Adult::SetMate(), and Rabbit_Adult::SetSocialStatus().

Referenced by Rabbit_Male::st_EvaluateTerritory(), Rabbit_Female::st_EvaluateTerritory(), and Rabbit_Female::st_UpdateBreedingStatus().

 {
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
     int sz = (int) m_InhabitantsList.size();
     for (int i=0; i<sz; i++)
     {
         Rabbit_Adult * p_rabAdult = dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[ i ]);
         if ((m_InhabitantsList[ i ]->GetRabbitType() == rob_type) && (p_rabAdult->GetMate() == NULL))
         {
             if (p_rabAdult->GetHasBurrow())
             {
 #ifdef __RABBITDEBUG
                 if (p_rabAdult->GetDigging() != -1)
                 {
                     int rubbish = 0;
                 }
 #endif
                 a_mate->SetDigging( -1 );
                 a_mate->SetMate( p_rabAdult );
                 p_rabAdult->SetMate( a_mate );
                 // If the rabbit already has a burrow then we have a free one now
                 if (a_mate->GetHasBurrow()) {
                     m_NoOccupiedBurrows--;
                 }
                 else a_mate->SetHasBurrow( true );
                 a_mate->SetSocialStatus( rabbit_socialstatus_subdominant );
                 p_rabAdult->SetSocialStatus( rabbit_socialstatus_subdominant );
                 break;
             }
             else
                 if (p_rabAdult->GetDigging() > -1)
             {
                 a_mate->SetMate(dynamic_cast<Rabbit_Adult*>(m_InhabitantsList[i]));
                 p_rabAdult->SetMate( a_mate );
                 int digging = p_rabAdult->GetDigging() / 2; // We have help so half the time
                 p_rabAdult->SetDigging( digging );
                 a_mate->SetDigging(digging);
                 a_mate->SetSocialStatus( rabbit_socialstatus_subordinate );
                 p_rabAdult->SetSocialStatus( rabbit_socialstatus_subordinate );
                 break;
             }
             // Else they are not interesting and we ignore them
         }
     }
 #ifdef __RABBITDEBUG
     this->DEBUG_InternalTest();
 #endif
 }

void Rabbit_Warren::NetworkEvaluation ( void )

Calculates and saves distance probabilities.

We need to randomise the list because otherwise the probability will always favour the first ones added - which causes NE movement in general

Definition at line 1709 of file Rabbit.cpp.

References m_foragesize, and m_LocalWarrenNetwork.

 {
     int nsz = (int) m_LocalWarrenNetwork.size();
     random_shuffle (m_LocalWarrenNetwork.begin(), m_LocalWarrenNetwork.end() );
     for (int i=0; i< nsz; i++ )
     {
         // Probability calculated as m_size/dist
         m_LocalWarrenNetwork[i].m_visitprob = m_foragesize / (double) (m_LocalWarrenNetwork[i].m_dist);
     }
 }

void Rabbit_Warren::OccupyBurrow ( )

a_rabbit occupies a free burrow

Definition at line 2071 of file Rabbit.cpp.

References m_NoOccupiedBurrows.

Referenced by JoinNOccupy(), Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
     m_NoOccupiedBurrows++;
 }

void Rabbit_Warren::OccupyNewBurrow ( )

a_rabbit occupies a newly dug burrow

Definition at line 2063 of file Rabbit.cpp.

References m_BurrowsUnderConstruction, m_NoBurrows, and m_NoOccupiedBurrows.

Referenced by Rabbit_Adult::EndStep().

 {
     m_NoOccupiedBurrows++;
     m_NoBurrows++;
     m_BurrowsUnderConstruction--;
 }

void Rabbit_Warren::OccupyWarren ( Rabbit_Adult * a_rabbit )

Adds the first rabbit to the warren list.

Definition at line 2077 of file Rabbit.cpp.

References Join(), m_BurrowsUnderConstruction, m_rabbitdiggingtime, and Rabbit_Base::SetDigging().

Referenced by Rabbit_Male::st_EvaluateTerritory(), and Rabbit_Female::st_EvaluateTerritory().

 {
     m_BurrowsUnderConstruction++;
     a_rabbit->SetDigging( m_rabbitdiggingtime ); // Heavy soil has double digging time
     Join(a_rabbit);
 }

void Rabbit_Warren::RabbitProductionRecord	(	RabbitObjectTypes	YoungType,
		int	kits
	)

inline

Stores data about production of rabbits throughout year.

Definition at line 582 of file Rabbit.h.

Referenced by Rabbit_Female::Rabbit_Female(), Rabbit_Juvenile::Rabbit_Juvenile(), Rabbit_Male::Rabbit_Male(), and Rabbit_Female::st_GiveBirth().

582 { m_ThisYearsProduction[YoungType] += kits; }

Rabbit_Warren::m_ThisYearsProduction

int m_ThisYearsProduction[rob_foobar]

Storage for rabbit production data.

Definition: Rabbit.h:744

void Rabbit_Warren::ResetAllRabbitProductionRecord ( void )

inline

Reset data about production of rabbits throughout year.

Definition at line 588 of file Rabbit.h.

References rob_foobar, and rob_Young.

Referenced by Rabbit_Warren().

588 { for (int r = (int) rob_Young; r < (int) rob_foobar; r++) m_ThisYearsProduction[r] = 0; }

rob_foobar

Definition: Rabbit.h:75

Rabbit_Warren::m_ThisYearsProduction

int m_ThisYearsProduction[rob_foobar]

Storage for rabbit production data.

Definition: Rabbit.h:744

rob_Young

Definition: Rabbit.h:70

void Rabbit_Warren::ResetRabbitProductionRecord ( RabbitObjectTypes YoungType )

inline

Reset specific data about production of rabbits throughout year.

Definition at line 586 of file Rabbit.h.

586 { m_ThisYearsProduction[YoungType] = 0; }

Rabbit_Warren::m_ThisYearsProduction

int m_ThisYearsProduction[rob_foobar]

Storage for rabbit production data.

Definition: Rabbit.h:744

void Rabbit_Warren::st_WarrenBeing ( void )

protected

The only warren behaviour - it just is.

This is the only warren behaviour - the warren just is, and this is where any daily updates to its status are performed.

First daily job it to determine whether warren maintenence should be kept up, increased or decreased. Then use this to determine the current burrow state. Then a check is made for a dominant female. If there is one then OK, otherwise see if one can be made.

Next the food availability is calculated. This is a cominbination of permanent forage and suitable temporary forage.

Finally if there is any chance that there is some pesticide to take into account the UpdatePesticide method is called.

Definition at line 1859 of file Rabbit.cpp.

References cfg_forageareamortscaler, DEBUG_InternalTest(), GetAllBreedingFemaleRabbits(), Rabbit_Population_Manager::GetForageDay(), Rabbit_Population_Manager::IsBreedingSeason(), m_diseaseconstant, m_InhabitantsList, m_maintenence, m_mortalitymultiplierA, m_mortalitymultiplierJ, m_NoBurrows, m_OurPopulationManager, m_rabbitdiggingtime, m_runningavCount, m_runningavFemales, m_soiltype, UpdateDominance(), UpdateForageInformation(), and CfgFloat::value().

Referenced by Step().

 {
 #ifdef __RABBITDEBUG
     DEBUG_InternalTest();
 #endif
 
     if (m_InhabitantsList.size() == 0)
     {
         m_maintenence -= 2 - m_soiltype; // Double rate of maintenence for light soil
     }
     if (m_maintenence > m_rabbitdiggingtime) m_maintenence = m_rabbitdiggingtime;
     if (m_maintenence < 0)
     {
         m_maintenence = m_rabbitdiggingtime;
         if (m_NoBurrows > 0) m_NoBurrows--;
     }
     // Dominance check
     UpdateDominance();
     // Food update
     UpdateForageInformation();
     // Now calculates the mortality chance for today
     double foragemult = 0;
     if (!m_OurPopulationManager->GetForageDay()) foragemult = 1 + cfg_forageareamortscaler.value(); // *(1 - m_availableforage); // m_foragearearatio is 0-1 and larger available forage is reduced.
     m_mortalitymultiplierA = 1 + m_diseaseconstant + foragemult; // Disease is the only density dependent death for adults
     // We need to de-couple mortality of juveniles and density
     m_mortalitymultiplierJ = 1 + foragemult;
 #ifdef __RABBITDEBUG
     DEBUG_InternalTest();
 #endif
     // Keep track of breeding females for POM
     if (m_OurPopulationManager->IsBreedingSeason()) {
         m_runningavCount++;
         m_runningavFemales += GetAllBreedingFemaleRabbits();
     }
 }

void Rabbit_Warren::Step ( void )

virtual

Warren step code.

Reimplemented from TAnimal.

Definition at line 1840 of file Rabbit.cpp.

References m_CurrentRState, TALMaSSObject::m_CurrentStateNo, TAnimal::m_OurLandscape, TALMaSSObject::m_StepDone, st_WarrenBeing(), toRabbits_InitialState, toRabbits_WarrenBeing, and Landscape::Warn().

 {
     if (m_StepDone || m_CurrentStateNo == -1) return;
     switch (m_CurrentRState)
     {
      case toRabbits_InitialState: 
          m_CurrentRState = toRabbits_WarrenBeing;
          break;
      case toRabbits_WarrenBeing: // Being state is never left for warrens - 'they just are'
          st_WarrenBeing();
          m_StepDone=true;
          break;
      default:
          m_OurLandscape->Warn("Rabbit_Warren::Step()","unknown state - default");
          exit(1);
     }
 }

void Rabbit_Warren::UpdateDominance ( void )

Checks for a dominant female and promotes one if necessary and possible.

Returns: false if none, true if unmated female found Checks the list of residents for a female with a burrow and no mate.

Definition at line 1930 of file Rabbit.cpp.

References ChooseNewDominant(), m_InhabitantsList, rabbit_socialstatus_subdominant, and rob_Female.

Referenced by st_WarrenBeing().

                                           {
     int sz = (int)m_InhabitantsList.size();
     for (int i = 0; i<sz; i++) {
         if (m_InhabitantsList[ i ]->GetRabbitType() == rob_Female) {
             if (dynamic_cast<Rabbit_Female*>(m_InhabitantsList[ i ])->GetSocialStatus() == rabbit_socialstatus_subdominant) return;
         }
     }
     // If we get here we have no dominant female, so see if one can be created.
     ChooseNewDominant();
 }

void Rabbit_Warren::UpdateForageInformation ( void )

protected

Updates the forage information depending upon the vegetation state.

This method updates the warren forage information based upon the vegetation height and digestability for each forage polygon. Other options which could be exercised here are to use the vegetation type, biomass or density.

Also calculated here is the amount of available forage relative to the current carrying capacity ratio. Low forage availability will increase death rates in adults, but only if the carrying capacity is too low (based on current forage).

Definition at line 1639 of file Rabbit.cpp.

References CalcCarryingCapacityRatio2(), CalcForageArea(), cfg_litterabsorptionconstant, m_availableforage, m_CarryingCapacityRatio, m_foragearea, m_foragearearatio, m_inv_availableforage, m_LEList, m_litterreabosorptionchance, m_maxForageHeight, m_minForageDigestability, TAnimal::m_OurLandscape, m_permforagearea, Landscape::SupplyDayInYear(), Landscape::SupplyGlobalDate(), Landscape::SupplyVegDigestability(), Landscape::SupplyVegHeight(), torh_TemporaryForage, UpdatePesticide(), CfgInt::value(), CfgFloat::value(), and CfgBool::value().

Referenced by st_WarrenBeing().

                                                   {
     double availableforage = m_permforagearea;
     for (vector<RabbitWarrenLEInfo>::size_type k = 0; k < m_LEList.size(); k++) {
         if (m_LEList[ k ].m_torh == torh_TemporaryForage) {
             double vegheight = m_OurLandscape->SupplyVegHeight( m_LEList[ k ].m_ref ); // m_ref is the landscape polyref
             double vegdigestability = m_OurLandscape->SupplyVegDigestability( m_LEList[ k ].m_ref );
             if ((vegheight < m_maxForageHeight) && (vegdigestability > m_minForageDigestability)) {
                 // 30 cm
                 m_LEList[ k ].m_forage = m_LEList[ k ].m_foragearea;
                 availableforage += m_LEList[ k ].m_foragearea;
             }
             else m_LEList[ k ].m_forage = 0.0;
         }
     }
     // Only do the expensive pesticide update if there is a chance that there is some pesticide to work with
     if (l_pest_enable_pesticide_engine.value()) UpdatePesticide();
 
     m_foragearea = CalcForageArea();
     if (m_OurLandscape->SupplyGlobalDate() % cfg_rabbitdensitydependencedelay.value() ==0) {
         m_CarryingCapacityRatio = CalcCarryingCapacityRatio2(); // Normally this is the same as m_BigFemaleRabbitsR, which gets bigger as rabbits get close to CC
     }
     m_foragearearatio = availableforage / m_foragearea;
     if ((m_foragearearatio) < m_CarryingCapacityRatio) {
         m_availableforage = m_foragearearatio / m_CarryingCapacityRatio;
         m_inv_availableforage = 1.0 / m_availableforage;
     }
     else {
         m_availableforage = 1.0;
         m_inv_availableforage = 0.0;
     }
     if (m_OurLandscape->SupplyDayInYear() == cfg_rabbitdensitydependencedelay.value()) {
         m_litterreabosorptionchance = cfg_litterabsorptionconstant.value() * pow( 1.0 - m_availableforage, cfg_litterabsorptionconstant.value() );
     }
 }

void Rabbit_Warren::UpdatePesticide ( void )

protected

Updates the pesticide concentration in forage polygons.

This is a very 'costly' method. It should not be called if there is no pesticide in use.

Runs through the warren forage area and sums the pesticide.If __RABBITMEANPESTICIDECONC is defined then the pesticide values in all polygons are divided by the area of forage in the warren and the concentration determined. Otherwise the maximum concentration is found in forage areas and set as the value for returning in m_forageP

Definition at line 1602 of file Rabbit.cpp.

References m_availableforage, m_forageP, m_foragesize, m_LEList, TAnimal::m_OurLandscape, m_TL_x, m_TL_y, Landscape::SupplyPesticide(), Landscape::SupplyPesticideDecay(), and Landscape::SupplyPolyRef().

Referenced by UpdateForageInformation().

                                           {
     m_forageP = 0.0;
     if (!m_OurLandscape->SupplyPesticideDecay()) return;
     for (int i = m_TL_x; i < m_TL_x + m_foragesize; i++) {
         for (int j = m_TL_y; j < m_TL_y + m_foragesize; j++) {
             // Unfortunately we need to check for each square whether the rabbit can forage here.
             int ele = m_OurLandscape->SupplyPolyRef( i, j );
             for (vector<RabbitWarrenLEInfo>::size_type k = 0; k < m_LEList.size(); k++) {
                 if (m_LEList[ k ].m_ref == ele) {
                     if (m_LEList[ k ].m_forage > 0.0) {
 #ifdef __RABBITMEANPESTICIDECONC
                         m_forageP += m_OurLandscape->SupplyPesticide( i, j );
 #else
                         double pe = m_OurLandscape->SupplyPesticide( i, j );
                         if (m_forageP< pe ) m_forageP = pe;
 #endif
                     }
                     break;
                 }
             }
         }
     }
     // Now calculate the mean concentration and mean forage concentration if needed
 #ifdef __RABBITMEANPESTICIDECONC
     m_forageP /= (double)m_availableforage;
 #endif
 }

void Rabbit_Warren::UpdateThisYearsBreeders ( )

Calculates and stores the number of breeders and non-breeders.

Loops through the list of inhabitants and checks if each is a female > 1 year, if so whether it produced a litter this year.

Returns: the number of females that produced litters this year

Definition at line 1815 of file Rabbit.cpp.

References GetLittersThisYear(), m_1yrOldFemales, m_breedingfemales, m_InhabitantsList, m_littersthisyear, m_nonbreedingfemales, and rob_Female.

                                             {
     m_breedingfemales = 0;
     m_nonbreedingfemales = 0;
     m_1yrOldFemales = 0;
     m_littersthisyear = 0;
     int sz = static_cast<int>(m_InhabitantsList.size());
     for (int r = 0; r < sz; r++) {
         if (m_InhabitantsList[ r ]->GetRabbitType() == rob_Female) {
             if (m_InhabitantsList[ r ]->GetAge() < 300) {
                 m_1yrOldFemales++;
             }else{
                 int litters = dynamic_cast<Rabbit_Female*>(m_InhabitantsList[ r ])->GetLittersThisYear();
                 if (litters > 0) m_breedingfemales++; else m_nonbreedingfemales++;
                 m_littersthisyear += litters;
             }
         }
     }
 }

Member Data Documentation

int Rabbit_Warren::m_1yrOldFemales

The number of 1 year old females.

Definition at line 547 of file Rabbit.h.

Referenced by UpdateThisYearsBreeders().

double Rabbit_Warren::m_availableforage

protected

Records the amount of forage currently available in the warren area as a proportion of what is the potential relative to rabbit numbers possible.

Definition at line 728 of file Rabbit.h.

Referenced by UpdateForageInformation(), and UpdatePesticide().

double Rabbit_Warren::m_BigFemaleRabbitsR

protected

Records the number of big female rabbits divided by m_CarryingCapacityR2.

Definition at line 710 of file Rabbit.h.

Referenced by CalcCarryingCapacityRatio1(), CalcCarryingCapacityRatio2(), and Rabbit_Warren().

int Rabbit_Warren::m_breedingfemales

The number of females that bred this year.

Definition at line 545 of file Rabbit.h.

Referenced by UpdateThisYearsBreeders().

int Rabbit_Warren::m_BurrowsUnderConstruction

protected

Records the burrows that are being dug.

Definition at line 718 of file Rabbit.h.

Referenced by IsFreeBurrow(), Leave(), OccupyNewBurrow(), OccupyWarren(), and Rabbit_Warren().

int Rabbit_Warren::m_CarryingCapacity

protected

Records the max number of rabbit pairs possible here.

Definition at line 704 of file Rabbit.h.

Referenced by InitEvaluation(), IsFreeBurrow(), and Rabbit_Warren().

double Rabbit_Warren::m_CarryingCapacityR

protected

Records the max number of rabbits possible here.

Definition at line 706 of file Rabbit.h.

Referenced by InitEvaluation().

double Rabbit_Warren::m_CarryingCapacityR2

protected

Records the max number of rabbits possible here divided by 2.

Definition at line 708 of file Rabbit.h.

Referenced by CalcCarryingCapacityRatio1(), and InitEvaluation().

double Rabbit_Warren::m_CarryingCapacityRatio

protected

Records the ratio between carrying capacity and no rabbits in warren.

Definition at line 712 of file Rabbit.h.

Referenced by Rabbit_Warren(), and UpdateForageInformation().

TTypeOfRabbitState Rabbit_Warren::m_CurrentRState

protected

Variable to record current behavioural state.

Definition at line 746 of file Rabbit.h.

Referenced by Rabbit_Warren(), and Step().

double Rabbit_Warren::m_diseaseconstant

protected

a measure of disease mortality likelihood

Definition at line 738 of file Rabbit.h.

Referenced by CalcDisease(), Rabbit_Warren(), and st_WarrenBeing().

int Rabbit_Warren::m_foragearea

protected

Variable holding the total potential forage area.

Definition at line 726 of file Rabbit.h.

Referenced by InitEvaluation(), and UpdateForageInformation().

double Rabbit_Warren::m_foragearearatio

protected

Records the amount of forage currently available in the warren area as a proportion of total forage area.

Definition at line 730 of file Rabbit.h.

Referenced by UpdateForageInformation().

double Rabbit_Warren::m_forageP

protected

Records the amount of pesticde as a mean concentration per unit area forage.

Definition at line 736 of file Rabbit.h.

Referenced by UpdatePesticide().

int Rabbit_Warren::m_foragesize

protected

Warren forage size in m.

Definition at line 696 of file Rabbit.h.

Referenced by InitEvaluation(), NetworkEvaluation(), Rabbit_Warren(), and UpdatePesticide().

vector<Rabbit_Base*> Rabbit_Warren::m_InhabitantsList

protected

List of rabbits that live here - for easy communication purposes.

Definition at line 752 of file Rabbit.h.

Referenced by ChooseNewDominant(), DEBUG_InternalTest(), DEBUG_InternalTest2(), GetAllBigFemaleRabbits(), GetAllBreedingFemaleRabbits(), IsFreeFemale(), IsFreeMale(), IsMember(), Join(), JoinNMate(), Leave(), Mate(), Rabbit_Warren(), st_WarrenBeing(), UpdateDominance(), and UpdateThisYearsBreeders().

double Rabbit_Warren::m_inv_availableforage

protected

The inverse of m_availableforage, prevents multiple re-calculation.

Definition at line 732 of file Rabbit.h.

Referenced by UpdateForageInformation().

vector<RabbitWarrenLEInfo> Rabbit_Warren::m_LEList

protected

List of polygons and the area which is part of the warren.

Definition at line 748 of file Rabbit.h.

Referenced by CalcForageArea(), CalcPermForageArea(), GetCoverArea(), GetCoverAreaVeg(), GetTempForageAreaVeg(), GetTemporaryForageArea(), InitEvaluation(), UpdateForageInformation(), and UpdatePesticide().

double Rabbit_Warren::m_litterreabosorptionchance

protected

Chance of litter reaborption based on the m_availableforage.

Definition at line 734 of file Rabbit.h.

Referenced by UpdateForageInformation().

int Rabbit_Warren::m_littersthisyear

The number of litters produced this year.

Definition at line 549 of file Rabbit.h.

Referenced by UpdateThisYearsBreeders().

vector<LocalWarrenNewtorkEntry> Rabbit_Warren::m_LocalWarrenNetwork

protected

List of local warrens and their accessibility from this warren.

Definition at line 750 of file Rabbit.h.

Referenced by CalcCarryingCapacityRatio2(), GetNetworkWarren(), and NetworkEvaluation().

int Rabbit_Warren::m_maintenence

protected

Warren maintenence score - if not max then houseing capacity is reduced.

Definition at line 702 of file Rabbit.h.

Referenced by Rabbit_Warren(), and st_WarrenBeing().

double Rabbit_Warren::m_maxForageHeight = cfg_maxForageHeight.value()

static

The maximum vegetation height assumed for forage potential.

From http://informedfarmers.com/rabbit-reproduction/
The size of a warren depends on the soil type. Typically, warrens can be around two metres deep, although warrens in sandy soils are more likely to be smaller and have fewer underground interconnections than warrens in hard soils.
This is because it is easier for rabbits to start a new warren in sandy soil but in harder, clay-type soils it is easier to extend an existing warren. On average, one warren will have 3 to 15 entrances, with each active entrance likely to house two adult rabbits.

Warren carrying capacity is assumed to be maximum if the 90% of whole area is under permanent forage. Max CC is 15 pairs. We assume that the number of pais is linearly related to the area above a minimum required for 3 pairs.

The warren is a square area of the landscape which is of a standard size and must contain a certain proportion of permanent forage habitat (input parameter RABBIT_WARRENMINPCTFORAGE ). The warren manages its own list of resident rabbits and is responsible for ensuring that the number of rabbits does not rise above its carrying capacity which is determined by the total forage available. Maximum possible carrying capacity is 15 burrows, minimum for a warren to exist is 3.
Daily actual carrying capacity is determined by the number of burrows possible and the number that are actually present. On creation there is no burrows present and a rabbit must first occupy the warren then dig the burrow before breeding can start. Subsequently the warren will grow as rabbits dig further burrows if the warren is continually occupied. After 2 years it will be assumed to have reached the maximum number of burrows possible.

Definition at line 541 of file Rabbit.h.

Referenced by Rabbit_Population_Manager::AssignStaticVariables(), GetCoverAreaVeg(), GetTempForageAreaVeg(), Rabbit_Population_Manager::Rabbit_Population_Manager(), and UpdateForageInformation().

double Rabbit_Warren::m_minForageDigestability = cfg_minForageDigestability.value()

static

The minimum vegetation digestability allowed for foraging.

Definition at line 543 of file Rabbit.h.

Referenced by Rabbit_Population_Manager::AssignStaticVariables(), and UpdateForageInformation().

double Rabbit_Warren::m_mortalitymultiplierA

protected

a measure of mortality likelihood - adults

Definition at line 740 of file Rabbit.h.

Referenced by st_WarrenBeing().