Subversion Repositories public iLand

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

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

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

#include "global.h"

#include "modules.h"

#include "plugin_interface.h"

#include "globalsettings.h"

#include "debugtimer.h"

#include "exception.h"

#include <QtPlugin>

// include the static modules here in the code:

#if QT_VERSION >= 0x050000

Q_IMPORT_PLUGIN(FirePlugin)

Q_IMPORT_PLUGIN(WindPlugin)

Q_IMPORT_PLUGIN(BarkBeetlePlugin)

#else

Q_IMPORT_PLUGIN(iland_fire)

Q_IMPORT_PLUGIN(iland_wind)

Q_IMPORT_PLUGIN(iland_barkbeetle)

#endif

Modules::Modules()

{

    init();

}

// load the static plugins

void Modules::init()

{

    foreach (QObject *plugin, QPluginLoader::staticInstances()) {

        DisturbanceInterface *di = qobject_cast<DisturbanceInterface *>(plugin);

        if (di) {

            qDebug() << di->name();

            // check xml file

            if (GlobalSettings::instance()->settings().valueBool(QString("modules.%1.enabled").arg(di->name()))) {

                // plugin is enabled: store in list of active modules

                mInterfaces.append(di);

                // check for other interfaces

                SetupResourceUnitInterface *si=qobject_cast<SetupResourceUnitInterface *>(plugin);

                if (si)

                    mSetupRUs.append(si);

                WaterInterface *wi = qobject_cast<WaterInterface *>(plugin);

                if (wi)

                    mWater.append(wi);

                TreeDeathInterface *td = qobject_cast<TreeDeathInterface*>(plugin);

                if (td)

                    mTreeDeath.append(td);

            }

        }

    }

    // fix the order of modules: make sure that "barkbeetle" is after "wind"

    DisturbanceInterface *wind = module(QStringLiteral("wind"));

    DisturbanceInterface *bb = module(QStringLiteral("barkbeetle"));

    if (wind && bb) {

        int iw = mInterfaces.indexOf(wind), ib = mInterfaces.indexOf(bb);

        if (ib<iw)

            mInterfaces.swap(iw, ib);

    }

}

DisturbanceInterface * Modules::module(const QString &module_name)

{

    foreach(DisturbanceInterface *di, mInterfaces)

        if (di->name() == module_name)

            return di;

    return 0;

}

void Modules::setupResourceUnit(const ResourceUnit *ru)

{

    foreach(SetupResourceUnitInterface *si, mSetupRUs)

        si->setupResourceUnit(ru);

}

void Modules::setup()

{

    foreach(DisturbanceInterface *di, mInterfaces)

        di->setup();

    // set up the scripting (i.e., Javascript)

    QJSEngine *engine = GlobalSettings::instance()->scriptEngine();

    foreach(DisturbanceInterface *di, mInterfaces)

        di->setupScripting(engine);

}

void Modules::calculateWater(const ResourceUnit *resource_unit, const WaterCycleData *water_data)

{

    foreach(WaterInterface *wi, mWater)

        wi->calculateWater(resource_unit, water_data);

}

void Modules::treeDeath(const Tree *tree, int removal_type)

{

    if (mTreeDeath.isEmpty())

        return;

    for (QList<TreeDeathInterface*>::const_iterator it=mTreeDeath.constBegin(); it!=mTreeDeath.constEnd(); ++it)

        (*it)->treeDeath(tree, removal_type);

}

void Modules::run()

{

    DebugTimer t("modules");

    // *** run in fixed order ***

    foreach(DisturbanceInterface *di, mInterfaces) {

        try {

            di->run();

        } catch (const IException &e) {

            qWarning() << "ERROR: uncaught exception in module '" << di->name() << "':";

            qWarning() << "ERROR:" << e.message();

            qWarning() << " **************************************** ";

        }

    }

    // *** run in random order ****

    //    QList<DisturbanceInterface*> run_list = mInterfaces;

    //    // execute modules in random order

    //    while (!run_list.isEmpty()) {

    //        int idx = irandom(0, run_list.size()-1);

    //        if (logLevelDebug())

    //            qDebug() << "executing disturbance module: " << run_list[idx]->name();

    //        try {

    //            run_list[idx]->run();

    //        } catch (const IException &e) {

    //            qWarning() << "ERROR: uncaught exception in module '" << run_list[idx]->name() << "':";

    //            qWarning() << "ERROR:" << e.message();

    //            qWarning() << " **************************************** ";

    //        }

    //        // remove from list

    //        run_list.removeAt(idx);

    //    }

}

void Modules::yearBegin()

{

    foreach(DisturbanceInterface *di, mInterfaces)

        di->yearBegin();

}