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 FMSTAND_H
#define FMSTAND_H

#include <QHash>
#include <QJSValue>

#include "activity.h"

class Species; // forward (iLand species)
class Tree; // forward (iLand tree)
//enum TreeRemovalType; // forward

namespace ABE {

class FOMEWrapper; // forward
class FMUnit; // forward

struct SSpeciesStand
{
    SSpeciesStand(): species(0), basalArea(0.), relBasalArea(0.) {}
    const Species *species; ///< the ID of the species (ie a pointer)
    double basalArea; ///< basal area m2
    double relBasalArea; ///< fraction [0..1] fraction of species based on basal area.
};

/** FMStand encapsulates a forest stand for the forest management engine.
 *  The spatial coverage is defined by a "stand grid".
 * */

class FMStand
{
public:
    /// c'tor: link stand to a forest management unit
    FMStand(FMUnit *unit, const int id);
    /// set the stand to be managed by a given 'stp'
    void setSTP(FMSTP *stp) {mSTP = stp; }
    void initialize();
    /// sets the STP but nothing else (after disturbance related clearance)
    void reset(FMSTP *stp);
    /// returns true if tracing is enabled for the stand
    bool trace() const { return property(QStringLiteral("trace")).toBool(); }
    const QString &context() const { return mContextStr; }

    void checkArea();
    void setArea(const double new_area_ha) { mArea = new_area_ha; } // area in ha

    void reload(bool force=false); // fetch new data from the forest stand
    // general properties
    int id() const {return mId; }
    const FMUnit *unit() const { return mUnit; }
    Activity::Phase phase() const { return mPhase; }
    int standType() const { return mStandType; }
    FMSTP *stp() const {return mSTP; }
    int lastUpdate() const { return mLastUpdate; }
    int lastExecution() const { return mLastExecution; }
    int initialStandId() const { return mInitialId; }
    void setInitialId(int origin_id) { mInitialId = origin_id; }
    // agent properties
    /// rotation period (years)
    double U() const { return mU; }
    /// thinning intensity (class); 1: low, 2: medium, 3: high
    int thinningIntensity() const { return mThinningIntensityClass; }
    /// species composition key
    int targetSpeciesIndex() const { return mSpeciesCompositionIndex; }

    void setU(const double rotation_length) { mU = rotation_length; }
    void setThinningIntensity(const int th_class) { mThinningIntensityClass = th_class; }
    void setTargetSpeciesIndex(const int index) { mSpeciesCompositionIndex = index; }

    // stand properties
    /// total area of the stand (ha)
    double area() const    {  return mArea; }
    /// absolute age: years since the rotation has started (years)
    double absoluteAge() const;
    /// total basal area (m2/ha)
    double basalArea() const {return mTotalBasalArea; }
    /// (average) age of the stand (weighted with basal area)
    double age() const {return mAge; }
    /// total standing volume (m3/ha) in the stand
    double volume() const {return mVolume; }
    /// number of trees of the stand (stems/ha) (>4m)
    double stems() const {return mStems; }
    /// mean dbh (basal area weighted, of trees>4m) in cm
    double dbh() const {return mDbh; }
    /// mean tree height (basal area weighted, of trees>4m), in m
    double height() const {return mHeight; }
    /// top height (mean height of the 100 thickest trees/ha), in m
    double topHeight() const {return mTopHeight; }
    /// scheduled harvest (planned harvest by activities, m3)
    double scheduledHarvest() const {return mScheduledHarvest; }
    /// total realized harvest (m3 on the full stand area) (note: salvage harvest ist part of final harvest)
    double totalHarvest() const { return mFinalHarvested + mThinningHarvest; }
    /// total realized thinning/tending harvests (m3 on the full stand area)
    double totalThinningHarvest() const { return mThinningHarvest; }
    /// total disturbed timber volume, includes also disturbed trees *not* harvested, m3
    double disturbedTimber() const { return mDisturbed; }

    /// mean annual increment (MAI), m3 timber/ha for the last decade
    double meanAnnualIncrement() const { return mMAIdecade; }
    /// mean annual increment (MAI), m3 timber/ha for the full rotation period
    double meanAnnualIncrementTotal() const { return mMAItotal; }

    bool readyForFinalHarvest() {return absoluteAge()> 0.8*U(); } // { return currentActivity()?(currentFlags().isFinalHarvest() && currentFlags().isScheduled()):false; }

    // specialized functions (invokable also from javascript)
    double basalArea(const QString &species_id) const;
    double relBasalArea(const QString &species_id) const;

    int nspecies() const  { return mSpeciesData.count(); }
    /// retrieve species-specific meta data by index (0: largest basal area share, up to nspecies()-1)
    SSpeciesStand &speciesData(const int index) {return mSpeciesData[index]; }
    SSpeciesStand &speciesData(const Species *species); ///< species-specific meta data by Species pointer


    void setAbsoluteAge(const double age);
    // actions
    /// main function
    bool execute(); ///< execute the current activity
    bool executeActivity(Activity *act); ///< execute activity given by "act".
    bool afterExecution(bool cancel = false);

    /// add a (simulated) harvest to the amount of planned harvest (used by the scheduling)
    void addScheduledHarvest(const double add_volume) {mScheduledHarvest += add_volume; }
    /// is called whenever a tree is removed (death, management, disturbance)
    void notifyTreeRemoval(Tree *tree, int reason);
    /// is called when bark beetles are likely to attack: return ABE changed forest structure
    bool notifyBarkBeetleAttack(double generations, int infested_px_per_ha);

    /// resets the harvest counters
    void resetHarvestCounter() { mFinalHarvested = 0.; mDisturbed=0.; mThinningHarvest=0.; }

    /// sleep() pauses the evaluation/execution of management activities
    /// for 'years_to_sleep'.
    void sleep(int years_to_sleep);
    int sleepYears() const {return mYearsToWait; }

    /// calculate mean annual increment (m3/ha) and return total MAI.
    double calculateMAI();

    // return stand-specific flags
    ActivityFlags &flags(const int index)  {return mStandFlags[index]; }
    /// flags of currently active Activity
    ActivityFlags &currentFlags()  { return flags(mCurrentIndex); }
    /// get a pointer to the current activity; returns 0 if no activity is set.
    Activity *currentActivity() const { return mCurrentIndex>-1?mStandFlags[mCurrentIndex].activity():0; }

    /// get a pointer to the last executed activity; returns 0 if no activity has been executed before.
    Activity *lastExecutedActivity() const { return mLastExecutedIndex>-1?mStandFlags[mLastExecutedIndex].activity():0; }

    int lastExecutionAge() const { return absoluteAge()>0 ? absoluteAge() : mLastRotationAge; }

    // custom property storage
    static void clearAllProperties() { mStandPropertyStorage.clear(); }
    /// set a property value for the current stand with the name 'name'
    void setProperty(const QString &name, QJSValue value);
    /// retrieve the value of the property 'name'. Returns an empty QJSValue if the property is not defined.
    QJSValue property(const QString &name) const;

    // retrieve current state of the object
    QStringList info();
    friend class FOMEWrapper;
private:
    int mId; ///< the unique numeric ID of the stand
    FMUnit *mUnit; ///< management unit that
    FMSTP *mSTP; ///< the stand treatment program assigned to this stand
    Activity::Phase mPhase; ///< silvicultural phase
    int mInitialId; ///< stand-id that was assigned in the beginning (this Id is kept when stands are split)
    int mStandType; ///< enumeration of stand (compositional)
    double mArea; ///< total stand area (ha)
    double mTotalBasalArea; ///< basal area of the stand
    double mAge; ///< average age (yrs) of the stand (basal area weighted)
    double mVolume; ///< standing volume (m3/ha) of the stand
    double mStems; ///< stems per ha (above 4m)
    double mDbh; ///< mean dbh (basal area weighted, of trees>4m) in cm
    double mHeight; ///< mean tree height (basal area weighted, of trees>4m), in m
    double mTopHeight; ///< top height (mean height of the 100 thickest trees per ha)
    double mScheduledHarvest; ///< harvest (m3) that is scheduled by activities
    double mFinalHarvested; ///< m3 of timber volume that has been harvested (regeneration phase)
    double mThinningHarvest; ///< m3 of timber that was harvested for thinning/tending
    double mDisturbed; ///< removed due to disturbance

    double mRemovedVolumeDecade; ///< removed volume of the decade (m3/ha)
    double mRemovedVolumeTotal; ///< removed volume of the rotation (m3/ha)

    double mLastMAIVolume; ///< safe the standing volume
    double mMAIdecade; ///< decadal mean annual increment (m3/ha*yr)
    double mMAItotal; ///< total (over the full rotation) mean annual increment (m3/ha*yr)


    int mRotationStartYear; ///< absolute year the current rotation has started
    int mYearsToWait; ///< variable indicates time to wait
    int mCurrentIndex; ///< the index of the current activity
    int mLastUpdate; ///< year of the last reload of data
    int mLastExecution; ///< year of the last execution of an activity
    int mLastExecutedIndex; ///< index of the last executed activity
    int mLastRotationAge; ///< age at which the last rotation ended

    double mU; ///< rotation length
    int mSpeciesCompositionIndex; ///< index of the active target species composition
    int mThinningIntensityClass; ///< currently active thinning intensity level

    void newRotatation(); ///< reset

    // storage for stand meta data (species level)
    QVector<SSpeciesStand> mSpeciesData;
    // storage for stand-specific management properties
    QVector<ActivityFlags> mStandFlags;
    // additional property values for each stand
    QString mContextStr;
    static QHash<const FMStand*, QHash<QString, QJSValue> > mStandPropertyStorage;

    friend class StandObj;
};


} // namespace
#endif // FMSTAND_H