biteagent.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 BITEAGENT_H
#define BITEAGENT_H
 
#include <QObject>
#include <QJSValue>
 
#include "bitecell.h"
#include "grid.h"
#include "biteitem.h"
#include "bitecellscript.h"
#include "bitewrapper.h"
#include "biteclimate.h"
 
namespace ABE {
class FMTreeList; // forward
}
class ScriptGrid;
 
namespace BITE {
 
struct BAgentStats {
    BAgentStats() { clear(); }
    void clear() { nDispersal=nColonizable=nActive=nNewlyColonized=treesKilled = 0; agentBiomass=m3Killed=totalImpact=0.; saplingsKilled=saplingsImpact=0; }
    int nDispersal; 
    int nColonizable; 
    int nActive; 
    int nNewlyColonized; 
    double agentBiomass; 
    int treesKilled; 
    double m3Killed; 
    double totalImpact; 
    int saplingsKilled; 
    int saplingsImpact; 
};
 
struct BACellStat {
    BACellStat() { clear(); }
    void clear() { nKilled=0; nHostTrees=0; m3Killed = 0.; totalImpact = 0.; nHostSaplings=0; saplingsKilled=0; saplingsImpact=0; }
    int nKilled; 
    int nHostTrees; 
    double m3Killed; 
    double totalImpact; 
    int nHostSaplings; 
    int saplingsKilled; 
    int saplingsImpact; 
 
};
 
class BiteLifeCycle;
 
class BiteAgent : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString name READ name)
    Q_PROPERTY(QString description READ description)
    Q_PROPERTY(int cellSize READ cellSize)
    Q_PROPERTY(int width READ width)
    Q_PROPERTY(int height READ height)
    Q_PROPERTY(bool verbose READ verbose WRITE setVerbose)
    Q_PROPERTY(ScriptGrid* drawGrid READ drawGrid)
    Q_PROPERTY(QStringList variables READ variables)
    Q_PROPERTY(int onTreeRemovedFilter READ onTreeRemovedFilter WRITE setOnTreeRemovedFilter)
 
public:
    BiteAgent(QObject *parent = nullptr);
    Q_INVOKABLE BiteAgent(QJSValue obj);
    ~BiteAgent();
 
    ScriptGrid *drawGrid() { Q_ASSERT(mDrawGrid != nullptr); return mDrawGrid; }
    Grid<double> *baseDrawGrid() { return &mBaseDrawGrid; }
 
 
    void setup(QJSValue obj);
    static void setCPPOwnership(QObject *obj);
    BiteWrapperCore *wrapper() { return &mWrapperCore; }
    const BiteClimate &biteClimate() const { return mClimateProvider; }
 
    void notifyItems(BiteCell *cell, BiteCell::ENotification what);
    const QVector<ResourceUnit*> &largeCellRUs(int cellindex) { return mRULookup[cellindex]; }
    void setLargeCellRuList(int cellindex, QVector<ResourceUnit*> &list);
 
    QString name() const {return mName; }
    QString description() const {return mDesc; }
    int cellSize() const { return mCellSize; }
    int width() const {return grid().sizeX(); }
    int height() const {return grid().sizeY(); }
 
    // return a list of all currently available cell variables
    QStringList variables();
 
    bool verbose() const { return mVerbose; }
    void setVerbose(bool v) { mVerbose = v; }
 
    // property that controls the reasons when the onTreeRemoved event handler should be called
    int onTreeRemovedFilter() const { return mOnTreeRemovedFilter; }
    void setOnTreeRemovedFilter(int value);
    void runOnTreeRemovedFilter(Tree *tree, int reason);
 
    const Grid<BiteCell*> &grid() const { return mGrid; }
    static ABE::FMTreeList* threadTreeList();
    static ABE::FMSaplingList* threadSaplingList();
    BAgentStats &stats()  { return mStats; }
    BiteLifeCycle *lifeCycle() const { return mLC; }
    void createStatsGrid();
    BACellStat *cellStat(const BiteCell *cell);
 
 
public slots:
    BiteCellScript *cell(int x, int y);
    bool isCellValid(int x, int y) { return grid().isIndexValid(x,y); }
    void run();
    void run(BiteCellScript *cell);
    BiteItem* item(QString name);
    QString info();
 
    double evaluate(BiteCellScript *cell, QString expr);
    void addVariable(ScriptGrid *grid, QString var_name);
    void addVariable(QString var_name);
    void updateVariable(QString var_name, double value);
    void updateVariable(QString var_name, QString expression);
    void updateVariable(QString var_name, QJSValue func);
    void updateDrawGrid(QString expression);
    void updateDrawGrid(QJSValue func);
    void saveGrid(QString expression, QString file_name);
private:
    static void runCell(BiteCell &cell);
    static QHash<QThread*, ABE::FMTreeList* > mTreeLists;
    static QHash<QThread*, ABE::FMSaplingList* > mSaplingLists;
 
    void setupScripting();
 
    BiteWrapperCore mWrapperCore;
    BiteClimate mClimateProvider;
 
    BAgentStats mStats;
 
    // grids
    void createBaseGrid();
    Grid<BiteCell*> mGrid;
    QVector<BiteCell> mCells;
 
    // grids for stats
    Grid<BACellStat> mStatsGrid;
 
    // grid for drawing
    Grid<double> mBaseDrawGrid;
    ScriptGrid *mDrawGrid;
 
    Events mEvents;
    QJSValue mThis;
    QJSValueList mTreeRemovedParams;
 
    // elements (i.e. processes)
    QVector<BiteItem*> mItems;
 
    // structure for looking up resource units covered by a cell (for large cells)
    QHash<int, QVector<ResourceUnit*> > mRULookup;
 
    BiteLifeCycle *mLC;
 
    QString mName;
    QString mDesc;
    int mCellSize;
    bool mVerbose;
    int mOnTreeRemovedFilter;
 
    // JS helper
    BiteCellScript mCell;
    QJSValue mScriptCell;
    QJSValue mTreeValue;
    ScriptTree mTree;
    QVector<Grid<double> *> mCreatedVarGrids;
 
 
};
 
} // end namespace
 
#endif // BITEAGENT_H