barkbeetlemodule.h

Go to the documentation of this file.

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland-model.org
**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl
**
**    This program is free software: you can redistribute it and/or modify
**    it under the terms of the GNU General Public License as published by
**    the Free Software Foundation, either version 3 of the License, or
**    (at your option) any later version.
**
**    This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program.  If not, see <http://www.gnu.org/licenses/>.
********************************************************************************************/
#ifndef BARKBEETLEMODULE_H
#define BARKBEETLEMODULE_H
 
#include "grid.h"
#include "layeredgrid.h"
#include "random.h"
#include "expression.h"
 
#include "bbgenerations.h"
 
 
 
class BarkBeetleCell
{
public:
    BarkBeetleCell() { reset(); }
    void clear() { n=0; n_total=0; killedYear=0; outbreakYear=0.f; infested=false;  p_colonize=0.f; deadtrees=NoDeadTrees; packageOutbreakYear=0.f; }
    void reset() {clear(); dbh=0.f; tree_stress=0.f; outbreakYear=0.f; n_events=0; sum_volume_killed=0.f; }
    bool isHost() const { return dbh>0.f; }
    bool isPotentialHost() const {return dbh>0.f && killedYear==0 && infested==false; }
    void setInfested(bool is_infested) { infested=is_infested; if (infested) { total_infested++; killedYear=0; n=0;} }
    void finishedSpread(int iteration) { infested=false; killedYear=iteration; killed=true; max_iteration=qMax(max_iteration, iteration); ++n_events; }
    float backgroundInfestationProbability; 
 
    bool infested; // true for cells that are currently occupied by beetles
    bool killed; // true for cells that are killed in the current year
    float dbh; // the dbh of the biggest spruce on the pixel
    float tree_stress; // the stress rating of this tree (SI)
    float p_colonize; // the highest probability (0..1) that a pixel is killed
    int n; // number of cohorts that landed on the pixel in each iteration
    int n_total; // number of cohorts that landed on a pixel (total)
    int killedYear; // year (iteration) at which pixel was killed ??
    float outbreakYear; // year in which the outbreak started (this information is preserved by spreading beatles)
    float packageOutbreakYear; // outbreak year of packages landing on a cell
    int n_events; // total number of events on the pixel since the start of the simulation
    float sum_volume_killed; // total killed volume (since start of the simulation) on a pixel (m3)
    enum DeadTrees { NoDeadTrees=0, StormDamage=10, SinkInVicinity=5, BeetleTrapTree=8 };
    DeadTrees deadtrees;
    bool isNeutralized() const { return deadtrees!=NoDeadTrees; }
 
    static void resetCounters() { total_infested=0; max_iteration=0; }
    static int total_infested;
    static int max_iteration;
 
};
 
class BarkBeetleRUCell
{
public:
    BarkBeetleRUCell(): scanned(false), generations(0.), add_sister(false),
        cold_days(0), cold_days_late(0), killed_trees(false),
        killed_pixels(0), host_pixels(0),
        infested(0.) {}
    double currentDamageFraction() { return host_pixels+killed_pixels>0? (killed_pixels)/double(host_pixels+killed_pixels): 0.; }
    bool scanned;
    double generations; // filial generations + 0.5 if full sisterbrood develops for last filial generation
    bool add_sister;
    int cold_days; // number of days in the winter season with t_min below a given threshold (-15 degree Celsius)
    int cold_days_late;
    bool killed_trees;
    int killed_pixels;
    int host_pixels;
    int infested; // number of pixels that are currently infested
 
};
 
class BarkBeetleLayers: public LayeredGrid<BarkBeetleCell> {
  public:
    void setGrid(const Grid<BarkBeetleCell> &grid) { mGrid = &grid; }
    double value(const BarkBeetleCell& data, const int index) const;
    const QVector<LayeredGridBase::LayerElement> &names();
    bool onClick(const QPointF &world_coord) const;
private:
    QVector<LayeredGridBase::LayerElement> mNames;
};
 
class BarkBeetleRULayers: public LayeredGrid<BarkBeetleRUCell> {
  public:
    void setGrid(const Grid<BarkBeetleRUCell> &grid) { mGrid = &grid; }
    double value(const BarkBeetleRUCell& data, const int index) const;
    const QVector<LayeredGridBase::LayerElement> &names();
    bool onClick(const QPointF &world_coord) const;
private:
    QVector<LayeredGridBase::LayerElement> mNames;
};
 
 
 
class ResourceUnit; // forward
class Tree; // forward
class BarkBeetleOut; // forward
class Climate; // forward
class BarkBeetleModule
{
public:
    BarkBeetleModule();
    ~BarkBeetleModule();
    static double cellsize() { return 10.; }
 
    void setup(); 
    void setup(const ResourceUnit *ru); 
    void loadParameters(bool do_reset=true); 
    void clearGrids(); 
    void loadAllVegetation(); 
 
    void run(int iteration=0);
 
    void treeDeath(const Tree *tree);
 
    void yearBegin(); 
    int manualYearBegin() { int y=mYear; yearBegin(); mYear = y + 1; return mYear; }
    int internalYear() const { return mYear; }
    // properties
    void setSimulate(bool do_simulate) { mSimulate = do_simulate; }
    bool simulate() const {return mSimulate; }
 
    void setEnabled(bool do_set_enabled) { mEnabled = do_set_enabled; }
    bool enabled() const { return mEnabled; }
private:
    void calculateGenerations(); 
    void calculateOutbreakFactor(); 
    void startSpread(); 
    int clumpedBackgroundActivation(QPoint start_idx); 
    void prepareInteractions(bool update_interaction=false); 
    void barkbeetleSpread(); 
    void barkbeetleKill(); 
    void scanResourceUnitTrees(const QPointF &position); 
    bool sanitationTreatment(QPointF coord) const; 
    //void calculateMeanDamage(); ///< calculate the mean damage percentage (fraction of killed pixels to host pixels)
    int mIteration;
    QString mAfterExecEvent;
    struct SBBParams {
        SBBParams(): minDbh(10.f), cohortsPerGeneration(30), cohortsPerSisterbrood(50),
            spreadKernelMaxDistance(100.), backgroundInfestationProbability(0.0001), initialInfestationProbability(0.),
            stormInfestationProbability(1.), winterMortalityBaseLevel(0.),
            outbreakDurationMin(0.), outbreakDurationMax(0.), deadTreeSelectivity(1.), sanitationTreatmentProb(0.) {}
        float minDbh; 
        int cohortsPerGeneration; 
        int cohortsPerSisterbrood; 
        QString spreadKernelFormula; 
        double spreadKernelMaxDistance; 
        double backgroundInfestationProbability; 
        double initialInfestationProbability; 
        double stormInfestationProbability; 
        double winterMortalityBaseLevel; 
        double outbreakDurationMin; 
        double outbreakDurationMax; 
        double deadTreeSelectivity; 
        double sanitationTreatmentProb; 
 
    } params;
    struct SBBStats {
        void clear() { infestedStart=0;infestedBackground=0; infestedStorm=0; maxGenerations=0;NCohortsLanded=0;NPixelsLanded=0;NCohortsSpread=0;NInfested=0;NWinterMortality=0;NAreaKilled=0;NTreesKilled=0;BasalAreaKilled=0.; VolumeKilled=0.;}
        int infestedStart; // # of pixels that are infested at the beginning of an iteration
        int infestedBackground; // # of pixels that are getting active
        int infestedStorm; // # of pixels that are activated due to storm damage
        int maxGenerations; // maxium number of generations found this year
        int NCohortsLanded; // number of cohorts that landed on new potential host pixels
        int NPixelsLanded; // number of potential host pixels that received at least one cohort
        int NCohortsSpread; // number of pixels that are spread from infested cells
        int NInfested; // number of newly infested pixels (a subset of those who 'landed')
        int NWinterMortality; // number of (infested) pixels that died off during winter
        int NAreaKilled; // number of pixels on which trees were killed
        int NTreesKilled; // number of spruce trees killed
        double BasalAreaKilled; // sum of basal area of killed trees
        double VolumeKilled; // sum of killed tree volumes (m3)
    } stats;
 
 
    bool mSimulate; 
    bool mEnabled; 
    int mYear; 
    BBGenerations mGenerations;
    RandomCustomPDF mKernelPDF;
    Expression mColonizeProbability; 
    Expression mWinterMortalityFormula; 
    Expression mOutbreakClimateSensitivityFormula;
    Expression mOutbreakDurationFormula;
    Grid<BarkBeetleCell> mGrid;
    Grid<BarkBeetleRUCell> mRUGrid;
    BarkBeetleLayers mLayers;
    BarkBeetleRULayers mRULayers;
    // reference climate
    QVector<double> mRefClimateAverages; 
    double *mClimateVariables[8]; // pointer to the variables
    const Climate *mRefClimate;
    double mRc; 
 
    friend class BarkBeetleScript;
    friend class BarkBeetleOut;
 
};
 
 
 
#endif // BARKBEETLEMODULE_H