species.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 SPECIES_H
#define SPECIES_H
#ifdef ILAND_GUI
#include <QColor>
#endif
 
#include "expression.h"
#include "globalsettings.h"
#include "speciesset.h"
 
class StampContainer; // forwards
class Stamp;
class Tree;
 
 
struct EstablishmentParameters
{
    double min_temp; 
    int chill_requirement; 
    int GDD_min, GDD_max; 
    double GDD_baseTemperature; 
    int bud_birst; 
    int frost_free; 
    double frost_tolerance; 
    double psi_min; 
    double SOL_thickness; 
    EstablishmentParameters(): min_temp(-37), chill_requirement(56), GDD_min(177), GDD_max(3261), GDD_baseTemperature(3.4),
                               bud_birst(255), frost_free(65), frost_tolerance(0.5), psi_min(0.), SOL_thickness(0.) {}
};
 
struct SaplingGrowthParameters
{
    Expression heightGrowthPotential; 
    int maxStressYears; 
    double stressThreshold; 
    float hdSapling; 
    double ReinekesR; 
    double referenceRatio; 
    SaplingGrowthParameters(): maxStressYears(3), stressThreshold(0.1), hdSapling(80.f), ReinekesR(1450.), referenceRatio(1.), browsingProbability(0.), sproutGrowth(0.) {}
    double representedStemNumberH(const double height) const { return mRepresentedClasses[limit(qRound(height*100.),0,mRepresentedClasses.size()-1)]; }
    double representedStemNumber(const double dbh) const { return ReinekesR*pow(dbh/25., -1.605) / double(cPxPerHectare); }
    double browsingProbability;
    double sproutGrowth; 
    double adultSproutProbability; 
    QVector<double> mRepresentedClasses; 
    void setupReinekeLookup();
};
 
 
class Species
{
public:
    Species(SpeciesSet *set) { mSet = set; mIndex=set->count(); mSeedDispersal=nullptr;  }
    ~Species();
    // maintenance
    void setup();
    void newYear();
 
    const SpeciesSet *speciesSet() const { return mSet; }
    // properties
    SeedDispersal *seedDispersal() const { return mSeedDispersal; }
    const QString &id() const { return mId; }
    const QString &name() const { return mName; }
#ifdef ILAND_GUI
    const QColor displayColor() const { return mDisplayColor; }
#endif
    int index() const { return mIndex; } 
    bool active() const { return true; } 
    int phenologyClass() const { return mPhenologyClass; } 
    bool isConiferous() const { return mConiferous; }
    bool isEvergreen() const { return mEvergreen; }
    bool isSeedYear() const { return mIsSeedYear; }
 
 
    // calculations: allometries for the tree compartments (stem, branches, foliage, fineroots, coarse roots)
    inline double biomassFoliage(const double dbh) const { return mFoliage_a * pow(dbh, mFoliage_b); }
    inline double biomassStem(const double dbh) const { return mStem_a * pow(dbh, mStem_b); }
    inline double biomassRoot(const double dbh) const { return mRoot_a * pow(dbh, mRoot_b); }
    inline double biomassBranch(const double dbh) const { return mBranch_a * pow(dbh, mBranch_b); }
    // inline double allometricRatio_wf() const { return mStem_b / mFoliage_b; }
    inline double allometricExponentStem() const { return mStem_b; }
    inline double allometricExponentBranch() const { return mBranch_b; }
    inline double allometricExponentFoliage() const { return mFoliage_b; }
    double allometricFractionStem(const double dbh) const;
    double finerootFoliageRatio() const { return mFinerootFoliageRatio; } 
    double barkThickness(const double dbh) const { return dbh * mBarkThicknessFactor; }
    // cn ratios
    double cnFoliage() const { return mCNFoliage; }
    double cnFineroot() const { return mCNFineroot; }
    double cnWood() const { return mCNWood; }
    // turnover rates
    double turnoverLeaf() const { return mTurnoverLeaf; }
    double turnoverRoot() const { return mTurnoverRoot; }
    // snags
    double snagKsw() const { return mSnagKSW; }
    double snagHalflife() const { return mSnagHalflife; }
    double snagKyl() const { return mSnagKYL; } 
    double snagKyr() const { return mSnagKYR; } 
 
    // hd-values
    void hdRange(const double dbh, double &rMinHD, double &rMaxHD) const;
    // growth
    double volumeFactor() const { return mVolumeFactor; } 
    double density() const { return mWoodDensity; } 
    double specificLeafArea() const { return mSpecificLeafArea; }
    // mortality
    double deathProb_intrinsic() const { return mDeathProb_intrinsic; }
    inline double deathProb_stress(const double &stress_index) const;
    // aging
    double aging(const float height, const int age) const;
    int estimateAge(const float height) const;
    // regeneration
    void seedProduction(const Tree *tree);
    void setSeedDispersal(SeedDispersal *seed_dispersal) {mSeedDispersal=seed_dispersal; }
    // environmental responses
    double vpdResponse(const double &vpd) const;
    inline double temperatureResponse(const double &delayed_temp) const;
    double nitrogenResponse(const double &availableNitrogen) const { return mSet->nitrogenResponse(availableNitrogen, mRespNitrogenClass); }
    double canopyConductance() const { return mMaxCanopyConductance; } 
    inline double soilwaterResponse(const double &psi_kPa) const; 
    double lightResponse(const double lightResourceIndex) const {return mSet->lightResponse(lightResourceIndex, mLightResponseClass); }
    double psiMin() const { return mPsiMin; }
    double vpdResponseExponent() const { return mRespVpdExponent; }
    // parameters for seed dispersal
    int maturityAge() const { return mMaturityYears; }
    void treeMigKernel(double &ras1, double &ras2, double &ks) const { ras1=mTM_as1; ras2=mTM_as2; ks=mTM_ks; }
    double fecundity_m2() const { return mFecundity_m2; }
    double nonSeedYearFraction() const { return mNonSeedYearFraction; }
    double fecunditySerotiny() const { return mSerotinyFecundity; }
    bool isTreeSerotinous(const int age) const;
 
    const EstablishmentParameters &establishmentParameters() const { return mEstablishmentParams; }
    const SaplingGrowthParameters &saplingGrowthParameters() const { return mSaplingGrowthParams; }
 
    const Stamp* stamp(const float dbh, const float height) const { return mLIPs.stamp(dbh, height);}
private:
    Q_DISABLE_COPY(Species)
    // helpers during setup
    bool boolVar(const QString s) { return mSet->var(s).toBool(); } 
    double doubleVar(const QString s) { return mSet->var(s).toDouble(); }
    int intVar(const QString s) { return mSet->var(s).toInt(); } 
    QString stringVar(const QString s) { return mSet->var(s).toString(); } 
    SpeciesSet *mSet; 
    StampContainer mLIPs; 
    QString mId;
    QString mName;
 
    int mIndex; 
    bool mConiferous; 
    bool mEvergreen; 
    // biomass allometries:
    double mFoliage_a, mFoliage_b;  
    double mStem_a, mStem_b; 
    double mRoot_a, mRoot_b; 
    double mBranch_a, mBranch_b; 
    // cn-ratios
    double mCNFoliage, mCNFineroot, mCNWood; 
    double mBarkThicknessFactor; 
 
    double mSpecificLeafArea; 
    // turnover rates
    double mTurnoverLeaf; 
    double mTurnoverRoot; 
    double mFinerootFoliageRatio; 
    // height-diameter-relationships
    Expression mHDlow; 
    Expression mHDhigh; 
    // stem density and taper
    double mWoodDensity; 
    double mFormFactor; 
    double mVolumeFactor; 
    // snag dynamics
    double mSnagKSW; 
    double mSnagKYL; 
    double mSnagKYR; 
    double mSnagHalflife; 
    // mortality
    double mDeathProb_intrinsic;  
    double mDeathProb_stress; 
    // Aging
    double mMaximumAge; 
    double mMaximumHeight; 
    Expression mAging;
    // environmental responses
    double mRespVpdExponent; 
    double mRespTempMin; 
    double mRespTempMax; 
    double mRespNitrogenClass; 
    double mPsiMin; 
    // water
    double mMaxCanopyConductance; 
    int mPhenologyClass;
    double mLightResponseClass; 
    // regeneration
    SeedDispersal *mSeedDispersal; 
    int mMaturityYears; 
    double mSeedYearProbability; 
    bool mIsSeedYear; 
    double mNonSeedYearFraction;  
    // regeneration - seed dispersal
    double mFecundity_m2; 
    double mTM_as1; 
    double mTM_as2; 
    double mTM_ks; 
    EstablishmentParameters mEstablishmentParams; 
    SaplingGrowthParameters mSaplingGrowthParams; 
    Expression mSerotiny; 
    double mSerotinyFecundity; 
 
#ifdef ILAND_GUI
    QColor mDisplayColor;
#else
    int mDisplayColor;
#endif
};
 
 
// inlined functions...
inline void Species::hdRange(const double dbh, double &rLowHD, double &rHighHD) const
{
    rLowHD = mHDlow.calculate(dbh);
    rHighHD = mHDhigh.calculate(dbh);
}
inline double Species::vpdResponse(const double &vpd) const
{
    return exp(mRespVpdExponent * vpd);
}
 
inline double Species::temperatureResponse(const double &delayed_temp) const
{
    double x = qMax(delayed_temp-mRespTempMin, 0.);
    x = qMin(x/(mRespTempMax-mRespTempMin), 1.);
    return x;
}
inline double Species::soilwaterResponse(const double &psi_kPa) const
{
    const double psi_mpa = psi_kPa / 1000.; // convert to MPa
    double result = limit( (psi_mpa - mPsiMin) / (-0.015 -  mPsiMin) , 0., 1.);
    return result;
}
 
inline double Species::deathProb_stress(const double &stress_index) const
{
    if (stress_index==0.)
        return 0.;
    double result = 1. - exp(-mDeathProb_stress*stress_index);
    return result;
}
 
#endif // SPECIES_H