Pesticide Class Reference

#include <pesticide.h>

Public Member Functions
void	DailyQueueAdd (LE *a_element_sprayed, double a_amount, PlantProtectionProducts a_ppp)
void	DiffusionMaskInitTest (void)
bool	GetAnythingToDecay (PlantProtectionProducts a_ppp)
	Pesticide (RasterMap *a_land, Landscape *a_map)
bool	SavePPM (double *a_map, int a_beginx, int a_width, int a_beginy, int a_height, char *a_filename)
double	SupplyPesticide (int a_polyref, PlantProtectionProducts a_ppp)
double	SupplyPesticide (int a_x, int a_y, PlantProtectionProducts a_ppp)
void	Tick (void)
virtual	~Pesticide (void)

Protected Member Functions
void	CalcRainWashOffFactors ()
	Pre-calculates the constants required for rain wash off with increasing rainfall and stores this in m_RainWashoffFactor. More...
void	DailyQueueClear (PlantProtectionProducts a_ppp)
void	DailyQueueProcess (PlantProtectionProducts a_ppp)
double	DiffusionFunction (double a_dist_meters)
void	DiffusionMaskInit (void)
void	DiffusionSprayPixel (int a_x, int a_limit_x, int a_y, int a_limit_y, double a_amount, double a_cover, PlantProtectionProducts a_ppp)
bool	ElementIsWater (int a_x, int a_y)
void	MainMapDecay (PlantProtectionProducts a_ppp)
void	TwinMapClear (int a_minx, int a_miny, int a_maxx, int a_maxy)
void	TwinMapDiffusion (int a_minx, int a_miny, int a_maxx, int a_maxy, double a_cover, PlantProtectionProducts a_ppp)
void	TwinMapSpray (LE *a_element_spryaed, double a_amount, int a_minx, int a_miny, int a_maxx, int a_maxy)
void	TwinMapSprayCorrectBorders (void)
void	TwinMapSprayPixel (int a_large_map_x, int a_large_map_y, double a_fractional_amount)

Protected Attributes
double	m_corr_x
double	m_corr_y
vector< vector< PesticideEvent * > >	m_daily_spray_queue
	List lists of landscape elements, which was sprayed on a given day. One for each PPP we track. More...
Diffusion_mask	m_diffusion_mask [4]
	Pre-calculated square diffusion map, assuming wind directions (4) Used after spraying an element in the pesticide map to determine how much of the sprayed material spreads into the surroundings. More...
RasterMap *	m_land
Landscape *	m_map
int	m_NoPPPs
	The number of active PPPs to track. More...
double	m_pest_daily_decay_frac
double	m_pest_daily_decay_frac_Soil
double	m_pest_daily_decay_frac_Veg
unsigned int	m_pest_map_height
	The height of one map in cellsize resolution. More...
vector< vector< double > >	m_pest_map_main
unsigned int	m_pest_map_size
	The total size of one map in cellsize resolution. More...
double *	m_pest_map_twin
	The complete pesticide map. More...
unsigned int	m_pest_map_width
	The width of one map in cellsize resolution. More...
double	m_prop
unsigned	m_rainfallcategory
	Daily rainfall saved here * 100 to use as an index to the Pesticide::m_RainWashoffFactor array - an optimisation to stop repeated calls to Landscape::SupplyRain. More...
double	m_RainWashoffFactor [10000]
	a structure to hold pre-calculated pesticide rain wash off factor (Rw) More...
bool	m_something_to_decay [ppp_foobar]
	Speed hack. Only actually run the daily decay routine on the pesticide map if and only if we are sure that there is some pesticide anywhere on the map for us to process. More...
int	m_wind
int	m_x_excess
int	m_y_excess

Detailed Description

Definition at line 106 of file pesticide.h.

Constructor & Destructor Documentation

Pesticide()

Pesticide::Pesticide	(	RasterMap *	a_land,
		Landscape *	a_map
	)

First determine the size of the maps we need in terms of the number of PPPs to track

For vegetation fraction, the decay is based on ln(2)/DT50

For soil fraction, the decay is based on 10^(log10(0.5) /DT50)

Definition at line 526 of file pesticide.cpp.

{
        if ( l_pest_enable_pesticide_engine.value())
        {
                m_NoPPPs = l_pest_NoPPPs.value();
                m_map = a_map;
                m_land = a_land;
                for (int i=0; i< m_NoPPPs; i++) m_something_to_decay[i] = false;
                m_daily_spray_queue.resize(m_NoPPPs);
 
                // Figure out critical border coordinates,
                // proportional fractions etc.
                m_prop     = 1.0 / ((double)(PEST_GRIDAREA));
                m_x_excess = m_land->MapWidth() & (PEST_GRIDSIZE-1);
                if ( m_x_excess ) {
                        m_corr_x   = (double)PEST_GRIDSIZE /(double)m_x_excess;
                }
                m_y_excess = m_land->MapHeight() & (PEST_GRIDSIZE-1);
                if ( m_y_excess ) {
                        m_corr_y = (double)PEST_GRIDSIZE / (double)m_y_excess;
                }
 
                m_pest_map_width = m_land->MapWidth() >> PEST_GRIDSIZE_POW2; // landscape width divided by the sqrt(cellsize)  e.g. cellsize 4 and landscape width = 10000, result is 10000/(sqrt(4) = 5000
                if ( m_land->MapWidth() & (PEST_GRIDSIZE-1))
                        m_pest_map_width++;
 
                m_pest_map_height = m_land->MapHeight() >> PEST_GRIDSIZE_POW2;
                if ( m_land->MapHeight() & (PEST_GRIDSIZE-1))
                        m_pest_map_height++;
 
                m_pest_map_size = m_pest_map_width * m_pest_map_height;
 
                m_pest_map_twin = new double[m_pest_map_size];
#ifdef __DETAILED_PESTICIDE_FATE
                m_pest_map_vegcanopy.resize(m_NoPPPs);
                m_pest_map_soil.resize(m_NoPPPs);
#else
                m_pest_map_main.resize(m_NoPPPs);
#endif
                for (int p = 0; p < m_NoPPPs; p++) {
#ifdef __DETAILED_PESTICIDE_FATE
                        m_pest_map_vegcanopy[p].resize(m_pest_map_size);
                        m_pest_map_soil[p].resize(m_pest_map_size);
                        fill(m_pest_map_vegcanopy[p].begin(), m_pest_map_vegcanopy[p].end(), 0.0);
                        fill(m_pest_map_soil[p].begin(), m_pest_map_soil[p].end(), 0.0);
#else
                        m_pest_map_main[p].resize(m_pest_map_size);
                        fill(m_pest_map_main[p].begin(), m_pest_map_main[p].end(), 0.0);
                
#endif
                        m_daily_spray_queue[p].resize(0);
                }
                
                for (unsigned int i = 0; i < m_pest_map_size; i++) m_pest_map_twin[i] = 0.0;    
 
                m_pest_daily_decay_frac = pow(10.0, log10(0.5) / l_pest_ai_half_life.value());
#ifdef __BORLANDC__
                m_pest_daily_decay_frac_Veg = log(double(2.0))/l_pest_ai_half_life_Veg.value();
#else
                m_pest_daily_decay_frac_Veg = log(2.0)/l_pest_ai_half_life_Veg.value();
#endif
 
                m_pest_daily_decay_frac_Soil = pow(10.0, log10(0.5) / l_pest_ai_half_life_Soil.value());
                // This calculates
                CalcRainWashOffFactors();
                DiffusionMaskInit();
                DiffusionMaskInitTest();
        }
}

References CalcRainWashOffFactors(), DiffusionMaskInit(), DiffusionMaskInitTest(), l_pest_ai_half_life, l_pest_ai_half_life_Soil, l_pest_ai_half_life_Veg, l_pest_enable_pesticide_engine, l_pest_NoPPPs, m_corr_x, m_corr_y, m_daily_spray_queue, m_land, m_map, m_NoPPPs, m_pest_daily_decay_frac, m_pest_daily_decay_frac_Soil, m_pest_daily_decay_frac_Veg, m_pest_map_height, m_pest_map_main, m_pest_map_size, m_pest_map_twin, m_pest_map_width, m_prop, m_something_to_decay, m_x_excess, m_y_excess, RasterMap::MapHeight(), RasterMap::MapWidth(), PEST_GRIDAREA, PEST_GRIDSIZE, PEST_GRIDSIZE_POW2, CfgInt::value(), CfgFloat::value(), and CfgBool::value().

~Pesticide()

Pesticide::~Pesticide ( void  )

virtual

Definition at line 621 of file pesticide.cpp.

{
        if (l_pest_enable_pesticide_engine.value())
        {
                for (int winddir = 0; winddir < 4; winddir++)
                {
                        for (unsigned int i = 0; i < m_diffusion_mask[winddir].size(); i++)
                        {
                                delete m_diffusion_mask[winddir][i];
                        }
                        m_diffusion_mask[winddir].resize(0);
                }
                delete m_pest_map_twin;
        }
}

References l_pest_enable_pesticide_engine, m_diffusion_mask, m_pest_map_twin, and CfgBool::value().

Member Function Documentation

CalcRainWashOffFactors()

void Pesticide::CalcRainWashOffFactors ( )

protected

Pre-calculates the constants required for rain wash off with increasing rainfall and stores this in m_RainWashoffFactor.

Calculates the proportion of pesticide that is washed off the canopy for 0.1 to 10mm of rain and for 0 to 100% cover in 1% steps.

Definition at line 599 of file pesticide.cpp.

{
        double rainsteps = 0.1; // mm, multiply rainfall by 100 to get this, save result as integer
        double coversteps = 1.0; // %, multiply cover by 100 to get this, save result as integer
        for (int i = 0; i < 100; i++)
        {
                double SC = i * coversteps;
                double LAI = log(0 - (1 - SC))*1.666666667; // This is the inverse of Beer's Law
                for (int r = 0; r < 100; r++)
                {
                        double P = r * rainsteps;
                        double Pi = LAI*(1 - (1 / ((1 + SC * P) / LAI)));
                        double Rw = 0.25*(SC * P - Pi); // Rw is a proportion of canopy pesticide washed off.
                        m_RainWashoffFactor[r * 100 + i] = Rw;
                }
        }
}

References m_RainWashoffFactor.

Referenced by Pesticide().

DailyQueueAdd()

void Pesticide::DailyQueueAdd	(	LE *	a_element_sprayed,
		double	a_amount,
		PlantProtectionProducts	a_ppp
	)

Definition at line 140 of file pesticide.cpp.

{
  PesticideEvent *l_event = new PesticideEvent( a_element_sprayed, a_amount, a_ppp );
    m_daily_spray_queue[a_ppp].push_back(l_event);
}

References m_daily_spray_queue.

Referenced by Orchard::DoDevelopment(), OrchardBand::DoDevelopment(), Farm::ProductApplication(), and Farm::ProductApplication_DateLimited().

DailyQueueClear()

void Pesticide::DailyQueueClear ( PlantProtectionProducts  a_ppp )

protected

Empties and resets the pesticide action queue. On calling any event not yet carried out will be deleted.

Definition at line 131 of file pesticide.cpp.

{
        if (! m_daily_spray_queue[a_ppp].empty())  m_daily_spray_queue[a_ppp].resize( 0 );
}

References m_daily_spray_queue.

Referenced by Tick().

DailyQueueProcess()

void Pesticide::DailyQueueProcess ( PlantProtectionProducts  a_ppp )

protected

If we are spraying at least one field. Force the main pesticide map which forces the decay method to run tomorrow. First we add the amount in m_amount to the twin map (all squares covered with the polygon get m_amount added) using TwinMapSpray
Next this twin map is added to the main map and if necessary it is here we sort out the allocation between vegetation canopy and soil fractions. This is done by TwinMapDiffusion

Definition at line 147 of file pesticide.cpp.

{
        if (0 == m_daily_spray_queue[a_ppp].size())
    // Event queue empty, nobody sprayed anything today.
    return;
 
  // Spraying at least one field. Force the main pesticide map
  // decay method to run tomorrow.
  m_something_to_decay[a_ppp] = true;
 
  for ( unsigned int i=0; i<m_daily_spray_queue[a_ppp].size(); i++ )
  {
          m_wind = g_land->SupplyWindDirection();
          int minx=m_daily_spray_queue[a_ppp][i]->m_sprayed_elem->GetMinX();
          int maxx=m_daily_spray_queue[a_ppp][i]->m_sprayed_elem->GetMaxX();
          int miny=m_daily_spray_queue[a_ppp][i]->m_sprayed_elem->GetMinY();
          int maxy=m_daily_spray_queue[a_ppp][i]->m_sprayed_elem->GetMaxY();
          // For cover we use the crop, and save this for later
          double cover = m_daily_spray_queue[a_ppp][i]->m_sprayed_elem->GetVegCover();
          TwinMapClear(minx, miny, maxx, maxy);
          // Add the amount in m_amount to the twin map (all squares covered with the polygon get m_amount added.
          TwinMapSpray( m_daily_spray_queue[a_ppp][i]->m_sprayed_elem, m_daily_spray_queue[a_ppp][i]->m_amount, minx, miny, maxx, maxy);
          // This adds it to the main map and if necessary sorts out the allocation between veg and soil.
          TwinMapDiffusion(minx, miny, maxx, maxy, cover, a_ppp);
  }
}

References g_land, m_daily_spray_queue, m_something_to_decay, m_wind, Landscape::SupplyWindDirection(), TwinMapClear(), TwinMapDiffusion(), and TwinMapSpray().

Referenced by Tick().

DiffusionFunction()

double Pesticide::DiffusionFunction ( double  a_dist_meters )

protected

The equation provided here is the one that determines the drift of pesticides with distance. It is important that if the drift is set to zero that the result of the equation is unity.

Definition at line 442 of file pesticide.cpp.

{
  double pp;
//   y=(2.753767)*(x+(1.86976))**(-2.121563)
#ifdef __WithinOrchardPesticideSim__
  if (a_dist_meters==0) pp=0.7784;
    else pp=0.0277;
#else
        //pp = (2.7705 * pow(a_dist_meters, -0.9787)) * 0.01; // german drif equation (reference)
        pp = (2.7705 * pow(a_dist_meters, -1.7)) * 0.01; // german drif equation - reduction of drift by 50%
        //pp = (2.7705 * pow(a_dist_meters, -2.5)) * 0.01; // german drif equation - reduction of drift by 75%
        //pp = (2.7705 * pow(a_dist_meters, -3.5)) * 0.01; // german drif equation - reduction of drift by 90%
 
    //pp=2.753767 * pow(( a_dist_meters+1.86976 ), -2.121563); // based on drift data from the spray drift calculator within FOCUS's surface water scenarios SWASH software (FOCUS, 2001)
    //pp= exp( l_pest_diffusion_slope.value() * a_dist_meters );
    pp=pow(( a_dist_meters+1 ), l_pest_diffusion_slope.value() );
    //pp = (2.7593 * pow(a_dist_meters,-0.9778)) * 0.001;
    if (pp<(l_pest_zero_threshold.value()/10)) pp=0;  // Don't bother with the little ones
#endif
   return pp;
}

References l_pest_diffusion_slope, l_pest_zero_threshold, and CfgFloat::value().

Referenced by DiffusionMaskInit().

DiffusionMaskInit()

void Pesticide::DiffusionMaskInit ( void  )

protected

l_pest_diffusion_grid_count contains the number of grid points to consider e.g. 1 will be a grid of 9 squares centred at the spray point, 2 will be 25 squares (2*2+1)^2 , 3 will be 49, etc..
The proportion of the applicationcation rate assuming it was sprayed in the centre square is calculated for each surrounding square. Wind direction is taken into account and the mask is created for four wind directions and saved.

Definition at line 325 of file pesticide.cpp.

{
  int l_grid        = l_pest_diffusion_grid_count.value();
  const int l_side_length = l_grid * 2 + 1;
  double* l_diff;
  l_diff = new double[l_side_length];
  int cells = 1;
  double sum = 1.0;
  l_diff[0] = 1.0;
  for (int l=1; l<l_side_length; l++)
  {
        l_diff[l] = DiffusionFunction(l);
        sum += l_diff[l];
  }
  for (int l=0; l<l_side_length; l++)
  {
        l_diff[l] /= sum;
        l_diff[l] /= cells;
        cells += 2; // 2 more cells per row away from centre square
  }
  // Calculated for 4 wind directions
  for (int wind=0; wind < 4; wind ++)
  {
          m_diffusion_mask[wind].resize( l_side_length * l_side_length );
          for ( int x = 0; x< l_side_length; x++ )
          {
                for ( int y= 0; y< l_side_length; y++ )
                {
                  m_diffusion_mask[wind][x + y * l_side_length] = new Diffusor( x, y, 0);  // first zero all values
                }
          }
  }
  int strtx = l_grid;
  int strty = l_grid;
  int fin = 1;
  // North
  for (int step = 0; step <= l_grid; step++)
     {
          for (int cc=0; cc<fin; cc++)
          {
                  m_diffusion_mask[0][ strtx + (cc-step) + ((strty-step)*l_side_length)]->SetFraction(l_diff[step]);
          }
  fin += 2;
  }
  // South
  fin = 1;
  for (int step = 0; step <= l_grid; step++)
     {
          for (int cc=0; cc<fin; cc++)
          {
                  m_diffusion_mask[2][ strtx + (cc-step) + ((strty+step)*l_side_length)]->SetFraction(l_diff[step]);
          }
          fin += 2;
  }
  // East
  fin = 1;
  for (int step = 0; step <= l_grid; step++)
     {
          for (int cc=0; cc<fin; cc++)
          {
                  m_diffusion_mask[3][ (strtx + step) + ((strty+(cc-step))*l_side_length)]->SetFraction(l_diff[step]);
          }
          fin += 2;
  }
  // West
  fin = 1;
  for (int step = 0; step <= l_grid; step++)
     {
          for (int cc=0; cc<fin; cc++)
          {
                  m_diffusion_mask[1][ (strtx - step) + ((strty+(cc-step))*l_side_length)]->SetFraction(l_diff[step]);
          }
          fin += 2;
  }
 
  delete[] l_diff;
}

References DiffusionFunction(), l_pest_diffusion_grid_count, m_diffusion_mask, and CfgInt::value().

Referenced by Pesticide().

DiffusionMaskInitTest()

void Pesticide::DiffusionMaskInitTest

(

void

)

Definition at line 640 of file pesticide.cpp.

{
  int l_grid        = l_pest_diffusion_grid_count.value();
  const int l_side_length = l_grid * 2 + 1;
 
 // Need a debug test, output all diffusion masks to file
  ofstream ofile("diffusionmask.txt",ios::out);
  for (int i=0; i<4; i++)
  {
          for ( int x = 0; x< l_side_length; x++ )
          {
                  for ( int y= 0; y< l_side_length; y++ )
                  {
                          ofile << m_diffusion_mask[i][x+(y*l_side_length)]->GetFraction() << '\t';
                  }
                  ofile << endl;
          }
          ofile << endl;
          ofile << endl;
  }
  ofile.close();
 }

References l_pest_diffusion_grid_count, m_diffusion_mask, and CfgInt::value().

Referenced by Pesticide().

DiffusionSprayPixel()

void Pesticide::DiffusionSprayPixel ( int  a_x, int  a_limit_x, int  a_y, int  a_limit_y, double  a_amount, double  a_cover, PlantProtectionProducts  a_ppp  )

inlineprotected

This sprays the pesticide (a_amount) by placing this into a pesticide cell in the main map. If more detailed pesticide fate is needed then a_amount will be partitioned between soil and canopy.
First a test is made to ensure that the coordinates given are within the landscape. If not the pesticide is sprayed off world, and lost.
Partioning, if occuring, is done based on two components - the canopy and the soil. The pesticide is partioned between the two based on the asssumed vegetation cover of the crop based on Beer's Law.

Definition at line 301 of file pesticide.cpp.

{
        // First we have to do the typical out of bounds checks - if these fail do nothing, the pesticide fell off the world
        if (a_x < 0 || a_x >= a_limit_x || a_y < 0 || a_y >= a_limit_y) return;
        // Now calculate the coordinate entry in the array and store this as l_coord
        int l_coord = a_y * a_limit_x + a_x;
#ifdef __DETAILED_PESTICIDE_FATE
        // Here we need to calculate the partition of pesticide into two compartments.
        m_pest_map_vegcanopy[a_ppp][l_coord] += a_amount * a_cover;
        m_pest_map_soil[a_ppp][l_coord] += a_amount - m_pest_map_vegcanopy[a_ppp][l_coord];
#else
        m_pest_map_main[a_ppp][l_coord] += a_amount;
#endif
}

References m_pest_map_main.

Referenced by TwinMapDiffusion().

ElementIsWater()

bool Pesticide::ElementIsWater ( int  a_x, int  a_y  )

inlineprotected

Definition at line 263 of file pesticide.h.

{
  TTypesOfLandscapeElement l_eletype =
    m_map->SupplyElementType( a_x, a_y );
 
  if ( l_eletype == tole_Freshwater ||
       l_eletype == tole_River      ||
           l_eletype == tole_Pond       ||
           l_eletype == tole_FishFarm   ||
       l_eletype == tole_Saltwater
       )
    return true;
 
  return false;
}

References m_map, Landscape::SupplyElementType(), tole_FishFarm, tole_Freshwater, tole_Pond, tole_River, and tole_Saltwater.

Referenced by SupplyPesticide().

GetAnythingToDecay()

bool Pesticide::GetAnythingToDecay ( PlantProtectionProducts  a_ppp )

inline

Definition at line 228 of file pesticide.h.

{ return (m_something_to_decay[a_ppp]); }

References m_something_to_decay.

Referenced by Landscape::SupplyPesticideDecay().

MainMapDecay()

void Pesticide::MainMapDecay ( PlantProtectionProducts  a_ppp )

protected

This is where the environmental decay takes place. Here we assume a first order decay based on a daily proportion of the cell total. If using detailed fate modelling then is calculation is more complex.

This is where the environmental decay takes place. Here we assume a first order decay based on a daily proportion of the cell total. If using detailed fate modelling then is calculation is more complex.

Definition at line 469 of file pesticide.cpp.

{
        if ( ! m_something_to_decay[a_ppp] )    return;
        double l_zero         = l_pest_zero_threshold.value();
        m_something_to_decay[a_ppp] = false;
        for ( unsigned int i=0; i<m_pest_map_size; i++ )
        {
#ifdef __DETAILED_PESTICIDE_FATE
                if ((m_pest_map_vegcanopy[a_ppp][i] > l_zero) )
                {
                        //Calculate wash-off  m_pest_map_width * m_pest_map_height y * m_pest_map_width + x
                        int x = ( i % m_pest_map_width ) << PEST_GRIDSIZE_POW2;
                        int y = ( i / m_pest_map_width ) << PEST_GRIDSIZE_POW2;
                        double cover = g_landscape_p->SupplyVegCover(x,y);
                        unsigned cov = 100 * cover; // Cover is steps of zero to 99, may need to check for bounds here (may get cover of 1.0 ?)
                        double Rwp = m_pest_map_vegcanopy[a_ppp][i] *= m_RainWashoffFactor[m_rainfallcategory+cov]; // m_RainWashoffFactor is the index to the array
                        m_pest_map_soil[a_ppp][i] = (m_pest_map_soil[a_ppp][i] + Rwp) * m_pest_daily_decay_frac_Soil;
                        m_pest_map_vegcanopy[a_ppp][i] -= Rwp;
                        m_pest_map_vegcanopy[a_ppp][i] *= m_pest_daily_decay_frac_Veg;
                        m_something_to_decay[a_ppp] = true;
                }
                else
                {
                        if (m_pest_map_soil[a_ppp][i] > l_zero)
                        {
                                m_pest_map_soil[a_ppp][i] = m_pest_map_soil[a_ppp][i] * m_pest_daily_decay_frac_Soil;
                                m_something_to_decay[a_ppp] = true;
                        }
                        else
                        {
                                m_pest_map_vegcanopy[a_ppp][i] = 0.0;
                                m_pest_map_soil[a_ppp][i] = 0.0;
                        }
                }
#else
          if (m_pest_map_main[a_ppp][i] > l_zero)
          {
                  m_pest_map_main[a_ppp][i]       *= m_pest_daily_decay_frac;
                  m_something_to_decay[a_ppp]      = true;
          }
          else
          {
                  m_pest_map_main[a_ppp][i]        = 0.0;
          }
#endif
  }
}

References g_landscape_p, l_pest_zero_threshold, m_pest_daily_decay_frac, m_pest_daily_decay_frac_Soil, m_pest_daily_decay_frac_Veg, m_pest_map_main, m_pest_map_size, m_pest_map_width, m_rainfallcategory, m_RainWashoffFactor, m_something_to_decay, PEST_GRIDSIZE_POW2, Landscape::SupplyVegCover(), and CfgFloat::value().

Referenced by Tick().

SavePPM()

bool Pesticide::SavePPM	(	double *	a_map,
		int	a_beginx,
		int	a_width,
		int	a_beginy,
		int	a_height,
		char *	a_filename
	)

Definition at line 673 of file pesticide.cpp.

{
  a_beginx = 0;
  a_width  = m_pest_map_width;
  a_beginy = 0;
  a_height = m_pest_map_height;
 
  SV_UINT32 linesize   = a_width*3;
  SV_UINT8* linebuffer = (SV_UINT8*)malloc(sizeof(SV_UINT8)* linesize);
 
  if ( linebuffer == NULL ) {
    g_msg->Warn( WARN_FATAL,
                 "Pesticide::SavePPM(): Out of memory!", "" );
    exit(1);
  }
 
  FILE* l_file;
  l_file=fopen(a_filename, "w" );
  if ( !l_file ) {
    printf("PesticideTest::SavePPM(): "
           "Unable to open file for writing: %s\n",
           a_filename );
    exit(1);
  }
 
  fprintf( l_file, "P6\n%d %d %d\n",
           a_width,
           a_height,
           255 );
 
  for ( int line=a_beginy; line< a_beginy + a_height; line++ ) {
    int i = 0;
    for ( int column=a_beginx; column < a_beginx + a_width; column++ ) {
      int localcolor = (int)( a_map[ line * m_pest_map_width + column ]
                                  * 255.0);
      if ( localcolor <= 255 ) {
        linebuffer [ i++ ] =  char (localcolor        & 0xff);
        linebuffer [ i++ ] = 0;
        linebuffer [ i++ ] = 0;
      } else {
        linebuffer [ i++ ] = 255;
        localcolor -= 255;
        if ( localcolor <= 255 ) {
          linebuffer [ i++ ] = char (localcolor);
          linebuffer [ i++ ] = 0;
        } else {
          linebuffer [ i++ ] = 255;
          localcolor -= 255;
          if ( localcolor <= 255 ) {
            linebuffer [ i++ ] = char (localcolor);
          } else {
            linebuffer [ i++ ] = 255;
          }
        }
      }
    }
    fwrite( linebuffer, sizeof(SV_UINT8), linesize, l_file );
  }
 
  fclose( l_file );
  free( linebuffer );
  return true;
}

References g_msg, m_pest_map_height, m_pest_map_width, SV_UINT32, SV_UINT8, MapErrorMsg::Warn(), and WARN_FATAL.

SupplyPesticide() [1/2]

double Pesticide::SupplyPesticide ( int  a_polyref, PlantProtectionProducts  a_ppp  )

inline

Definition at line 347 of file pesticide.h.

{
        // This is an approximation because we have no idea about the actual variation
        // in pesticide concentrations within the polygon.
        int l_c = m_map->SupplyPesticideCell(a_ele);
        return m_pest_map_main[a_ppp][l_c];
}

References m_map, m_pest_map_main, and Landscape::SupplyPesticideCell().

SupplyPesticide() [2/2]

double Pesticide::SupplyPesticide ( int  a_x, int  a_y, PlantProtectionProducts  a_ppp  )

inline

Parameters

a_x	the x-coord in landscape x units
a_y	the y-coord in landscape x units

Returns

Returns the value of the pesticide grid cell containing a_x,a_y

Definition at line 329 of file pesticide.h.

{
#ifdef PEST_WATER_CHECK
        if (ElementIsWater(a_x, a_y))
                return 0.0;
#endif
 
        int l_x = a_x >> PEST_GRIDSIZE_POW2;
        int l_y = a_y >> PEST_GRIDSIZE_POW2;
 
        return m_pest_map_main[a_ppp][l_y * m_pest_map_width + l_x];
}

References ElementIsWater(), m_pest_map_main, m_pest_map_width, and PEST_GRIDSIZE_POW2.

Referenced by Landscape::SupplyPesticide(), Landscape::SupplyPesticideP(), and Landscape::SupplyPesticideS().

Tick()

void Pesticide::Tick

(

void

)

Definition at line 97 of file pesticide.cpp.

{
        if (!l_pest_enable_pesticide_engine.value())
        {
                return;
        }
        // Calculate DT50 rates
        // DT50 will change by the rate of 0.22 extra per degree different from 20
        double temp = g_weather->GetTemp();
        double Dt50 = l_pest_ai_half_life.value()* exp(0.094779*(20 - temp));
 
        m_pest_daily_decay_frac = pow(10.0, log10(0.5) / Dt50);
        // Get todays rainfall
        m_rainfallcategory = (unsigned)floor(g_land->SupplyRain() * 100 + 0.5);
        if (m_rainfallcategory >= 100) m_rainfallcategory = 99;
        // Now make it an index to the 100x100 array.
        m_rainfallcategory *= 100;
        if (!l_pest_enable_pesticide_engine.value())
        {
                for (int ppp = ppp_1; ppp < m_NoPPPs; ppp++)
                {
                        DailyQueueClear((PlantProtectionProducts) ppp);
                }
                return;
        }
        for (int ppp = ppp_1; ppp < m_NoPPPs; ppp++)
        {
                MainMapDecay((PlantProtectionProducts)ppp);
                DailyQueueProcess((PlantProtectionProducts)ppp);
                DailyQueueClear((PlantProtectionProducts)ppp);
        }
}

References DailyQueueClear(), DailyQueueProcess(), g_land, g_weather, Weather::GetTemp(), l_pest_ai_half_life, l_pest_enable_pesticide_engine, m_NoPPPs, m_pest_daily_decay_frac, m_rainfallcategory, MainMapDecay(), ppp_1, Landscape::SupplyRain(), CfgFloat::value(), and CfgBool::value().

Referenced by Landscape::Tick().

TwinMapClear()

void Pesticide::TwinMapClear ( int  a_minx, int  a_miny, int  a_maxx, int  a_maxy  )

protected

Definition at line 181 of file pesticide.cpp.

{
        for ( int y=a_miny; y<=a_maxy; y++ )
        {
                int t = y * m_pest_map_width;
                for ( int x=a_minx; x<=a_maxx; x++ )
                {
                        m_pest_map_twin[t + x] = 0.0;
                }
        }
}

References m_pest_map_twin, and m_pest_map_width.

Referenced by DailyQueueProcess().

TwinMapDiffusion()

void Pesticide::TwinMapDiffusion ( int  a_minx, int  a_miny, int  a_maxx, int  a_maxy, double  a_cover, PlantProtectionProducts  a_ppp  )

protected

Definition at line 276 of file pesticide.cpp.

{
        for ( int y=a_miny; y<a_maxy; y++ )
        {
                int t = y*m_pest_map_width;
                for ( int x=a_minx; x<a_maxx; x++ )
                {
                        if ( m_pest_map_twin[ t + x ] > 0.0 )
                        {
                                double l_amount = m_pest_map_twin[ t + x ];
                                for ( unsigned int i=0; i<m_diffusion_mask[m_wind].size(); i++ )
                                {
                                        // This adds the pesticide to the main map - simply adds the calculated amount.
                                        DiffusionSprayPixel( x + m_diffusion_mask[m_wind][i]->Getdx(),m_pest_map_width,y + m_diffusion_mask[m_wind][i]->Getdy(),
                                                m_pest_map_height,m_diffusion_mask[m_wind][i]->GetFraction() *l_amount, a_cover, a_ppp);
                                }
                        }
                }
        }
}

References DiffusionSprayPixel(), m_diffusion_mask, m_pest_map_height, m_pest_map_twin, m_pest_map_width, and m_wind.

Referenced by DailyQueueProcess().

TwinMapSpray()

void Pesticide::TwinMapSpray ( LE *  a_element_spryaed, double  a_amount, int  a_minx, int  a_miny, int  a_maxx, int  a_maxy  )

protected

This is where the initial pesticide concentration is applied to the map. A twin of the real maps is used for spraying the amount of pesticide that is sprayed over each cell and then copied to the real one by using a 'diffusion' process to spread it out to all surrounding cells for drift.

Going through the whole landscape is very slow and unnecessary for small polygons. Since our polygons do not extend beyond the edge of the map ie do not wrap round, then we only need a measure of minx, maxx, miny, maxy. This is set up at the start of the simulation.

Definition at line 194 of file pesticide.cpp.

{
        /* Replaced with more detailed fate code for EFSA June 2014
        if (l_pest_use_application_rate.value()) {
                // We are applying a field rate. The actual residue needs to be calculated here
                double biomass = a_element_sprayed->GetVegBiomass();
                double cover = a_element_sprayed->GetVegCover();
                // rate is in mg/m and needs to be converted to mg/kg
                double residue = (a_amount/(biomass*0.001)) * 0.435855; // g to kg veg  // 0.435855 is a specific calculation to obtain the same residue that Joe Crocker used for the scale of use study
                a_amount = residue * cover;
        }
        */
        double l_fractional_amount = a_amount * m_prop; //  m_prop is a constant related to the grid area (i.e. how many squares are in one grid square).
        int l_large_map_index = a_element_sprayed->GetMapIndex();
        for ( int y=a_miny; y<=a_maxy; y++ ) {
                for ( int x=a_minx; x<=a_maxx; x++ ) {
                        if ( m_land->Get( x, y ) == l_large_map_index )
                        {
                                // This adds the l_fractional_amount to the twin map
                                TwinMapSprayPixel( x, y, l_fractional_amount );
                        }
                }
        }
        TwinMapSprayCorrectBorders();
}

References RasterMap::Get(), LE::GetMapIndex(), m_land, m_prop, TwinMapSprayCorrectBorders(), and TwinMapSprayPixel().

Referenced by DailyQueueProcess().

TwinMapSprayCorrectBorders()

void Pesticide::TwinMapSprayCorrectBorders ( void  )

protected

Definition at line 230 of file pesticide.cpp.

{
  if ( m_x_excess ) {
   for ( unsigned int i=0; i<m_pest_map_width-1; i++ ) {
      m_pest_map_twin[ i * m_pest_map_width + m_pest_map_height-1 ] *=  m_corr_x;
    }
  }
 
  if ( m_y_excess ) {
    unsigned int l_additive = (m_pest_map_height-1)*m_pest_map_width;
    for ( unsigned int i=0; i<m_pest_map_height-1; i++ ) {
      m_pest_map_twin[ i + l_additive ] *=      m_corr_y;
    }
  }
 
  if ( m_x_excess && m_y_excess ) {
    m_pest_map_twin[ m_pest_map_size-1 ] *= (((double)(PEST_GRIDAREA)) / ((double)(m_x_excess*m_y_excess)));
  }
}

References m_corr_x, m_corr_y, m_pest_map_height, m_pest_map_size, m_pest_map_twin, m_pest_map_width, m_x_excess, m_y_excess, and PEST_GRIDAREA.

Referenced by TwinMapSpray().

TwinMapSprayPixel()

void Pesticide::TwinMapSprayPixel ( int  a_large_map_x, int  a_large_map_y, double  a_fractional_amount  )

inlineprotected

Definition at line 357 of file pesticide.h.

{
        int l_x = a_large_map_x >> PEST_GRIDSIZE_POW2;
        int l_y = a_large_map_y >> PEST_GRIDSIZE_POW2;
 
        m_pest_map_twin[l_y * m_pest_map_width + l_x] +=
                a_fractional_amount;
}

References m_pest_map_twin, m_pest_map_width, and PEST_GRIDSIZE_POW2.

Referenced by TwinMapSpray().

Member Data Documentation

m_corr_x

double Pesticide::m_corr_x

protected

Definition at line 157 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

m_corr_y

double Pesticide::m_corr_y

protected

Definition at line 158 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

m_daily_spray_queue

vector<vector <PesticideEvent*> > Pesticide::m_daily_spray_queue

protected

List lists of landscape elements, which was sprayed on a given day. One for each PPP we track.

Definition at line 200 of file pesticide.h.

Referenced by DailyQueueAdd(), DailyQueueClear(), DailyQueueProcess(), and Pesticide().

m_diffusion_mask

Diffusion_mask Pesticide::m_diffusion_mask[4]

protected

Pre-calculated square diffusion map, assuming wind directions (4)
Used after spraying an element in the pesticide map to determine how much of the sprayed material spreads into the surroundings.

Definition at line 197 of file pesticide.h.

Referenced by DiffusionMaskInit(), DiffusionMaskInitTest(), TwinMapDiffusion(), and ~Pesticide().

m_land

RasterMap* Pesticide::m_land

protected

Definition at line 168 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSpray().

m_map

Landscape* Pesticide::m_map

protected

Definition at line 171 of file pesticide.h.

Referenced by ElementIsWater(), Pesticide(), and SupplyPesticide().

m_NoPPPs

int Pesticide::m_NoPPPs

protected

The number of active PPPs to track.

Definition at line 149 of file pesticide.h.

Referenced by Pesticide(), and Tick().

m_pest_daily_decay_frac

double Pesticide::m_pest_daily_decay_frac

protected

Definition at line 163 of file pesticide.h.

Referenced by MainMapDecay(), Pesticide(), and Tick().

m_pest_daily_decay_frac_Soil

double Pesticide::m_pest_daily_decay_frac_Soil

protected

Definition at line 165 of file pesticide.h.

Referenced by MainMapDecay(), and Pesticide().

m_pest_daily_decay_frac_Veg

double Pesticide::m_pest_daily_decay_frac_Veg

protected

Definition at line 164 of file pesticide.h.

Referenced by MainMapDecay(), and Pesticide().

m_pest_map_height

unsigned int Pesticide::m_pest_map_height

protected

The height of one map in cellsize resolution.

Definition at line 188 of file pesticide.h.

Referenced by Pesticide(), SavePPM(), TwinMapDiffusion(), and TwinMapSprayCorrectBorders().

m_pest_map_main

vector<vector <double> > Pesticide::m_pest_map_main

protected

Definition at line 179 of file pesticide.h.

Referenced by DiffusionSprayPixel(), MainMapDecay(), Pesticide(), and SupplyPesticide().

m_pest_map_size

unsigned int Pesticide::m_pest_map_size

protected

The total size of one map in cellsize resolution.

Definition at line 184 of file pesticide.h.

Referenced by MainMapDecay(), Pesticide(), and TwinMapSprayCorrectBorders().

m_pest_map_twin

double* Pesticide::m_pest_map_twin

protected

The complete pesticide map.

Definition at line 182 of file pesticide.h.

Referenced by Pesticide(), TwinMapClear(), TwinMapDiffusion(), TwinMapSprayCorrectBorders(), TwinMapSprayPixel(), and ~Pesticide().

m_pest_map_width

unsigned int Pesticide::m_pest_map_width

protected

The width of one map in cellsize resolution.

Definition at line 186 of file pesticide.h.

Referenced by MainMapDecay(), Pesticide(), SavePPM(), SupplyPesticide(), TwinMapClear(), TwinMapDiffusion(), TwinMapSprayCorrectBorders(), and TwinMapSprayPixel().

m_prop

double Pesticide::m_prop

protected

Definition at line 156 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSpray().

m_rainfallcategory

unsigned Pesticide::m_rainfallcategory

protected

Daily rainfall saved here * 100 to use as an index to the Pesticide::m_RainWashoffFactor array - an optimisation to stop repeated calls to Landscape::SupplyRain.

Definition at line 193 of file pesticide.h.

Referenced by MainMapDecay(), and Tick().

m_RainWashoffFactor

double Pesticide::m_RainWashoffFactor[10000]

protected

a structure to hold pre-calculated pesticide rain wash off factor (Rw)

Definition at line 191 of file pesticide.h.

Referenced by CalcRainWashOffFactors(), and MainMapDecay().

m_something_to_decay

bool Pesticide::m_something_to_decay[ppp_foobar]

protected

Speed hack. Only actually run the daily decay routine on the pesticide map if and only if we are sure that there is some pesticide anywhere on the map for us to process.

Cleared daily by MainMapDecay().

Set to true when either adding pesticide to the map, or by the MainMapDecay() method itself, when it finds remains of pesticide anywhere on the pesticide map during its run. One copy is needed for each active PPP

Definition at line 146 of file pesticide.h.

Referenced by DailyQueueProcess(), GetAnythingToDecay(), MainMapDecay(), and Pesticide().

m_wind

int Pesticide::m_wind

protected

Definition at line 159 of file pesticide.h.

Referenced by DailyQueueProcess(), and TwinMapDiffusion().

m_x_excess

int Pesticide::m_x_excess

protected

Definition at line 154 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

m_y_excess

int Pesticide::m_y_excess

protected

Definition at line 155 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

---

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

• pesticide.h
• pesticide.cpp