fmstand.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 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; 
    double basalArea; 
    double relBasalArea; 
};
 
class FMStand
{
public:
    FMStand(FMUnit *unit, const int id);
    void setSTP(FMSTP *stp) {mSTP = stp; }
    void initialize();
    void reset(FMSTP *stp);
    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
    double U() const { return mU; }
    int thinningIntensity() const { return mThinningIntensityClass; }
    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
    double area() const    {  return mArea; }
    double absoluteAge() const;
    double basalArea() const {return mTotalBasalArea; }
    double age() const {return mAge; }
    double volume() const {return mVolume; }
    double stems() const {return mStems; }
    double dbh() const {return mDbh; }
    double height() const {return mHeight; }
    double topHeight() const {return mTopHeight; }
    double scheduledHarvest() const {return mScheduledHarvest; }
    double totalHarvest() const { return mFinalHarvested + mThinningHarvest + mSalvaged; }
    double totalThinningHarvest() const { return mThinningHarvest; }
    double disturbedTimber() const { return mDisturbed; }
    double salvagedTimber() const { return mSalvaged; }
 
    double meanAnnualIncrement() const { return mMAIdecade; }
    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(); }
    SSpeciesStand &speciesData(const int index) {return mSpeciesData[index]; }
    SSpeciesStand &speciesData(const Species *species); 
 
 
    // actions
    bool execute(); 
    bool executeActivity(Activity *act); 
    bool afterExecution(bool cancel = false);
 
    void addScheduledHarvest(const double add_volume) {mScheduledHarvest += add_volume; }
    void notifyTreeRemoval(Tree *tree, int reason);
    bool notifyBarkBeetleAttack(double generations, int infested_px_per_ha);
 
    void resetHarvestCounter() { mFinalHarvested = 0.;  mThinningHarvest=0.;  }
    void resetDisturbanceSalvage() { mSalvaged=0.;  mDisturbed=0.; }
 
    void sleep(int years_to_sleep);
    int sleepYears() const {return mYearsToWait; }
 
    double calculateMAI();
 
    void setAbsoluteAge(const double age);
 
    int setToLatestForcedActivity();
 
 
    // return stand-specific flags
    ActivityFlags &flags(const int index)  {return mStandFlags[index]; }
    ActivityFlags &currentFlags()  { return flags(mCurrentIndex); }
    Activity *currentActivity() const { return mCurrentIndex>-1?mStandFlags[mCurrentIndex].activity():nullptr; }
 
    Activity *lastExecutedActivity() const { return mLastExecutedIndex>-1?mStandFlags[mLastExecutedIndex].activity():nullptr; }
 
    int lastExecutionAge() const { return absoluteAge()>0 ? static_cast<int>(absoluteAge()) : mLastRotationAge; }
 
    // custom property storage
    static void clearAllProperties() { mStandPropertyStorage.clear(); }
    void setProperty(const QString &name, QJSValue value);
    QJSValue property(const QString &name) const;
 
    // retrieve current state of the object
    QStringList info();
    friend class FOMEWrapper;
private:
    int mId; 
    FMUnit *mUnit; 
    FMSTP *mSTP; 
    Activity::Phase mPhase; 
    int mInitialId; 
    int mStandType; 
    double mArea; 
    double mTotalBasalArea; 
    double mAge; 
    double mVolume; 
    double mStems; 
    double mDbh; 
    double mHeight; 
    double mTopHeight; 
    double mScheduledHarvest; 
    double mFinalHarvested; 
    double mThinningHarvest; 
    double mDisturbed; 
    double mSalvaged; 
 
    double mRemovedVolumeDecade; 
    double mRemovedVolumeTotal; 
 
    double mLastMAIVolume; 
    double mMAIdecade; 
    double mMAItotal; 
 
 
    int mRotationStartYear; 
    int mYearsToWait; 
    int mCurrentIndex; 
    int mLastUpdate; 
    int mLastExecution; 
    int mLastExecutedIndex; 
    int mLastRotationAge; 
 
    double mU; 
    int mSpeciesCompositionIndex; 
    int mThinningIntensityClass; 
 
    void newRotatation(); 
 
    // 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