tree.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 TREE_H
#define TREE_H
#include <QPointF>
 
#include "grid.h"
 
 
// mortality workshop 2015 / COST Action with H. Bugmann
//#define ALT_TREE_MORTALITY
 
 
// forwards
class Species;
class Stamp;
class ResourceUnit;
struct HeightGridValue;
struct TreeGrowthData;
class TreeOut;
class TreeRemovedOut;
class LandscapeRemovedOut;
class Saplings;
class ScriptTree;
 
class Tree
{
public:
    // lifecycle
    Tree();
    void setup(); 
 
    // access to properties
    int id() const { return mId; } 
    int age() const { return mAge; } 
    const QPointF position() const { Q_ASSERT(mGrid!=0); return mGrid->cellCenterPoint(mPositionIndex); }
 
    const QPoint positionIndex() const { return mPositionIndex; } 
    const Species* species() const { Q_ASSERT(mRU!=0); return mSpecies; } 
    const ResourceUnit *ru() const { Q_ASSERT(mRU!=0); return mRU; } 
 
    // properties
    float dbh() const { return mDbh; } 
    float height() const { return mHeight; } 
    float lightResourceIndex() const { return mLRI; } 
    float leafArea() const { return mLeafArea; } 
    double volume() const; 
    double basalArea() const; 
    bool isDead() const { return flag(Tree::TreeDead); } 
    float crownRadius() const; 
    // biomass properties
    float biomassFoliage() const { return mFoliageMass; } 
    float biomassBranch() const { return mBranchMass; }  
    float biomassFineRoot() const { return mFineRootMass; } 
    float biomassCoarseRoot() const { return mCoarseRootMass; } 
    float biomassStem() const { return mStemMass + mNPPReserve; } 
    float biomassReserve() const { return mNPPReserve; } 
    double barkThickness() const; 
    float stressIndex() const { return mStressIndex; } 
 
    // actions
    enum TreeRemovalType { TreeDeath=0, TreeHarvest=1, TreeDisturbance=2, TreeSalavaged=3, TreeKilled=4, TreeCutDown=5};
    void die(TreeGrowthData *d=nullptr);
    void remove(double removeFoliage=0., double removeBranch=0., double removeStem=0. );
    void removeDisturbance(const double stem_to_soil_fraction, const double stem_to_snag_fraction,
                           const double branch_to_soil_fraction, const double branch_to_snag_fraction,
                           const double foliage_to_soil_fraction);
 
    void enableDebugging(const bool enable=true) {setFlag(Tree::TreeDebugging, enable); }
    void removeBiomassOfTree(const double removeFoliageFraction, const double removeBranchFraction, const double removeStemFraction);
    void removeRootBiomass(const double removeFineRootFraction, const double removeCoarseRootFraction);
 
    // setters for initialization
    void setNewId() { mId = m_nextId++; } 
    void setId(const int id) { mId = id; } 
    void setPosition(const QPointF pos) { Q_ASSERT(mGrid!=nullptr); mPositionIndex = mGrid->indexAt(pos); }
    void setPosition(const QPoint posIndex) { mPositionIndex = posIndex; }
    void setDbh(const float dbh) { mDbh=dbh; }
    void setHeight(const float height);
    void setSpecies(Species *ts) { mSpecies=ts; }
    void setRU(ResourceUnit *ru) { mRU = ru; }
    void setAge(const int age, const float treeheight);
 
    // management flags (used by ABE management system)
    void markForHarvest(bool do_mark) { setFlag(Tree::MarkForHarvest, do_mark);}
    bool isMarkedForHarvest() const { return flag(Tree::MarkForHarvest);}
    void markForCut(bool do_mark) { setFlag(Tree::MarkForCut, do_mark);}
    bool isMarkedForCut() const { return flag(Tree::MarkForCut);}
    void markCropTree(bool do_mark) { setFlag(Tree::MarkCropTree, do_mark);}
    bool isMarkedAsCropTree() const { return flag(Tree::MarkCropTree);}
    void markCropCompetitor(bool do_mark) { setFlag(Tree::MarkCropCompetitor, do_mark);}
    bool isMarkedAsCropCompetitor() const { return flag(Tree::MarkCropCompetitor);}
    // death reasons
    void setDeathReasonWind()  { setFlag(Tree::TreeDeadWind, true); }
    void setDeathReasonBarkBeetle()  { setFlag(Tree::TreeDeadBarkBeetle, true); }
    void setDeathReasonFire()  { setFlag(Tree::TreeDeadFire, true); }
    void setDeathCutdown()  { setFlag(Tree::TreeDeadKillAndDrop, true); }
    void setAffectedBite() { setFlag(Tree::TreeAffectedBite, true); }
    void setIsHarvested()  { setFlag(Tree::TreeHarvested, true); }
 
    bool isDeadWind() const { return flag(Tree::TreeDeadWind);}
    bool isDeadBarkBeetle() const { return flag(Tree::TreeDeadBarkBeetle);}
    bool isDeadFire() const { return flag(Tree::TreeDeadFire);}
    bool isAffectedBite() const { return flag(Tree::TreeAffectedBite); }
    bool isCutdown() const { return flag(Tree::TreeDeadKillAndDrop);}
    bool isHarvested() const { return flag(Tree::TreeHarvested);}
 
    // grid based light-concurrency functions
    void applyLIP(); 
    void readLIF(); 
    void heightGrid(); 
 
    void applyLIP_torus(); 
    void readLIF_torus(); 
    void heightGrid_torus(); 
 
    void calcLightResponse(); 
    // growth, etc.
    void grow(); 
 
    // static functions
    static void setGrid(FloatGrid* gridToStamp, Grid<HeightGridValue> *dominanceGrid);
    // statistics
    static void resetStatistics();
    static int statPrints() { return m_statPrint; }
    static int statCreated() { return m_statCreated; }
#ifdef ALT_TREE_MORTALITY
    static void mortalityParams(double dbh_inc_threshold, int stress_years, double stress_mort_prob);
#endif
 
    QString dump();
    void dumpList(QList<QVariant> &rTargetList);
    const Stamp *stamp() const { return mStamp; } 
 
private:
    // helping functions
    void partitioning(TreeGrowthData &d); 
    double relative_height_growth(); 
    void grow_diameter(TreeGrowthData &d); 
    void mortality(TreeGrowthData &d); 
 
#ifdef ALT_TREE_MORTALITY
    void altMortality(TreeGrowthData &d); 
#endif
    void notifyTreeRemoved(TreeRemovalType reason); 
 
    // state variables
    int mId; 
    int mAge; 
    float mDbh; 
    float mHeight; 
    QPoint mPositionIndex; 
    // biomass compartements
    float mLeafArea; 
    float mOpacity; 
    float mFoliageMass; 
    float mStemMass; 
    float mBranchMass; 
    float mFineRootMass; 
    float mCoarseRootMass; 
    // production relevant
    float mNPPReserve; 
    float mLRI; 
    float mLightResponse; 
    // auxiliary
    float mDbhDelta; 
    float mStressIndex; 
 
    // Stamp, Species, Resource Unit
    const Stamp *mStamp;
    Species *mSpecies;
    ResourceUnit *mRU;
 
    // various flags
    int mFlags;
    enum Flags { TreeDead=1, TreeDebugging=2,
                 TreeDeadBarkBeetle=16, TreeDeadWind=32, TreeDeadFire=64, TreeDeadKillAndDrop=128, TreeHarvested=256,
                 MarkForCut=512, // mark tree for being cut down
                 MarkForHarvest=1024, // mark tree for being harvested
                 MarkCropTree=2048, // mark as crop tree
                 MarkCropCompetitor=4096, // mark as competitor for a crop tree
                 TreeAffectedBite=8192 // affected or killed by biotic disturbance module (BITE)
               };
    void setFlag(const Tree::Flags flag, const bool value) { if (value) mFlags |= flag; else mFlags &= (flag ^ 0xffffff );}
    void setFlag(const int flag, const bool value) { if (value) mFlags |= flag; else mFlags &= (flag ^ 0xffffff );}
    bool flag(const Tree::Flags flag) const { return mFlags & flag; }
    int flags() const {return mFlags; }
 
    // special functions
    bool isDebugging() { return flag(Tree::TreeDebugging); }
 
    // static data
    static FloatGrid *mGrid;
    static Grid<HeightGridValue> *mHeightGrid;
    static TreeRemovedOut *mRemovalOutput;
    static void setTreeRemovalOutput(TreeRemovedOut *rout) { mRemovalOutput=rout; }
    static LandscapeRemovedOut *mLSRemovalOutput;
    static void setLandscapeRemovalOutput(LandscapeRemovedOut *rout) { mLSRemovalOutput=rout; }
    static Saplings *saps;
 
    // statistics
    static int m_statPrint;
    static int m_statAboveZ;
    static int m_statCreated;
    static int m_nextId;
 
    // friends
    friend class TreeWrapper;
    friend class StandStatistics;
    friend class TreeOut;
    friend class TreeRemovedOut;
    friend class LandscapeRemovedOut;
    friend class Snapshot;
    friend class SnapshotItem;
    friend class ScriptTree;
};
 
struct TreeGrowthData
{
    double NPP; 
    double NPP_above; 
    double NPP_stem;  
    double stress_index; 
    TreeGrowthData(): NPP(0.), NPP_above(0.), NPP_stem(0.), stress_index(0.) {}
};
#endif // TREE_H