Pesticide Class Reference

#include <pesticide.h>

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

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

Protected Attributes
bool	m_something_to_decay
int	m_x_excess
int	m_y_excess
double	m_prop
double	m_corr_x
double	m_corr_y
int	m_wind
double	m_pest_daily_decay_frac
double	m_pest_daily_decay_frac_Veg
double	m_pest_daily_decay_frac_Soil
RasterMap *	m_land
Landscape *	m_map
double *	m_pest_map_main
double *	m_pest_map_twin
unsigned int	m_pest_map_size
unsigned int	m_pest_map_width
unsigned int	m_pest_map_height
double	m_RainWashoffFactor [10000]
	a structure to hold pre-calculated pesticide rain wash off factor (Rw) More...
unsigned	m_rainfallcategory
	Daily rainfall saved here * 100 to use as an indext to the Pesticide::m_RainWashoffFactor array - an optimisation to stop repeated calls to Landscape::SupplyRain. 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...
vector< PesticideEvent * >	m_daily_spray_queue

Detailed Description

Definition at line 107 of file pesticide.h.

Constructor & Destructor Documentation

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

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 490 of file pesticide.cpp.

References CalcRainWashOffFactors(), DiffusionMaskInit(), DiffusionMaskInitTest(), g_msg, l_pest_ai_half_life, l_pest_ai_half_life_Soil, l_pest_ai_half_life_Veg, l_pest_enable_pesticide_engine, m_corr_x, m_corr_y, m_land, m_map, 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, CfgFloat::value(), CfgBool::value(), MapErrorMsg::Warn(), and WARN_FATAL.

{
    if ( l_pest_enable_pesticide_engine.value())
    {
        m_map = a_map;
        m_land = a_land;
        m_something_to_decay = false;

        // 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;
        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 = (double*)malloc(sizeof(double)* m_pest_map_size);

#ifdef __DETAILED_PESTICIDE_FATE
        m_pest_map_vegcanopy = (double*)malloc(sizeof(double)* m_pest_map_size);
        m_pest_map_soil = (double*)malloc(sizeof(double)* m_pest_map_size);
        if (l_pest_enable_pesticide_engine.value() && ((m_pest_map_twin == NULL) || (m_pest_map_vegcanopy == NULL) || (m_pest_map_soil == NULL)))
        {
            g_msg->Warn(WARN_FATAL,"Pesticide::Pesticide(): Out of memory.", "" );
            exit(1);
        }
#else
        m_pest_map_main = (double*)malloc(sizeof(double)* m_pest_map_size);
        if (l_pest_enable_pesticide_engine.value() && ((m_pest_map_twin == NULL) || (m_pest_map_main == NULL)))
        {
            g_msg->Warn(WARN_FATAL,"Pesticide::Pesticide(): Out of memory.", "" );
            exit(1);
        }
#endif
        for ( unsigned int i=0; i<m_pest_map_size; i++ ) {
#ifdef __DETAILED_PESTICIDE_FATE
            m_pest_map_vegcanopy[i] = 0.0;
            m_pest_map_soil[i] = 0.0;;
#else
            m_pest_map_main[i] = 0.0;
#endif
            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();
    }
}

Pesticide::~Pesticide ( void  )

virtual

Definition at line 587 of file pesticide.cpp.

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

{
#ifdef __DETAILED_PESTICIDE_FATE
    if (l_pest_enable_pesticide_engine.value()) {
        free( m_pest_map_soil );
        free(m_pest_map_vegcanopy);
    }
#else
    if (l_pest_enable_pesticide_engine.value()) {
        free( m_pest_map_main );
    }
#endif
    if ( l_pest_enable_pesticide_engine.value()) {
    free( m_pest_map_twin );
    //free( m_pest_map_mask );
  }

  for (int w=0; w<4; w++)
  {
      for ( unsigned int i=0; i<m_diffusion_mask[w].size(); i++ )
      {
          delete m_diffusion_mask[w][i];
      }
      m_diffusion_mask[w].resize(0);
  }
  DailyQueueClear();
}

Member Function Documentation

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 565 of file pesticide.cpp.

References m_RainWashoffFactor.

Referenced by Pesticide().

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

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

Definition at line 105 of file pesticide.cpp.

References m_daily_spray_queue.

Referenced by Orchard::DoDevelopment(), OrchardBand::DoDevelopment(), Farm::ProductApplication0(), Farm::ProductApplication1(), and Farm::Trial_PesticideTreat_DateLimited().

{
  PesticideEvent *l_event = new PesticideEvent( a_element_sprayed, a_amount );

  m_daily_spray_queue.resize( m_daily_spray_queue.size() + 1 );
  m_daily_spray_queue[ m_daily_spray_queue.size() - 1 ] =
    l_event;
}

void Pesticide::DailyQueueClear ( void  )

protected

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

Definition at line 93 of file pesticide.cpp.

References m_daily_spray_queue.

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

{
  for ( unsigned int i=0; i<m_daily_spray_queue.size(); i++ ) {
    delete m_daily_spray_queue[i];
  }
  m_daily_spray_queue.resize( 0 );
}

void Pesticide::DailyQueueProcess ( void  )

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 115 of file pesticide.cpp.

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

Referenced by Tick().

{
    if (0 == m_daily_spray_queue.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 = true;

  for ( unsigned int i=0; i<m_daily_spray_queue.size(); i++ )
  {
      m_wind = g_land->SupplyWindDirection();
      int minx=m_daily_spray_queue[i]->m_sprayed_elem->GetMinX();
      int maxx=m_daily_spray_queue[i]->m_sprayed_elem->GetMaxX();
      int miny=m_daily_spray_queue[i]->m_sprayed_elem->GetMinY();
      int maxy=m_daily_spray_queue[i]->m_sprayed_elem->GetMaxY();
      // For cover we use the crop, and save this for later
      double cover = m_daily_spray_queue[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[i]->m_sprayed_elem, m_daily_spray_queue[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);
  }
}

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 412 of file pesticide.cpp.

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

Referenced by DiffusionMaskInit().

{
  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.753767 * pow(( a_dist_meters+1.86976 ), -2.121563);
    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;
}

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 295 of file pesticide.cpp.

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

Referenced by Pesticide().

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

void Pesticide::DiffusionMaskInitTest

(

void

)

Definition at line 618 of file pesticide.cpp.

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

Referenced by Pesticide().

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

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

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 272 of file pesticide.cpp.

References m_pest_map_main.

Referenced by TwinMapDiffusion().

{
    // 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[l_coord] += a_amount * a_cover;
    m_pest_map_soil[l_coord] += a_amount - m_pest_map_vegcanopy[l_coord];
#else
    m_pest_map_main[l_coord] += a_amount;
#endif
}

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

inlineprotected

Definition at line 254 of file pesticide.h.

References PEST_GRIDSIZE_POW2, tole_FishFarm, tole_Freshwater, tole_Pond, tole_River, and tole_Saltwater.

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

bool Pesticide::GetAnythingToDecay ( )

inline

Definition at line 219 of file pesticide.h.

Referenced by Landscape::SupplyPesticideDecay().

{ return (m_something_to_decay); }

void Pesticide::MainMapDecay ( void  )

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 434 of file pesticide.cpp.

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().

{
    if ( ! m_something_to_decay )    return;
    double l_zero         = l_pest_zero_threshold.value();
    m_something_to_decay = false;
    for ( unsigned int i=0; i<m_pest_map_size; i++ )
    {
#ifdef __DETAILED_PESTICIDE_FATE
        if ((m_pest_map_vegcanopy[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[i] *= m_RainWashoffFactor[m_rainfallcategory+cov]; // m_RainWashoffFactor is the index to the array
            m_pest_map_soil[i] = (m_pest_map_soil[i] + Rwp) * m_pest_daily_decay_frac_Soil;
            m_pest_map_vegcanopy[i] -= Rwp;
            m_pest_map_vegcanopy[i] *= m_pest_daily_decay_frac_Veg;
            m_something_to_decay = true;
        }
        else
        {
            if (m_pest_map_soil[i] > l_zero)
            {
                m_pest_map_soil[i] = m_pest_map_soil[i]  * m_pest_daily_decay_frac_Soil;
                m_something_to_decay = true;
            }
            else
            {
                m_pest_map_vegcanopy[i] = 0.0;
                m_pest_map_soil[i] = 0.0;
            }
#else
      if (m_pest_map_main[i] > l_zero)
      {
          m_pest_map_main[i]       *= m_pest_daily_decay_frac;
          m_something_to_decay      = true;
      }
      else
      {
          m_pest_map_main[i]        = 0.0;
      }
#endif
  }
}

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

Definition at line 651 of file pesticide.cpp.

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

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

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

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 320 of file pesticide.h.

References PEST_GRIDSIZE_POW2.

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

{
#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[l_y * m_pest_map_width + l_x];
}

double Pesticide::SupplyPesticide ( int  a_polyref )

inline

Definition at line 338 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[l_c];
}

void Pesticide::Tick

(

void

)

Definition at line 75 of file pesticide.cpp.

References DailyQueueClear(), DailyQueueProcess(), l_pest_enable_pesticide_engine, m_rainfallcategory, MainMapDecay(), Landscape::SupplyRain(), and CfgBool::value().

Referenced by Landscape::Tick().

{
    // 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())
    {
        DailyQueueClear();
        return;
    }
    MainMapDecay();
    DailyQueueProcess();
    DailyQueueClear();
}

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

protected

Definition at line 149 of file pesticide.cpp.

References m_pest_map_twin, and m_pest_map_width.

Referenced by DailyQueueProcess().

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

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

protected

Definition at line 250 of file pesticide.cpp.

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

Referenced by DailyQueueProcess().

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

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 162 of file pesticide.cpp.

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

Referenced by DailyQueueProcess().

{
    /* 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();
    /*
    * 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.
    */
    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();
}

void Pesticide::TwinMapSprayCorrectBorders ( void  )

protected

Definition at line 204 of file pesticide.cpp.

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().

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

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

inlineprotected

Definition at line 348 of file pesticide.h.

References PEST_GRIDSIZE_POW2.

Referenced by TwinMapSpray().

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

Member Data Documentation

double Pesticide::m_corr_x

protected

Definition at line 152 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

double Pesticide::m_corr_y

protected

Definition at line 153 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

vector<PesticideEvent*> Pesticide::m_daily_spray_queue

protected

Definition at line 191 of file pesticide.h.

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

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 188 of file pesticide.h.

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

RasterMap* Pesticide::m_land

protected

Definition at line 163 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSpray().

Landscape* Pesticide::m_map

protected

Definition at line 166 of file pesticide.h.

Referenced by Pesticide().

double Pesticide::m_pest_daily_decay_frac

protected

Definition at line 158 of file pesticide.h.

Referenced by MainMapDecay(), and Pesticide().

double Pesticide::m_pest_daily_decay_frac_Soil

protected

Definition at line 160 of file pesticide.h.

Referenced by MainMapDecay(), and Pesticide().

double Pesticide::m_pest_daily_decay_frac_Veg

protected

Definition at line 159 of file pesticide.h.

Referenced by MainMapDecay(), and Pesticide().

unsigned int Pesticide::m_pest_map_height

protected

Definition at line 179 of file pesticide.h.

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

double* Pesticide::m_pest_map_main

protected

Definition at line 174 of file pesticide.h.

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

unsigned int Pesticide::m_pest_map_size

protected

Definition at line 177 of file pesticide.h.

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

double* Pesticide::m_pest_map_twin

protected

Definition at line 176 of file pesticide.h.

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

unsigned int Pesticide::m_pest_map_width

protected

Definition at line 178 of file pesticide.h.

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

double Pesticide::m_prop

protected

Definition at line 151 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSpray().

unsigned Pesticide::m_rainfallcategory

protected

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

Definition at line 184 of file pesticide.h.

Referenced by MainMapDecay(), and Tick().

double Pesticide::m_RainWashoffFactor[10000]

protected

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

Definition at line 182 of file pesticide.h.

Referenced by CalcRainWashOffFactors(), and MainMapDecay().

bool Pesticide::m_something_to_decay

protected

Definition at line 144 of file pesticide.h.

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

int Pesticide::m_wind

protected

Definition at line 154 of file pesticide.h.

Referenced by DailyQueueProcess(), and TwinMapDiffusion().

int Pesticide::m_x_excess

protected

Definition at line 149 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

int Pesticide::m_y_excess

protected

Definition at line 150 of file pesticide.h.

Referenced by Pesticide(), and TwinMapSprayCorrectBorders().

---

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

• D:/CJT/Repos/ALMaSS_all/Landscape/pesticide.h
• D:/CJT/Repos/ALMaSS_all/Landscape/pesticide.cpp