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 FOMESCRIPT_H

#define FOMESCRIPT_H

#include <QObject>

#include <QStringList>

#include "fmstand.h"

#include "fmunit.h"

namespace ABE {

class StandObj;

class UnitObj;

class SimulationObj;

class SchedulerObj;

class STPObj;

class FMTreeList; // forward

class FMSTP; // forward

class ActivityObj;

/// FomeScript provides general helping functions for the Javascript world.

/// the object is known as 'fmengine'.

class FomeScript : public QObject

{

    Q_OBJECT

    Q_PROPERTY(bool verbose READ verbose WRITE setVerbose)

    Q_PROPERTY(int standId READ standId WRITE setStandId)

public:

    explicit FomeScript(QObject *parent = 0);

    ~FomeScript();

    // prepare scripting features

    void setupScriptEnvironment();

    // functions

    /// prepares the context for executing javascript functions

    /// by setting up all internal structures for the forest stand 'stand'.

    static void setExecutionContext(FMStand *stand, bool add_agent=false);

    /// special function for setting context without a valid stand

    static void setActivity(Activity *act);

    /// static accessor function for the responsible script bridge

    static FomeScript *bridge();

    /// returns a string for debug/trace messages

    const QString &context() const { return mStand?mStand->context():mInvalidContext; }

    /// convert a javascript object to a string (for debug output)

    static QString JStoString(QJSValue value);

    StandObj *standObj() const { return mStandObj; }

    UnitObj *siteObj() const { return mUnitObj; }

    FMTreeList *treesObj() const { return mTrees; }

    ActivityObj *activityObj() const { return mActivityObj; }

    // Properties

    /// verbose: when true, the logging intensity is increased significantly.

    bool verbose() const;

    void setVerbose(bool arg);

    int standId() const;

    void setStandId(int new_stand_id);

signals:

public slots:

    /// logging function (which includes exeuction context)

    void log(QJSValue value);

    /// abort execution

    void abort(QJSValue message);

    /// adds a management program (STP) that is provided as the Javascript object 'program'. 'name' is used internally.

    bool addManagement(QJSValue program, QString name);

    /// set the STP with the name 'name' to the (new) 'program'. This reloads the STP definition (and all activities).

    /// if 'name' is not present, nothing happens.

    bool updateManagement(QJSValue program, QString name);

    /// add a certain stp (given by 'name') to the agent 'agentname'. Returns false if either stp or agent were not found.

    bool addManagementToAgentType(QString name, QString agentname);

    /// add an agent definition (Javascript). 'name' is used internally. Returns true on success.

    bool addAgentType(QJSValue program, QString name);

    /// create an agent of type 'agent_type' (the name of an agent type) and give the name 'agent_name'. 'agent_name' needs to be unique.

    QJSValue addAgent(QString agent_type, QString agent_name);

    /// executes an activity for stand 'stand_id'. This bypasses the normal scheduling (useful for debugging/testing).

    /// returns false if activity could not be found for the stand.

    bool runActivity(int stand_id, QString activity);

    /// executes an the "evaluate" part of the activity for stand 'stand_id'. This bypasses the normal scheduling (useful for debugging/testing).

    /// returns false if activity could not be found for the stand.

    bool runActivityEvaluate(int stand_id, QString activity);

    /// execute 'function' of the agent for the given stand; this is primarily aimed at testing/debugging.

    bool runAgent(int stand_id, QString function);

    // special functions

    bool isValidStand(int stand_id);

    QStringList standIds();

    QJSValue activity(QString stp_name, QString activity_name);

    void runPlanting(int stand_id, QJSValue planting_item);

public:

    static int levelIndex(const QString &level_label);

    static const QString levelLabel(const int level_index);

private:

    static QString mInvalidContext;

    const FMStand *mStand;

    StandObj *mStandObj;

    UnitObj *mUnitObj;

    SimulationObj *mSimulationObj;

    ActivityObj *mActivityObj;

    FMTreeList *mTrees;

    SchedulerObj *mSchedulerObj;

    STPObj *mSTPObj;

    QString mLastErrorMessage;

};

/// StandObj is the bridge to stand variables from the Javascript world

class StandObj: public QObject

{

    Q_OBJECT

    Q_PROPERTY (bool trace READ trace WRITE setTrace)

    Q_PROPERTY (QJSValue agent READ agent)

    Q_PROPERTY (double basalArea READ basalArea)

    Q_PROPERTY (double age READ age)

    Q_PROPERTY (double absoluteAge READ absoluteAge WRITE setAbsoluteAge)

    Q_PROPERTY (double volume READ volume)

    Q_PROPERTY (double height READ height)

    Q_PROPERTY (double topHeight READ topHeight)

    Q_PROPERTY (int id READ id)

    Q_PROPERTY (int nspecies READ nspecies)

    Q_PROPERTY (double area READ area)

    Q_PROPERTY (int elapsed READ timeSinceLastExecution)

    Q_PROPERTY (QString lastActivity READ lastActivity)

    Q_PROPERTY (double U READ rotationLength)

    Q_PROPERTY(QString speciesComposition READ speciesComposition )

    Q_PROPERTY(QString thinningIntensity READ thinningIntensity )

/*    basalArea: 0, // total basal area/ha of the stand

    volume: 100, // total volume/ha of the stand

    speciesCount: 3, // number of species present in the stand with trees > 4m

    age: 100, // "age" of the stand (in relation to "U")

    flags: {}*/

public slots:

    /// basal area of a given species (m2/ha) given by Id.

    double speciesBasalAreaOf(QString species_id) const {return mStand->basalArea(species_id); }

    double relSpeciesBasalAreaOf(QString species_id) const {return mStand->relBasalArea(species_id); }

    double speciesBasalArea(int index) const { if (index>=0 && index<nspecies()) return mStand->speciesData(index).basalArea; else return 0.; }

    double relSpeciesBasalArea(int index) const { if (index>=0 && index<nspecies()) return mStand->speciesData(index).relBasalArea; else return 0.; }

    QString speciesId(int index) const;

    // set and get standspecific data (persistent!)

    void setFlag(const QString &name, QJSValue value){ const_cast<FMStand*>(mStand)->setProperty(name, value);}

    QJSValue flag(const QString &name) { return const_cast<FMStand*>(mStand)->property(name); }

    QJSValue activity(QString name);

    QJSValue agent();

    // actions

    /// force a reload of the stand data.

    void reload() { if (mStand) mStand->reload(true); }

    void sleep(int years) { if (mStand) mStand->sleep(years); }

    void setAbsoluteAge(double arg);

    /// start the management program again (initialize the stand)

    void reset();

public:

    explicit StandObj(QObject *parent = 0): QObject(parent), mStand(0) {}

    // system stuff

    void setStand(FMStand* stand) { mStand = stand; }

    bool trace() const;

    void setTrace(bool do_trace);

    // properties of the forest

    double basalArea() const { if (mStand)return mStand->basalArea(); throwError("basalArea"); return -1.;}

    double height() const { if (mStand)return mStand->height(); throwError("height"); return -1.;}

    double topHeight() const { if (mStand)return mStand->topHeight(); throwError("topHeight"); return -1.;}

    double age() const {if (mStand)return mStand->age(); throwError("age"); return -1.;}

    double absoluteAge() const {if (mStand)return mStand->absoluteAge(); throwError("absoluteAge"); return -1.;  }

    double volume() const {if (mStand) return mStand->volume(); throwError("volume"); return -1.; }

    int id() const { if (mStand) return mStand->id(); throwError("id"); return -1; }

    int nspecies() const {if (mStand) return mStand->nspecies();  throwError("id"); return -1;}

    double area() const {if (mStand) return mStand->area();  throwError("area"); return -1;}

    int timeSinceLastExecution() const;

    QString lastActivity() const;

    double rotationLength() const;

    QString speciesComposition() const;

    QString thinningIntensity() const;

private:

    void throwError(QString msg) const;

    FMStand *mStand;

};

/** @brief The UnitObj class is the Javascript object known as 'unit' in JS and represents

 * a management unit.

*/

class UnitObj: public QObject

{

    Q_OBJECT

    Q_PROPERTY (QString harvestMode READ harvestMode)

    Q_PROPERTY(QString speciesComposition READ speciesComposition )

    Q_PROPERTY(double U READ U )

    Q_PROPERTY(QString thinningIntensity READ thinningIntensity )

    // performance indicators

    Q_PROPERTY(double MAIChange READ MAIChange )

    Q_PROPERTY(double MAILevel READ MAILevel )

    Q_PROPERTY(double landscapeMAI READ landscapeMAI )

    Q_PROPERTY(double mortalityChange READ mortalityChange )

    Q_PROPERTY(double mortalityLevel READ mortalityLevel )

    Q_PROPERTY(double regenerationChange READ regenerationChange )

    Q_PROPERTY(double regenerationLevel READ regenerationLevel )

public slots:

    /// main function to provide agent decisions to the engine

    bool agentUpdate(QString what, QString how, QString when);

public:

    explicit UnitObj(QObject *parent = 0): QObject(parent) {}

    void setStand(const FMStand* stand) { mStand = stand; }

    QString harvestMode() const;

    QString speciesComposition() const;

    double U() const;

    QString thinningIntensity() const;

    // performance indicators

    double MAIChange() const;

    double MAILevel() const;

    double landscapeMAI() const;

    double mortalityChange() const;

    double mortalityLevel() const;

    double regenerationChange() const;

    double regenerationLevel() const;

private:

    const FMStand *mStand;

};

/** @brief The SimulationObj encapsulates the 'simulation' object in JS. The 'simulation' object

 * is used for global scenarios (e.g., changes in timber price).

*/

class SimulationObj: public QObject

{

    Q_OBJECT

    Q_PROPERTY (double timberPriceIndex READ timberPriceIndex)

public:

    explicit SimulationObj(QObject *parent = 0): QObject(parent) {}

    double timberPriceIndex() const { return 1.010101; } // dummy

private:

};

/** @brief The STPObj encapsulates the 'stp' object in JS. The 'stp' object

 * is provides a link to the currently active stand treatment programme.

*/

class STPObj: public QObject

{

    Q_OBJECT

    Q_PROPERTY (QString name READ name)

    Q_PROPERTY (QJSValue options READ options)

public:

    void setSTP(FMStand *stand);

    explicit STPObj(QObject *parent = 0): QObject(parent) { mSTP = 0;}

    QJSValue options() { return mOptions; }

    QString name();

private:

    FMSTP *mSTP;

    QJSValue mOptions; ///< options of the current STP

};

/**

 * @brief The ActivityObj class encapsulates the 'activity' object in JS. The 'activity'

 * can be used to fine-tune the management activities (e.g., set the enable/disable flags).

 */

class ActivityObj : public QObject

{

    Q_OBJECT

    Q_PROPERTY (bool enabled READ enabled WRITE setEnabled)

    Q_PROPERTY(bool active READ active WRITE setActive)

    Q_PROPERTY(bool finalHarvest READ finalHarvest WRITE setFinalHarvest)

    Q_PROPERTY(bool scheduled READ scheduled WRITE setScheduled)

    Q_PROPERTY(QString name READ name)

public:

    explicit ActivityObj(QObject *parent = 0): QObject(parent) { mActivityIndex=-1; mStand=0; mActivity=0; }

    // used to construct a link to a given activty (with an index that could be not the currently active index!)

    ActivityObj(FMStand *stand, Activity *act, int index ): QObject(0) { mActivityIndex=index; mStand=stand; mActivity=act; }

    /// default-case: set a forest stand as the context.

    void setStand(FMStand *stand) { mStand = stand; mActivity=0; mActivityIndex=-1;}

    /// set an activity context (without a stand) to access base properties of activities

    void setActivity(Activity *act) { mStand = 0; mActivity=act; mActivityIndex=-1;}

    /// set an activity that is not the current activity of the stand

    void setActivityIndex(const int index) { mActivityIndex = index; }

    // properties

    QString name() const;

    bool enabled() const;

    void setEnabled(bool do_enable);

    bool active() const { return flags().active(); }

    void setActive(bool activate) { flags().setActive(activate);}

    bool finalHarvest() const { return flags().isFinalHarvest(); }

    void setFinalHarvest(bool isfinal) { flags().setFinalHarvest(isfinal);}

    bool scheduled() const { return flags().isScheduled(); }

    void setScheduled(bool issched) { flags().setIsScheduled(issched);}

public slots:

private:

    ActivityFlags &flags() const; // get (depending on the linked objects) the right flags

    static ActivityFlags mEmptyFlags;

    int mActivityIndex; // link to base activity

    Activity *mActivity; // pointer

    FMStand *mStand; // and to the forest stand....

};

/**

 * @brief The SchedulerObj class is accessible via 'scheduler' in Javascript.

 */

class SchedulerObj : public QObject

{

    Q_OBJECT

    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled)

    Q_PROPERTY(double harvestIntensity READ harvestIntensity WRITE setHarvestIntensity)

    Q_PROPERTY(double useSustainableHarvest READ useSustainableHarvest WRITE setUseSustainableHarvest)

    Q_PROPERTY(double maxHarvestLevel READ maxHarvestLevel WRITE setMaxHarvestLevel)

public slots:

    void dump() const; ///< write log to console

public:

    explicit SchedulerObj(QObject *parent = 0): QObject(parent) {mStand=0; }

    void setStand(FMStand *stand) { mStand = stand;}

    bool enabled();

    void setEnabled(bool is_enabled);

    double harvestIntensity();

    void setHarvestIntensity(double new_intensity);

    double useSustainableHarvest();

    void setUseSustainableHarvest(double new_level);

    double maxHarvestLevel();

    void setMaxHarvestLevel(double new_harvest_level);

private:

    FMStand *mStand; // link to the forest stand

};

} // namespace

#endif // FOMESCRIPT_H