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 "abe_global.h"

#include "agenttype.h"

#include "agent.h"

#include "fmstp.h"

#include "forestmanagementengine.h"

#include "fmunit.h"

#include "fmstand.h"

#include "fomescript.h"

#include <QJSEngine>

namespace ABE {

/** @class AgentType

    @ingroup abe

    AgentType implements an abstract agent type (e.g., farmer or forest company). The class defines basic behavior of

    agents.

  */

AgentType::AgentType()

{

}

void AgentType::setupSTP(QJSValue agent_code, const QString agent_name)

{

    mName = agent_name;

    mSTP.clear();

    mJSObj = agent_code;

    if (!agent_code.isObject())

        throw IException(QString("ABE:AgentType:setup: the javascript object for agent '%1' could not be found.").arg(agent_name));

    QJSValue stps = agent_code.property("stp");

    if (!stps.isObject())

        throw IException(QString("ABE:AgentType:setup: the javascript definition of agent '%1' does not have a section for 'stp'.").arg(agent_name));

    QJSValueIterator it(stps);

    while (it.hasNext()) {

        it.next();

        FMSTP *stp = ForestManagementEngine::instance()->stp(it.value().toString());

        if (!stp)

           throw IException(QString("ABE:AgentType:setup: definition of agent '%1': the STP for mixture type '%2': '%3' is not available.").arg(agent_name).arg(it.name()).arg(it.value().toString()));

        mSTP[it.name()] = stp;

    }

    if (FMSTP::verbose())

        qCDebug(abeSetup) << "setup of agent" << agent_name << mSTP.size() << "links to STPs established.";

}

void AgentType::addSTP(QString stp_name)

{

    FMSTP *stp = ForestManagementEngine::instance()->stp(stp_name);

    if (!stp)

       throw IException(QString("AgentType::addSTP: definition of agent '%1': the STP  '%2' is not available.").arg(mName).arg(stp_name));

    mSTP[stp_name] = stp;

}

Agent *AgentType::createAgent(QString agent_name)

{

    // call the newAgent function in the javascript object assigned to this agent type

    QJSValue func = mJSObj.property("newAgent");

    if (!func.isCallable())

        throw IException(QString("The agent type '%1' does not have a valid 'newAgent' function.").arg(name()));

    QJSValue result = func.callWithInstance(mJSObj);

    if (result.isError())

        throw IException(QString("calling the 'newAgent' function of agent type '%1' returned with the following error: %2").arg(name()).arg(result.toString()));

    Agent *agent = new Agent(this, result);

    if (!agent_name.isEmpty()) {

        agent->setName(agent_name);

    } else {

        if (result.property("name").isUndefined())

            result.setProperty("name", agent->name()); //  set the auto-generated name also for the JS world

        else

            agent->setName(result.property("name").toString()); // set the JS-name also internally

    }

    ForestManagementEngine::instance()->addAgent(agent);

    return agent;

}

void AgentType::addAgentUpdate(const AgentUpdate &update, FMUnit *unit)

{

    // clear agent updates...

    QMultiHash<const FMUnit*, AgentUpdate>::iterator hi= mAgentChanges.begin();

    while (hi != mAgentChanges.end()) {

        if (!hi.value().isValid())

            hi = mAgentChanges.erase(hi);

        else

            ++hi;

    }

    AgentUpdate &rUpdate = mAgentChanges.insertMulti(unit, update).value();

    rUpdate.setCounter( unit->numberOfStands() );

    // set default unit value

    switch (update.type()) {

    case AgentUpdate::UpdateU: unit->setU( update.value().toInt() ); break;

    case AgentUpdate::UpdateThinning: unit->setThinningIntensity(update.value().toInt()); break;

    case AgentUpdate::UpdateSpecies: break;

    default: break;

    }

    if (update.age()==-1)

        return;

    // check stands that should be updated immediateley

    const QMultiMap<FMUnit*, FMStand*> &stands = ForestManagementEngine::instance()->stands();

    QMultiMap<FMUnit*, FMStand*>::const_iterator it = stands.constFind(const_cast<FMUnit*>(unit));

    while (it != stands.constEnd() && it.key()==unit) {

        FMStand *stand = it.value();

        if (stand->trace())

            qCDebug(abe) << stand->context() << "Agent-update: update if stand-age: " << stand->age() << " < update-age: " << update.age();

        if (stand->age() <= update.age())

            agentUpdateForStand(stand, QString(), stand->age());

        ++it;

    }

}

bool AgentType::agentUpdateForStand(FMStand *stand, QString after_activity, int age)

{

    //

    QMultiHash<const FMUnit*, AgentUpdate>::iterator uit = mAgentChanges.find(stand->unit());

    bool action = false;

    while (uit != mAgentChanges.end() && uit.key()==stand->unit()) {

        AgentUpdate &update = uit.value();

        if (!update.isValid()) {

            ++uit;

            continue;

        }

        // timing of update

        if (!after_activity.isEmpty() && update.afterActivity()==after_activity) {

            // do something

            action = true;

        }

        if (update.age()>-1 && age<update.age()) {

            // do something

            action = true;

        }

        // update the stand

        if (action) {

            update.decrease();

            switch (update.type()) {

            case AgentUpdate::UpdateU: {

                int current_u = stand->U(); // stand->stp()->rotationLengthType(stand->U());

                int new_u = update.value().toInt();

                if (current_u == new_u) {

                    if (stand->trace())

                        qCDebug(abe) << stand->context() << "AgentUpdate: update of U to" << new_u << " not done (value already set).";

                    break;

                }

                stand->setU( new_u );

                // stand->setU( stand->stp()->rotationLengthOfType(new_u) );

                qCDebug(abe) << stand->context() << "AgentUpdate: changed to U" << stand->U();

                // QML like dynamic expressions

                stand->stp()->evaluateDynamicExpressions(stand);

                break;

            }

            case AgentUpdate::UpdateThinning: {

                int current_th = stand->thinningIntensity();

                int new_th = update.value().toInt();

                if (current_th == new_th) {

                    if (stand->trace())

                        qCDebug(abe) << stand->context() << "AgentUpdate: update of thinningIntensity class to" << new_th << " not done (value already set).";

                    break;

                }

                stand->setThinningIntensity(new_th );

                qCDebug(abe) << stand->context() << "AgentUpdate: changed to thinningIntensity class:" << stand->thinningIntensity();

                stand->stp()->evaluateDynamicExpressions(stand);

                break;

            }

            default: break; // TODO: UpdateSpecies???

            }

        }

        ++uit;

    }

    return action;

}

FMSTP *AgentType::stpByName(const QString &name)

{

    if (mSTP.contains(name))

        return mSTP[name];

    else

        return 0;

}

int AgentType::speciesCompositionIndex(const QString &key)

{

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

        if (mSpeciesCompositions[i] == key)

            return i;

    return -1;

}

QString AgentType::speciesCompositionName(const int index)

{

    if (index>=0 && index < mSpeciesCompositions.count())

        return mSpeciesCompositions[index];

    return QString();

}

AgentUpdate::UpdateType AgentUpdate::label(const QString &name)

{

    if (name=="U") return UpdateU;

    if (name=="thinningIntensity") return UpdateThinning;

    if (name=="species") return UpdateSpecies;

    return UpdateInvalid;

}

QString AgentUpdate::dump()

{

    QString line;

    switch (type()) {

    case UpdateU:   line= QString("AgentUpdate: update U to '%1'.").arg(mValue); break;

    case UpdateThinning:   line= QString("AgentUpdate: update thinning interval to '%1'.").arg(mValue); break;

    case UpdateSpecies:   line= QString("AgentUpdate: update species composition to '%1'.").arg(mValue); break;

    default: break;

    }

    if (!mAfterActivity.isEmpty())

        return line + QString("Update after activity '%1'.").arg(mAfterActivity);

    return line + QString("Update (before) age '%1'.").arg(mAge);

}

} // namespace