WebSVN - public iLand - Diff - Rev 1111 and 1114


Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/model.cpp':
/********************************************************************************************
**    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/>.
********************************************************************************************/

/** @class Model
  Main object of the iLand model composited of various sub models / sub components.
  @ingroup core
  The class Model is the top level container of iLand. The Model holds a collection of ResourceUnits, links to SpeciesSet and Climate.
  ResourceUnit are grid cells with (currently) a size of 1 ha (100x100m). Many stand level processes (NPP produciton, WaterCycle) operate on this
  level.
  The Model also contain the landscape-wide 2m LIF-grid (http://iland.boku.ac.at/competition+for+light).

  */
#include "global.h"
#include "model.h"
#include "sqlhelper.h"

#include "xmlhelper.h"
#include "debugtimer.h"
#include "environment.h"
#include "timeevents.h"
#include "helper.h"
#include "resourceunit.h"
#include "climate.h"
#include "speciesset.h"
#include "standloader.h"
#include "tree.h"
#include "management.h"
#include "saplings.h"
#include "modelsettings.h"
#include "standstatistics.h"
#include "mapgrid.h"
#include "modelcontroller.h"
#include "modules.h"
#include "dem.h"
#include "grasscover.h"

#include "outputmanager.h"

#include "forestmanagementengine.h"

#include <QtCore>
#include <QtXml>

/** iterate over all trees of the model. return NULL if all trees processed.
  Usage:
  @code
  AllTreeIterator trees(model);
  while (Tree *tree = trees.next()) { // returns NULL when finished.
     tree->something(); // do something
  }
  @endcode  */
Tree *AllTreeIterator::next()
{

    if (!mTreeEnd) {
        // initialize to first ressource unit
        mRUIterator = mModel->ruList().constBegin();
        // fast forward to the first RU with trees
        while (mRUIterator!=mModel->ruList().constEnd()) {
            if ((*mRUIterator)->trees().count()>0)
                break;
            ++mRUIterator;
        }
            // finished if all RU processed
        if (mRUIterator == mModel->ruList().constEnd())
            return NULL;
        mTreeEnd = &((*mRUIterator)->trees().back()) + 1; // let end point to "1 after end" (STL-style)
        mCurrent = &((*mRUIterator)->trees().front());
    }
    if (mCurrent==mTreeEnd) {
        ++mRUIterator; // switch to next RU (loop until RU with trees is found)
        while (mRUIterator!=mModel->ruList().constEnd()) {
            if ((*mRUIterator)->trees().count()>0) {
                break;
            }
            ++mRUIterator;
        }
        if (mRUIterator == mModel->ruList().constEnd()) {
            mCurrent = NULL;
            return NULL; // finished!!
        }else {
            mTreeEnd = &((*mRUIterator)->trees().back()) + 1;
            mCurrent = &((*mRUIterator)->trees().front());
        }
    }

    return mCurrent++;
}
Tree *AllTreeIterator::nextLiving()
{
    while (Tree *t = next())
        if (!t->isDead()) return t;
    return NULL;
}
Tree *AllTreeIterator::current() const
{
    return mCurrent?mCurrent-1:NULL;
}


ModelSettings Model::mSettings;
Model::Model()
{
    initialize();
    GlobalSettings::instance()->setModel(this);
    GlobalSettings::instance()->resetScriptEngine(); // clear the script
    QString dbg="running in release mode.";
    DBGMODE( dbg="running in debug mode."; );
    qDebug() << dbg;
}

Model::~Model()
{
    clear();
    GlobalSettings::instance()->setModel(NULL);
}

/** Initial setup of the Model.
  */
void Model::initialize()
{
   mSetup = false;
   GlobalSettings::instance()->setCurrentYear(0);
   mGrid = 0;
   mHeightGrid = 0;
   mManagement = 0;
   mABEManagement = 0;
   mEnvironment = 0;
   mTimeEvents = 0;
   mStandGrid = 0;
   mModules = 0;
   mDEM = 0;
   mGrassCover = 0;
   mSaplings=0;
}

/** sets up the simulation space.
*/
void Model::setupSpace()
{
    XmlHelper xml(GlobalSettings::instance()->settings().node("model.world"));
    double cellSize = xml.value("cellSize", "2").toDouble();
    double width = xml.value("width", "100").toDouble();
    double height = xml.value("height", "100").toDouble();
    double buffer = xml.value("buffer", "60").toDouble();
    mModelRect = QRectF(0., 0., width, height);

    qDebug() << QString("setup of the world: %1x%2m with cell-size=%3m and %4m buffer").arg(width).arg(height).arg(cellSize).arg(buffer);

    QRectF total_grid(QPointF(-buffer, -buffer), QPointF(width+buffer, height+buffer));
    qDebug() << "setup grid rectangle:" << total_grid;

    if (mGrid)
        delete mGrid;
    mGrid = new FloatGrid(total_grid, cellSize);
    mGrid->initialize(1.f);
    if (mHeightGrid)
        delete mHeightGrid;
    mHeightGrid = new HeightGrid(total_grid, cellSize*5);
    mHeightGrid->wipe(); // set all to zero
    Tree::setGrid(mGrid, mHeightGrid);

    // setup the spatial location of the project area
    if (xml.hasNode("location")) {
        // setup of spatial location
        double loc_x = xml.valueDouble("location.x");
        double loc_y = xml.valueDouble("location.y");
        double loc_z = xml.valueDouble("location.z");
        double loc_rot = xml.valueDouble("location.rotation");
        setupGISTransformation(loc_x, loc_y, loc_z, loc_rot);
        qDebug() << "setup of spatial location: x/y/z" << loc_x << loc_y << loc_z << "rotation:" << loc_rot;
    } else {
        setupGISTransformation(0., 0., 0., 0.);
    }

    // load environment (multiple climates, speciesSets, ...
    if (mEnvironment)
        delete mEnvironment;
    mEnvironment = new Environment();

    if (xml.valueBool("environmentEnabled", false)) {
        QString env_file = GlobalSettings::instance()->path(xml.value("environmentFile"));
        bool grid_mode = (xml.value("environmentMode")=="grid");
        QString grid_file = GlobalSettings::instance()->path(xml.value("environmentGrid"));
        if (grid_mode) {
            if (QFile::exists(grid_file))
                mEnvironment->setGridMode(grid_file);
            else
                throw IException(QString("File '%1' specified in key 'environmentGrid' does not exit ('environmentMode' is 'grid').").arg(grid_file) );
        }

        if (!mEnvironment->loadFromFile(env_file))
            return;
    } else {
        // load and prepare default values
        // (2) SpeciesSets: currently only one a global species set.
        SpeciesSet *speciesSet = new SpeciesSet();
        mSpeciesSets.push_back(speciesSet);
        speciesSet->setup();
        // Climate...
        Climate *c = new Climate();
        mClimates.push_back(c);
        mEnvironment->setDefaultValues(c, speciesSet);
    } // environment?

    // time series data
    if (xml.valueBool(".timeEventsEnabled", false)) {
        mTimeEvents = new TimeEvents();
        mTimeEvents->loadFromFile(GlobalSettings::instance()->path(xml.value("timeEventsFile"), "script"));
    }


    // simple case: create ressource units in a regular grid.
    if (xml.valueBool("resourceUnitsAsGrid")) {

        mRUmap.setup(QRectF(0., 0., width, height),100.); // Grid, that holds positions of resource units
        mRUmap.wipe();

        bool mask_is_setup = false;
        if (xml.valueBool("standGrid.enabled")) {
            QString fileName = GlobalSettings::instance()->path(xml.value("standGrid.fileName"));
            mStandGrid = new MapGrid(fileName,false); // create stand grid index later

            if (mStandGrid->isValid()) {
                for (int i=0;i<mStandGrid->grid().count();i++) {
                    const int &grid_value = mStandGrid->grid().constValueAtIndex(i);
                    mHeightGrid->valueAtIndex(i).setValid( grid_value > -1 );
                    if (grid_value>-1)
                        mRUmap.valueAt(mStandGrid->grid().cellCenterPoint(i)) = (ResourceUnit*)1;
                    if (grid_value < -1)
                        mHeightGrid->valueAtIndex(i).setForestOutside(true);
                }
            }
            mask_is_setup = true;
        } else {
            if (!GlobalSettings::instance()->settings().paramValueBool("torus")) {
                // in the case we have no stand grid but only a large rectangle (without the torus option)
                // we assume a forest outside
                for (int i=0;i<mHeightGrid->count();++i) {
                    const QPointF &p = mHeightGrid->cellCenterPoint(mHeightGrid->indexOf(i));
                    if (p.x() < 0. || p.x()>width || p.y()<0. || p.y()>height) {
                        mHeightGrid->valueAtIndex(i).setForestOutside(true);
                        mHeightGrid->valueAtIndex(i).setValid(false);
                    }
                }

            }
        }

        ResourceUnit **p; // ptr to ptr!
        ResourceUnit *new_ru;

        int ru_index = 0;
        for (p=mRUmap.begin(); p!=mRUmap.end(); ++p) {
            QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));
            if (!mStandGrid || !mStandGrid->isValid() || *p>NULL) {
                mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.
                // create resource units for valid positions only
                new_ru = new ResourceUnit(ru_index++); // create resource unit
                new_ru->setClimate( mEnvironment->climate() );
                new_ru->setSpeciesSet( mEnvironment->speciesSet() );
                new_ru->setup();
                new_ru->setID( mEnvironment->currentID() ); // set id of resource unit in grid mode
                new_ru->setBoundingBox(r);
                mRU.append(new_ru);
                *p = new_ru; // save in the RUmap grid
            }
        }
        if (mEnvironment) {
            // retrieve species sets and climates (that were really used)
            mSpeciesSets << mEnvironment->speciesSetList();
            mClimates << mEnvironment->climateList();
            QString climate_file_list;
            for (int i=0, c=0;i<mClimates.count();++i) {
                climate_file_list += mClimates[i]->name() + ", ";
                if (++c>5) {
                    climate_file_list += "...";
                    break;
                }

            }
            qDebug() << "Setup of climates: #loaded:" << mClimates.count() << "tables:" << climate_file_list;


        }

        qDebug() << "setup of" << mEnvironment->climateList().size() << "climates performed.";

        if (mStandGrid && mStandGrid->isValid())
            mStandGrid->createIndex();
        // now store the pointers in the grid.
        // Important: This has to be done after the mRU-QList is complete - otherwise pointers would
        // point to invalid memory when QList's memory is reorganized (expanding)
//        ru_index = 0;
//        for (p=mRUmap.begin();p!=mRUmap.end(); ++p) {
//            *p = mRU.value(ru_index++);
//        }
        qDebug() << "created a grid of ResourceUnits: count=" << mRU.count() << "number of RU-map-cells:" << mRUmap.count();


        calculateStockableArea();

        // setup of the project area mask
        if (!mask_is_setup && xml.valueBool("areaMask.enabled", false) && xml.hasNode("areaMask.imageFile")) {
            // to be extended!!! e.g. to load ESRI-style text files....
            // setup a grid with the same size as the height grid...
            FloatGrid tempgrid((int)mHeightGrid->cellsize(), mHeightGrid->sizeX(), mHeightGrid->sizeY());
            QString fileName = GlobalSettings::instance()->path(xml.value("areaMask.imageFile"));
            loadGridFromImage(fileName, tempgrid); // fetch from image
            for (int i=0;i<tempgrid.count(); i++)
                mHeightGrid->valueAtIndex(i).setValid( tempgrid.valueAtIndex(i)>0.99 );
            qDebug() << "loaded project area mask from" << fileName;
        }

        // list of "valid" resource units
        QList<ResourceUnit*> valid_rus;
        foreach(ResourceUnit* ru, mRU)
            if (ru->id()!=-1)
                valid_rus.append(ru);

        // setup of the digital elevation map (if present)
        QString dem_file = xml.value("DEM");
        if (!dem_file.isEmpty()) {
            mDEM = new DEM(GlobalSettings::instance()->path(dem_file));
            // add them to the visuals...
            GlobalSettings::instance()->controller()->addGrid(mDEM, "DEM height", GridViewRainbow, 0, 1000);
            GlobalSettings::instance()->controller()->addGrid(mDEM->slopeGrid(), "DEM slope", GridViewRainbow, 0, 3);
            GlobalSettings::instance()->controller()->addGrid(mDEM->aspectGrid(), "DEM aspect", GridViewRainbow, 0, 360);
            GlobalSettings::instance()->controller()->addGrid(mDEM->viewGrid(), "DEM view", GridViewGray, 0, 1);

        }

        // setup of saplings
        if (mSaplings) {
            delete mSaplings; mSaplings=0;
        }
        if (settings().regenerationEnabled) {
            mSaplings = new Saplings();
            mSaplings->setup();
        }


        // setup of the grass cover
        if (!mGrassCover)
            mGrassCover = new GrassCover();
        mGrassCover->setup();

        // setup of external modules
        mModules->setup();
        if (mModules->hasSetupResourceUnits()) {
            for (ResourceUnit **p=mRUmap.begin(); p!=mRUmap.end(); ++p) {
                if (*p) {
                    QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));
                    mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.
                    mModules->setupResourceUnit( *p );
                }
            }
        }

        // setup of scripting environment
        ScriptGlobal::setupGlobalScripting();

        // setup the helper that does the multithreading
        threadRunner.setup(valid_rus);
        threadRunner.setMultithreading(GlobalSettings::instance()->settings().valueBool("system.settings.multithreading"));
        threadRunner.print();


    } else  {
        throw IException("resourceUnitsAsGrid MUST be set to true - at least currently :)");
    }
    mSetup = true;
}


/** clear() frees all ressources allocated with the run of a simulation.

  */
void Model::clear()
{
    mSetup = false;
    qDebug() << "Model clear: attempting to clear" << mRU.count() << "RU, " << mSpeciesSets.count() << "SpeciesSets.";
    // clear ressource units
    qDeleteAll(mRU); // delete ressource units (and trees)
    mRU.clear();

    qDeleteAll(mSpeciesSets); // delete species sets
    mSpeciesSets.clear();

    // delete climate data
    qDeleteAll(mClimates);

    // delete the grids
    if (mGrid)
        delete mGrid;
    if (mHeightGrid)
        delete mHeightGrid;
    if (mSaplings)
        delete mSaplings;
    if (mManagement)
        delete mManagement;
    if (mEnvironment)
        delete mEnvironment;
    if (mTimeEvents)
        delete mTimeEvents;
    if (mStandGrid)
        delete mStandGrid;
    if (mModules)
        delete mModules;
    if (mDEM)
        delete mDEM;
    if (mGrassCover)
        delete mGrassCover;
    if (mABEManagement)
        delete mABEManagement;

    mGrid = 0;
    mHeightGrid = 0;
    mManagement = 0;
    mEnvironment = 0;
    mTimeEvents = 0;
    mStandGrid  = 0;
    mModules = 0;
    mDEM = 0;
    mGrassCover = 0;
    mABEManagement = 0;

    GlobalSettings::instance()->outputManager()->close();

    qDebug() << "Model ressources freed.";
}

/** Setup of the Simulation.
  This really creates the simulation environment and does the setup of various aspects.
  */
void Model::loadProject()
{
    DebugTimer dt("load project");
    GlobalSettings *g = GlobalSettings::instance();
    g->printDirecories();
    const XmlHelper &xml = g->settings();

    g->clearDatabaseConnections();
    // database connections: reset
    GlobalSettings::instance()->clearDatabaseConnections();
    // input and climate connection
    // see initOutputDatabase() for output database
    QString dbPath = g->path( xml.value("system.database.in"), "database");
    GlobalSettings::instance()->setupDatabaseConnection("in", dbPath, true);
    dbPath = g->path( xml.value("system.database.climate"), "database");
    GlobalSettings::instance()->setupDatabaseConnection("climate", dbPath, true);

    mSettings.loadModelSettings();
    mSettings.print();
    // random seed: if stored value is <> 0, use this as the random seed (and produce hence always an equal sequence of random numbers)
    uint seed = xml.value("system.settings.randomSeed","0").toUInt();
    RandomGenerator::setup(RandomGenerator::ergMersenneTwister, seed); // use the MersenneTwister as default
    // linearization of expressions: if true *and* linearize() is explicitely called, then
    // function results will be cached over a defined range of values.
    bool do_linearization = xml.valueBool("system.settings.expressionLinearizationEnabled", false);
    Expression::setLinearizationEnabled(do_linearization);
    if (do_linearization)
        qDebug() << "The linearization of certains expressions is enabled (performance optimization).";

    // log level
    QString log_level = xml.value("system.settings.logLevel", "debug").toLower();
    if (log_level=="debug") setLogLevel(0);
    if (log_level=="info") setLogLevel(1);
    if (log_level=="warning") setLogLevel(2);
    if (log_level=="error") setLogLevel(3);

    // snag dynamics / soil model enabled? (info used during setup of world)
    changeSettings().carbonCycleEnabled = xml.valueBool("model.settings.carbonCycleEnabled", false);
    // class size of snag classes
    Snag::setupThresholds(xml.valueDouble("model.settings.soil.swdDBHClass12"),
                          xml.valueDouble("model.settings.soil.swdDBHClass23"));

    // setup of modules
    if (mModules)
        delete mModules;
    mModules = new Modules();

    changeSettings().regenerationEnabled = xml.valueBool("model.settings.regenerationEnabled", false);


    setupSpace();
    if (mRU.isEmpty())
        throw IException("Setup of Model: no resource units present!");

    // (3) additional issues
    // (3.1) load javascript code into the engine
    QString script_file = xml.value("system.javascript.fileName");
    if (!script_file.isEmpty()) {
        script_file = g->path(script_file, "script");
        ScriptGlobal::loadScript(script_file);
        g->controller()->setLoadedJavascriptFile(script_file);
    }

    // (3.2) setup of regeneration
    if (settings().regenerationEnabled) {
        foreach(SpeciesSet *ss, mSpeciesSets)
            ss->setupRegeneration();
    }
    Sapling::setRecruitmentVariation(xml.valueDouble("model.settings.seedDispersal.recruitmentDimensionVariation",0.1));

    // (3.3) management
    bool use_abe = xml.valueBool("model.management.abeEnabled");
    if (use_abe) {
        // use the agent based forest management engine
        mABEManagement = new ABE::ForestManagementEngine();
        // setup of ABE after loading of trees.

    }
    // use the standard management
    QString mgmtFile = xml.value("model.management.file");
    if (!mgmtFile.isEmpty() && xml.valueBool("model.management.enabled")) {
        mManagement = new Management();
        QString path = GlobalSettings::instance()->path(mgmtFile, "script");
        mManagement->loadScript(path);
        qDebug() << "setup management using script" << path;
    }



}

void Model::reloadABE()
{
    // delete firest
    if (mABEManagement)
        delete mABEManagement;
    mABEManagement = new ABE::ForestManagementEngine();
    // and setup
    mABEManagement->setup();
    mABEManagement->runOnInit(true);

    mABEManagement->initialize();

    mABEManagement->runOnInit(false);

}


ResourceUnit *Model::ru(QPointF coord)
{
    if (!mRUmap.isEmpty() && mRUmap.coordValid(coord))
        return mRUmap.valueAt(coord);
    return ru(); // default RU if there is only one
}

void Model::initOutputDatabase()
{
    GlobalSettings *g = GlobalSettings::instance();
    QString dbPath = g->path(g->settings().value("system.database.out"), "output");
    // create run-metadata
    int maxid = SqlHelper::queryValue("select max(id) from runs", g->dbin()).toInt();

    maxid++;
    QString timestamp = QDateTime::currentDateTime().toString("yyyyMMdd_hhmmss");
    SqlHelper::executeSql(QString("insert into runs (id, timestamp) values (%1, '%2')").arg(maxid).arg(timestamp), g->dbin());
    // replace path information
    dbPath.replace("$id$", QString::number(maxid));
    dbPath.replace("$date$", timestamp);
    // setup final path
   g->setupDatabaseConnection("out", dbPath, false);

}


/// multithreaded running function for the resource unit level establishment
ResourceUnit *nc_sapling_growth_establishment(ResourceUnit *unit)
{
    try {
        { // DebugTimer t("nc_saplingGrowth"); t.setSilent();
        // define a height map for the current resource unit on the stack
        float sapling_map[cPxPerRU*cPxPerRU];
        // set the map and initialize it:
        unit->setSaplingHeightMap(sapling_map);


        // (1) calculate the growth of (already established) saplings (populate sapling map)
        QList<ResourceUnitSpecies*>::const_iterator rus;
        for (rus=unit->ruSpecies().cbegin(); rus!=unit->ruSpecies().cend(); ++rus)
            (*rus)->calclulateSaplingGrowth();

        } { // DebugTimer t("nc_Establishment"); t.setSilent();

        // (2) calculate the establishment probabilities of new saplings
        for (QList<ResourceUnitSpecies*>::const_iterator rus=unit->ruSpecies().cbegin(); rus!=unit->ruSpecies().cend(); ++rus)
            (*rus)->calculateEstablishment();

        }

    } catch (const IException& e) {
        GlobalSettings::instance()->controller()->throwError(e.message());
    }

    unit->setSaplingHeightMap(0); // invalidate again
    return unit;

}


/// multithreaded execution of the carbon cycle routine
ResourceUnit *nc_carbonCycle(ResourceUnit *unit)
{
    try {
        // (1) do calculations on snag dynamics for the resource unit
        unit->calculateCarbonCycle();
        // (2) do the soil carbon and nitrogen dynamics calculations (ICBM/2N)
    } catch (const IException& e) {
        GlobalSettings::instance()->controller()->throwError(e.message());
    }

    return unit;
}

/// beforeRun performs several steps before the models starts running.
/// inter alia: * setup of the stands
///             * setup of the climates
void Model::beforeRun()
{
    // setup outputs
    // setup output database
    if (GlobalSettings::instance()->dbout().isOpen())
        GlobalSettings::instance()->dbout().close();
    initOutputDatabase();
    GlobalSettings::instance()->outputManager()->setup();
    GlobalSettings::instance()->clearDebugLists();

    // initialize stands
    StandLoader loader(this);
    {
    DebugTimer loadtrees("load trees");
    loader.processInit();
    }
    // initalization of ABE
    if (mABEManagement) {
        mABEManagement->setup();
        mABEManagement->runOnInit(true);
    }

    // load climate
    {
        if (logLevelDebug()) qDebug() << "attempting to load climate..." ;
        DebugTimer loadclim("load climate");
        foreach(Climate *c, mClimates) {
            if (!c->isSetup())
                c->setup();
        }
        // load the first year of the climate database
        foreach(Climate *c, mClimates)
            c->nextYear();

    }


    { DebugTimer loadinit("load standstatistics");
    if (logLevelDebug()) qDebug() << "attempting to calculate initial stand statistics (incl. apply and read pattern)..." ;
    Tree::setGrid(mGrid, mHeightGrid);
    // debugCheckAllTrees(); // introduced for debugging session (2012-04-06)
    applyPattern();
    readPattern();
    loader.processAfterInit(); // e.g. initialization of saplings

    // force the compilation of initial stand statistics
    createStandStatistics();
    }

    // initalization of ABE (now all stands are properly set up)
    if (mABEManagement) {
        mABEManagement->initialize();
        mABEManagement->runOnInit(false);
    }


    // outputs to create with inital state (without any growth) are called here:
    GlobalSettings::instance()->setCurrentYear(0); // set clock to "0" (for outputs with initial state)

    GlobalSettings::instance()->outputManager()->execute("stand"); // year=0
    GlobalSettings::instance()->outputManager()->execute("landscape"); // year=0
    GlobalSettings::instance()->outputManager()->execute("sapling"); // year=0
    GlobalSettings::instance()->outputManager()->execute("tree"); // year=0
    GlobalSettings::instance()->outputManager()->execute("dynamicstand"); // year=0

    GlobalSettings::instance()->setCurrentYear(1); // set to first year

}

/** Main model runner.
  The sequence of actions is as follows:
  (1) Load the climate of the new year
  (2) Reset statistics for resource unit as well as for dead/managed trees
  (3) Invoke Management.
  (4) *after* that, calculate Light patterns
  (5) 3PG on stand level, tree growth. Clear stand-statistcs before they are filled by single-tree-growth. calculate water cycle (with LAIs before management)
  (6) execute Regeneration
  (7) invoke disturbance modules
  (8) calculate statistics for the year
  (9) write database outputs
  */
void Model::runYear()
{
    DebugTimer t("Model::runYear()");
    GlobalSettings::instance()->systemStatistics()->reset();
    RandomGenerator::checkGenerator(); // see if we need to generate new numbers...
    // initalization at start of year for external modules
    mModules->yearBegin();

    // execute scheduled events for the current year
    if (mTimeEvents)
        mTimeEvents->run();

    // load the next year of the climate database (except for the first year - the first climate year is loaded immediately
    if (GlobalSettings::instance()->currentYear()>1) {
        foreach(Climate *c, mClimates)
            c->nextYear();
    }

    // reset statistics
    foreach(ResourceUnit *ru, mRU)
        ru->newYear();

    foreach(SpeciesSet *set, mSpeciesSets)
        set->newYear();
    // management classic
    if (mManagement) {
        DebugTimer t("management");
        mManagement->run();
        GlobalSettings::instance()->systemStatistics()->tManagement+=t.elapsed();
    }
    // ... or ABE (the agent based variant)
    if (mABEManagement) {
        DebugTimer t("ABE:run");
        mABEManagement->run();
        GlobalSettings::instance()->systemStatistics()->tManagement+=t.elapsed();
    }

    // if trees are dead/removed because of management, the tree lists
    // need to be cleaned (and the statistics need to be recreated)
    cleanTreeLists();

    // process a cycle of individual growth
    applyPattern(); // create Light Influence Patterns
    readPattern(); // readout light state of individual trees
    grow(); // let the trees grow (growth on stand-level, tree-level, mortality)
    mGrassCover->execute(); // evaluate the grass / herb cover (and its effect on regeneration)

    // regeneration
    if (settings().regenerationEnabled) {
        // seed dispersal
        DebugTimer tseed("Regeneration and Establishment");
        foreach(SpeciesSet *set, mSpeciesSets)
            set->regeneration(); // parallel execution for each species set

        GlobalSettings::instance()->systemStatistics()->tSeedDistribution+=tseed.elapsed();
        // establishment
        Sapling::updateBrowsingPressure();

        { DebugTimer t("saplingGrowthEstablishment");
        executePerResourceUnit( nc_sapling_growth_establishment, false /* true: force single thraeded operation */);
        GlobalSettings::instance()->systemStatistics()->tSaplingAndEstablishment+=t.elapsed();
        }

        Establishment::debugInfo(); // debug test

    }

    // calculate soil / snag dynamics
    if (settings().carbonCycleEnabled) {
        DebugTimer ccycle("carbon cylce");
        executePerResourceUnit( nc_carbonCycle, false /* true: force single threaded operation */);
        GlobalSettings::instance()->systemStatistics()->tCarbonCycle+=ccycle.elapsed();

    }

    // external modules/disturbances
    mModules->run();

    // cleanup of tree lists if external modules removed trees.
    cleanTreeLists();


    DebugTimer toutput("outputs");
    // calculate statistics
    foreach(ResourceUnit *ru, mRU)
        ru->yearEnd();

    // create outputs
    OutputManager *om = GlobalSettings::instance()->outputManager();
    om->execute("tree"); // single tree output
    om->execute("treeremoval"); // single removed tree output
    om->execute("stand"); //resource unit level x species
    om->execute("landscape"); //landscape x species
    om->execute("landscape_removed"); //removed trees on landscape x species
    om->execute("sapling"); // sapling layer per RU x species
    om->execute("production_month"); // 3pg responses growth per species x RU x month
    om->execute("dynamicstand"); // output with user-defined columns (based on species x RU)
    om->execute("standdead"); // resource unit level x species
    om->execute("management"); // resource unit level x species
    om->execute("carbon"); // resource unit level, carbon pools above and belowground
    om->execute("carbonflow"); // resource unit level, GPP, NPP and total carbon flows (atmosphere, harvest, ...)

    GlobalSettings::instance()->systemStatistics()->tWriteOutput+=toutput.elapsed();
    GlobalSettings::instance()->systemStatistics()->tTotalYear+=t.elapsed();
    GlobalSettings::instance()->systemStatistics()->writeOutput();

    GlobalSettings::instance()->setCurrentYear(GlobalSettings::instance()->currentYear()+1);

    // try to clean up a bit of memory (useful if many large JS objects (e.g., grids) are used)
    GlobalSettings::instance()->scriptEngine()->collectGarbage();
}



void Model::afterStop()
{
    // do some cleanup
}

/// multithreaded running function for LIP printing
ResourceUnit* nc_applyPattern(ResourceUnit *unit)
{

    QVector<Tree>::iterator tit;
    QVector<Tree>::iterator tend = unit->trees().end();

    try {

        // light concurrence influence
        if (!GlobalSettings::instance()->settings().paramValueBool("torus")) {
            // height dominance grid
            for (tit=unit->trees().begin(); tit!=tend; ++tit)
                (*tit).heightGrid(); // just do it ;)

            for (tit=unit->trees().begin(); tit!=tend; ++tit)
                (*tit).applyLIP(); // just do it ;)

        } else {
            // height dominance grid
            for (tit=unit->trees().begin(); tit!=tend; ++tit)
                (*tit).heightGrid_torus(); // just do it ;)

            for (tit=unit->trees().begin(); tit!=tend; ++tit)
                (*tit).applyLIP_torus(); // do it the wraparound way
        }
        return unit;
    } catch (const IException &e) {
        GlobalSettings::instance()->controller()->throwError(e.message());
    }
    return unit;
}

/// multithreaded running function for LIP value extraction
ResourceUnit *nc_readPattern(ResourceUnit *unit)
{
    QVector<Tree>::iterator tit;
    QVector<Tree>::iterator  tend = unit->trees().end();
    try {
        if (!GlobalSettings::instance()->settings().paramValueBool("torus")) {
            for (tit=unit->trees().begin(); tit!=tend; ++tit)
                (*tit).readLIF(); // multipliactive approach
        } else {
            for (tit=unit->trees().begin(); tit!=tend; ++tit)
                (*tit).readLIF_torus(); // do it the wraparound way
        }
    } catch (const IException &e) {
        GlobalSettings::instance()->controller()->throwError(e.message());
    }
    return unit;
}

/// multithreaded running function for the growth of individual trees
ResourceUnit *nc_grow(ResourceUnit *unit)
{
    QVector<Tree>::iterator tit;
    QVector<Tree>::iterator  tend = unit->trees().end();
    try {
        unit->beforeGrow(); // reset statistics
        // calculate light responses
        // responses are based on *modified* values for LightResourceIndex
        for (tit=unit->trees().begin(); tit!=tend; ++tit) {
            (*tit).calcLightResponse();
        }

        unit->calculateInterceptedArea();

        for (tit=unit->trees().begin(); tit!=tend; ++tit) {
            (*tit).grow(); // actual growth of individual trees
        }
    } catch (const IException &e) {
        GlobalSettings::instance()->controller()->throwError(e.message());
    }

    GlobalSettings::instance()->systemStatistics()->treeCount+=unit->trees().count();
    return unit;
}

/// multithreaded running function for the resource level production
ResourceUnit *nc_production(ResourceUnit *unit)
{
    try {
        unit->production();
    } catch (const IException &e) {
        GlobalSettings::instance()->controller()->throwError(e.message());
    }
    return unit;
}


void Model::test()
{
    // Test-funktion: braucht 1/3 time von readGrid()
    DebugTimer t("test");
    FloatGrid averaged = mGrid->averaged(10);
    int count = 0;
    float *end = averaged.end();
    for (float *p=averaged.begin(); p!=end; ++p)
        if (*p > 0.9)
            count++;
    qDebug() << count << "LIF>0.9 of " << averaged.count();
}

void Model::debugCheckAllTrees()
{
    AllTreeIterator at(this);
    bool has_errors = false; double dummy=0.;
    while (Tree *t = at.next()) {
        // plausibility
        if (t->dbh()<0 || t->dbh()>10000. || t->biomassFoliage()<0. || t->height()>1000. || t->height() < 0.
                || t->biomassFoliage() <0.)
            has_errors = true;
        // check for objects....
        dummy = t->stamp()->offset() + t->ru()->ruSpecies()[1]->statistics().count();
    }
    if (has_errors)
        qDebug() << "model: debugCheckAllTrees found problems" << dummy;
}

void Model::applyPattern()
{

    DebugTimer t("applyPattern()");
    // intialize grids...
    initializeGrid();

    // initialize height grid with a value of 4m. This is the height of the regeneration layer
    for (HeightGridValue *h=mHeightGrid->begin();h!=mHeightGrid->end();++h) {
        h->resetCount(); // set count = 0, but do not touch the flags
        h->height = 4.f;
    }

    threadRunner.run(nc_applyPattern);
    GlobalSettings::instance()->systemStatistics()->tApplyPattern+=t.elapsed();
}

void Model::readPattern()
{
    DebugTimer t("readPattern()");
    threadRunner.run(nc_readPattern);
    GlobalSettings::instance()->systemStatistics()->tReadPattern+=t.elapsed();

}

/** Main function for the growth of stands and trees.
   This includes several steps.
   (1) calculate the stocked area (i.e. count pixels in height grid)
   (2) 3PG production (including response calculation, water cycle)
   (3) single tree growth (including mortality)
   (4) cleanup of tree lists (remove dead trees)
  */
void Model::grow()
{

    if (!settings().growthEnabled)
        return;
    { DebugTimer t("growRU()");
    calculateStockedArea();

    // multithreaded: mutex for the message handler in mainwindow solved the crashes.
    threadRunner.run(nc_production);
    }

    DebugTimer t("growTrees()");
    threadRunner.run(nc_grow); // actual growth of individual trees

    foreach(ResourceUnit *ru, mRU) {
       ru->cleanTreeList();
       ru->afterGrow();
       //qDebug() << (b-n) << "trees died (of" << b << ").";
   }
   GlobalSettings::instance()->systemStatistics()->tTreeGrowth+=t.elapsed();
}

/** calculate for each resource unit the fraction of area which is stocked.
  This is done by checking the pixels of the global height grid.
  */
void Model::calculateStockedArea()
{
    // iterate over the whole heightgrid and count pixels for each ressource unit
    HeightGridValue *end = mHeightGrid->end();
    QPointF cp;
    ResourceUnit *ru;
    for (HeightGridValue *i=mHeightGrid->begin(); i!=end; ++i) {
        cp = mHeightGrid->cellCenterPoint(mHeightGrid->indexOf(i));
        if (mRUmap.coordValid(cp)) {
            ru = mRUmap.valueAt(cp);
            if (ru) {
                ru->countStockedPixel( (*i).count()>0 );
            }
        }

    }
}

/** calculate for each resource unit the stockable area.
  "stockability" is determined by the isValid flag of resource units which in turn
  is derived from stand grid values.
  */
void Model::calculateStockableArea()
{

    mTotalStockableArea = 0.;
    foreach(ResourceUnit *ru, mRU) {
        // //
        //        if (ru->id()==-1) {
        //            ru->setStockableArea(0.);
        //            continue;
        //        }
        GridRunner<HeightGridValue> runner(*mHeightGrid, ru->boundingBox());
        int valid=0, total=0;
        while (runner.next()) {
            if ( runner.current()->isValid() )
                valid++;
            total++;
        }
        if (total) {
 
            ru->setStockableArea( cHeightPixelArea * valid); // in m2
            mTotalStockableArea += cHeightPixelArea * valid / 10000.; // in ha
            if (valid==0 && ru->id()>-1) {
                // invalidate this resource unit
                ru->setID(-1);
            }
            if (valid>0 && ru->id()==-1) {
                qDebug() << "Warning: a resource unit has id=-1 but stockable area (id was set to 0)!!! ru: " << ru->boundingBox() << "with index" << ru->index();
                ru->setID(0);
                // test-code
                //GridRunner<HeightGridValue> runner(*mHeightGrid, ru->boundingBox());
                //while (runner.next()) {
                //    qDebug() << mHeightGrid->cellCenterPoint(mHeightGrid->indexOf( runner.current() )) << ": " << runner.current()->isValid();
                //}

            }
        } else
            throw IException("calculateStockableArea: resource unit without pixels!");

    }
    // mark those pixels that are at the edge of a "forest-out-of-area"
    GridRunner<HeightGridValue> runner(*mHeightGrid, mHeightGrid->metricRect());
    HeightGridValue* neighbors[8];
    while (runner.next()) {
        if (runner.current()->isForestOutside()) {
            // if the current pixel is a "radiating" border pixel,
            // then check the neighbors and set a flag if the pixel is a neighbor of a in-project-area pixel.
            runner.neighbors8(neighbors);
            for (int i=0;i<8;++i)
                if (neighbors[i] &&  neighbors[i]->isValid())
                    runner.current()->setIsRadiating();

        }
    }

    qDebug() << "Total stockable area of the landscape is" << mTotalStockableArea << "ha.";

}

void Model::initializeGrid()
{
    // fill the whole grid with a value of "1."
    mGrid->initialize(1.f);

    // apply special values for grid cells border regions where out-of-area cells
    // radiate into the main LIF grid.
    QPoint p;
    int ix_min, ix_max, iy_min, iy_max, ix_center, iy_center;
    const int px_offset = cPxPerHeight / 2; // for 5 px per height grid cell, the offset is 2
    const int max_radiate_distance = 7;
    const float step_width = 1.f / (float)max_radiate_distance;
    int c_rad = 0;
    for (HeightGridValue *hgv=mHeightGrid->begin(); hgv!=mHeightGrid->end(); ++hgv) {
        if (hgv->isRadiating()) {
            p=mHeightGrid->indexOf(hgv);
            ix_min = p.x() * cPxPerHeight - max_radiate_distance + px_offset;
            ix_max = ix_min + 2*max_radiate_distance + 1;
            ix_center = ix_min + max_radiate_distance;
            iy_min = p.y() * cPxPerHeight - max_radiate_distance + px_offset;
            iy_max = iy_min + 2*max_radiate_distance + 1;
            iy_center = iy_min + max_radiate_distance;
            for (int y=iy_min; y<=iy_max; ++y) {
                for (int x=ix_min; x<=ix_max; ++x) {
                    if (!mGrid->isIndexValid(x,y) ||  !(*mHeightGrid)(x/cPxPerHeight, y/cPxPerHeight).isValid())
                        continue;
                    float value = qMax(qAbs(x-ix_center), qAbs(y-iy_center)) * step_width;
                    float &v = mGrid->valueAtIndex(x, y);
                    if (value>=0.f && v>value)
                        v = value;
                }
            }
            c_rad++;
        }
    }
    if (logLevelDebug())
        qDebug() << "initialize grid:" << c_rad << "radiating pixels...";

}


/// Force the creation of stand statistics.
/// - stocked area (for resourceunit-areas)
/// - ru - statistics
void Model::createStandStatistics()
{
    calculateStockedArea();
    foreach(ResourceUnit *ru, mRU) {
        ru->addTreeAgingForAllTrees();
        ru->createStandStatistics();
    }
}

void Model::cleanTreeLists()
{
    foreach(ResourceUnit *ru, GlobalSettings::instance()->model()->ruList()) {
        if (ru->hasDiedTrees()) {
            ru->cleanTreeList();
            ru->recreateStandStatistics();
        }
    }
}


 

Rev 1111	Rev 1114
1	Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/model.cpp':	1	Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/model.cpp':
2	/********************************************************************************************	2	/********************************************************************************************
3	** iLand - an individual based forest landscape and disturbance model	3	** iLand - an individual based forest landscape and disturbance model
4	** http://iland.boku.ac.at	4	** http://iland.boku.ac.at
5	** Copyright (C) 2009- Werner Rammer, Rupert Seidl	5	** Copyright (C) 2009- Werner Rammer, Rupert Seidl
6	**	6	**
7	** This program is free software: you can redistribute it and/or modify	7	** This program is free software: you can redistribute it and/or modify
8	** it under the terms of the GNU General Public License as published by	8	** it under the terms of the GNU General Public License as published by
9	** the Free Software Foundation, either version 3 of the License, or	9	** the Free Software Foundation, either version 3 of the License, or
10	** (at your option) any later version.	10	** (at your option) any later version.
11	**	11	**
12	** This program is distributed in the hope that it will be useful,	12	** This program is distributed in the hope that it will be useful,
13	** but WITHOUT ANY WARRANTY; without even the implied warranty of	13	** but WITHOUT ANY WARRANTY; without even the implied warranty of
14	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	** GNU General Public License for more details.	15	** GNU General Public License for more details.
16	**	16	**
17	** You should have received a copy of the GNU General Public License	17	** You should have received a copy of the GNU General Public License
18	** along with this program. If not, see <http://www.gnu.org/licenses/>.	18	** along with this program. If not, see <http://www.gnu.org/licenses/>.
19	********************************************************************************************/	19	********************************************************************************************/
20		20
21	/** @class Model	21	/** @class Model
22	Main object of the iLand model composited of various sub models / sub components.	22	Main object of the iLand model composited of various sub models / sub components.
23	@ingroup core	23	@ingroup core
24	The class Model is the top level container of iLand. The Model holds a collection of ResourceUnits, links to SpeciesSet and Climate.	24	The class Model is the top level container of iLand. The Model holds a collection of ResourceUnits, links to SpeciesSet and Climate.
25	ResourceUnit are grid cells with (currently) a size of 1 ha (100x100m). Many stand level processes (NPP produciton, WaterCycle) operate on this	25	ResourceUnit are grid cells with (currently) a size of 1 ha (100x100m). Many stand level processes (NPP produciton, WaterCycle) operate on this
26	level.	26	level.
27	The Model also contain the landscape-wide 2m LIF-grid (http://iland.boku.ac.at/competition+for+light).	27	The Model also contain the landscape-wide 2m LIF-grid (http://iland.boku.ac.at/competition+for+light).
28		28
29	*/	29	*/
30	#include "global.h"	30	#include "global.h"
31	#include "model.h"	31	#include "model.h"
32	#include "sqlhelper.h"	32	#include "sqlhelper.h"
33		33
34	#include "xmlhelper.h"	34	#include "xmlhelper.h"
35	#include "debugtimer.h"	35	#include "debugtimer.h"
36	#include "environment.h"	36	#include "environment.h"
37	#include "timeevents.h"	37	#include "timeevents.h"
38	#include "helper.h"	38	#include "helper.h"
39	#include "resourceunit.h"	39	#include "resourceunit.h"
40	#include "climate.h"	40	#include "climate.h"
41	#include "speciesset.h"	41	#include "speciesset.h"
42	#include "standloader.h"	42	#include "standloader.h"
43	#include "tree.h"	43	#include "tree.h"
44	#include "management.h"	44	#include "management.h"
45	#include "saplings.h"	45	#include "saplings.h"
46	#include "modelsettings.h"	46	#include "modelsettings.h"
47	#include "standstatistics.h"	47	#include "standstatistics.h"
48	#include "mapgrid.h"	48	#include "mapgrid.h"
49	#include "modelcontroller.h"	49	#include "modelcontroller.h"
50	#include "modules.h"	50	#include "modules.h"
51	#include "dem.h"	51	#include "dem.h"
52	#include "grasscover.h"	52	#include "grasscover.h"
53		53
54	#include "outputmanager.h"	54	#include "outputmanager.h"
55		55
56	#include "forestmanagementengine.h"	56	#include "forestmanagementengine.h"
57		57
58	#include <QtCore>	58	#include <QtCore>
59	#include <QtXml>	59	#include <QtXml>
60		60
61	/** iterate over all trees of the model. return NULL if all trees processed.	61	/** iterate over all trees of the model. return NULL if all trees processed.
62	Usage:	62	Usage:
63	@code	63	@code
64	AllTreeIterator trees(model);	64	AllTreeIterator trees(model);
65	while (Tree *tree = trees.next()) { // returns NULL when finished.	65	while (Tree *tree = trees.next()) { // returns NULL when finished.
66	tree->something(); // do something	66	tree->something(); // do something
67	}	67	}
68	@endcode */	68	@endcode */
69	Tree *AllTreeIterator::next()	69	Tree *AllTreeIterator::next()
70	{	70	{
71		71
72	if (!mTreeEnd) {	72	if (!mTreeEnd) {
73	// initialize to first ressource unit	73	// initialize to first ressource unit
74	mRUIterator = mModel->ruList().constBegin();	74	mRUIterator = mModel->ruList().constBegin();
75	// fast forward to the first RU with trees	75	// fast forward to the first RU with trees
76	while (mRUIterator!=mModel->ruList().constEnd()) {	76	while (mRUIterator!=mModel->ruList().constEnd()) {
77	if ((*mRUIterator)->trees().count()>0)	77	if ((*mRUIterator)->trees().count()>0)
78	break;	78	break;
79	++mRUIterator;	79	++mRUIterator;
80	}	80	}
81	// finished if all RU processed	81	// finished if all RU processed
82	if (mRUIterator == mModel->ruList().constEnd())	82	if (mRUIterator == mModel->ruList().constEnd())
83	return NULL;	83	return NULL;
84	mTreeEnd = &((*mRUIterator)->trees().back()) + 1; // let end point to "1 after end" (STL-style)	84	mTreeEnd = &((*mRUIterator)->trees().back()) + 1; // let end point to "1 after end" (STL-style)
85	mCurrent = &((*mRUIterator)->trees().front());	85	mCurrent = &((*mRUIterator)->trees().front());
86	}	86	}
87	if (mCurrent==mTreeEnd) {	87	if (mCurrent==mTreeEnd) {
88	++mRUIterator; // switch to next RU (loop until RU with trees is found)	88	++mRUIterator; // switch to next RU (loop until RU with trees is found)
89	while (mRUIterator!=mModel->ruList().constEnd()) {	89	while (mRUIterator!=mModel->ruList().constEnd()) {
90	if ((*mRUIterator)->trees().count()>0) {	90	if ((*mRUIterator)->trees().count()>0) {
91	break;	91	break;
92	}	92	}
93	++mRUIterator;	93	++mRUIterator;
94	}	94	}
95	if (mRUIterator == mModel->ruList().constEnd()) {	95	if (mRUIterator == mModel->ruList().constEnd()) {
96	mCurrent = NULL;	96	mCurrent = NULL;
97	return NULL; // finished!!	97	return NULL; // finished!!
98	}else {	98	}else {
99	mTreeEnd = &((*mRUIterator)->trees().back()) + 1;	99	mTreeEnd = &((*mRUIterator)->trees().back()) + 1;
100	mCurrent = &((*mRUIterator)->trees().front());	100	mCurrent = &((*mRUIterator)->trees().front());
101	}	101	}
102	}	102	}
103		103
104	return mCurrent++;	104	return mCurrent++;
105	}	105	}
106	Tree *AllTreeIterator::nextLiving()	106	Tree *AllTreeIterator::nextLiving()
107	{	107	{
108	while (Tree *t = next())	108	while (Tree *t = next())
109	if (!t->isDead()) return t;	109	if (!t->isDead()) return t;
110	return NULL;	110	return NULL;
111	}	111	}
112	Tree *AllTreeIterator::current() const	112	Tree *AllTreeIterator::current() const
113	{	113	{
114	return mCurrent?mCurrent-1:NULL;	114	return mCurrent?mCurrent-1:NULL;
115	}	115	}
116		116
117		117
118	ModelSettings Model::mSettings;	118	ModelSettings Model::mSettings;
119	Model::Model()	119	Model::Model()
120	{	120	{
121	initialize();	121	initialize();
122	GlobalSettings::instance()->setModel(this);	122	GlobalSettings::instance()->setModel(this);
123	GlobalSettings::instance()->resetScriptEngine(); // clear the script	123	GlobalSettings::instance()->resetScriptEngine(); // clear the script
124	QString dbg="running in release mode.";	124	QString dbg="running in release mode.";
125	DBGMODE( dbg="running in debug mode."; );	125	DBGMODE( dbg="running in debug mode."; );
126	qDebug() << dbg;	126	qDebug() << dbg;
127	}	127	}
128		128
129	Model::~Model()	129	Model::~Model()
130	{	130	{
131	clear();	131	clear();
132	GlobalSettings::instance()->setModel(NULL);	132	GlobalSettings::instance()->setModel(NULL);
133	}	133	}
134		134
135	/** Initial setup of the Model.	135	/** Initial setup of the Model.
136	*/	136	*/
137	void Model::initialize()	137	void Model::initialize()
138	{	138	{
139	mSetup = false;	139	mSetup = false;
140	GlobalSettings::instance()->setCurrentYear(0);	140	GlobalSettings::instance()->setCurrentYear(0);
141	mGrid = 0;	141	mGrid = 0;
142	mHeightGrid = 0;	142	mHeightGrid = 0;
143	mManagement = 0;	143	mManagement = 0;
144	mABEManagement = 0;	144	mABEManagement = 0;
145	mEnvironment = 0;	145	mEnvironment = 0;
146	mTimeEvents = 0;	146	mTimeEvents = 0;
147	mStandGrid = 0;	147	mStandGrid = 0;
148	mModules = 0;	148	mModules = 0;
149	mDEM = 0;	149	mDEM = 0;
150	mGrassCover = 0;	150	mGrassCover = 0;
151	mSaplings=0;	151	mSaplings=0;
152	}	152	}
153		153
154	/** sets up the simulation space.	154	/** sets up the simulation space.
155	*/	155	*/
156	void Model::setupSpace()	156	void Model::setupSpace()
157	{	157	{
158	XmlHelper xml(GlobalSettings::instance()->settings().node("model.world"));	158	XmlHelper xml(GlobalSettings::instance()->settings().node("model.world"));
159	double cellSize = xml.value("cellSize", "2").toDouble();	159	double cellSize = xml.value("cellSize", "2").toDouble();
160	double width = xml.value("width", "100").toDouble();	160	double width = xml.value("width", "100").toDouble();
161	double height = xml.value("height", "100").toDouble();	161	double height = xml.value("height", "100").toDouble();
162	double buffer = xml.value("buffer", "60").toDouble();	162	double buffer = xml.value("buffer", "60").toDouble();
163	mModelRect = QRectF(0., 0., width, height);	163	mModelRect = QRectF(0., 0., width, height);
164		164
165	qDebug() << QString("setup of the world: %1x%2m with cell-size=%3m and %4m buffer").arg(width).arg(height).arg(cellSize).arg(buffer);	165	qDebug() << QString("setup of the world: %1x%2m with cell-size=%3m and %4m buffer").arg(width).arg(height).arg(cellSize).arg(buffer);
166		166
167	QRectF total_grid(QPointF(-buffer, -buffer), QPointF(width+buffer, height+buffer));	167	QRectF total_grid(QPointF(-buffer, -buffer), QPointF(width+buffer, height+buffer));
168	qDebug() << "setup grid rectangle:" << total_grid;	168	qDebug() << "setup grid rectangle:" << total_grid;
169		169
170	if (mGrid)	170	if (mGrid)
171	delete mGrid;	171	delete mGrid;
172	mGrid = new FloatGrid(total_grid, cellSize);	172	mGrid = new FloatGrid(total_grid, cellSize);
173	mGrid->initialize(1.f);	173	mGrid->initialize(1.f);
174	if (mHeightGrid)	174	if (mHeightGrid)
175	delete mHeightGrid;	175	delete mHeightGrid;
176	mHeightGrid = new HeightGrid(total_grid, cellSize*5);	176	mHeightGrid = new HeightGrid(total_grid, cellSize*5);
177	mHeightGrid->wipe(); // set all to zero	177	mHeightGrid->wipe(); // set all to zero
178	Tree::setGrid(mGrid, mHeightGrid);	178	Tree::setGrid(mGrid, mHeightGrid);
179		179
180	// setup the spatial location of the project area	180	// setup the spatial location of the project area
181	if (xml.hasNode("location")) {	181	if (xml.hasNode("location")) {
182	// setup of spatial location	182	// setup of spatial location
183	double loc_x = xml.valueDouble("location.x");	183	double loc_x = xml.valueDouble("location.x");
184	double loc_y = xml.valueDouble("location.y");	184	double loc_y = xml.valueDouble("location.y");
185	double loc_z = xml.valueDouble("location.z");	185	double loc_z = xml.valueDouble("location.z");
186	double loc_rot = xml.valueDouble("location.rotation");	186	double loc_rot = xml.valueDouble("location.rotation");
187	setupGISTransformation(loc_x, loc_y, loc_z, loc_rot);	187	setupGISTransformation(loc_x, loc_y, loc_z, loc_rot);
188	qDebug() << "setup of spatial location: x/y/z" << loc_x << loc_y << loc_z << "rotation:" << loc_rot;	188	qDebug() << "setup of spatial location: x/y/z" << loc_x << loc_y << loc_z << "rotation:" << loc_rot;
189	} else {	189	} else {
190	setupGISTransformation(0., 0., 0., 0.);	190	setupGISTransformation(0., 0., 0., 0.);
191	}	191	}
192		192
193	// load environment (multiple climates, speciesSets, ...	193	// load environment (multiple climates, speciesSets, ...
194	if (mEnvironment)	194	if (mEnvironment)
195	delete mEnvironment;	195	delete mEnvironment;
196	mEnvironment = new Environment();	196	mEnvironment = new Environment();
197		197
198	if (xml.valueBool("environmentEnabled", false)) {	198	if (xml.valueBool("environmentEnabled", false)) {
199	QString env_file = GlobalSettings::instance()->path(xml.value("environmentFile"));	199	QString env_file = GlobalSettings::instance()->path(xml.value("environmentFile"));
200	bool grid_mode = (xml.value("environmentMode")=="grid");	200	bool grid_mode = (xml.value("environmentMode")=="grid");
201	QString grid_file = GlobalSettings::instance()->path(xml.value("environmentGrid"));	201	QString grid_file = GlobalSettings::instance()->path(xml.value("environmentGrid"));
202	if (grid_mode) {	202	if (grid_mode) {
203	if (QFile::exists(grid_file))	203	if (QFile::exists(grid_file))
204	mEnvironment->setGridMode(grid_file);	204	mEnvironment->setGridMode(grid_file);
205	else	205	else
206	throw IException(QString("File '%1' specified in key 'environmentGrid' does not exit ('environmentMode' is 'grid').").arg(grid_file) );	206	throw IException(QString("File '%1' specified in key 'environmentGrid' does not exit ('environmentMode' is 'grid').").arg(grid_file) );
207	}	207	}
208		208
209	if (!mEnvironment->loadFromFile(env_file))	209	if (!mEnvironment->loadFromFile(env_file))
210	return;	210	return;
211	} else {	211	} else {
212	// load and prepare default values	212	// load and prepare default values
213	// (2) SpeciesSets: currently only one a global species set.	213	// (2) SpeciesSets: currently only one a global species set.
214	SpeciesSet *speciesSet = new SpeciesSet();	214	SpeciesSet *speciesSet = new SpeciesSet();
215	mSpeciesSets.push_back(speciesSet);	215	mSpeciesSets.push_back(speciesSet);
216	speciesSet->setup();	216	speciesSet->setup();
217	// Climate...	217	// Climate...
218	Climate *c = new Climate();	218	Climate *c = new Climate();
219	mClimates.push_back(c);	219	mClimates.push_back(c);
220	mEnvironment->setDefaultValues(c, speciesSet);	220	mEnvironment->setDefaultValues(c, speciesSet);
221	} // environment?	221	} // environment?
222		222
223	// time series data	223	// time series data
224	if (xml.valueBool(".timeEventsEnabled", false)) {	224	if (xml.valueBool(".timeEventsEnabled", false)) {
225	mTimeEvents = new TimeEvents();	225	mTimeEvents = new TimeEvents();
226	mTimeEvents->loadFromFile(GlobalSettings::instance()->path(xml.value("timeEventsFile"), "script"));	226	mTimeEvents->loadFromFile(GlobalSettings::instance()->path(xml.value("timeEventsFile"), "script"));
227	}	227	}
228		228
229		229
230	// simple case: create ressource units in a regular grid.	230	// simple case: create ressource units in a regular grid.
231	if (xml.valueBool("resourceUnitsAsGrid")) {	231	if (xml.valueBool("resourceUnitsAsGrid")) {
232		232
233	mRUmap.setup(QRectF(0., 0., width, height),100.); // Grid, that holds positions of resource units	233	mRUmap.setup(QRectF(0., 0., width, height),100.); // Grid, that holds positions of resource units
234	mRUmap.wipe();	234	mRUmap.wipe();
235		235
236	bool mask_is_setup = false;	236	bool mask_is_setup = false;
237	if (xml.valueBool("standGrid.enabled")) {	237	if (xml.valueBool("standGrid.enabled")) {
238	QString fileName = GlobalSettings::instance()->path(xml.value("standGrid.fileName"));	238	QString fileName = GlobalSettings::instance()->path(xml.value("standGrid.fileName"));
239	mStandGrid = new MapGrid(fileName,false); // create stand grid index later	239	mStandGrid = new MapGrid(fileName,false); // create stand grid index later
240		240
241	if (mStandGrid->isValid()) {	241	if (mStandGrid->isValid()) {
242	for (int i=0;i<mStandGrid->grid().count();i++) {	242	for (int i=0;i<mStandGrid->grid().count();i++) {
243	const int &grid_value = mStandGrid->grid().constValueAtIndex(i);	243	const int &grid_value = mStandGrid->grid().constValueAtIndex(i);
244	mHeightGrid->valueAtIndex(i).setValid( grid_value > -1 );	244	mHeightGrid->valueAtIndex(i).setValid( grid_value > -1 );
245	if (grid_value>-1)	245	if (grid_value>-1)
246	mRUmap.valueAt(mStandGrid->grid().cellCenterPoint(i)) = (ResourceUnit*)1;	246	mRUmap.valueAt(mStandGrid->grid().cellCenterPoint(i)) = (ResourceUnit*)1;
247	if (grid_value < -1)	247	if (grid_value < -1)
248	mHeightGrid->valueAtIndex(i).setForestOutside(true);	248	mHeightGrid->valueAtIndex(i).setForestOutside(true);
249	}	249	}
250	}	250	}
251	mask_is_setup = true;	251	mask_is_setup = true;
252	} else {	252	} else {
253	if (!GlobalSettings::instance()->settings().paramValueBool("torus")) {	253	if (!GlobalSettings::instance()->settings().paramValueBool("torus")) {
254	// in the case we have no stand grid but only a large rectangle (without the torus option)	254	// in the case we have no stand grid but only a large rectangle (without the torus option)
255	// we assume a forest outside	255	// we assume a forest outside
256	for (int i=0;i<mHeightGrid->count();++i) {	256	for (int i=0;i<mHeightGrid->count();++i) {
257	const QPointF &p = mHeightGrid->cellCenterPoint(mHeightGrid->indexOf(i));	257	const QPointF &p = mHeightGrid->cellCenterPoint(mHeightGrid->indexOf(i));
258	if (p.x() < 0. \|\| p.x()>width \|\| p.y()<0. \|\| p.y()>height) {	258	if (p.x() < 0. \|\| p.x()>width \|\| p.y()<0. \|\| p.y()>height) {
259	mHeightGrid->valueAtIndex(i).setForestOutside(true);	259	mHeightGrid->valueAtIndex(i).setForestOutside(true);
260	mHeightGrid->valueAtIndex(i).setValid(false);	260	mHeightGrid->valueAtIndex(i).setValid(false);
261	}	261	}
262	}	262	}
263		263
264	}	264	}
265	}	265	}
266		266
267	ResourceUnit **p; // ptr to ptr!	267	ResourceUnit **p; // ptr to ptr!
268	ResourceUnit *new_ru;	268	ResourceUnit *new_ru;
269		269
270	int ru_index = 0;	270	int ru_index = 0;
271	for (p=mRUmap.begin(); p!=mRUmap.end(); ++p) {	271	for (p=mRUmap.begin(); p!=mRUmap.end(); ++p) {
272	QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));	272	QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));
273	if (!mStandGrid \|\| !mStandGrid->isValid() \|\| *p>NULL) {	273	if (!mStandGrid \|\| !mStandGrid->isValid() \|\| *p>NULL) {
274	mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.	274	mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.
275	// create resource units for valid positions only	275	// create resource units for valid positions only
276	new_ru = new ResourceUnit(ru_index++); // create resource unit	276	new_ru = new ResourceUnit(ru_index++); // create resource unit
277	new_ru->setClimate( mEnvironment->climate() );	277	new_ru->setClimate( mEnvironment->climate() );
278	new_ru->setSpeciesSet( mEnvironment->speciesSet() );	278	new_ru->setSpeciesSet( mEnvironment->speciesSet() );
279	new_ru->setup();	279	new_ru->setup();
280	new_ru->setID( mEnvironment->currentID() ); // set id of resource unit in grid mode	280	new_ru->setID( mEnvironment->currentID() ); // set id of resource unit in grid mode
281	new_ru->setBoundingBox(r);	281	new_ru->setBoundingBox(r);
282	mRU.append(new_ru);	282	mRU.append(new_ru);
283	*p = new_ru; // save in the RUmap grid	283	*p = new_ru; // save in the RUmap grid
284	}	284	}
285	}	285	}
286	if (mEnvironment) {	286	if (mEnvironment) {
287	// retrieve species sets and climates (that were really used)	287	// retrieve species sets and climates (that were really used)
288	mSpeciesSets << mEnvironment->speciesSetList();	288	mSpeciesSets << mEnvironment->speciesSetList();
289	mClimates << mEnvironment->climateList();	289	mClimates << mEnvironment->climateList();
290	QString climate_file_list;	290	QString climate_file_list;
291	for (int i=0, c=0;i<mClimates.count();++i) {	291	for (int i=0, c=0;i<mClimates.count();++i) {
292	climate_file_list += mClimates[i]->name() + ", ";	292	climate_file_list += mClimates[i]->name() + ", ";
293	if (++c>5) {	293	if (++c>5) {
294	climate_file_list += "...";	294	climate_file_list += "...";
295	break;	295	break;
296	}	296	}
297		297
298	}	298	}
299	qDebug() << "Setup of climates: #loaded:" << mClimates.count() << "tables:" << climate_file_list;	299	qDebug() << "Setup of climates: #loaded:" << mClimates.count() << "tables:" << climate_file_list;
300		300
301		301
302	}	302	}
303		303
304	qDebug() << "setup of" << mEnvironment->climateList().size() << "climates performed.";	304	qDebug() << "setup of" << mEnvironment->climateList().size() << "climates performed.";
305		305
306	if (mStandGrid && mStandGrid->isValid())	306	if (mStandGrid && mStandGrid->isValid())
307	mStandGrid->createIndex();	307	mStandGrid->createIndex();
308	// now store the pointers in the grid.	308	// now store the pointers in the grid.
309	// Important: This has to be done after the mRU-QList is complete - otherwise pointers would	309	// Important: This has to be done after the mRU-QList is complete - otherwise pointers would
310	// point to invalid memory when QList's memory is reorganized (expanding)	310	// point to invalid memory when QList's memory is reorganized (expanding)
311	// ru_index = 0;	311	// ru_index = 0;
312	// for (p=mRUmap.begin();p!=mRUmap.end(); ++p) {	312	// for (p=mRUmap.begin();p!=mRUmap.end(); ++p) {
313	// *p = mRU.value(ru_index++);	313	// *p = mRU.value(ru_index++);
314	// }	314	// }
315	qDebug() << "created a grid of ResourceUnits: count=" << mRU.count() << "number of RU-map-cells:" << mRUmap.count();	315	qDebug() << "created a grid of ResourceUnits: count=" << mRU.count() << "number of RU-map-cells:" << mRUmap.count();
316		316
317		317
318	calculateStockableArea();	318	calculateStockableArea();
319		319
320	// setup of the project area mask	320	// setup of the project area mask
321	if (!mask_is_setup && xml.valueBool("areaMask.enabled", false) && xml.hasNode("areaMask.imageFile")) {	321	if (!mask_is_setup && xml.valueBool("areaMask.enabled", false) && xml.hasNode("areaMask.imageFile")) {
322	// to be extended!!! e.g. to load ESRI-style text files....	322	// to be extended!!! e.g. to load ESRI-style text files....
323	// setup a grid with the same size as the height grid...	323	// setup a grid with the same size as the height grid...
324	FloatGrid tempgrid((int)mHeightGrid->cellsize(), mHeightGrid->sizeX(), mHeightGrid->sizeY());	324	FloatGrid tempgrid((int)mHeightGrid->cellsize(), mHeightGrid->sizeX(), mHeightGrid->sizeY());
325	QString fileName = GlobalSettings::instance()->path(xml.value("areaMask.imageFile"));	325	QString fileName = GlobalSettings::instance()->path(xml.value("areaMask.imageFile"));
326	loadGridFromImage(fileName, tempgrid); // fetch from image	326	loadGridFromImage(fileName, tempgrid); // fetch from image
327	for (int i=0;i<tempgrid.count(); i++)	327	for (int i=0;i<tempgrid.count(); i++)
328	mHeightGrid->valueAtIndex(i).setValid( tempgrid.valueAtIndex(i)>0.99 );	328	mHeightGrid->valueAtIndex(i).setValid( tempgrid.valueAtIndex(i)>0.99 );
329	qDebug() << "loaded project area mask from" << fileName;	329	qDebug() << "loaded project area mask from" << fileName;
330	}	330	}
331		331
332	// list of "valid" resource units	332	// list of "valid" resource units
333	QList<ResourceUnit*> valid_rus;	333	QList<ResourceUnit*> valid_rus;
334	foreach(ResourceUnit* ru, mRU)	334	foreach(ResourceUnit* ru, mRU)
335	if (ru->id()!=-1)	335	if (ru->id()!=-1)
336	valid_rus.append(ru);	336	valid_rus.append(ru);
337		337
338	// setup of the digital elevation map (if present)	338	// setup of the digital elevation map (if present)
339	QString dem_file = xml.value("DEM");	339	QString dem_file = xml.value("DEM");
340	if (!dem_file.isEmpty()) {	340	if (!dem_file.isEmpty()) {
341	mDEM = new DEM(GlobalSettings::instance()->path(dem_file));	341	mDEM = new DEM(GlobalSettings::instance()->path(dem_file));
342	// add them to the visuals...	342	// add them to the visuals...
343	GlobalSettings::instance()->controller()->addGrid(mDEM, "DEM height", GridViewRainbow, 0, 1000);	343	GlobalSettings::instance()->controller()->addGrid(mDEM, "DEM height", GridViewRainbow, 0, 1000);
344	GlobalSettings::instance()->controller()->addGrid(mDEM->slopeGrid(), "DEM slope", GridViewRainbow, 0, 3);	344	GlobalSettings::instance()->controller()->addGrid(mDEM->slopeGrid(), "DEM slope", GridViewRainbow, 0, 3);
345	GlobalSettings::instance()->controller()->addGrid(mDEM->aspectGrid(), "DEM aspect", GridViewRainbow, 0, 360);	345	GlobalSettings::instance()->controller()->addGrid(mDEM->aspectGrid(), "DEM aspect", GridViewRainbow, 0, 360);
346	GlobalSettings::instance()->controller()->addGrid(mDEM->viewGrid(), "DEM view", GridViewGray, 0, 1);	346	GlobalSettings::instance()->controller()->addGrid(mDEM->viewGrid(), "DEM view", GridViewGray, 0, 1);
347		347
348	}	348	}
349		349
350	// setup of saplings	350	// setup of saplings
351	if (mSaplings) {	351	if (mSaplings) {
352	delete mSaplings; mSaplings=0;	352	delete mSaplings; mSaplings=0;
353	}	353	}
354	if (settings().regenerationEnabled) {	354	if (settings().regenerationEnabled) {
355	mSaplings = new Saplings();	355	mSaplings = new Saplings();
356	mSaplings->setup();	356	mSaplings->setup();
357	}	357	}
358		358
359		359
360	// setup of the grass cover	360	// setup of the grass cover
361	if (!mGrassCover)	361	if (!mGrassCover)
362	mGrassCover = new GrassCover();	362	mGrassCover = new GrassCover();
363	mGrassCover->setup();	363	mGrassCover->setup();
364		364
365	// setup of external modules	365	// setup of external modules
366	mModules->setup();	366	mModules->setup();
367	if (mModules->hasSetupResourceUnits()) {	367	if (mModules->hasSetupResourceUnits()) {
368	for (ResourceUnit **p=mRUmap.begin(); p!=mRUmap.end(); ++p) {	368	for (ResourceUnit **p=mRUmap.begin(); p!=mRUmap.end(); ++p) {
369	if (*p) {	369	if (*p) {
370	QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));	370	QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));
371	mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.	371	mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.
372	mModules->setupResourceUnit( *p );	372	mModules->setupResourceUnit( *p );
373	}	373	}
374	}	374	}
375	}	375	}
376		376
377	// setup of scripting environment	377	// setup of scripting environment
378	ScriptGlobal::setupGlobalScripting();	378	ScriptGlobal::setupGlobalScripting();
379		379
380	// setup the helper that does the multithreading	380	// setup the helper that does the multithreading
381	threadRunner.setup(valid_rus);	381	threadRunner.setup(valid_rus);
382	threadRunner.setMultithreading(GlobalSettings::instance()->settings().valueBool("system.settings.multithreading"));	382	threadRunner.setMultithreading(GlobalSettings::instance()->settings().valueBool("system.settings.multithreading"));
383	threadRunner.print();	383	threadRunner.print();
384		384
385		385
386	} else {	386	} else {
387	throw IException("resourceUnitsAsGrid MUST be set to true - at least currently :)");	387	throw IException("resourceUnitsAsGrid MUST be set to true - at least currently :)");
388	}	388	}
389	mSetup = true;	389	mSetup = true;
390	}	390	}
391		391
392		392
393	/** clear() frees all ressources allocated with the run of a simulation.	393	/** clear() frees all ressources allocated with the run of a simulation.
394		394
395	*/	395	*/
396	void Model::clear()	396	void Model::clear()
397	{	397	{
398	mSetup = false;	398	mSetup = false;
399	qDebug() << "Model clear: attempting to clear" << mRU.count() << "RU, " << mSpeciesSets.count() << "SpeciesSets.";	399	qDebug() << "Model clear: attempting to clear" << mRU.count() << "RU, " << mSpeciesSets.count() << "SpeciesSets.";
400	// clear ressource units	400	// clear ressource units
401	qDeleteAll(mRU); // delete ressource units (and trees)	401	qDeleteAll(mRU); // delete ressource units (and trees)
402	mRU.clear();	402	mRU.clear();
403		403
404	qDeleteAll(mSpeciesSets); // delete species sets	404	qDeleteAll(mSpeciesSets); // delete species sets
405	mSpeciesSets.clear();	405	mSpeciesSets.clear();
406		406
407	// delete climate data	407	// delete climate data
408	qDeleteAll(mClimates);	408	qDeleteAll(mClimates);
409		409
410	// delete the grids	410	// delete the grids
411	if (mGrid)	411	if (mGrid)
412	delete mGrid;	412	delete mGrid;
413	if (mHeightGrid)	413	if (mHeightGrid)
414	delete mHeightGrid;	414	delete mHeightGrid;
415	if (mSaplings)	415	if (mSaplings)
416	delete mSaplings;	416	delete mSaplings;
417	if (mManagement)	417	if (mManagement)
418	delete mManagement;	418	delete mManagement;
419	if (mEnvironment)	419	if (mEnvironment)
420	delete mEnvironment;	420	delete mEnvironment;
421	if (mTimeEvents)	421	if (mTimeEvents)
422	delete mTimeEvents;	422	delete mTimeEvents;
423	if (mStandGrid)	423	if (mStandGrid)
424	delete mStandGrid;	424	delete mStandGrid;
425	if (mModules)	425	if (mModules)
426	delete mModules;	426	delete mModules;
427	if (mDEM)	427	if (mDEM)
428	delete mDEM;	428	delete mDEM;
429	if (mGrassCover)	429	if (mGrassCover)
430	delete mGrassCover;	430	delete mGrassCover;
431	if (mABEManagement)	431	if (mABEManagement)
432	delete mABEManagement;	432	delete mABEManagement;
433		433
434	mGrid = 0;	434	mGrid = 0;
435	mHeightGrid = 0;	435	mHeightGrid = 0;
436	mManagement = 0;	436	mManagement = 0;
437	mEnvironment = 0;	437	mEnvironment = 0;
438	mTimeEvents = 0;	438	mTimeEvents = 0;
439	mStandGrid = 0;	439	mStandGrid = 0;
440	mModules = 0;	440	mModules = 0;
441	mDEM = 0;	441	mDEM = 0;
442	mGrassCover = 0;	442	mGrassCover = 0;
443	mABEManagement = 0;	443	mABEManagement = 0;
444		444
445	GlobalSettings::instance()->outputManager()->close();	445	GlobalSettings::instance()->outputManager()->close();
446		446
447	qDebug() << "Model ressources freed.";	447	qDebug() << "Model ressources freed.";
448	}	448	}
449		449
450	/** Setup of the Simulation.	450	/** Setup of the Simulation.
451	This really creates the simulation environment and does the setup of various aspects.	451	This really creates the simulation environment and does the setup of various aspects.
452	*/	452	*/
453	void Model::loadProject()	453	void Model::loadProject()
454	{	454	{
455	DebugTimer dt("load project");	455	DebugTimer dt("load project");
456	GlobalSettings *g = GlobalSettings::instance();	456	GlobalSettings *g = GlobalSettings::instance();
457	g->printDirecories();	457	g->printDirecories();
458	const XmlHelper &xml = g->settings();	458	const XmlHelper &xml = g->settings();
459		459
460	g->clearDatabaseConnections();	460	g->clearDatabaseConnections();
461	// database connections: reset	461	// database connections: reset
462	GlobalSettings::instance()->clearDatabaseConnections();	462	GlobalSettings::instance()->clearDatabaseConnections();
463	// input and climate connection	463	// input and climate connection
464	// see initOutputDatabase() for output database	464	// see initOutputDatabase() for output database
465	QString dbPath = g->path( xml.value("system.database.in"), "database");	465	QString dbPath = g->path( xml.value("system.database.in"), "database");
466	GlobalSettings::instance()->setupDatabaseConnection("in", dbPath, true);	466	GlobalSettings::instance()->setupDatabaseConnection("in", dbPath, true);
467	dbPath = g->path( xml.value("system.database.climate"), "database");	467	dbPath = g->path( xml.value("system.database.climate"), "database");
468	GlobalSettings::instance()->setupDatabaseConnection("climate", dbPath, true);	468	GlobalSettings::instance()->setupDatabaseConnection("climate", dbPath, true);
469		469
470	mSettings.loadModelSettings();	470	mSettings.loadModelSettings();
471	mSettings.print();	471	mSettings.print();
472	// random seed: if stored value is <> 0, use this as the random seed (and produce hence always an equal sequence of random numbers)	472	// random seed: if stored value is <> 0, use this as the random seed (and produce hence always an equal sequence of random numbers)
473	uint seed = xml.value("system.settings.randomSeed","0").toUInt();	473	uint seed = xml.value("system.settings.randomSeed","0").toUInt();
474	RandomGenerator::setup(RandomGenerator::ergMersenneTwister, seed); // use the MersenneTwister as default	474	RandomGenerator::setup(RandomGenerator::ergMersenneTwister, seed); // use the MersenneTwister as default
475	// linearization of expressions: if true and linearize() is explicitely called, then	475	// linearization of expressions: if true and linearize() is explicitely called, then
476	// function results will be cached over a defined range of values.	476	// function results will be cached over a defined range of values.
477	bool do_linearization = xml.valueBool("system.settings.expressionLinearizationEnabled", false);	477	bool do_linearization = xml.valueBool("system.settings.expressionLinearizationEnabled", false);
478	Expression::setLinearizationEnabled(do_linearization);	478	Expression::setLinearizationEnabled(do_linearization);
479	if (do_linearization)	479	if (do_linearization)
480	qDebug() << "The linearization of certains expressions is enabled (performance optimization).";	480	qDebug() << "The linearization of certains expressions is enabled (performance optimization).";
481		481
482	// log level	482	// log level
483	QString log_level = xml.value("system.settings.logLevel", "debug").toLower();	483	QString log_level = xml.value("system.settings.logLevel", "debug").toLower();
484	if (log_level=="debug") setLogLevel(0);	484	if (log_level=="debug") setLogLevel(0);
485	if (log_level=="info") setLogLevel(1);	485	if (log_level=="info") setLogLevel(1);
486	if (log_level=="warning") setLogLevel(2);	486	if (log_level=="warning") setLogLevel(2);
487	if (log_level=="error") setLogLevel(3);	487	if (log_level=="error") setLogLevel(3);
488		488
489	// snag dynamics / soil model enabled? (info used during setup of world)	489	// snag dynamics / soil model enabled? (info used during setup of world)
490	changeSettings().carbonCycleEnabled = xml.valueBool("model.settings.carbonCycleEnabled", false);	490	changeSettings().carbonCycleEnabled = xml.valueBool("model.settings.carbonCycleEnabled", false);
491	// class size of snag classes	491	// class size of snag classes
492	Snag::setupThresholds(xml.valueDouble("model.settings.soil.swdDBHClass12"),	492	Snag::setupThresholds(xml.valueDouble("model.settings.soil.swdDBHClass12"),
493	xml.valueDouble("model.settings.soil.swdDBHClass23"));	493	xml.valueDouble("model.settings.soil.swdDBHClass23"));
494		494
495	// setup of modules	495	// setup of modules
496	if (mModules)	496	if (mModules)
497	delete mModules;	497	delete mModules;
498	mModules = new Modules();	498	mModules = new Modules();
499		499
500	changeSettings().regenerationEnabled = xml.valueBool("model.settings.regenerationEnabled", false);	500	changeSettings().regenerationEnabled = xml.valueBool("model.settings.regenerationEnabled", false);

Subversion Repositories public iLand

(root)/src/core/model.cpp @ 1222 - Rev 1111 → 1114