pesticide.h

Go to the documentation of this file.

//
// pesticide.h
//
/*
*******************************************************************************************************
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.
********************************************************************************************************
*/

#ifndef PESTICIDE_H
#define PESTICIDE_H

//#define __DETAILED_PESTICIDE_FATE

// Side length of a square in the pesticide map is given by this parameter
// as a power of two. Ie. 3 will give a side length of 8 main map units
// as 2^3 equals 8, which must also be set below
//
// Unfortunately it would be a huge performance penalty to have to make
// this a runtime configuration variable, it has to be compiled in.
// Standard rough settings here:

#define PEST_GRIDSIZE_POW2 0
#define PEST_GRIDSIZE      1
#define PEST_GRIDAREA      1  // i.e. PEST_GRIDSIZE^2
/*
#define PEST_GRIDSIZE_POW2 2
#define PEST_GRIDSIZE      4
#define PEST_GRIDAREA      16  // i.e. PEST_GRIDSIZE^2
*/


// Consider undef for production code, no speed penalty if defined.
#define PEST_DEBUG

// Check for water bodies when asking for pesticide concentration
// at main map coords x,y? Speed vs. reality tradeoff. You
// probably want this defined.
//#define PEST_WATER_CHECK


extern class Pesticide *g_pest;


struct PesticideEvent
{
  LE*   m_sprayed_elem;
  double m_amount;

  PesticideEvent( LE* a_sprayed_elem, double a_amount ) {
    m_sprayed_elem = a_sprayed_elem;
    m_amount       = a_amount;
  }
};

class Diffusor
{
  int   m_dx;
  int   m_dy;
  double m_fraction;

public:
  Diffusor( int a_dx, int a_dy, double a_fraction ) {
    m_dx       = a_dx;
    m_dy       = a_dy;
    m_fraction = a_fraction;
  }

  void SetFraction(double a_frac) { m_fraction = a_frac; }
  double GetFraction() { return m_fraction; }
  int Getdx() { return m_dx; }
  int Getdy() { return m_dy; }

};

typedef vector <Diffusor*> Diffusion_mask;


class Pesticide
{
  // Method call stack and ordering:
  //
  // Pesticide()
  //   DiffusionMaskInit()
  //     DiffusionFunction()
  //
  // Tick()
  //   MainMapDecay()
  //   DailyQueueProcess()
  //     TwinMapClear()
  //     TwinMapSpray()
  //       TwinMapSprayPixel()
  //       TwinMapSprayCorrectBorders()
  //     TwinMapCopyToMask()
  //     TwinMapDiffusion()
  //       DiffusionSprayPixel()
  //         ElementIsWater()
  //     TwinMapAddToMain()
  //   DailyQueueClear()
  //
  // SupplyPesticide()
  // #ifdef PEST_WATER_CHECK
  //   ElementIsWater()
  // #endif

 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.
  bool  m_something_to_decay;

  // Main map coordinates beyond which we have to use special
  // proportional constants when adding new amounts of pesticide
  // to the pesticide map.
  int   m_x_excess;
  int   m_y_excess;
  double m_prop;
  double m_corr_x;
  double m_corr_y;
  int m_wind;

  // Daily decay fraction, precalculated from the pesticide
  // half life parameter, for general, vegetation and soil
  double m_pest_daily_decay_frac;
  double m_pest_daily_decay_frac_Veg;
  double m_pest_daily_decay_frac_Soil;

  // Local copy of pointer to the main map object.
  RasterMap *m_land;

  // Local copy of pointer to the main landscape object.
  Landscape *m_map;

  // The pesticide map itself, and its twins used when adding newly
  // sprayed squares to the main map.
#ifdef __DETAILED_PESTICIDE_FATE
      double       *m_pest_map_vegcanopy;
      double       *m_pest_map_soil;
#else
      double       *m_pest_map_main;
#endif
      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];
      unsigned m_rainfallcategory;

      Diffusion_mask m_diffusion_mask[4];

      // List of landscape elements, which was sprayed on a given day.
      vector <PesticideEvent*> m_daily_spray_queue;

      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 TwinMapCopyToMask( int a_minx, int a_miny, int a_maxx, int a_maxy );
      //void TwinMapAddToMain( 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();

public:
  void  Tick( void );
  void  DailyQueueAdd( LE* a_element_sprayed, double a_amount );
  bool GetAnythingToDecay(){ return (m_something_to_decay); }
  // Doesn't make sense for the pesticide map, as one cannot guarantee
  // that all the area covered by a particular polygon has the
  // same concentration of pesticide, but as an approximation we use the
  // grid cell covering ValidX & ValidY for that polygon.
  //
#ifdef __DETAILED_PESTICIDE_FATE
  double SupplyPesticideS(int a_x, int a_y);
  double SupplyPesticideP(int a_x, int a_y);
  double SupplyPesticideS(int a_polyref);
  double SupplyPesticideP(int a_polyref);
#else
  double SupplyPesticide( int a_x, int a_y );
  double SupplyPesticide(int a_polyref);
#endif

  Pesticide( RasterMap *a_land, Landscape *a_map );
  virtual ~Pesticide( void );

#ifdef PEST_DEBUG
  /* *** For testing of the pesticide engine. */

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

  void DiffusionMaskInitTest( void );
  //void Test( Landscape *a_map );
#endif

};



inline bool Pesticide::ElementIsWater( int a_x, int a_y )
{
  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;
}


#ifdef __DETAILED_PESTICIDE_FATE

inline double Pesticide::SupplyPesticideS(int a_x, int a_y)
{
    int l_x = a_x >> PEST_GRIDSIZE_POW2;
    int l_y = a_y >> PEST_GRIDSIZE_POW2;

    return m_pest_map_soil[l_y * m_pest_map_width + l_x];
}

inline double Pesticide::SupplyPesticideP(int a_x, int a_y)
{
    int l_x = a_x >> PEST_GRIDSIZE_POW2;
    int l_y = a_y >> PEST_GRIDSIZE_POW2;

    return m_pest_map_vegcanopy[l_y * m_pest_map_width + l_x];
}

inline double Pesticide::SupplyPesticideS(int a_ele)
{
    int l_c = m_map->SupplyPesticideCell(a_ele);
    return m_pest_map_soil[l_c];
}

inline double Pesticide::SupplyPesticideP(int a_ele)
{
    int l_c = m_map->SupplyPesticideCell(a_ele);
    return m_pest_map_vegcanopy[l_c];
}

#else
inline double Pesticide::SupplyPesticide(int a_x, int a_y)
{
#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];
}

inline double Pesticide::SupplyPesticide(int a_ele)
{
    // 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];
}

#endif

inline void Pesticide::TwinMapSprayPixel(int a_large_map_x,
    int a_large_map_y,
    double a_fractional_amount)
{
    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;
}

#endif // PESTICIDE_H