WebSVN - public iLand - Diff - Rev 1085 and 1087


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

    // 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 1085	Rev 1087
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));	-
358	mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.	-
359	mModules->setupResourceUnit( *p );	-
-		357	if (*p) {
-		358	QRectF r = mRUmap.cellRect(mRUmap.indexOf(p));
-		359	mEnvironment->setPosition( r.center() ); // if environment is 'disabled' default values from the project file are used.
-		360	mModules->setupResourceUnit( *p );
-		361	}
360	}	362	}
361	}	363	}
362		364
363	// setup of scripting environment	365	// setup of scripting environment
364	ScriptGlobal::setupGlobalScripting();	366	ScriptGlobal::setupGlobalScripting();
365		367
366	// setup the helper that does the multithreading	368	// setup the helper that does the multithreading
367	threadRunner.setup(valid_rus);	369	threadRunner.setup(valid_rus);
368	threadRunner.setMultithreading(GlobalSettings::instance()->settings().valueBool("system.settings.multithreading"));	370	threadRunner.setMultithreading(GlobalSettings::instance()->settings().valueBool("system.settings.multithreading"));
369	threadRunner.print();	371	threadRunner.print();
370		372
371		373
372	} else {	374	} else {
373	throw IException("resourceUnitsAsGrid MUST be set to true - at least currently :)");	375	throw IException("resourceUnitsAsGrid MUST be set to true - at least currently :)");
374	}	376	}
375	mSetup = true;	377	mSetup = true;
376	}	378	}
377		379
378		380
379	/** clear() frees all ressources allocated with the run of a simulation.	381	/** clear() frees all ressources allocated with the run of a simulation.
380		382
381	*/	383	*/
382	void Model::clear()	384	void Model::clear()
383	{	385	{
384	mSetup = false;	386	mSetup = false;
385	qDebug() << "Model clear: attempting to clear" << mRU.count() << "RU, " << mSpeciesSets.count() << "SpeciesSets.";	387	qDebug() << "Model clear: attempting to clear" << mRU.count() << "RU, " << mSpeciesSets.count() << "SpeciesSets.";
386	// clear ressource units	388	// clear ressource units
387	qDeleteAll(mRU); // delete ressource units (and trees)	389	qDeleteAll(mRU); // delete ressource units (and trees)
388	mRU.clear();	390	mRU.clear();
389		391
390	qDeleteAll(mSpeciesSets); // delete species sets	392	qDeleteAll(mSpeciesSets); // delete species sets
391	mSpeciesSets.clear();	393	mSpeciesSets.clear();
392		394
393	// delete climate data	395	// delete climate data
394	qDeleteAll(mClimates);	396	qDeleteAll(mClimates);
395		397
396	// delete the grids	398	// delete the grids
397	if (mGrid)	399	if (mGrid)
398	delete mGrid;	400	delete mGrid;
399	if (mHeightGrid)	401	if (mHeightGrid)
400	delete mHeightGrid;	402	delete mHeightGrid;
401	if (mManagement)	403	if (mManagement)
402	delete mManagement;	404	delete mManagement;
403	if (mEnvironment)	405	if (mEnvironment)
404	delete mEnvironment;	406	delete mEnvironment;
405	if (mTimeEvents)	407	if (mTimeEvents)
406	delete mTimeEvents;	408	delete mTimeEvents;
407	if (mStandGrid)	409	if (mStandGrid)
408	delete mStandGrid;	410	delete mStandGrid;
409	if (mModules)	411	if (mModules)
410	delete mModules;	412	delete mModules;
411	if (mDEM)	413	if (mDEM)
412	delete mDEM;	414	delete mDEM;
413	if (mGrassCover)	415	if (mGrassCover)
414	delete mGrassCover;	416	delete mGrassCover;
415	if (mABEManagement)	417	if (mABEManagement)
416	delete mABEManagement;	418	delete mABEManagement;
417		419
418	mGrid = 0;	420	mGrid = 0;
419	mHeightGrid = 0;	421	mHeightGrid = 0;
420	mManagement = 0;	422	mManagement = 0;
421	mEnvironment = 0;	423	mEnvironment = 0;
422	mTimeEvents = 0;	424	mTimeEvents = 0;
423	mStandGrid = 0;	425	mStandGrid = 0;
424	mModules = 0;	426	mModules = 0;
425	mDEM = 0;	427	mDEM = 0;
426	mGrassCover = 0;	428	mGrassCover = 0;
427	mABEManagement = 0;	429	mABEManagement = 0;
428		430
429	GlobalSettings::instance()->outputManager()->close();	431	GlobalSettings::instance()->outputManager()->close();
430		432
431	qDebug() << "Model ressources freed.";	433	qDebug() << "Model ressources freed.";
432	}	434	}
433		435
434	/** Setup of the Simulation.	436	/** Setup of the Simulation.
435	This really creates the simulation environment and does the setup of various aspects.	437	This really creates the simulation environment and does the setup of various aspects.
436	*/	438	*/
437	void Model::loadProject()	439	void Model::loadProject()
438	{	440	{
439	DebugTimer dt("load project");	441	DebugTimer dt("load project");
440	GlobalSettings *g = GlobalSettings::instance();	442	GlobalSettings *g = GlobalSettings::instance();
441	g->printDirecories();	443	g->printDirecories();
442	const XmlHelper &xml = g->settings();	444	const XmlHelper &xml = g->settings();
443		445
444	g->clearDatabaseConnections();	446	g->clearDatabaseConnections();
445	// database connections: reset	447	// database connections: reset
446	GlobalSettings::instance()->clearDatabaseConnections();	448	GlobalSettings::instance()->clearDatabaseConnections();
447	// input and climate connection	449	// input and climate connection
448	// see initOutputDatabase() for output database	450	// see initOutputDatabase() for output database
449	QString dbPath = g->path( xml.value("system.database.in"), "database");	451	QString dbPath = g->path( xml.value("system.database.in"), "database");
450	GlobalSettings::instance()->setupDatabaseConnection("in", dbPath, true);	452	GlobalSettings::instance()->setupDatabaseConnection("in", dbPath, true);
451	dbPath = g->path( xml.value("system.database.climate"), "database");	453	dbPath = g->path( xml.value("system.database.climate"), "database");
452	GlobalSettings::instance()->setupDatabaseConnection("climate", dbPath, true);	454	GlobalSettings::instance()->setupDatabaseConnection("climate", dbPath, true);
453		455
454	mSettings.loadModelSettings();	456	mSettings.loadModelSettings();
455	mSettings.print();	457	mSettings.print();
456	// random seed: if stored value is <> 0, use this as the random seed (and produce hence always an equal sequence of random numbers)	458	// random seed: if stored value is <> 0, use this as the random seed (and produce hence always an equal sequence of random numbers)
457	uint seed = xml.value("system.settings.randomSeed","0").toUInt();	459	uint seed = xml.value("system.settings.randomSeed","0").toUInt();
458	RandomGenerator::setup(RandomGenerator::ergMersenneTwister, seed); // use the MersenneTwister as default	460	RandomGenerator::setup(RandomGenerator::ergMersenneTwister, seed); // use the MersenneTwister as default
459	// linearization of expressions: if true and linearize() is explicitely called, then	461	// linearization of expressions: if true and linearize() is explicitely called, then
460	// function results will be cached over a defined range of values.	462	// function results will be cached over a defined range of values.
461	bool do_linearization = xml.valueBool("system.settings.expressionLinearizationEnabled", false);	463	bool do_linearization = xml.valueBool("system.settings.expressionLinearizationEnabled", false);
462	Expression::setLinearizationEnabled(do_linearization);	464	Expression::setLinearizationEnabled(do_linearization);
463	if (do_linearization)	465	if (do_linearization)
464	qDebug() << "The linearization of certains expressions is enabled (performance optimization).";	466	qDebug() << "The linearization of certains expressions is enabled (performance optimization).";
465		467
466	// log level	468	// log level
467	QString log_level = xml.value("system.settings.logLevel", "debug").toLower();	469	QString log_level = xml.value("system.settings.logLevel", "debug").toLower();
468	if (log_level=="debug") setLogLevel(0);	470	if (log_level=="debug") setLogLevel(0);
469	if (log_level=="info") setLogLevel(1);	471	if (log_level=="info") setLogLevel(1);
470	if (log_level=="warning") setLogLevel(2);	472	if (log_level=="warning") setLogLevel(2);
471	if (log_level=="error") setLogLevel(3);	473	if (log_level=="error") setLogLevel(3);
472		474
473	// snag dynamics / soil model enabled? (info used during setup of world)	475	// snag dynamics / soil model enabled? (info used during setup of world)
474	changeSettings().carbonCycleEnabled = xml.valueBool("model.settings.carbonCycleEnabled", false);	476	changeSettings().carbonCycleEnabled = xml.valueBool("model.settings.carbonCycleEnabled", false);
475	// class size of snag classes	477	// class size of snag classes
476	Snag::setupThresholds(xml.valueDouble("model.settings.soil.swdDBHClass12"),	478	Snag::setupThresholds(xml.valueDouble("model.settings.soil.swdDBHClass12"),
477	xml.valueDouble("model.settings.soil.swdDBHClass23"));	479	xml.valueDouble("model.settings.soil.swdDBHClass23"));
478		480
479	// setup of modules	481	// setup of modules
480	if (mModules)	482	if (mModules)
481	delete mModules;	483	delete mModules;
482	mModules = new Modules();	484	mModules = new Modules();
483		485
484	setupSpace();	486	setupSpace();
485	if (mRU.isEmpty())	487	if (mRU.isEmpty())
486	throw IException("Setup of Model: no resource units present!");	488	throw IException("Setup of Model: no resource units present!");
487		489
488	// (3) additional issues	490	// (3) additional issues
489	// (3.1) load javascript code into the engine	491	// (3.1) load javascript code into the engine
490	QString script_file = xml.value("system.javascript.fileName");	492	QString script_file = xml.value("system.javascript.fileName");
491	if (!script_file.isEmpty()) {	493	if (!script_file.isEmpty()) {
492	script_file = g->path(script_file, "script");	494	script_file = g->path(script_file, "script");
493	ScriptGlobal::loadScript(script_file);	495	ScriptGlobal::loadScript(script_file);
494	g->controller()->setLoadedJavascriptFile(script_file);	496	g->controller()->setLoadedJavascriptFile(script_file);
495	}	497	}

Subversion Repositories public iLand

(root)/src/core/model.cpp @ 1222 - Rev 1085 → 1087