RodenticideManager Class Reference

Class for management of bait locations. More...

#include <Rodenticide.h>

Public Member Functions
void	Diffuse (int a_x, int a_y)
	Move poisoned mice around to twin map. More...
void	DistributeRing (int a_x, int a_y, double a_amount)
	Distribute an amount to the twin map in a ring. More...
void	DoDeath (void)
	Reduce each cell in twin map by m_deathRate. More...
void	DoDiffuse (void)
void	DoImmigration (void)
void	DoPlaceBait ()
	Initiates bait placement for those bait locations necessary. More...
void	DumpRodenticideMap (string a_fname)
	Dumps a map of rodenticide loads per 1m2 cells. More...
int	GetBaitStartDate (TTypesBaitLocation)
	Determines when the bait will be placed within a season. More...
double	GetMap (int a_x, int a_y)
	Get poisoned mice at x,y. More...
double	GetMapTwin (int a_x, int a_y)
	Get poisoned mice at x,y on twin map. More...
double	GetRodenticide (unsigned a_x, int a_y)
	Return the poisoned mice value at x,y. More...
void	InitiateRodenticidePolyData (string a_fname)
	Opens and initiates the output file for polygon rodenticide information. More...
void	RecordRodenticidePolyData (string a_fname)
	Records rodenticide loads per polygon. More...
	RodenticideManager (string fname, Landscape *a_land)
	RodenticideManager constructor. More...
void	SetMap (int a_x, int a_y, double a_p)
	Set poisoned mice at x,y. More...
void	SetMapTwin (int a_x, int a_y, double a_p)
	Set poisoned mice at x,y on twin map. More...
void	SetMapTwinMult (int a_x, int a_y, double a_p)
	Multiply poisoned mice at x,y on twin map by constant. More...
void	SetMapTwinP (int a_x, int a_y, double a_p)
	Add to poisoned mice at x,y on twin map. More...
bool	ShouldPlaceBait (TTypesBaitLocation)
	Place bait dependent upon a frequency test. More...
void	Tick (void)
	Advance one day. More...
virtual	~RodenticideManager (void)
	RodenticideManager destructor. More...

Protected Attributes
vector< BaitLocation >	m_BaitList
	List of bait locations. More...
double	m_deathRate
	poisoned mice death rate More...
double	m_diffusionRate
	poisoned mice diffusion rate More...
int	m_gridsize
	rodenticide grid size - also affect diffusion rate More...
int	m_height
int	m_heightm1
double	m_immigrationRate
	poisoned mice immigration rate More...
Landscape *	m_land
	Landscape pointer. More...
vector< double >	m_pmouse_map_main
	Map of probability of encountering a poisoned mouse. More...
vector< double >	m_pmouse_map_twin
	Temporary map for calculation poisoned mouse diffusion. More...
int	m_seasonstartprob [tbl_foobar][1000]
	season start probability distribution More...
int	m_width
	Landscape dimensions. More...

Detailed Description

Class for management of bait locations.

Constructor & Destructor Documentation

RodenticideManager::RodenticideManager	(	string	fname,
		Landscape *	a_land
	)

RodenticideManager constructor.

Uses the file name to open a file and read in all bait locations required for managemnet

Creates the rodenticide grid with its twin-map and fills them with zeros. The maps have a resolution which is defined by __RODENTICIDE_GRID_RES. Cannot have diffusion of >= map width or height - this needs checking to prevent wrapping around the world.

Read in and handle the probability distributions for seasonal start dates for bait locations. BaitLocationsSeasonalStartProbs.txt holds a column of daily probability for bait placement for each building type ()values range 0.0 to 1.0).

References cfg_rodenticide_deathRate(), cfg_rodenticide_diffusionRate(), cfg_rodenticide_gridsize(), cfg_rodenticide_immigrationRate(), BaitLocation::SetBLtype(), BaitLocation::SetX(), BaitLocation::SetY(), Landscape::SupplySimAreaWidth(), and tbl_foobar.

{
        // Read in input parameters
        m_gridsize = cfg_rodenticide_gridsize.value();
        m_deathRate = 1.0-cfg_rodenticide_deathRate.value();
        m_diffusionRate = cfg_rodenticide_diffusionRate.value();
        m_immigrationRate = cfg_rodenticide_immigrationRate.value();
        ifstream ifile(a_fname.c_str(), ios::in);
        if ( !ifile.is_open() )
        {
                cout << "Cannot open input file " << a_fname << endl;
                char ch;
                cin >> ch;
                exit(1);
        }
        int noBaits, x, y, blt;
        TTypesBaitLocation BL_type = tbl_foobar;
        BaitLocation Bait(0,0,BL_type);
        ifile >> noBaits;
        for (int i = 0; i < noBaits; i++)
        {
                ifile >> x >> y >> blt;
                Bait.SetX(x >> m_gridsize);
                Bait.SetY(y >> m_gridsize);
                Bait.SetBLtype((TTypesBaitLocation)blt);
                m_BaitList.push_back(Bait);
        }
        // Need to put actual baits out in the landscape
        m_land = a_land;
        m_width = m_land->SupplySimAreaWidth() >> m_gridsize;
        m_height = m_land->SupplySimAreaHeight() >> m_gridsize;
        m_heightm1 = m_height-1; // Saves many many calculations later.
        m_pmouse_map_main.resize((m_width+1) * (m_height+1));
        m_pmouse_map_twin.resize((m_width+1) * (m_height+1));
        for (int i=0; i<m_width+1; ++i) for (int j=0; j<m_height+1; ++j)
        {
                m_pmouse_map_main[j*m_height + i] = 0;
                m_pmouse_map_twin[j*m_height + i] = 0;
        }
        ifstream i2file("BaitLocationsSeasonalStartProbs.txt", ios::in);
        if ( !ifile.is_open() )
        {
                cout << "Cannot open input file " << "BaitLocationsSeasonalStartProbs.txt" << endl;
                char ch;
                cin >> ch;
                exit(1);
        }
        double temp[tbl_foobar][365];
        for (int i = 0; i < 365; i++)
        {
                for (int j=0; j<tbl_foobar; j++)
                {
                        i2file >> temp[j][i];
                }
        }
        // BaitLocationsSeasonalStartProbs.txt data exists in temp.
        // Next for each building type fill in the probability array in fractions of 0.1
        // each entry corresponds to one day when bait might be started
        for (int j=0; j<tbl_foobar; j++)
        {
                int index = 0;
                for (int i = 0; i < 365; i++)
                {
                        int prob = (int) floor((temp[j][i]*10)+0.5) + index; // input data sums to 100, so  multiply by 10 is 1000
                        if (prob>1000) prob=1000;
                        for (int k=index; k<prob; k++) m_seasonstartprob[j][k] = i;
                        index=prob;
                        if (index>=1000) i=365;
                }
        }
        InitiateRodenticidePolyData("RodenticidePolyData.txt");
}

RodenticideManager::~RodenticideManager ( void  )

virtual

RodenticideManager destructor.

{
        ;
}

Member Function Documentation

void RodenticideManager::Diffuse	(	int	a_x,
		int	a_y
	)

Move poisoned mice around to twin map.

{
        double before = GetMap(a_x, a_y);
        if (before < 0.00001)
        {
                SetMapTwinP(a_x, a_y,0); // Prevents infinitely small calculations
                return;
        }
        double after = before * m_diffusionRate;
        double diff_out = after/8;
        SetMapTwinP(a_x, a_y,before-after);
        DistributeRing(a_x,a_y,diff_out);
}

void RodenticideManager::DistributeRing ( int  a_x, int  a_y, double  a_amount  )

inline

Distribute an amount to the twin map in a ring.

Distribute a_amount to the eight cells around m_x,m_y

{
        int x1 = a_x - 1;
        int y1 = a_y - 1;
        int y2 = y1 + 2;
        int x2 = x1 + 2;
        if ((y1<0) || (y2==m_height) || (x1<0) || (x2==m_width))
        {
                // We need to do this to prevent the diffusion building a wall around the edge, but it could be assessed as to whether the speed penalty is worth it
                x1 = (x1 + m_width) % m_width;
                x2 = (x2 + m_width) % m_width;
                y1 = (y1 + m_height) % m_height;
                y2 = (y2 + m_height) % m_height;
        }
        SetMapTwinP(x1,y1,a_amount);
        SetMapTwinP(x1,y2,a_amount);
        SetMapTwinP(x1,a_y,a_amount);
        SetMapTwinP(x2,y1,a_amount);
        SetMapTwinP(x2,y2,a_amount);
        SetMapTwinP(x2,a_y,a_amount);
        SetMapTwinP(a_x,y1,a_amount);
        SetMapTwinP(a_x,y2,a_amount);
}

void RodenticideManager::DoDeath ( void  )

inline

Reduce each cell in twin map by m_deathRate.

        {
                for (int i=0;i<m_width; i++)
                        for (int j=0; j<m_height; j++) SetMapTwinMult(i,j,m_deathRate);
        }

void RodenticideManager::DoDiffuse ( void  )

inline

        {
                for (int i=0;i<m_width; i++)
                        for (int j=0; j<m_height; j++)  this->Diffuse(i,j);
        }

void RodenticideManager::DoImmigration

(

void

)

{
        unsigned sz = (unsigned) m_BaitList.size();
        for (unsigned i=0; i<sz; i++)
        {
                if (m_BaitList[i].GetMass()>0)
                {
                        m_BaitList[i].ReduceMass(1); // subtract 1 from mass
                        int x = m_BaitList[i].GetX();
                        int y = m_BaitList[i].GetY();
                        m_pmouse_map_main[y*m_width + x] += m_immigrationRate;
                }
        }
}

void RodenticideManager::DoPlaceBait

(

void

)

Initiates bait placement for those bait locations necessary.

Depending upon the bait type, whether the bait has been used this year and whether it is destined to be used this method will add mass to the bait locations.
Housekeeping on Jan 1st is to remove all masses and zero all flags for the start of the new year.
The first test is of date, since whether a BL is used is determined by the frequency of that BL type on Jan 1st.
The next test is on the season, determining the start of bait placement.
NB this not so time critical so no optimising of the loops is done here.

References cfg_rodenticide_BLchristmasstrees_Length(), cfg_rodenticide_BLcountry_Length(), cfg_rodenticide_BLtown_Length(), cfg_rodenticide_BLwoodland_Length(), tbl_christmasstrees, tbl_country, tbl_town, and tbl_woodland.

{
        int day = m_land->SupplyDayInYear();
        unsigned sz = (unsigned) m_BaitList.size();
        if (day==0)
        {
                for (unsigned i=0; i<sz; i++)
                {
                        m_BaitList[i].Reset();
                        if (ShouldPlaceBait(m_BaitList[i].GetBLtype()))
                        {
                                m_BaitList[i].SetUseFlag(true);
                                m_BaitList[i].SetstartDay(GetBaitStartDate(m_BaitList[i].GetBLtype()));
                        }
                }
        }
        // Loop through all the BLs and initiate any needed doing today
        for (unsigned i=0; i<sz; i++)
        {
                if (m_BaitList[i].GetUseFlag())
                {
                        if (m_BaitList[i].GetstartDay() == day )
                        {
                                // Due to start today, so set bait mass & unset use flag because we have used it now.
                                // Find the bait mass
                                int mass;
                                switch (m_BaitList[i].GetBLtype())
                                {
                                case tbl_town:
                                        mass = cfg_rodenticide_BLtown_Length.value();
                                        break;
                                case tbl_country:
                                        mass = cfg_rodenticide_BLcountry_Length.value();
                                        break;
                                case tbl_woodland:
                                        mass = cfg_rodenticide_BLwoodland_Length.value();
                                        break;
                                case tbl_christmasstrees:
                                        mass = cfg_rodenticide_BLchristmasstrees_Length.value(); // uses same as woodland
                                        break;
                                default:
                                        g_msg->Warn( WARN_FILE, "RodenticideManager::DoPlaceBait(void): Unknown bait type","");
                                        exit( 0 );
                                }
                                m_BaitList[i].SetMass(mass);
                                m_BaitList[i].SetUseFlag(false);
                                // Add the bait to the main map
                                SetMap(m_BaitList[i].GetX(),m_BaitList[i].GetY(),1.0);
                        }
                }
        }

}

void RodenticideManager::DumpRodenticideMap

(

string

a_fname

)

Dumps a map of rodenticide loads per 1m2 cells.

Uses the file name to open a file and saves the rodenticide value for each cell at the time this method is called.

{
        ofstream ofile(a_fname.c_str(), ios::out);
        if ( !ofile.is_open() )
        {
                cout << "Cannot open output file for rodenticide map dump " << a_fname << endl;
                char ch;
                cin >> ch;
                exit(1);
        }
        int xext = m_land->SupplySimAreaWidth();
        int yext = m_land->SupplySimAreaHeight();
        ofile << "Width: "<< xext << endl;
        ofile << "Height: "<< yext << endl;
        for (int y=0; y<yext; y++)
        {
                for (int x=0; x<xext; x++)
                {
                        ofile << m_land->SupplyRodenticide(x,y) << '\t';
                }
                ofile << endl;
        }
        ofile.close();
}

int RodenticideManager::GetBaitStartDate

(

TTypesBaitLocation

a_BLt

)

Determines when the bait will be placed within a season.

References g_rand_uni.

{
        int chance = (int) floor((g_rand_uni() * 1000)+0.5);
        return m_seasonstartprob[a_BLt][chance];
}

double RodenticideManager::GetMap ( int  a_x, int  a_y  )

inline

Get poisoned mice at x,y.

{ return m_pmouse_map_main[a_y*m_width + a_x]; }

double RodenticideManager::GetMapTwin ( int  a_x, int  a_y  )

inline

Get poisoned mice at x,y on twin map.

{ return m_pmouse_map_twin[a_y*m_width + a_x]; }

double RodenticideManager::GetRodenticide ( unsigned  a_x, int  a_y  )

inline

Return the poisoned mice value at x,y.

{ return m_pmouse_map_main[(a_x >> m_gridsize) + (a_y >> m_gridsize)*m_width]; }

void RodenticideManager::InitiateRodenticidePolyData

(

string

a_fname

)

Opens and initiates the output file for polygon rodenticide information.

Uses the file name to open a file and saves the rodenticide value for each polygon at the time this method is called.

{
        ofstream ofile(a_fname.c_str(), ios::out);
        if ( !ofile.is_open() )
        {
                cout << "Cannot open output file for rodenticide poly initiate " << a_fname << endl;
                char ch;
                cin >> ch;
                exit(1);
        }
        int noPoly=m_land->SupplyNumberOfPolygons();
        ofile << noPoly << endl;
        for (int p=0; p<(noPoly-1); p++)
        {
                ofile << m_land->SupplyPolyRefVector(p) << '\t';
        }
        ofile << m_land->SupplyPolyRefVector(noPoly-1) << endl;
        for (int p=0; p<(noPoly-1); p++)
        {
                ofile << m_land->SupplyElementTypeFromVector(p) << '\t';
        }
        ofile << m_land->SupplyElementTypeFromVector(noPoly-1) << endl;
        for (int p=0; p<(noPoly-1); p++)
        {
                int area = (int) m_land->SupplyPolygonAreaVector(p);
                ofile << area << '\t';
        }
        ofile << m_land->SupplyPolygonAreaVector(noPoly-1);
        ofile.close();
}

void RodenticideManager::RecordRodenticidePolyData

(

string

a_fname

)

Records rodenticide loads per polygon.

Uses the file name to open a file and saves the rodenticide value for each polygon at the time this method is called.

{
        ofstream ofile(a_fname.c_str(), ios::app);
        if ( !ofile.is_open() )
        {
                cout << "Cannot open output file for rodenticide poly data " << a_fname << endl;
                char ch;
                cin >> ch;
                exit(1);
        }
        int noPoly=m_land->SupplyLargestPolyNumUsed()+1;
        double* polyR = new double [noPoly];
        for (int p=0; p<(noPoly); p++) polyR[p]=0.0;
        int xext = m_land->SupplySimAreaWidth();
        int yext = m_land->SupplySimAreaHeight();
        for (int y=0; y<yext; y++)
        {
                for (int x=0; x<xext; x++)
                {
                        double Rdt = m_land->SupplyRodenticide(x,y);
                        int pindex = m_land->SupplyPolyRefIndex(x,y);
                        polyR[pindex]+=Rdt;
                }
        }
        ofile << endl; // Got to be here to easily allow an eof test later
        for (int p=0; p<(noPoly-1); p++)
        {
                ofile << polyR[p] << '\t';
        }
        ofile << polyR[noPoly-1];
        ofile.close();
        delete polyR;
}

void RodenticideManager::SetMap ( int  a_x, int  a_y, double  a_p  )

inline

Set poisoned mice at x,y.

{ m_pmouse_map_main[a_y*m_width + a_x] = a_p; }

void RodenticideManager::SetMapTwin ( int  a_x, int  a_y, double  a_p  )

inline

Set poisoned mice at x,y on twin map.

{ m_pmouse_map_twin[a_y*m_width + a_x] = a_p; }

void RodenticideManager::SetMapTwinMult ( int  a_x, int  a_y, double  a_p  )

inline

Multiply poisoned mice at x,y on twin map by constant.

{ m_pmouse_map_twin[a_y*m_width + a_x] *= a_p; }

void RodenticideManager::SetMapTwinP ( int  a_x, int  a_y, double  a_p  )

inline

Add to poisoned mice at x,y on twin map.

{ m_pmouse_map_twin[a_y*m_width + a_x] += a_p; }

bool RodenticideManager::ShouldPlaceBait

(

TTypesBaitLocation

a_BLt

)

Place bait dependent upon a frequency test.

References cfg_rodenticide_BLchristmastrees_AnnFreq(), cfg_rodenticide_BLcountry_AnnFreq(), cfg_rodenticide_BLtown_AnnFreq(), cfg_rodenticide_BLwoodland_AnnFreq(), g_rand_uni, tbl_christmasstrees, tbl_country, tbl_foobar, tbl_town, and tbl_woodland.

{
#ifdef __RODENTICIDE_DISTRIBUTIONTEST
        return true;
#endif
        double chance = g_rand_uni();
        switch (a_BLt)
        {
        case tbl_town:
                if (chance < cfg_rodenticide_BLtown_AnnFreq.value()) return true;
                break;
        case tbl_country:
                if (chance < cfg_rodenticide_BLcountry_AnnFreq.value()) return true;
                break;
        case tbl_woodland:
                if (chance < cfg_rodenticide_BLwoodland_AnnFreq.value()) return true;
                break;
        case tbl_christmasstrees:
                if (chance < cfg_rodenticide_BLchristmastrees_AnnFreq.value()) return true;
                break;
        case tbl_foobar:
                cout << "Unknown building type" << endl;
                char ch;
                cin >> ch;
                exit(1);
                break;
        }
        return false;
}

void RodenticideManager::Tick

(

void

)

Advance one day.

Check for bait location placement each day, but also do intialisation on Jan 1st.

For each bait location - first add immigration to the main map.

Then calculate diffusion for every cell - this is time consuming! Diffusion is added to twin map.

Apply mortalities to all cells in the twin map.

Finally swap the twin map and main map, then clear the twin map.

References cfg_rodenticide_dumpmapday(), cfg_rodenticide_dumpmapstartyear(), cfg_rodenticide_dumppolyendyear(), cfg_rodenticide_dumppolyinterval(), and cfg_rodenticide_dumppolystartyear().

{
        DoPlaceBait();
        DoImmigration();
        DoDiffuse();
        DoDeath();
        m_pmouse_map_twin.swap(m_pmouse_map_main); // Swap the twim map to the main map
        m_pmouse_map_twin.assign((m_width+1) * (m_height+1), 0); // clears the twin map
        // OUTPUT
        int year = m_land->SupplyYearNumber();
        int today = m_land->SupplyDayInYear();
        if ((cfg_rodenticide_dumpmapstartyear.value()>=year)  && (cfg_rodenticide_dumpmapstartyear.value()<=year) &&(cfg_rodenticide_dumpmapday.value()==today) )
        {
                DumpRodenticideMap("RodenticideMap.txt");
        }
        if ((year >= cfg_rodenticide_dumppolystartyear.value())  && (year <= cfg_rodenticide_dumppolyendyear.value()) )
        {
                if (today % cfg_rodenticide_dumppolyinterval.value()==0) RecordRodenticidePolyData("RodenticidePolyData.txt");
        }
}

Member Data Documentation

vector<BaitLocation> RodenticideManager::m_BaitList

protected

List of bait locations.

double RodenticideManager::m_deathRate

protected

poisoned mice death rate

double RodenticideManager::m_diffusionRate

protected

poisoned mice diffusion rate

int RodenticideManager::m_gridsize

protected

rodenticide grid size - also affect diffusion rate

int RodenticideManager::m_height

protected

int RodenticideManager::m_heightm1

protected

double RodenticideManager::m_immigrationRate

protected

poisoned mice immigration rate

Landscape* RodenticideManager::m_land

protected

Landscape pointer.

vector<double> RodenticideManager::m_pmouse_map_main

protected

Map of probability of encountering a poisoned mouse.

vector<double> RodenticideManager::m_pmouse_map_twin

protected

Temporary map for calculation poisoned mouse diffusion.

int RodenticideManager::m_seasonstartprob[tbl_foobar][1000]

protected

season start probability distribution

int RodenticideManager::m_width

protected

Landscape dimensions.

---

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

• Rodenticide.h
• Rodenticide.cpp