WebSVN - public iLand - Diff - Rev 1068 and 1071


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 "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;
}

/** 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 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) {
                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 (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();

    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
    changeSettings().regenerationEnabled = xml.valueBool("model.settings.regenerationEnabled", false);
    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();

    mABEManagement->initialize();

}


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

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


    // 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("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);
}



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

Subversion Repositories public iLand

(root)/src/core/model.cpp @ 1222 - Rev 1068 → 1071