Subversion Repositories public iLand

Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/management.cpp':

Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/management.cpp':

/********************************************************************************************

/********************************************************************************************

**    iLand - an individual based forest landscape and disturbance model

**    iLand - an individual based forest landscape and disturbance model

**    http://iland.boku.ac.at

**    http://iland.boku.ac.at

**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl

**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl

**

**

**    This program is free software: you can redistribute it and/or modify

**    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

**    it under the terms of the GNU General Public License as published by

**    the Free Software Foundation, either version 3 of the License, or

**    the Free Software Foundation, either version 3 of the License, or

**    (at your option) any later version.

**    (at your option) any later version.

**

**

**    This program is distributed in the hope that it will be useful,

**    This program is distributed in the hope that it will be useful,

**    but WITHOUT ANY WARRANTY; without even the implied warranty of

**    but WITHOUT ANY WARRANTY; without even the implied warranty of

**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

**    GNU General Public License for more details.

**    GNU General Public License for more details.

**

**

**    You should have received a copy of the GNU General Public License

**    You should have received a copy of the GNU General Public License

**    along with this program.  If not, see <http://www.gnu.org/licenses/>.

**    along with this program.  If not, see <http://www.gnu.org/licenses/>.

********************************************************************************************/

********************************************************************************************/

#include "global.h"

#include "global.h"

#include "management.h"

#include "management.h"

#include "helper.h"

#include "helper.h"

#include "model.h"

#include "model.h"

#include "resourceunit.h"

#include "resourceunit.h"

#include "tree.h"

#include "tree.h"

#include "expressionwrapper.h"

#include "expressionwrapper.h"

#include "sapling.h"

#include "sapling.h"

#include "soil.h"

#include "soil.h"

//#include "climateconverter.h"

//#include "climateconverter.h"

//#include "csvfile.h"

//#include "csvfile.h"

#include "scriptglobal.h"

#include "scriptglobal.h"

#include "mapgrid.h"

#include "mapgrid.h"

//#include "modules.h"

//#include "modules.h"

#include <QtScript>

#include <QtScript>

/** @class Management Management executes management routines.

/** @class Management Management executes management routines.

  @ingroup core

  @ingroup core

  The actual iLand management is based on Javascript functions. This class provides

  The actual iLand management is based on Javascript functions. This class provides

  the frame for executing the javascript as well as the functions that are called by scripts and

  the frame for executing the javascript as well as the functions that are called by scripts and

  that really do the work.

  that really do the work.

  See http://iland.boku.ac.at/iLand+scripting, http://iland.boku.ac.at/Object+Management for management Javascript API.

  See http://iland.boku.ac.at/iLand+scripting, http://iland.boku.ac.at/Object+Management for management Javascript API.

  */

  */

// global output function

// global output function

QString Management::executeScript(QString cmd)

QString Management::executeScript(QString cmd)

{

{

    return ScriptGlobal::executeScript(cmd);

    return ScriptGlobal::executeScript(cmd);

}

}

Management::Management()

Management::Management()

{

{

    // setup the scripting engine

    // setup the scripting engine

    mEngine = GlobalSettings::instance()->scriptEngine();

    mEngine = GlobalSettings::instance()->scriptEngine();

    QScriptValue objectValue = mEngine->newQObject(this);

    QScriptValue objectValue = mEngine->newQObject(this);

    mEngine->globalObject().setProperty("management", objectValue);

    mEngine->globalObject().setProperty("management", objectValue);

    // default values for removal fractions

    // default values for removal fractions

    // 100% of the stem, 0% of foliage and branches

    // 100% of the stem, 0% of foliage and branches

    mRemoveFoliage = 0.;

    mRemoveFoliage = 0.;

    mRemoveBranch = 0.;

    mRemoveBranch = 0.;

    mRemoveStem = 1.;

    mRemoveStem = 1.;

}

}

Management::~Management()

Management::~Management()

{

{

}

}

int Management::remain(int number)

int Management::remain(int number)

{

{

    qDebug() << "remain called (number): " << number;

    qDebug() << "remain called (number): " << number;

    Model *m = GlobalSettings::instance()->model();

    Model *m = GlobalSettings::instance()->model();

    AllTreeIterator at(m);

    AllTreeIterator at(m);

    QList<Tree*> trees;

    QList<Tree*> trees;

    while (Tree *t=at.next())

    while (Tree *t=at.next())

        trees.push_back(t);

        trees.push_back(t);

    int to_kill = trees.count() - number;

    int to_kill = trees.count() - number;

    qDebug() << trees.count() << " standing, targetsize" << number << ", hence " << to_kill << "trees to remove";

    qDebug() << trees.count() << " standing, targetsize" << number << ", hence " << to_kill << "trees to remove";

    for (int i=0;i<to_kill;i++) {

    for (int i=0;i<to_kill;i++) {

        int index = irandom(0, trees.count()-1);

        int index = irandom(0, trees.count()-1);

        trees[index]->remove();

        trees[index]->remove();

        trees.removeAt(index);

        trees.removeAt(index);

    }

    }

    mRemoved += to_kill;

    mRemoved += to_kill;

    return to_kill;

    return to_kill;

}

}

int Management::kill()

int Management::kill()

{

{

    int c = mTrees.count();

    int c = mTrees.count();

    for (int i=0;i<mTrees.count();i++)

    for (int i=0;i<mTrees.count();i++)

        mTrees[i].first->remove();

        mTrees[i].first->remove();

    mTrees.clear();

    mTrees.clear();

    return c;

    return c;

}

}

int Management::kill(QString filter, double fraction)

int Management::kill(QString filter, double fraction)

{

{

   return remove_trees(filter, fraction, false);

   return remove_trees(filter, fraction, false);

}

}

int Management::manage(QString filter, double fraction)

int Management::manage(QString filter, double fraction)

{

{

    return remove_trees(filter, fraction, true);

    return remove_trees(filter, fraction, true);

}

}

int Management::remove_percentiles(int pctfrom, int pctto, int number, bool management)

int Management::remove_percentiles(int pctfrom, int pctto, int number, bool management)

{

{

    if (mTrees.isEmpty())

    if (mTrees.isEmpty())

        return 0;

        return 0;

    int index_from = limit(int(pctfrom/100. * mTrees.count()), 0, mTrees.count());

    int index_from = limit(int(pctfrom/100. * mTrees.count()), 0, mTrees.count());

    int index_to = limit(int(pctto/100. * mTrees.count()), 0, mTrees.count()-1);

    int index_to = limit(int(pctto/100. * mTrees.count()), 0, mTrees.count()-1);

    if (index_from>=index_to)

    if (index_from>=index_to)

        return 0;

        return 0;

    qDebug() << "attempting to remove" << number << "trees between indices" << index_from << "and" << index_to;

    qDebug() << "attempting to remove" << number << "trees between indices" << index_from << "and" << index_to;

    int i;

    int i;

    int count = number;

    int count = number;

    if (index_to-index_from <= number)  {

    if (index_to-index_from <= number)  {

        // kill all

        // kill all

        if (management) {

        if (management) {

            // management

            // management

            for (i=index_from; i<index_to; i++)

            for (i=index_from; i<index_to; i++)

                mTrees.at(i).first->remove(removeFoliage(), removeBranch(), removeStem());

                mTrees.at(i).first->remove(removeFoliage(), removeBranch(), removeStem());

        } else {

        } else {

            // just kill...

            // just kill...

            for (i=index_from; i<index_to; i++)

            for (i=index_from; i<index_to; i++)

                mTrees.at(i).first->remove();

                mTrees.at(i).first->remove();

        }

        }

        count = index_to - index_from;

        count = index_to - index_from;

    } else {

    } else {

        // kill randomly the provided number

        // kill randomly the provided number

        int cancel = 1000;

        int cancel = 1000;

        while(number>=0) {

        while(number>=0) {

            int rnd_index = irandom(index_from, index_to);

            int rnd_index = irandom(index_from, index_to);

            if (mTrees[rnd_index].first->isDead()) {

            if (mTrees[rnd_index].first->isDead()) {

                if (--cancel<0) {

                if (--cancel<0) {

                    qDebug() << "Management::kill: canceling search." << number << "trees left.";

                    qDebug() << "Management::kill: canceling search." << number << "trees left.";

                    count-=number; // not all trees were killed

                    count-=number; // not all trees were killed

                    break;

                    break;

                }

                }

                continue;

                continue;

            }

            }

            cancel = 1000;

            cancel = 1000;

            number--;

            number--;

            if (management) {

            if (management) {

                mTrees[rnd_index].first->remove( removeFoliage(), removeBranch(), removeStem() );

                mTrees[rnd_index].first->remove( removeFoliage(), removeBranch(), removeStem() );

            } else {

            } else {

                mTrees[rnd_index].first->remove();

                mTrees[rnd_index].first->remove();

            }

            }

        }

        }

    }

    }

    qDebug() << count << "removed.";

    qDebug() << count << "removed.";

    // clean up the tree list...

    // clean up the tree list...

    for (int i=mTrees.count()-1; i>=0; --i) {

    for (int i=mTrees.count()-1; i>=0; --i) {

        if (mTrees[i].first->isDead())

        if (mTrees[i].first->isDead())

            mTrees.removeAt(i);

            mTrees.removeAt(i);

    }

    }

    return count; // killed or manages

    return count; // killed or manages

}

}

/** remove trees from a list and reduce the list.

/** remove trees from a list and reduce the list.

  */

  */

int Management::remove_trees(QString expression, double fraction, bool management)

int Management::remove_trees(QString expression, double fraction, bool management)

{

{

    TreeWrapper tw;

    TreeWrapper tw;

    Expression expr(expression,&tw);

    Expression expr(expression,&tw);

    expr.enableIncSum();

    expr.enableIncSum();

    int n = 0;

    int n = 0;

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    try {

    try {

        while (tp!=mTrees.end()) {

        while (tp!=mTrees.end()) {

            tw.setTree(tp->first);

            tw.setTree(tp->first);

            // if expression evaluates to true and if random number below threshold...

            // if expression evaluates to true and if random number below threshold...

            if (expr.calculate(tw) && drandom() <=fraction) {

            if (expr.calculate(tw) && drandom() <=fraction) {

                // remove from system

                // remove from system

                if (management)

                if (management)

                    tp->first->remove(removeFoliage(), removeBranch(), removeStem()); // management with removal fractions

                    tp->first->remove(removeFoliage(), removeBranch(), removeStem()); // management with removal fractions

                else

                else

                    tp->first->remove(); // kill

                    tp->first->remove(); // kill

                // remove from tree list

                // remove from tree list

                tp = mTrees.erase(tp);

                tp = mTrees.erase(tp);

                n++;

                n++;

            } else {

            } else {

                ++tp;

                ++tp;

            }

            }

        }

        }

    } catch(const IException &e) {

    } catch(const IException &e) {

        context()->throwError(e.message());

        context()->throwError(e.message());

    }

    }

    return n;

    return n;

}

}

// calculate aggregates for all trees in the internal list

// calculate aggregates for all trees in the internal list

double Management::aggregate_function(QString expression, QString filter, QString type)

double Management::aggregate_function(QString expression, QString filter, QString type)

{

{

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    TreeWrapper tw;

    TreeWrapper tw;

    Expression expr(expression,&tw);

    Expression expr(expression,&tw);

    double sum = 0.;

    double sum = 0.;

    int n=0;

    int n=0;

    try {

    try {

        if (filter.isEmpty()) {

        if (filter.isEmpty()) {

            // without filtering

            // without filtering

            while (tp!=mTrees.end()) {

            while (tp!=mTrees.end()) {

                tw.setTree(tp->first);

                tw.setTree(tp->first);

                sum += expr.calculate();

                sum += expr.calculate();

                ++n;

                ++n;

                ++tp;

                ++tp;

            }

            }

        } else {

        } else {

            // with filtering

            // with filtering

            Expression filter_expr(filter,&tw);

            Expression filter_expr(filter,&tw);

            filter_expr.enableIncSum();

            filter_expr.enableIncSum();

            while (tp!=mTrees.end()) {

            while (tp!=mTrees.end()) {

                tw.setTree(tp->first);

                tw.setTree(tp->first);

                if (filter_expr.calculate()) {

                if (filter_expr.calculate()) {

                    sum += expr.calculate();

                    sum += expr.calculate();

                    ++n;

                    ++n;

                }

                }

                ++tp;

                ++tp;

            }

            }

        }

        }

    } catch(const IException &e) {

    } catch(const IException &e) {

        context()->throwError(e.message());

        context()->throwError(e.message());

    }

    }

    if (type=="sum")

    if (type=="sum")

        return sum;

        return sum;

    if (type=="mean")

    if (type=="mean")

        return n>0?sum/double(n):0.;

        return n>0?sum/double(n):0.;

    return 0.;

    return 0.;

}

}

// from the range percentile range pctfrom to pctto (each 1..100)

// from the range percentile range pctfrom to pctto (each 1..100)

int Management::kill(int pctfrom, int pctto, int number)

int Management::kill(int pctfrom, int pctto, int number)

{

{

    return remove_percentiles(pctfrom, pctto, number, false);

    return remove_percentiles(pctfrom, pctto, number, false);

}

}

// from the range percentile range pctfrom to pctto (each 1..100)

// from the range percentile range pctfrom to pctto (each 1..100)

int Management::manage(int pctfrom, int pctto, int number)

int Management::manage(int pctfrom, int pctto, int number)

{

{

    return remove_percentiles(pctfrom, pctto, number, true);

    return remove_percentiles(pctfrom, pctto, number, true);

}

}

int Management::manage()

int Management::manage()

{

{

    int c = mTrees.count();

    int c = mTrees.count();

    for (int i=0;i<mTrees.count();i++)

    for (int i=0;i<mTrees.count();i++)

        mTrees[i].first->remove(removeFoliage(),

        mTrees[i].first->remove(removeFoliage(),

                                removeBranch(),

                                removeBranch(),

                                removeStem()); // remove with current removal fractions

                                removeStem()); // remove with current removal fractions

    mTrees.clear();

    mTrees.clear();

    return c;

    return c;

}

}

void Management::run()

void Management::run()

{

{

    mTrees.clear();

    mTrees.clear();

    mRemoved=0;

    mRemoved=0;

    qDebug() << "Management::run() called";

    qDebug() << "Management::run() called";

    QScriptValue mgmt = mEngine->globalObject().property("manage");

    QScriptValue mgmt = mEngine->globalObject().property("manage");

    int year = GlobalSettings::instance()->currentYear();

    int year = GlobalSettings::instance()->currentYear();

    mgmt.call(QScriptValue(), QScriptValueList()<<year);

    mgmt.call(QScriptValue(), QScriptValueList()<<year);

    if (mEngine->hasUncaughtException())

    if (mEngine->hasUncaughtException())

        qDebug() << "Script Error occured: " << mEngine->uncaughtException().toString() << "\n" << mEngine->uncaughtExceptionBacktrace();

        qDebug() << "Script Error occured: " << mEngine->uncaughtException().toString() << "\n" << mEngine->uncaughtExceptionBacktrace();

    if (mRemoved>0) {

    if (mRemoved>0) {

        foreach(ResourceUnit *ru, GlobalSettings::instance()->model()->ruList())

        foreach(ResourceUnit *ru, GlobalSettings::instance()->model()->ruList())

           ru->cleanTreeList();

           ru->cleanTreeList();

    }

    }

}

}

void Management::loadScript(const QString &fileName)

void Management::loadScript(const QString &fileName)

{

{

    mScriptFile = fileName;

    mScriptFile = fileName;

    ScriptGlobal::loadScript(fileName);

    ScriptGlobal::loadScript(fileName);

}

}

int Management::filter(QVariantList idList)

int Management::filter(QVariantList idList)

{

{

    QVector<int> ids;

    QVector<int> ids;

    foreach(const QVariant &v, idList)

    foreach(const QVariant &v, idList)

        if (!v.isNull())

        if (!v.isNull())

            ids << v.toInt();

            ids << v.toInt();

//    QHash<int, int> ids;

//    QHash<int, int> ids;

//    foreach(const QVariant &v, idList)

//    foreach(const QVariant &v, idList)

//        ids[v.toInt()] = 1;

//        ids[v.toInt()] = 1;

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    while (tp!=mTrees.end()) {

    while (tp!=mTrees.end()) {

        if (!ids.contains(tp->first->id()) )

        if (!ids.contains(tp->first->id()) )

            tp = mTrees.erase(tp);

            tp = mTrees.erase(tp);

        else

        else

            ++tp;

            ++tp;

    }

    }

    qDebug() << "Management::filter by id-list:" << mTrees.count();

    qDebug() << "Management::filter by id-list:" << mTrees.count();

    return mTrees.count();

    return mTrees.count();

}

}

int Management::filter(QString filter)

int Management::filter(QString filter)

{

{

    TreeWrapper tw;

    TreeWrapper tw;

    Expression expr(filter,&tw);

    Expression expr(filter,&tw);

    expr.enableIncSum();

    expr.enableIncSum();

    int n_before = mTrees.count();

    int n_before = mTrees.count();

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    QList<QPair<Tree*, double> >::iterator tp=mTrees.begin();

    try {

    try {

        while (tp!=mTrees.end()) {

        while (tp!=mTrees.end()) {

            tw.setTree(tp->first);

            tw.setTree(tp->first);

            if (expr.calculate(tw))

            if (expr.calculate(tw))

                tp = mTrees.erase(tp);

                tp = mTrees.erase(tp);

            else

            else

                ++tp;

                ++tp;

        }

        }

    } catch(const IException &e) {

    } catch(const IException &e) {

        context()->throwError(e.message());

        context()->throwError(e.message());

    }

    }

    qDebug() << "filtering with" << filter << "N=" << n_before << "/" << mTrees.count()  << "trees (before/after filtering).";

    qDebug() << "filtering with" << filter << "N=" << n_before << "/" << mTrees.count()  << "trees (before/after filtering).";

    return mTrees.count();

    return mTrees.count();

}

}

int Management::load(int ruindex)

int Management::load(int ruindex)

{

{

    Model *m = GlobalSettings::instance()->model();

    Model *m = GlobalSettings::instance()->model();

    ResourceUnit *ru = m->ru(ruindex);

    ResourceUnit *ru = m->ru(ruindex);

    if (!ru)

    if (!ru)

        return -1;

        return -1;

    mTrees.clear();

    mTrees.clear();

    for (int i=0;i<ru->trees().count();i++)

    for (int i=0;i<ru->trees().count();i++)

        if (!ru->tree(i)->isDead())

        if (!ru->tree(i)->isDead())

            mTrees.push_back(QPair<Tree*,double>(ru->tree(i), 0.));

            mTrees.push_back(QPair<Tree*,double>(ru->tree(i), 0.));

    return mTrees.count();

    return mTrees.count();

}

}

int Management::load(QString filter)

int Management::load(QString filter)

{

{

    TreeWrapper tw;

    TreeWrapper tw;

    Model *m = GlobalSettings::instance()->model();

    Model *m = GlobalSettings::instance()->model();

    mTrees.clear();

    mTrees.clear();

    AllTreeIterator at(m);

    AllTreeIterator at(m);

    if (filter.isEmpty()) {

    if (filter.isEmpty()) {

        while (Tree *t=at.nextLiving())

        while (Tree *t=at.nextLiving())

            if (!t->isDead())

            if (!t->isDead())

                mTrees.push_back(QPair<Tree*, double>(t, 0.));

                mTrees.push_back(QPair<Tree*, double>(t, 0.));

    } else {

    } else {

        Expression expr(filter,&tw);

        Expression expr(filter,&tw);

        expr.enableIncSum();

        expr.enableIncSum();

        qDebug() << "filtering with" << filter;

        qDebug() << "filtering with" << filter;

        while (Tree *t=at.nextLiving()) {

        while (Tree *t=at.nextLiving()) {

            tw.setTree(t);

            tw.setTree(t);

            if (!t->isDead() && expr.execute())

            if (!t->isDead() && expr.execute())

                mTrees.push_back(QPair<Tree*, double>(t, 0.));

                mTrees.push_back(QPair<Tree*, double>(t, 0.));

        }

        }

    }

    }

    return mTrees.count();

    return mTrees.count();

}

}

/**

/**

*/

*/

void Management::loadFromTreeList(QList<Tree*>tree_list)

void Management::loadFromTreeList(QList<Tree*>tree_list)

{

{

    mTrees.clear();

    mTrees.clear();

    for (int i=0;i<tree_list.count();++i)

    for (int i=0;i<tree_list.count();++i)

        mTrees.append(QPair<Tree*, double>(tree_list[i], 0.));

        mTrees.append(QPair<Tree*, double>(tree_list[i], 0.));

}

}

// loadFromMap: script access

// loadFromMap: script access

void Management::loadFromMap(MapGridWrapper *wrap, int key)

void Management::loadFromMap(MapGridWrapper *wrap, int key)

{

{

    if (!wrap) {

    if (!wrap) {

        context()->throwError("loadFromMap called with invalid map object!");

        context()->throwError("loadFromMap called with invalid map object!");

        return;

        return;

    }

    }

    loadFromMap(wrap->map(), key);

    loadFromMap(wrap->map(), key);

}

}

void Management::killSaplings(MapGridWrapper *wrap, int key)

void Management::killSaplings(MapGridWrapper *wrap, int key)

{

{

    //MapGridWrapper *wrap = qobject_cast<MapGridWrapper*>(map_grid_object.toQObject());

    //MapGridWrapper *wrap = qobject_cast<MapGridWrapper*>(map_grid_object.toQObject());

    //if (!wrap) {

    //if (!wrap) {

    //    context()->throwError("loadFromMap called with invalid map object!");

    //    context()->throwError("loadFromMap called with invalid map object!");

    //    return;

    //    return;

    //}

    //}

    //loadFromMap(wrap->map(), key);

    //loadFromMap(wrap->map(), key);

    // retrieve all sapling trees on the stand:

    // retrieve all sapling trees on the stand:

    QList<QPair<ResourceUnitSpecies *, SaplingTree *> > list = wrap->map()->saplingTrees(key);

    QList<QPair<ResourceUnitSpecies *, SaplingTree *> > list = wrap->map()->saplingTrees(key);

    // for now, just kill em all...

    // for now, just kill em all...

    for (QList<QPair<ResourceUnitSpecies *, SaplingTree *> >::iterator it = list.begin(); it!=list.end(); ++it) {

    for (QList<QPair<ResourceUnitSpecies *, SaplingTree *> >::iterator it = list.begin(); it!=list.end(); ++it) {

        // (*it).second->pixel = 0;

        // (*it).second->pixel = 0;

        (*it).first->changeSapling().clearSapling( *(*it).second, false); // kill and move biomass to soil

        (*it).first->changeSapling().clearSapling( *(*it).second, false); // kill and move biomass to soil

    }

    }

    // the storage for unused/invalid saplingtrees is released lazily (once a year, after growth)

    // the storage for unused/invalid saplingtrees is released lazily (once a year, after growth)

}

}

/// specify removal fractions

/// specify removal fractions

/// @param SWDFrac 0: no change, 1: remove all of standing woody debris

/// @param SWDFrac 0: no change, 1: remove all of standing woody debris

/// @param DWDfrac 0: no change, 1: remove all of downled woody debris

/// @param DWDfrac 0: no change, 1: remove all of downled woody debris

/// @param litterFrac 0: no change, 1: remove all of soil litter

/// @param litterFrac 0: no change, 1: remove all of soil litter

/// @param soilFrac 0: no change, 1: remove all of soil organic matter

/// @param soilFrac 0: no change, 1: remove all of soil organic matter

void Management::removeSoilCarbon(MapGridWrapper *wrap, int key, double SWDfrac, double DWDfrac, double litterFrac, double soilFrac)

void Management::removeSoilCarbon(MapGridWrapper *wrap, int key, double SWDfrac, double DWDfrac, double litterFrac, double soilFrac)

{

{

    if (!(SWDfrac>=0. && SWDfrac<=1. && DWDfrac>=0. && DWDfrac<=1. && soilFrac>=0. && soilFrac<=1. && litterFrac>=0. && litterFrac<=1.)) {

    if (!(SWDfrac>=0. && SWDfrac<=1. && DWDfrac>=0. && DWDfrac<=1. && soilFrac>=0. && soilFrac<=1. && litterFrac>=0. && litterFrac<=1.)) {

        context()->throwError(QString("removeSoilCarbon called with invalid parameters!!\nArgs: %1").arg(context()->argumentsObject().toString()));

        context()->throwError(QString("removeSoilCarbon called with invalid parameters!!\nArgs: %1").arg(context()->argumentsObject().toString()));

        return;

        return;

    }

    }

    QList<QPair<ResourceUnit*, double> > ru_areas = wrap->map()->resourceUnitAreas(key);

    QList<QPair<ResourceUnit*, double> > ru_areas = wrap->map()->resourceUnitAreas(key);

    double total_area = 0.;

    double total_area = 0.;

    for (int i=0;i<ru_areas.size();++i) {

    for (int i=0;i<ru_areas.size();++i) {

        ResourceUnit *ru = ru_areas[i].first;

        ResourceUnit *ru = ru_areas[i].first;

        double area_factor = ru_areas[i].second; // 0..1

        double area_factor = ru_areas[i].second; // 0..1

        total_area += area_factor;

        total_area += area_factor;

        // swd

        // swd

        if (SWDfrac>0.)

        if (SWDfrac>0.)

            ru->snag()->removeCarbon(SWDfrac*area_factor);

            ru->snag()->removeCarbon(SWDfrac*area_factor);

        // soil pools

        // soil pools

        ru->soil()->disturbance(DWDfrac*area_factor, litterFrac*area_factor, soilFrac*area_factor);

        ru->soil()->disturbance(DWDfrac*area_factor, litterFrac*area_factor, soilFrac*area_factor);

        // qDebug() << ru->index() << area_factor;

        // qDebug() << ru->index() << area_factor;

    }

    }

    qDebug() << "total area" << total_area << "of" << wrap->map()->area(key);

    qDebug() << "total area" << total_area << "of" << wrap->map()->area(key);

}

}

/** slash snags (SWD and otherWood-Pools) of polygon \p key on the map \p wrap.

/** slash snags (SWD and otherWood-Pools) of polygon \p key on the map \p wrap.

  The factor is scaled to the overlapping area of \p key on the resource unit.

  The factor is scaled to the overlapping area of \p key on the resource unit.

  @param wrap MapGrid to use together with \p key

  @param wrap MapGrid to use together with \p key

  @param key ID of the polygon.

  @param key ID of the polygon.

  @param slash_fraction 0: no change, 1: 100%

  @param slash_fraction 0: no change, 1: 100%

   */

   */

void Management::slashSnags(MapGridWrapper *wrap, int key, double slash_fraction)

void Management::slashSnags(MapGridWrapper *wrap, int key, double slash_fraction)

{

{

    if (slash_fraction<0 || slash_fraction>1) {

    if (slash_fraction<0 || slash_fraction>1) {

        context()->throwError(QString("slashSnags called with invalid parameters!!\nArgs: %1").arg(context()->argumentsObject().toString()));

        context()->throwError(QString("slashSnags called with invalid parameters!!\nArgs: %1").arg(context()->argumentsObject().toString()));

        return;

        return;

    }

    }

    QList<QPair<ResourceUnit*, double> > ru_areas = wrap->map()->resourceUnitAreas(key);

    QList<QPair<ResourceUnit*, double> > ru_areas = wrap->map()->resourceUnitAreas(key);

    double total_area = 0.;

    double total_area = 0.;

    for (int i=0;i<ru_areas.size();++i) {

    for (int i=0;i<ru_areas.size();++i) {

        ResourceUnit *ru = ru_areas[i].first;

        ResourceUnit *ru = ru_areas[i].first;

        double area_factor = ru_areas[i].second; // 0..1

        double area_factor = ru_areas[i].second; // 0..1

        total_area += area_factor;

        total_area += area_factor;

        ru->snag()->management(slash_fraction * area_factor);

        ru->snag()->management(slash_fraction * area_factor);

        // qDebug() << ru->index() << area_factor;

        // qDebug() << ru->index() << area_factor;

    }

    }

    qDebug() << "total area" << total_area << "of" << wrap->map()->area(key);

    qDebug() << "total area" << total_area << "of" << wrap->map()->area(key);

}

}

/** loadFromMap selects trees located on pixels with value 'key' within the grid 'map_grid'.

/** loadFromMap selects trees located on pixels with value 'key' within the grid 'map_grid'.

*/

*/

void Management::loadFromMap(const MapGrid *map_grid, int key)

void Management::loadFromMap(const MapGrid *map_grid, int key)

{

{

    if (!map_grid) {

    if (!map_grid) {

        qDebug() << "invalid parameter for Management::loadFromMap: Map expected!";

        qDebug() << "invalid parameter for Management::loadFromMap: Map expected!";

        return;

        return;

    }

    }

    if (map_grid->isValid()) {

    if (map_grid->isValid()) {

        QList<Tree*> tree_list = map_grid->trees(key);

        QList<Tree*> tree_list = map_grid->trees(key);

        loadFromTreeList( tree_list );

        loadFromTreeList( tree_list );

    } else {

    } else {

        qDebug() << "Management::loadFromMap: grid is not valid - no trees loaded";

        qDebug() << "Management::loadFromMap: grid is not valid - no trees loaded";

    }

    }

}

}

bool treePairValue(const QPair<Tree*, double> &p1, const QPair<Tree*, double> &p2)

bool treePairValue(const QPair<Tree*, double> &p1, const QPair<Tree*, double> &p2)

{

{

    return p1.second < p2.second;

    return p1.second < p2.second;

}

}

void Management::sort(QString statement)

void Management::sort(QString statement)

{

{

    TreeWrapper tw;

    TreeWrapper tw;

    Expression sorter(statement, &tw);

    Expression sorter(statement, &tw);

    // fill the "value" part of the tree storage with a value for each tree

    // fill the "value" part of the tree storage with a value for each tree

    for (int i=0;i<mTrees.count(); ++i) {

    for (int i=0;i<mTrees.count(); ++i) {

        tw.setTree(mTrees.at(i).first);

        tw.setTree(mTrees.at(i).first);

        mTrees[i].second = sorter.execute();

        mTrees[i].second = sorter.execute();

   }

   }

   // now sort the list....

   // now sort the list....

   qSort(mTrees.begin(), mTrees.end(), treePairValue);

   qSort(mTrees.begin(), mTrees.end(), treePairValue);

}

}

double Management::percentile(int pct)

double Management::percentile(int pct)

{

{

    if (mTrees.count()==0)

    if (mTrees.count()==0)

        return -1.;

        return -1.;

    int idx = int( (pct/100.) * mTrees.count());

    int idx = int( (pct/100.) * mTrees.count());

    if (idx>=0 && idx<mTrees.count())

    if (idx>=0 && idx<mTrees.count())

        return mTrees.at(idx).second;

        return mTrees.at(idx).second;

    else

    else

        return -1;

        return -1;

}

}

/// random shuffle of all trees in the list

/// random shuffle of all trees in the list

void Management::randomize()

void Management::randomize()

{

{

    // fill the "value" part of the tree storage with a random value for each tree

    // fill the "value" part of the tree storage with a random value for each tree

    for (int i=0;i<mTrees.count(); ++i) {

    for (int i=0;i<mTrees.count(); ++i) {

        mTrees[i].second = drandom();

        mTrees[i].second = drandom();

    }

    }

    // now sort the list....

    // now sort the list....

    qSort(mTrees.begin(), mTrees.end(), treePairValue);

    qSort(mTrees.begin(), mTrees.end(), treePairValue);

}

}