Subversion Repositories public iLand

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland.boku.ac.at
**    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 SNAG_H
#define SNAG_H
#include <QList>
#include <QVariant>
class Tree; // forward
class Species; // forward
class ResourceUnit; // forward

/** CNPair stores a duple of carbon and nitrogen (kg/ha)
    use addBiomass(biomass, cnratio) to add biomass; use operators (+, +=, *, *=) for simple operations. */
class CNPair
{
public:
    CNPair(): C(0.), N(0.) {}
    static void setCFraction(const double fraction) { biomassCFraction = fraction; } ///< set the global fraction of carbon of biomass
    CNPair(const double c, const double n) {C=c; N=n; }
    bool isEmpty() const { return C==0.; } ///< returns true if pool is empty
    bool isValid() const { return C>=0. && N>=0.; } ///< return true if pool is valid (content of C or N >=0)
    double C; // carbon pool (kg C/ha)
    double N; // nitrogen pool (kg N/ha)
    double CN() { return N>0?C/N:0.; } ///< current CN ratio
    void clear() {C=0.; N=0.; }
    /// retrieve the amount of biomass (kg/ha). Uses the global C-fraciton. Soil pools are in t/ha!!!
    double biomass() const {return C / biomassCFraction; }
    /// add biomass to the pool (kg dry mass/ha); CNratio is used to calculate the N-Content, the global C-Fraction of biomass is used to
    /// calculate the amount of carbon of 'biomass'.
    void addBiomass(const double biomass, const double CNratio) { C+=biomass*biomassCFraction; N+=biomass*biomassCFraction/CNratio; }
    // some simple operators
    void operator+=(const CNPair &s) { C+=s.C; N+=s.N; } ///< add contents of a pool
    void operator*=(const double factor) { C*=factor; N*=factor; } ///< Multiply pool with 'factor'
    const CNPair operator+(const CNPair &p2) const { return CNPair(C+p2.C, N+p2.N); } ///< return the sum of two pools
    const CNPair operator-(const CNPair &p2) const { return CNPair(C-p2.C, N-p2.N); } ///< return the difference of two pools
    const CNPair operator*(const double factor) const { return CNPair(C*factor, N*factor); } ///< return the pool multiplied with 'factor'
protected:
    static double biomassCFraction;
};

/** CNPool provides (in addition to CNPair) also a weighted parameter value (e.g. a decay rate) */
class CNPool: public CNPair
{
public:
    CNPool(): CNPair(), mParameter(0.) {}
    CNPool(const double c, const double n, const double param_value) {C=c; N=n; mParameter=param_value; }
    double parameter() const { return mParameter; } ///< get weighting parameter
    double parameter(const CNPool &s) const; ///< 'simulate' weighting (get weighted param value of 's' with the current content)
    void clear() { CNPair::clear(); mParameter=0.; }

    /// add biomass with a specific 'CNRatio' and 'parameter_value'
    void addBiomass(const double biomass, const double CNratio, const double parameter_value);
    void add(const CNPair &s, const double parameter_value) { operator+=(CNPool(s.C, s.N, parameter_value));} ///< convenience function
    void setParameter(const double value) { mParameter = value; }

    void operator+=(const CNPool &s);
    const CNPool operator*(const double factor) const { return CNPool(C*factor, N*factor, mParameter); } ///< return the pool multiplied with 'factor'
private:
    double mParameter;
};

class Snag
{
public:
    Snag();
    static void setupThresholds(const double lower, const double upper); ///< setup class thresholds, needs to be called only once... (static)
    void setup( const ResourceUnit *ru); ///< initial setup routine.
    void scaleInitialState(); ///< used to scale the input to the actual area of the resource unit
    void newYear(); ///< to be executed at the beginning of a simulation year. This cleans up the transfer pools.
    void calculateYear(); ///< to be called at the end of the year (after tree growth, harvesting). Calculates flow to the soil.
    // access
    bool isStateEmpty() const { return mTotalSnagCarbon == 0.; }
    bool isEmpty() const { return mLabileFlux.isEmpty() && mRefractoryFlux.isEmpty() && isStateEmpty(); }
    const CNPool &labileFlux() const { return mLabileFlux; } ///< litter flux to the soil (kg/ha)
    const CNPool &refractoryFlux() const {return  mRefractoryFlux; } ///< deadwood flux to the soil (kg/ha)
    double climateFactor() const { return mClimateFactor; } ///< the 're' climate factor to modify decay rates (also used in ICBM/2N model)
    double totalCarbon() const { return mTotalSnagCarbon; } ///< total carbon in snags (kg/ha)
    const CNPair &totalSWD() const { return mTotalSWD; } ///< sum of C and N in SWD pools (stems) kg/ha
    const CNPair &totalOtherWood() const { return mTotalOther; } ///< sum of C and N in other woody pools (branches + coarse roots) kg/ha
    const CNPair &fluxToAtmosphere() const { return mTotalToAtm; } ///< total kg/ha heterotrophic respiration / flux to atm
    const CNPair &fluxToExtern() const { return mTotalToExtern; } ///< total kg/ha harvests
    const CNPair &fluxToDisturbance() const { return mTotalToDisturbance; } ///< total kg/ha due to disturbance (e.g. fire)
    // actions
    /// add for a tree with diameter
    void addTurnoverLitter(const Species *species, const double litter_foliage, const double litter_fineroot);
    void addTurnoverWood(const Species *species, const double woody_biomass);

    /// adds the 'tree' to the appropriate Snag pools.
    void addMortality(const Tree* tree);

    /// add residual biomass of 'tree' after harvesting.
    /// remove_(stem, branch, foliage)_pct: percentage of biomass compartment that is removed by the harvest operation.
    /// the harvested biomass is collected.
    void addHarvest(const Tree* tree, const double remove_stem_pct, const double remove_branch_pct, const double remove_foliage_pct );

    /// a tree dies and the biomass of the tree is split between snags/soils/removals
    /// @param tree the tree to process
    /// @param stem_to_snag fraction (0..1) of the stem biomass that should be moved to a standing snag
    /// @param stem_to_soil fraction (0..1) of the stem biomass that should go directly to the soil
    /// @param branch_to_snag fraction (0..1) of the branch biomass that should be moved to a standing snag
    /// @param branch_to_soil fraction (0..1) of the branch biomass that should go directly to the soil
    /// @param foliage_to_soil fraction (0..1) of the foliage biomass that should go directly to the soil
    void addDisturbance(const Tree *tree, const double stem_to_snag, const double stem_to_soil,
                        const double branch_to_snag, const double branch_to_soil,
                        const double foliage_to_soil) { addBiomassPools(tree, stem_to_snag, stem_to_soil, branch_to_snag, branch_to_soil, foliage_to_soil);}

    /// add (died) biomass from the regeneration layer
    void addToSoil(const Species *species, const CNPair &woody_pool, const CNPair &litter_pool);

    /// disturbance function: remove the fraction of 'factor' of biomass from the SWD pools; 0: remove nothing, 1: remove all
    void removeCarbon(const double factor);
    /// cut down swd and move to soil pools
    void management(const double factor);
    QList<QVariant> debugList(); ///< return a debug output
private:
    /// split the biomass of a tree into snag pools or move part of the tree directly to the soil
    void addBiomassPools(const Tree *tree, const double stem_to_snag, const double stem_to_soil, const double branch_to_snag, const double branch_to_soil, const double foliage_to_soil);
    double calculateClimateFactors(); ///< calculate climate factor 're' for the current year
    double mClimateFactor; ///< current mean climate factor (influenced by temperature and soil water content)
    const ResourceUnit *mRU; ///< link to resource unit
    /// access SWDPool as function of diameter (cm)
    int poolIndex(const float dbh) { if (dbh<mDBHLower) return 0; if (dbh>mDBHHigher) return 2; return 1;}
    CNPool mSWD[3]; ///< standing woody debris pool (0: smallest dimater class, e.g. <10cm, 1: medium, 2: largest class (e.g. >30cm)) kg/ha
    CNPair mTotalSWD; ///< sum of mSWD[x]
    double mNumberOfSnags[3]; ///< number of snags in diameter class
    double mAvgDbh[3]; ///< average diameter in class (cm)
    double mAvgHeight[3]; ///< average height in class (m)
    double mAvgVolume[3]; ///< average volume in class (m3)
    double mTimeSinceDeath[3]; ///< time since death: mass-weighted age of the content of the snag pool
    double mKSW[3]; ///< standing woody debris decay rate (weighted average of species values)
    double mCurrentKSW[3]; ///< swd decay rate (average for trees of the current year)
    double mHalfLife[3]; ///< half-life values (yrs) (averaged)
    CNPool mToSWD[3]; ///< transfer pool; input of the year is collected here (for each size class)
    CNPool mLabileFlux; ///< flux to labile soil pools (kg/ha)
    CNPool mRefractoryFlux; ///< flux to the refractory soil pool (kg/ha)
    CNPool mOtherWood[5]; ///< pool for branch biomass and coarse root biomass
    CNPair mTotalOther; ///< sum of mOtherWood[x]
    int mBranchCounter; ///< index which of the branch pools should be emptied
    double mTotalSnagCarbon; ///< sum of carbon content in all snag compartments (kg/ha)
    CNPair mTotalIn; ///< total input to the snag state (i.e. mortality/harvest and litter)
    CNPair mSWDtoSoil; ///< total flux from standing dead wood (book-keeping) -> soil (kg/ha)
    CNPair mTotalToAtm; ///< flux to atmosphere (kg/ha)
    CNPair mTotalToExtern; ///< total flux of masses removed from the site (i.e. harvesting) kg/ha
    CNPair mTotalToDisturbance; ///< fluxes due to disturbance
    static double mDBHLower, mDBHHigher; ///< thresholds used to classify to SWD-Pools
    static double mCarbonThreshold[3]; ///< carbon content thresholds that are used to decide if the SWD-pool should be emptied

    friend class Snapshot;
};

#endif // SNAG_H