WebSVN - public iLand - Diff - Rev 1104 and 1111


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("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()
{

    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);
            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();

        }
    }

}

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

Subversion Repositories public iLand

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