snag.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 SNAG_H
#define SNAG_H
#include <QList>
#include <QVariant>
class Tree; // forward
class Species; // forward
class ResourceUnit; // forward
 
class CNPair
{
public:
    CNPair(): C(0.), N(0.) {}
    static void setCFraction(const double fraction) { biomassCFraction = fraction; } 
    CNPair(const double c, const double n) {C=c; N=n; }
    bool isEmpty() const { return C==0.; } 
    bool isValid() const { return C>=0. && N>=0.; } 
    double C; // carbon pool (kg C/ha)
    double N; // nitrogen pool (kg N/ha)
    double CN() { return N>0?C/N:0.; } 
    void clear() {C=0.; N=0.; }
    double biomass() const {return C / biomassCFraction; }
    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; } 
    void operator*=(const double factor) { C*=factor; N*=factor; } 
    const CNPair operator+(const CNPair &p2) const { return CNPair(C+p2.C, N+p2.N); } 
    const CNPair operator-(const CNPair &p2) const { return CNPair(C-p2.C, N-p2.N); } 
    const CNPair operator*(const double factor) const { return CNPair(C*factor, N*factor); } 
protected:
    static double biomassCFraction;
};
 
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; } 
    double parameter(const CNPool &s) const; 
    void clear() { CNPair::clear(); mParameter=0.; }
 
    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));} 
    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); } 
private:
    double mParameter;
};
 
class Snag
{
public:
    Snag();
    static void setupThresholds(const double lower, const double upper); 
    void setup( const ResourceUnit *ru); 
    void scaleInitialState(); 
    void newYear(); 
    void calculateYear(); 
    // access
    bool isStateEmpty() const { return mTotalSnagCarbon == 0.; }
    bool isEmpty() const { return mLabileFlux.isEmpty() && mRefractoryFlux.isEmpty() && isStateEmpty(); }
    const CNPool &labileFlux() const { return mLabileFlux; } 
    const CNPool &refractoryFlux() const {return  mRefractoryFlux; } 
    double labileFluxAbovegroundCarbon() const { return mLabileFluxAbovegroundCarbon; } 
    double refractoryFluxAbovegroundCarbon() const { return mRefrFluxAbovegroundCarbon; } 
    double climateFactor() const { return mClimateFactor; } 
    double totalCarbon() const { return mTotalSnagCarbon; } 
    const CNPair &totalSWD() const { return mTotalSWD; } 
    const CNPair &totalOtherWood() const { return mTotalOther; } 
    double otherWoodAbovegroundFraction() const { return mOtherWoodAbovegroundFrac; } 
    const CNPair &fluxToAtmosphere() const { return mTotalToAtm; } 
    const CNPair &fluxToExtern() const { return mTotalToExtern; } 
    const CNPair &fluxToDisturbance() const { return mTotalToDisturbance; } 
 
    double freshDeciduousFoliage() const { return mDeciduousFoliageLitter; }
    // actions
    void addTurnoverLitter(const Species *species, const double litter_foliage, const double litter_fineroot);
    void addTurnoverWood(const Species *species, const double woody_biomass);
 
    void addMortality(const Tree* tree);
 
    void addHarvest(const Tree* tree, const double remove_stem_pct, const double remove_branch_pct, const double remove_foliage_pct );
 
    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);}
 
    void addToSoil(const Species *species, const CNPair &woody_pool, const CNPair &litter_pool, double woody_aboveground_C, double fine_aboveground_C);
 
    void addBiomassToSoil(const CNPool &woody_pool, const CNPool &litter_pool);
 
    void removeCarbon(const double factor);
    void management(const double factor);
    QList<QVariant> debugList(); 
private:
    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(); 
    double mClimateFactor; 
    const ResourceUnit *mRU; 
    int poolIndex(const float dbh) { if (dbh<mDBHLower) return 0; if (dbh>mDBHHigher) return 2; return 1;}
    CNPool mSWD[3]; 
    CNPair mTotalSWD; 
    double mNumberOfSnags[3]; 
    double mAvgDbh[3]; 
    double mAvgHeight[3]; 
    double mAvgVolume[3]; 
    double mTimeSinceDeath[3]; 
    double mKSW[3]; 
    double mCurrentKSW[3]; 
    double mHalfLife[3]; 
    CNPool mToSWD[3]; 
    CNPool mLabileFlux; 
    CNPool mRefractoryFlux; 
    CNPool mOtherWood[5]; 
    CNPair mTotalOther; 
    int mBranchCounter; 
    double mDeciduousFoliageLitter; 
    double mLabileFluxAbovegroundCarbon; 
    double mRefrFluxAbovegroundCarbon; 
    double mOtherWoodAbovegroundFrac; 
    double mTotalSnagCarbon; 
    CNPair mTotalIn; 
    CNPair mSWDtoSoil; 
    CNPair mTotalToAtm; 
    CNPair mTotalToExtern; 
    CNPair mTotalToDisturbance; 
    static double mDBHLower, mDBHHigher; 
    static double mCarbonThreshold[3]; 
 
    friend class Snapshot;
};
 
#endif // SNAG_H