firemodule.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 FIREMODULE_H
#define FIREMODULE_H
 
#include "grid.h"
#include "layeredgrid.h"
#include "expression.h"
 
class WaterCycleData;
class ResourceUnit;
class FireModule;
class FireOut;
class FireScript;
 
class FireRUData
{
public:
    FireRUData(): mKBDIref(0.), mRefMgmt(0.), mRefAnnualPrecipitation(0.), mKBDI(0.), mValid(false), mRU(nullptr) { fireRUStats.clear(); fireRUStats.n_cum_fire=0; fireRUStats.year_last_fire=0; }
    void setup(const ResourceUnit *ru);
    bool valid() const { return mValid; } 
    bool allowIgnition() const { return mRefMgmt>0.; }
    void reset() { mKBDI = 0.; }
    double kbdi() const { return mKBDI; }
    double kbdiRef() const { return mKBDIref; }
    double baseIgnitionProbability() const { return mBaseIgnitionProb; }
    double managementSuppression() const { return mRefMgmt; }
    const ResourceUnit *ru() const { return mRU; }
 
    // access data
 
    // statistics for the resource unit
    struct {
        int fire_id;
        // statistics for:
        int n_trees_died; 
        int n_trees; 
        int n_cells; 
        int n_cum_fire; 
        int year_last_fire; 
        double died_basal_area; 
        double basal_area; 
        double fuel_moss; 
        double fuel_ff; 
        double fuel_dwd; 
        double crown_kill; 
        double avg_dbh; 
        // enter() can be called multiple times
        void enter(const int this_fire_id) {
            if (fire_id!=this_fire_id) {
                fire_id = this_fire_id;
                // clear all stats
                n_trees_died = n_trees = n_cells = 0;
                died_basal_area = basal_area = fuel_moss = fuel_ff = fuel_dwd = crown_kill = avg_dbh = 0.;
            }
        }
        // call once after fire is finished
        void calculate(const int this_fire_id, int current_year) {
            if (fire_id==this_fire_id) {
                // calculate averages
                if (n_cells>0) {
                    crown_kill /= double(n_cells);
                    //fuel_moss /= double(n_cells);
                    //fuel_ff /= double(n_cells);
                    //fuel_dwd /= double(n_cells);
                    avg_dbh /= double(n_cells);
                    n_cum_fire++;
                    year_last_fire = current_year;
                }
            }
        }
        void clear() { fire_id=-1;  enter(0);}
    } fireRUStats;
private:
    // parameters
    double mKBDIref; 
    double mRefMgmt; 
    double mRefLand; 
    double mRefAnnualPrecipitation; 
    double mFireReturnInterval; 
    double mAverageFireSize; 
    double mMinFireSize; 
    double mMaxFireSize; 
    double mBaseIgnitionProb; 
    double mFireExtinctionProb; 
    // variables
    double mKBDI; 
    bool mValid; 
    const ResourceUnit *mRU; 
 
    friend class FireModule; // allow access to member values
    friend class FireLayers;
};
 
class FireLayers: public LayeredGrid<FireRUData> {
  public:
    void setData(const Grid<FireRUData> &grid, FireModule *module) { mGrid = &grid; mFireModule=module; }
    double value(const FireRUData& data, const int index) const;
    const QVector<LayeredGridBase::LayerElement> &names();
private:
    QVector<LayeredGridBase::LayerElement> mNames;
    FireModule *mFireModule;
};
class FireModule
{
public:
    FireModule();
    void setup(); 
    void setup(const ResourceUnit *ru); 
    void setScriptObj(FireScript *sm) {mFireScript = sm; }
 
    static double cellsize() { return 20.; }
 
    // actions
    void run();
    void yearBegin();
    void calculateDroughtIndex(const ResourceUnit *resource_unit, const WaterCycleData *water_data);
 
    // main fire functions
    double ignition(bool only_ignite = false);
    void spread(const QPoint &start_point, const bool prescribed = false);
    void severity();
 
    // helper functions
    int fireId() const { return mFireId; } 
    double fireX() const { return fireStats.startpoint.x(); } 
    double fireY() const { return fireStats.startpoint.y(); } 
    void testSpread();
    double prescribedIgnition(const double x_m, const double y_m, const double firesize, const double windspeed, const double winddirection);
    double burnInIgnition(const double x_m, const double y_m, const double length, double max_fire_size, bool simulate=false);
 
private:
    double calculateFireSize(const FireRUData *data);
 
    // functions for the cellular automata
    void probabilisticSpread(const QPoint &start_point, QRect burn_in=QRect(), int burn_in_cells=0);
    void calculateSpreadProbability(const FireRUData &fire_data, const double height, const float *pixel_from, float *pixel_to, const int direction);
 
    double calcSlopeFactor(const double slope) const;
 
    double calcWindFactor(const double direction) const;
 
    bool burnPixel(const QPoint &pos, FireRUData &ru_data);
    void afterFire();
 
    double calcCombustibleFuel(const FireRUData &ru_data, double &rMoss_kg_ha, double &rForestFloor_kg_ha, double &rDWD_kg_ha);
 
    void setupBorderGrid();
 
    int mFireId; 
    // parameters
    double mWindSpeedMin;
    double mWindSpeedMax;
    double mWindDirection;
    double mCurrentWindSpeed;
    double mCurrentWindDirection;
    double mPrescribedFiresize; // fire size from javascript
    double mMinimumFuel; 
    // fuel parameters
    double mFuelkFC1; 
    double mFuelkFC2;
    double mFuelkFC3;
    // crown kill
    double mCrownKillkCK1; 
    double mCrownKillkCK2;
    double mCrownKillDbh; 
    Expression mMortalityFormula; 
    double *mFormula_bt;
    double *mFormula_ck;
    double mBurnSoilBiomass; 
    double mBurnStemFraction; 
    double mBurnBranchFraction; 
    double mBurnFoliageFraction; 
 
    bool mOnlyFireSimulation; 
    bool mAllowBurnIn; 
    // event handler
    QString mAfterFireEvent; 
 
    // data
    Grid<FireRUData> mRUGrid; 
    Grid<float> mGrid; 
    Grid<char> mBorderGrid; 
    FireLayers mFireLayers;
    FireScript *mFireScript;
 
    // functions
    FireRUData &data(const ResourceUnit *ru); 
 
    // statistics
    struct {
        int iterations;
        int fire_size_plan_m2;
        int fire_size_realized_m2;
        double fire_psme_total; 
        double fire_psme_died; 
        QPointF startpoint;
    } fireStats;
    friend class FireOut;
    friend class FireScript;
    friend class FireLayers;
 
};
 
#endif // FIREMODULE_H