model.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 MODEL_H
#define MODEL_H
#include <QtCore>
#include <QtXml>
 
#include "global.h"
 
#include "grid.h"
#include "threadrunner.h"
#include "modelsettings.h"
 
// forward declarations
class ResourceUnit;
class SpeciesSet;
class Management;
class Saplings;
 
namespace ABE {
class ForestManagementEngine;
}
class Climate;
class Environment;
class TimeEvents;
class MapGrid;
class Modules;
class DEM;
class GrassCover;
class SVDStates;
namespace BITE { class BiteEngine; }
 
struct HeightGridValue
{
    float height; 
    int count() const { return mCount & 0x0000ffff; } 
    void increaseCount() { mCount++; } 
    void resetCount() { mCount &= 0xffff0000; } 
    bool isValid() const { return !isBitSet(mCount, 16); }
    void setValid(const bool valid) { setBit(mCount, 16, !valid); } 
    void setForestOutside(const bool is_outside) { setBit(mCount, 17, is_outside); }
    bool isForestOutside() const {return isBitSet(mCount, 17); } 
    void setIsRadiating() { setBit(mCount, 18, true); } 
    bool isRadiating() const { return isBitSet(mCount, 18); }
    float stemHeight() const { return static_cast<float> (mCount >> 20 & 0xff);}
    void clearStemHeight() { mCount &= 0xF00FFFFF; }
    void setStemHeight(float h) {    unsigned int hval = static_cast<unsigned int>(h + 0.5f); // round: +0.5 + truncate
                                      unsigned int w = mCount;
                                      w &= 0xF00FFFFF;
                                      w |= hval << 20;
                                      mCount = w; }
    void init(const float aheight, const int acount) { height=aheight;mCount=static_cast<unsigned int>(acount); }
private:
    quint32 mCount;  // 32 bit unsigned int (even on 64bit platforms)
 
};
typedef Grid<HeightGridValue> HeightGrid;
 
class Model
{
public:
    Model();
    ~Model();
    // start/stop/run
    void beforeRun(); 
    void runYear(); 
    void afterStop(); 
 
    // access to elements
    const ThreadRunner &threadExec() const {return threadRunner; }
    const QRectF &extent() const { return mModelRect; } 
    double totalStockableArea() const { return mTotalStockableArea; } 
    ResourceUnit *ru() { return mRU.front(); }
    ResourceUnit *ru(QPointF coord); 
    ResourceUnit *ru(int index) { return (index>=0&&index<mRU.count())? mRU[index] : NULL; } 
    ResourceUnit *ruById(int id) const; 
    const QList<ResourceUnit*> &ruList() const {return mRU; }
    Management *management() const { return mManagement; }
    ABE::ForestManagementEngine *ABEngine() const { return mABEManagement; }
    BITE::BiteEngine *biteEngine() const { return mBiteEngine; }
 
    Environment *environment() const {return mEnvironment; }
    Saplings *saplings() const {return mSaplings; }
    TimeEvents *timeEvents() const { return mTimeEvents; }
    Modules *modules() const { return mModules; }
    const DEM *dem() const { return mDEM; }
    GrassCover *grassCover() const { return mGrassCover; }
    SpeciesSet *speciesSet() const { if (mSpeciesSets.count()==1) return mSpeciesSets.first(); return NULL; }
    const QList<Climate*> climates() const { return mClimates; }
    SVDStates *svdStates() const { return mSVDStates; }
 
    // global grids
    FloatGrid *grid() { return mGrid; } 
    HeightGrid *heightGrid() { return mHeightGrid; } 
    const MapGrid *standGrid() { return mStandGrid; } 
    const Grid<ResourceUnit*> &RUgrid() { return mRUmap; }
    const HeightGridValue heightGridValue(const int ix, const int iy) const { return  mHeightGrid->constValueAtIndex(ix/cPxPerHeight, iy/cPxPerHeight); }
    const HeightGridValue &heightGridValue(const float *lif_ptr) const { QPoint p = mGrid->indexOf(lif_ptr); return mHeightGrid->constValueAtIndex(p.x()/cPxPerHeight, p.y()/cPxPerHeight); }
 
    // setup/maintenance
    void clear(); 
    void loadProject(); 
    bool isSetup() const { return mSetup; } 
    static const ModelSettings &settings() {return mSettings;} 
    static ModelSettings &changeSettings() {return mSettings;} 
    void onlyApplyLightPattern() { applyPattern(); readPattern(); }
    void reloadABE(); 
    QString currentTask() const { return mCurrentTask; }
    void setCurrentTask(QString what) { mCurrentTask = what; }
 
    // actions
    void createStandStatistics();
    void cleanTreeLists(bool recalculate_stats);
    void executePerResourceUnit(void (*funcptr)(ResourceUnit*), const bool forceSingleThreaded=false) { threadRunner.run(funcptr, forceSingleThreaded);}
 
private:
    void initialize(); 
    void setupSpace(); 
    void initOutputDatabase(); 
 
    void applyPattern(); 
    void readPattern(); 
    void grow(); 
 
    void calculateStockedArea(); 
    void calculateStockableArea(); 
    void initializeGrid(); 
 
    void test();
    void debugCheckAllTrees();
    bool multithreading() const { return threadRunner.multithreading(); }
    ThreadRunner threadRunner;
    static ModelSettings mSettings;
    QString mCurrentTask;
    bool mSetup;
    QList<ResourceUnit*> mRU;
    Grid<ResourceUnit*> mRUmap;
    QList<SpeciesSet*> mSpeciesSets;
    QList<Climate*> mClimates;
    //
    Modules *mModules; 
    //
    QRectF mModelRect; 
    double mTotalStockableArea; 
    // global grids...
    FloatGrid *mGrid; 
    HeightGrid *mHeightGrid; 
    Saplings *mSaplings;
    Management *mManagement; 
    ABE::ForestManagementEngine *mABEManagement; 
    BITE::BiteEngine *mBiteEngine; 
    Environment *mEnvironment; 
    TimeEvents *mTimeEvents; 
    MapGrid *mStandGrid; 
    // Digital elevation model
    DEM *mDEM; 
    GrassCover *mGrassCover; 
    // SVD States
    SVDStates *mSVDStates;
};
 
class Tree;
class AllTreeIterator
{
public:
    AllTreeIterator(Model* model): mModel(model), mTreeEnd(0),mCurrent(0) {}
    void reset() { mTreeEnd=0; mCurrent=0; }
    Tree *next();
    Tree *nextLiving();
    Tree *current() const;
    Tree *operator*() const { return current();  }
    ResourceUnit *currentRU() const { return *mRUIterator; }
private:
    Model *mModel;
    Tree *mTreeEnd;
    Tree *mCurrent;
    QList<ResourceUnit*>::const_iterator mRUIterator;
};
#endif // MODEL_H