saplings.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 SAPLINGS_H
#define SAPLINGS_H
 
#include "grid.h"
#include "snag.h"
#include "model.h"
#include <QRectF>
class ResourceUnitSpecies; // forward
class ResourceUnit; // forward
 
struct SaplingTree {
    SaplingTree() { clear(); }
    short unsigned int age;  // age of the cohort in years
    short signed int species_index; // index of the species within the resource-unit-species container
    unsigned char stress_years; // number of consecutive years that a sapling suffers from stress
    unsigned char flags; // flags, e.g. whether sapling stems from sprouting
    float height; // height of the sapling in meter
    bool is_occupied() const { return height>0.f; }
    void clear()  {  age=0; species_index=-1; stress_years=0; flags=0; height=0.f;  }
    void setSapling(const float h_m, const int age_yrs, const int species_idx) { height=h_m;
                                                                                 age=static_cast<short unsigned int>(age_yrs);
                                                                                 stress_years=0;
                                                                                 species_index=static_cast<short signed int>(species_idx); }
    // flags
    // sprouting - bit 1
    bool is_sprout() const { return flags & 1; }
    void set_sprout(const bool sprout) {if (sprout) flags |= 1; else flags &= (1 ^ 0xffffff ); }
    // browsing - bit 2
    bool is_browsed() const { return flags & 2; }
    void set_browsed(const bool browse) {if (browse) flags |= 2; else flags &= (2 ^ 0xffffff ); }
    // get resource unit species of the sapling tree
    ResourceUnitSpecies *resourceUnitSpecies(const ResourceUnit *ru) const;
};
#define NSAPCELLS 5
struct SaplingCell {
    enum ECellState { CellInvalid=0, 
                      CellEmpty=1,   
                      CellGrass=2,   
                      CellFree=3,    
                      CellFull=4};   
    SaplingCell() {
        state=CellInvalid;
        ru=nullptr;
    }
    ECellState state;
    SaplingTree saplings[NSAPCELLS];
    ResourceUnit *ru;
    bool hasFreeSlots() const {return state>CellInvalid && state<CellFull; }
    void checkState() { if (state==CellInvalid) return;
                        bool free = false;
                        bool occupied=false;
                        for (int i=0;i<NSAPCELLS;++i) {
                            // locked for all species, if a sapling of one species >1.3m
                            if (saplings[i].height>1.3f) {state = CellFull; return; }
                            occupied |= saplings[i].is_occupied();
                            // locked, if all slots are occupied.
                            if (!saplings[i].is_occupied())
                                free=true;
                        }
                        state = free? (occupied? CellEmpty: CellFree) : CellFull;
                      }
    int free_index() {
        for (int i=0;i<NSAPCELLS;++i)
            if (!saplings[i].is_occupied())
                return i;
        return -1;
    }
    int n_occupied() {
        int n=0;
        for (int i=0;i<NSAPCELLS;++i)
            n+=saplings[i].is_occupied();
        return n;
    }
 
    SaplingTree *addSapling(const float h_m, const int age_yrs, const int species_idx) {
        int idx = free_index();
        if (idx==-1)
            return nullptr;
        saplings[idx].setSapling(h_m, age_yrs, species_idx);
        return &saplings[idx];
    }
    float max_height() { if (state==CellInvalid) return 0.f;
                         float h_max = 0.f;
                         for (int i=0;i<NSAPCELLS;++i)
                             h_max = std::max(saplings[i].height, h_max);
                         return h_max;
                       }
    bool has_new_saplings() { if (state==CellInvalid) return 0.f;
                        for (int i=0;i<NSAPCELLS;++i)
                            if (saplings[i].is_occupied() && saplings[i].age<2)
                                return true;
                        return false;
    }
    SaplingTree *saplingOfSpecies(int species_index) {
        if (state==CellInvalid) return nullptr;
        for (int i=0;i<NSAPCELLS;++i)
            if (saplings[i].species_index == species_index)
                return &saplings[i];
        return nullptr;
    }
};
class ResourceUnit;
class Saplings;
 
class SaplingStat
{
public:
    SaplingStat() { clearStatistics(); }
    void clearStatistics();
    void calculate(const Species *species, ResourceUnit *ru);
    // actions
    void addCarbonOfDeadSapling(float dbh) { mDied++; mSumDbhDied+=dbh;  }
 
    // access to statistics
    int newSaplings() const { return mAdded; }
    int newSaplingsVegetative() const { return mAddedVegetative; }
    int diedSaplings() const { return mDied; }
    int livingCohorts() const { return mLiving; } 
    double livingSaplings() const { return mLivingSaplings; } 
    double livingSaplingsSmall() const { return mLivingSmallSaplings; }
    int recruitedSaplings() const { return mRecruited; }
    double livingStemNumber(const Species *species, double &rAvgDbh, double &rAvgHeight, double &rAvgAge) const;
 
    double averageHeight() const { return mAvgHeight; }
    double averageAge() const { return mAvgAge; }
    double averageDeltaHPot() const { return mAvgDeltaHPot; }
    double averageDeltaHRealized() const { return mAvgHRealized; }
    float leafArea() const { return mLeafArea; }
    void setLeafArea(float leaf_area){ mLeafArea = leaf_area; }
    double leafAreaIndex() const {return mLeafAreaIndex; }
    double basalArea() const { return mBasalArea; }
    // carbon and nitrogen
    const CNPair &carbonLiving() const { return mCarbonLiving; } 
    const CNPair &carbonGain() const { return mCarbonGain; } 
 
private:
    short int mAdded; 
    short int mAddedVegetative; 
    short int mRecruited; 
    short int mDied; 
    float mSumDbhDied; 
    short int mLiving; 
    short int mCohortsWithDbh; 
    float mLivingSaplings; 
    float mLivingSmallSaplings; 
    float mAvgHeight; 
    float mAvgAge; 
    float mAvgDeltaHPot; 
    float mAvgHRealized; 
    float mLeafArea; 
    float mLeafAreaIndex; 
    float mBasalArea; 
    CNPair mCarbonLiving; 
    CNPair mCarbonGain; 
    float mCarbonOfRecruitedTrees; 
 
    friend class Saplings;
 
};
class Saplings
{
public:
    Saplings();
    void setup();
    void calculateInitialStatistics(const ResourceUnit *ru);
    // main functions
    void establishment(const ResourceUnit *ru);
    void saplingGrowth(const ResourceUnit *ru);
 
    void simplifiedGrassCover(const ResourceUnit *ru);
 
    double topHeight(const ResourceUnit *ru) const;
 
    // access
    SaplingCell *cell(QPoint lif_coords, bool only_valid=true, ResourceUnit **rRUPtr=nullptr);
 
    QPointF coordOfCell(ResourceUnit *ru, int cell_index);
 
    void clearSaplings(const QRectF &rectangle, const bool remove_biomass, bool resprout);
    void clearSaplings(SaplingCell *s, ResourceUnit *ru, const bool remove_biomass, bool resprout);
    void clearAllSaplings();
 
    int addSaplings(const QRectF &rectangle, QString species, double height, int age);
 
    int addSprout(const Tree *t, bool tree_is_removed);
 
    static void setRecruitmentVariation(const double variation) { mRecruitmentVariation = variation; }
    static void updateBrowsingPressure();
 
private:
    bool growSapling(const ResourceUnit *ru, SaplingCell &scell, SaplingTree &tree, int isc, HeightGridValue &hgv, float lif_value, int cohorts_on_px);
    void vegetativeSprouting(const Species *species, SaplingCell &scell, QPoint tree_pos);
    //Grid<SaplingCell> mGrid;
    static double mRecruitmentVariation;
    static double mBrowsingPressure;
};
 
 
class MapGrid; // forward
class SaplingCellRunner
{
public:
    SaplingCellRunner(const int stand_id, const MapGrid *stand_grid=nullptr);
    ~SaplingCellRunner();
    SaplingCell *next();
    ResourceUnit *ru() const { return mRU; }
    QPointF currentCoord() const;
private:
    GridRunner<float> *mRunner;
    ResourceUnit *mRU;
    const MapGrid *mStandGrid;
    int mStandId;
};
 
#endif // SAPLINGS_H