pesticide.cpp

Go to the documentation of this file.

//
// pesticide.cpp
//
/*
*******************************************************************************************************
Copyright (c) 2003, Christopher John Topping, EcoSol
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/

#define _CRT_SECURE_NO_DEPRECATE
//#define __WithinOrchardPesticideSim__

#include <vector>
#include <cstdio> // Only needed for debugging purposes.
#include <math.h>
#include <iostream>
#include <fstream>
#include "ls.h"

using namespace std;

CfgBool l_pest_enable_pesticide_engine( "PEST_ENABLE_PESTICIDE_ENGINE",CFG_CUSTOM, false );
static CfgFloat l_pest_ai_half_life("PEST_AI_HALF_LIFE", CFG_CUSTOM, 10.0);
static CfgFloat l_pest_ai_half_life_Soil("PEST_AI_HALF_LIFE_SOIL", CFG_CUSTOM, 10.0);
static CfgFloat l_pest_ai_half_life_Veg("PEST_AI_HALF_LIFE_VEG", CFG_CUSTOM, 10.0);
static CfgFloat l_pest_diffusion_slope("PEST_DRIFT_SLOPE", CFG_CUSTOM, -0.6122);
static CfgInt   l_pest_diffusion_grid_count("PEST_DIFFUSION_GRID_COUNT",CFG_CUSTOM, 1 );
static CfgFloat l_pest_zero_threshold("PEST_ZERO_THRESHOLD",CFG_CUSTOM, 0.00001 );
CfgFloat l_pest_insecticide_amount("PEST_INSECTICIDE_AMOUNT",CFG_CUSTOM, 0.00 );
CfgFloat l_pest_product_0_amount("PEST_PRODUCT_ZERO_AMOUNT",CFG_CUSTOM, 0.004145 );
CfgFloat l_pest_product_1_amount("PEST_PRODUCT_ONE_AMOUNT", CFG_CUSTOM, 0.004145);
CfgBool l_pest_use_application_rate("PEST_USE_APPLICATIONRATE", CFG_CUSTOM, false);
CfgFloat l_pest_daily_mort( "PEST_DAILY_MORTALITY", CFG_CUSTOM, 0.25 );
CfgFloat l_pest_daily_mort2( "PEST_DAILY_MORTALITY_TWO", CFG_CUSTOM, 0.25 );
CfgFloat l_pest_trigger_threshold1( "PEST_TRIGGER_THRESHOLD_ONE", CFG_CUSTOM, 1.0 );
CfgFloat l_pest_trigger_threshold2( "PEST_TRIGGER_THRESHOLD_TWO", CFG_CUSTOM, 1.0 );

CfgInt cfg_pest_productapplic_startdate("PEST_PRODUCTAPPLIC_STARTDATE", CFG_CUSTOM, -1);
CfgInt cfg_pest_productapplic_startdate2("PEST_PRODUCTAPPLIC_STARTDATE_TWO",CFG_CUSTOM,-1);
CfgInt cfg_pest_productapplic_startdate3("PEST_PRODUCTAPPLIC_STARTDATE_THREE",CFG_CUSTOM,-1);
CfgInt cfg_pest_productapplic_period("PEST_PRODUCTAPPLIC_PERIOD",CFG_CUSTOM,1);

CfgBool cfg_pest_residue_or_rate("PEST_RESIDUE_OR_RATE",CFG_CUSTOM,true);

CfgBool cfg_pest_springbarley_on("PEST_SPRINGBARLEY_ON", CFG_CUSTOM, false);
CfgBool cfg_pest_winterwheat_on("PEST_WINTERWHEAT_ON", CFG_CUSTOM, false);
CfgBool cfg_pest_winterrape_on("PEST_WINTERRAPE_ON", CFG_CUSTOM, false);
CfgBool cfg_pest_SBS_ERA("PEST_SBS_ERA", CFG_CUSTOM, false);

class Pesticide *g_pest;
extern Landscape *g_land;



void Pesticide::Tick( void )
{
    // 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::DailyQueueClear( void )
{
  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::DailyQueueAdd( LE*   a_element_sprayed, double a_amount )
{
  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::DailyQueueProcess( void )
{
    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);
  }
}
//-----------------------------------------------------------------------------------------------------------------------------

void Pesticide::TwinMapClear( int a_minx, int a_miny, int a_maxx, int a_maxy )
{
    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::TwinMapSpray( LE* a_element_sprayed, double a_amount, int a_minx, int a_miny, int a_maxx, int a_maxy )
{
    /* 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 )
{
  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::TwinMapCopyToMask( int a_minx, int a_miny, int a_maxx, int a_maxy  )
{
    // Copy the newly calculated pesticide amounts over to the mask map
    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_mask[t + x]  = m_pest_map_twin[t + x];
        }
    }
}
*/
//-----------------------------------------------------------------------------------------------------------------------------

/*
void Pesticide::TwinMapAddToMain( void )
{
  for ( unsigned int i=0; i<m_pest_map_size; i++ ) {
    m_pest_map_main[i] += m_pest_map_twin[i];
  }
}
//-----------------------------------------------------------------------------------------------------------------------------
*/
void Pesticide::TwinMapDiffusion( int a_minx, int a_miny, int a_maxx, int a_maxy, double a_cover )
{
    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);
                }
            }
        }
    }
}
//-----------------------------------------------------------------------------------------------------------------------------

inline void Pesticide::DiffusionSprayPixel(int a_x, int a_limit_x, int a_y, int a_limit_y, double a_amount, double a_cover)
{
    // 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
}
//-----------------------------------------------------------------------------------------------------------------------------

void Pesticide::DiffusionMaskInit( void )
{
  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::DiffusionMaskInit( void )
{
  int l_grid        = l_pest_diffusion_grid_count.value();
  int l_side_length = l_grid * 2 + 1;

  m_diffusion_mask.resize( l_side_length * l_side_length );

  unsigned int i    = 0;
  //double l_diff_zero = DiffusionFunction( 0.0 );
  double l_diff_sum = 0.0;
  for ( int x = -l_grid; x < l_grid + 1; x++ ) {
    for ( int y = -l_grid; y < l_grid + 1; y++ ) {
      double l_dist = sqrt( (double) x*x + y*y ); //  ***CJT*** added 28/8/2009
      // m_diffusion_mask has the square to drift spray to with the proportions relative to the amount received in the centre square
      // but the total may be greater than one, so we need the adjustment provided by the second loop
      double l_diff = DiffusionFunction(l_dist);
      l_diff_sum += l_diff;
      m_diffusion_mask[i] = new Diffusor( x, y, l_diff);  // ***CJT*** changed 28/8/2009 l_diff_zero
      i++;
    }
  }
  for ( unsigned x = 0; x < i; x++) {
        m_diffusion_mask[x]->m_fraction /= l_diff_sum;
  }
}

*/

double Pesticide::DiffusionFunction( double a_dist_meters )
{
  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::MainMapDecay( void )
{
    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
  }
}
//-----------------------------------------------------------------------------------------------------------------------------

Pesticide::Pesticide( RasterMap* a_land, Landscape *a_map )
{
    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();
    }
}
//-----------------------------------------------------------------------------------------------------------------------------

void Pesticide::CalcRainWashOffFactors()
{
    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;
        }
    }
}
//-----------------------------------------------------------------------------------------------------------------------------

Pesticide::~Pesticide( void )
{
#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();
}
//-----------------------------------------------------------------------------------------------------------------------------

#ifdef PEST_DEBUG

void Pesticide::DiffusionMaskInitTest( void )
{
  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();
 }
//-----------------------------------------------------------------------------------------------------------------------------

// For file saving and loading.
#define CFG_CHANNEL_BITS      8
#define CFG_CHANNEL_MAXVAL    (2^CFG_CHANNEL_BITS-1)

#define SV_UINT32 unsigned int
#define SV_INT32  int
#define SV_UINT8  unsigned char
#define SV_INT8   char

bool Pesticide::SavePPM( double *a_map,
             int a_beginx, int a_width,
             int a_beginy, int a_height,
             char* a_filename )
{
  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;
}
//-----------------------------------------------------------------------------------------------------------------------------

/*
void Pesticide::Test( Landscape *a_map )
{
  for ( int i=0; i<730; i++) {

    if ( random(100) < 10 ) {
      int l_sprays = random(5)+1;
      for ( int j=0; j<l_sprays; j++ ) {
    int l_x = random(1500);
    int l_y = random(1500);
    DailyQueueAdd( a_map->
               SupplyLEPointer( a_map->SupplyPolyRef( l_x, l_y )),
               1.0 );
      }
      char l_filename[20];
      sprintf( l_filename, "ppms/p%04d.ppm", i );
      SavePPM( m_pest_map_main,
           0, 0, 0, 0,
           l_filename );
    }

    Tick();
  }
}
//-----------------------------------------------------------------------------------------------------------------------------
*/
#endif // PEST_DEBUG