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 ACTIVITY_H

#define ACTIVITY_H

#include <QJSValue>

#include <QVector>

#include <QMap>

class Expression; // forward

namespace ABE {

class FMStand;

class FMSTP;

class Schedule {

public:

    // setup and life cycle

    Schedule()  {}

    Schedule(QJSValue &js_value) { clear(); setup(js_value); }

    void clear() { tmin=tmax=topt=-1; tminrel=tmaxrel=toptrel=-1.; force_execution=false; repeat_interval=-1; repeat=false; absolute=false; }

    void setup(const QJSValue &js_value);

    QString dump() const;

    // functions

    /// value() evaluates the schedule for the given 'stand'.

    /// return 0..1 (0: no fit, 1: perfect time).

    /// Special value -1: expired (i.e. current time past the maximum schedule time).

    double value(const FMStand *stand, const int specific_year=-1);

    /// gives (fixed) earliest possible execution time

    double minValue(const double U=100.) const;

    /// returns the latest possible execution time

    double maxValue(const double U=100.) const;

    /// returns the "optimal" year, i.e. the first year when prob. to execute is highest.

    double optimalValue(const double U=100.) const;

    // some stuffs

    int tmin; int tmax; int topt;

    double tminrel; double tmaxrel; double toptrel;

    bool force_execution;

    // repeating

    int repeat_interval;

    bool repeat;

    bool absolute;

};

class Events {

public:

    Events() {}

    /// clear the list of events

    void clear();

    /// setup events from the javascript object

    void setup(QJSValue &js_value, QStringList event_names);

    /// execute javascript event /if registered) in the context of the forest stand 'stand'.

    QJSValue run(const QString event, FMStand *stand, QJSValueList *params=0);

    /// returns true, if the event 'event' is available.

    bool hasEvent(const QString &event) const;

    QString dump(); ///< prints some debug info

private:

    QJSValue mInstance; ///< object holding the events

    QMap<QString, QJSValue> mEvents; ///< list of event names and javascript functions

};

/** DynamicExpression encapsulates an "expression" that can be either a iLand expression, a constant or a javascript function.

*/

struct DynamicExpression {

    DynamicExpression(): filter_type(ftInvalid), expr(0) {}

    ~DynamicExpression();

    void setup(const QJSValue &js_value);

    bool evaluate(FMStand *stand) const;

    bool isValid() const { return filter_type!=ftInvalid;}

    QString dump() const;

private:

    enum { ftInvalid, ftExpression, ftJavascript} filter_type;

    Expression *expr;

    QJSValue func;

};

class Constraints {

public:

    Constraints() {}

    void setup(QJSValue &js_value); ///< setup from javascript

    double evaluate(FMStand *stand); ///< run the constraints

    QStringList dump(); ///< prints some debug info

private:

    QList<DynamicExpression> mConstraints;

};

class Activity; //forward

/** Activity meta data (enabled, active, ...) that need to be stored

    per stand. */

class ActivityFlags

{

public:

    ActivityFlags(): mActivity(0), mFlags(0) {}

    ActivityFlags(Activity *act): mActivity(act), mFlags(0) {}

    Activity *activity() const {return mActivity; }

    bool active() const {return flag(Active); }

    bool enabled() const {return flag(Enabled);}

    bool isRepeating() const {return flag(Repeater);}

    bool isPending() const {return flag(Pending); }

    bool isForcedNext() const {return flag(ExecuteNext); }

    bool isFinalHarvest() const {return flag(FinalHarvest); }

    bool isExecuteImmediate() const {return flag(ExecuteImmediate); }

    bool isScheduled() const {return flag(IsScheduled);}

    bool isDoSimulate() const {return flag(DoSimulate);}

    bool isSalvage() const {return flag(IsSalvage);}

    void setActive(const bool active) { setFlag(Active, active); }

    void setEnabled(const bool enabled) { setFlag(Enabled, enabled); }

    void setIsRepeating(const bool repeat) { setFlag(Repeater, repeat); }

    void setIsPending(const bool pending) { setFlag(Pending, pending); }

    void setForceNext(const bool isnext) { setFlag(ExecuteNext, isnext); }

    void setFinalHarvest(const bool isfinal) { setFlag(FinalHarvest, isfinal); }

    void setExecuteImmediate(const bool doexec) { setFlag(ExecuteImmediate, doexec);}

    void setIsScheduled(const bool doschedule) {setFlag(IsScheduled, doschedule); }

    void setDoSimulate(const bool dosimulate) {setFlag(DoSimulate, dosimulate); }

    void setIsSalvage(const bool issalvage) {setFlag(IsSalvage, issalvage); }

private:

    /// (binary coded)  flags

    enum Flags { Active=1,  // if false, the activity has already been executed

                 Enabled=2,  // if false, the activity can not be executed

                 Repeater=4, // if true, the activity is executed

                 ExecuteNext=8, // this activity should be executed next (kind of "goto"

                 ExecuteImmediate=16, // should be executed immediately by the scheduler (e.g. required sanitary cuttings)

                 Pending=32,  // the activity is currently in the scheduling algorithm

                 FinalHarvest=64,  // the management of the activity is a "endnutzung" (compared to "vornutzung")

                 IsScheduled=128, // the execution time of the activity is scheduled by the Scheduler component

                 DoSimulate=256,  // the default operation mode of harvests (simulate or not)

                 IsSalvage=512   // the activity is triggered by tree mortality events

                 };

    bool flag(const ActivityFlags::Flags flag) const { return mFlags & flag; }

    void setFlag(const ActivityFlags::Flags flag, const bool value) { if (value) mFlags |= flag; else mFlags &= (flag ^ 0xffffff );}

    Activity *mActivity; ///< link to activity

    int mFlags;

};

/// Activity is the base class for management activities

class Activity

{

public:

    // life cycle

    Activity(const FMSTP *parent);

    virtual ~Activity();

    /// Activity factory - create activities for given 'type'

    static Activity *createActivity(const QString &type, FMSTP *stp);

    // properties

    enum Phase { Invalid, Tending, Thinning, Regeneration, All };

    const FMSTP *program() const { return mProgram; }

    virtual QString type() const;

    QString name() const {return mName; } ///< name of the activity as provided by JS

    int index() const { return mIndex; } ///< index of the activity within the STP

    /// get earlist possible scheduled year (relative to rotation begin)

    int earlistSchedule(const double U=100.) const {return mSchedule.minValue(U); }

    /// get latest possible scheduled year (relative to rotation begin)

    int latestSchedule(const double U=100.) const { return mSchedule.maxValue(U); }

    /// get optimal scheduled year (relative to rotation begin)

    int optimalSchedule(const double U=100.) const { return mSchedule.optimalValue(U); }

    bool isRepeatingActivity() const { return mSchedule.repeat; }

    // main actions

    /// setup of the activity (events, schedule, constraints). additional setup in derived classes.

    virtual void setup(QJSValue value);

    /// returns a value > 0 if the activity coult be scheduled now

    virtual double scheduleProbability(FMStand *stand, const int specific_year=-1);

    /// returns a probability for the activity to be executed (ie all constraints are fulfilled)

    /// return value is 0 if the activity can not be executed (maximum result is 1)

    virtual double execeuteProbability(FMStand *stand);

    /// executes the action (usually defined in derived classes) using the context of 'stand'.

    virtual bool execute(FMStand *stand);

    /// executes the evaluation of the forest stand.

    /// returns true, when the stand should enter the scheduler.

    virtual bool evaluate(FMStand *stand);

    /// function that evaluates "bound" dynamic expressions

    virtual void evaluateDyanamicExpressions(FMStand *stand);

    /// dumps some information for debugging

    virtual QStringList info();

protected:

    Schedule &schedule()  { return mSchedule; }

    Constraints &constraints()  { return mConstraints; }

    Events &events()  { return mEvents; }

    ActivityFlags &standFlags(FMStand *stand=0);

    ActivityFlags mBaseActivity; // base properties of the activity (that can be changed for each stand)

    static QStringList mAllowedProperties; // list of properties (e.g. 'schedule') that are parsed by the base activity

private:

    void setIndex(const int index) { mIndex = index; } // used during setup

    void setName(const QString &name) { mName = name; }

    int mIndex; ///< index of the activity within the STP

    QString mName; ///< the name of the activity;

    const FMSTP *mProgram; // link to the management programme the activity is part of

    Schedule mSchedule; // timing of activity

    Constraints mConstraints; // constraining factors

    Events mEvents; // action handlers such as "onExecute"

    DynamicExpression mEnabledIf; // enabledIf property (dynamically evaluated)

    friend class FMSTP; // allow access of STP class to internals

    friend class FMStand; // allow access of the activity class (e.g for events)

    friend class ActivityObj; // allow access to scripting function

};

} // namespace

Q_DECLARE_TYPEINFO(ABE::ActivityFlags, Q_PRIMITIVE_TYPE); // declare as POD structure to allow more efficient copying

#endif // ACTIVITY_H