WebSVN - public iLand - Diff - Rev 643 and 646 - /src/core/modelcontroller.cpp


Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/modelcontroller.cpp':
/** ModelController is a helper class used to
  control the flow of operations during a model run.
  Really useful???? or a dispatcher???
  */

#include "global.h"
#include "modelcontroller.h"
#include <QObject>

#include "model.h"
#include "helper.h"
#include "expression.h"
#include "expressionwrapper.h"
#include "../output/outputmanager.h"

#include "species.h"
#include "speciesset.h"
#include "mapgrid.h"

#include "mainwindow.h" // for the debug message buffering

ModelController::ModelController()
{
    mModel = NULL;
    mPaused = false;
    mRunning = false;
    mYearsToRun = 0;
    mViewerWindow = 0;
}

ModelController::~ModelController()
{
    destroy();
}

void ModelController::connectSignals()
{
    if (!mViewerWindow)
        return;
    connect(this,SIGNAL(bufferLogs(bool)), mViewerWindow, SLOT(bufferedLog(bool)));
}

/// prepare a list of all (active) species
QHash<QString, QString> ModelController::availableSpecies()
{
    QHash<QString, QString> list;
    if (mModel) {
        SpeciesSet *set = mModel->speciesSet();
        if (!set)
            throw IException("there are 0 or more than one species sets.");
        foreach (const Species *s, set->activeSpecies()) {
            list[s->id()] = s->name();
        }
    }
    return list;
}

bool ModelController::canCreate()
{
    if (mModel)
        return false;
    return true;
}

bool ModelController::canDestroy()
{
    return mModel != NULL;
}

bool ModelController::canRun()
{
    if (mModel && mModel->isSetup())
        return true;
    return false;
}

bool ModelController::isRunning()
{
    return mRunning;
}

bool ModelController::isFinished()
{
    if (!mModel)
        return false;
    return canRun() && !isRunning()  && mFinished;
}

int ModelController::currentYear() const
{
    return GlobalSettings::instance()->currentYear();
}

void ModelController::setFileName(QString initFileName)
{
    mInitFile = initFileName;
    try {
        GlobalSettings::instance()->loadProjectFile(mInitFile);
    } catch(const IException &e) {
        QString error_msg = e.message();
        Helper::msg(error_msg);
        qDebug() << error_msg;
    }
}

void ModelController::create()
{
    if (!canCreate())
        return;
    emit bufferLogs(true);

    try {
        DebugTimer::clearAllTimers();
        mModel = new Model();
        mModel->loadProject();
        if (!mModel->isSetup())
            return;

        // reset clock...
        GlobalSettings::instance()->setCurrentYear(1); // reset clock
        // initialization of trees, output on startup
        mModel->beforeRun();
    } catch(const IException &e) {
        QString error_msg = e.message();
        Helper::msg(error_msg);
        qDebug() << error_msg;
    }
    emit bufferLogs(false);

    qDebug() << "Model created.";
}

void ModelController::destroy()
{
    if (canDestroy()) {
        delete mModel;
        mModel = 0;
        GlobalSettings::instance()->setCurrentYear(0);
        qDebug() << "ModelController: Model destroyed.";
    }
}

void ModelController::runloop()
{
    static QTime sLastTime = QTime::currentTime();
    QApplication::processEvents();
    if (mPaused)
        return;
    bool doStop = false;
    bool hasError = false;
    if (GlobalSettings::instance()->currentYear()<=1) {
        sLastTime = QTime::currentTime(); // reset clock at the beginning of the simulation
    }

    if (!mCanceled && GlobalSettings::instance()->currentYear() < mYearsToRun) {
        emit bufferLogs(true);
        hasError = runYear(); // do the work
        mRunning = true;
        emit year(GlobalSettings::instance()->currentYear());
        if (!hasError) {
            int elapsed = sLastTime.msecsTo(QTime::currentTime());
            int time=0;
            if (currentYear()%50==0 && elapsed>10000)
                time = 100; // a 100ms pause...
            if (currentYear()%100==0 && elapsed>10000) {
                time = 500; // a 500ms pause...
            }
            if (time>0) {
                sLastTime = QTime::currentTime(); // reset clock
                qDebug() << "--- little break ---- (after " << elapsed << "ms).";
            }
            QTimer::singleShot(time,this, SLOT(runloop()));
        }
        else
           doStop = true; // an error occured

    } else {
        doStop = true; // all years simulated
    }

    if (doStop || mCanceled) {
                // finished
        mRunning = false;
        GlobalSettings::instance()->outputManager()->save();
        DebugTimer::printAllTimers();
        mFinished = true;
        emit bufferLogs(false); // stop buffering
        emit finished(QString());
    }

    QApplication::processEvents();
}

void ModelController::run(int years)
{
    if (!canRun())
        return;
    emit bufferLogs(true); // start buffering

    DebugTimer many_runs(QString("Timer for %1 runs").arg(years));
    mPaused = false;
    mFinished = false;
    mCanceled = false;
    mYearsToRun = years;
    //GlobalSettings::instance()->setCurrentYear(1); // reset clock

    DebugTimer::clearAllTimers();

    runloop(); // start the running loop

}

bool ModelController::runYear()
{
    if (!canRun()) return false;
    DebugTimer t("ModelController:runYear");
    qDebug() << "ModelController: run year" << currentYear();

    if (GlobalSettings::instance()->settings().paramValueBool("debug_clear"))
        GlobalSettings::instance()->clearDebugLists();  // clear debug data
    bool err=false;
    try {
        emit bufferLogs(true);
        mModel->runYear();
        fetchDynamicOutput();
    } catch(const IException &e) {
        QString error_msg = e.message();
        Helper::msg(error_msg);
        qDebug() << error_msg;
        err=true;
    }
    emit bufferLogs(false);
    return err;
}

bool ModelController::pause()
{
    if(!isRunning())
        return mPaused;

    if (mPaused) {
        // currently in pause - mode -> continue
        mPaused = false;
        QTimer::singleShot(0,this, SLOT(runloop())); // continue loop
    } else {
        // currently running -> set to pause mode
        GlobalSettings::instance()->outputManager()->save();
        mPaused = true;
        emit bufferLogs(false);
    }
    return mPaused;
}

void ModelController::cancel()
{
    mCanceled = true;
}

QMutex error_mutex;
void ModelController::throwError(const QString msg)
{
    QMutexLocker lock(&error_mutex); // serialize access
    qDebug() << "ModelController: throwError reached:";
    qDebug() << msg;
    emit bufferLogs(false);
    emit bufferLogs(true); // start buffering again

    throw IException(msg); // raise error again

}
//////////////////////////////////////
// dynamic outut
//////////////////////////////////////
//////////////////////////////////////
void ModelController::setupDynamicOutput(QString fieldList)
{
    mDynFieldList.clear();
    if (!fieldList.isEmpty()) {
        QRegExp rx("((?:\\[.+\\]|\\w+)\\.\\w+)");
        int pos=0;
        while ((pos = rx.indexIn(fieldList, pos)) != -1) {
            mDynFieldList.append(rx.cap(1));
            pos += rx.matchedLength();
        }

        //mDynFieldList = fieldList.split(QRegExp("(?:\\[.+\\]|\\w+)\\.\\w+"), QString::SkipEmptyParts);
        mDynFieldList.prepend("count");
        mDynFieldList.prepend("year"); // fixed fields.
    }
    mDynData.clear();
    mDynData.append(mDynFieldList.join(";"));
}

QString ModelController::dynamicOutput()
{
    return mDynData.join("\n");
}

const QStringList aggList = QStringList() << "mean" << "sum" << "min" << "max" << "p25" << "p50" << "p75" << "p5"<< "p10" << "p90" << "p95";
void ModelController::fetchDynamicOutput()
{
    if (mDynFieldList.isEmpty())
        return;
    DebugTimer t("dynamic output");
    QStringList var;
    QString lastVar = "";
    QVector<double> data;
    AllTreeIterator at(mModel);
    TreeWrapper tw;
    int var_index;
    StatData stat;
    double value;
    QStringList line;
    Expression custom_expr;
    bool simple_expression;
    foreach (QString field, mDynFieldList) {
        if (field=="count" || field=="year")
            continue;
        if (field.count()>0 && field.at(0)=='[') {
            QRegExp rex("\\[(.+)\\]\\.(\\w+)");
            rex.indexIn(field);
            var = rex.capturedTexts();
            var.pop_front(); // drop first element (contains the full string)
            simple_expression = false;
        } else {
            var = field.split(QRegExp("\\W+"), QString::SkipEmptyParts);
            simple_expression = true;
        }
        if (var.count()!=2)
                throw IException(QString("Invalid variable name for dynamic output:") + field);
        if (var.first()!=lastVar) {
            // load new field
            data.clear();
            at.reset(); var_index = 0;
            if (simple_expression) {
                var_index = tw.variableIndex(var.first());
                if (var_index<0)
                    throw IException(QString("Invalid variable name for dynamic output:") + var.first());

            } else {
                custom_expr.setExpression(var.first());
                custom_expr.setModelObject(&tw);
            }
            while (Tree *t = at.next()) {
                tw.setTree(t);
                if (simple_expression)
                    value = tw.value(var_index);
                else
                    value = custom_expr.execute();
                data.push_back(value);
            }
            stat.setData(data);
        }
        // fetch data
        var_index = aggList.indexOf(var[1]);
        switch (var_index) {
            case 0: value = stat.mean(); break;
            case 1: value = stat.sum(); break;
            case 2: value = stat.min(); break;
            case 3: value = stat.max(); break;
            case 4: value = stat.percentile25(); break;
            case 5: value = stat.median(); break;
            case 6: value = stat.percentile75(); break;
            case 7: value = stat.percentile(5); break;
            case 8: value = stat.percentile(10); break;
            case 9: value = stat.percentile(90); break;
            case 10: value = stat.percentile(95); break;
            default: throw IException(QString("Invalid aggregate expression for dynamic output: %1\nallowed:%2")
                                  .arg(var[1]).arg(aggList.join(" ")));
        }
        line+=QString::number(value);
    }
    line.prepend( QString::number(data.size()) );
    line.prepend( QString::number(GlobalSettings::instance()->currentYear()) );
    mDynData.append(line.join(";"));
}

void ModelController::saveScreenshot(QString file_name)
{
    if (!mViewerWindow)
        return;
    QImage img = mViewerWindow->screenshot();
    img.save(file_name);
}

void ModelController::paintMap(MapGrid *map, double min_value, double max_value)
{
    if (mViewerWindow) {
        mViewerWindow->paintGrid(map, "", GridViewRainbow, min_value, max_value);
        qDebug() << "painted map grid" << map->name() << "min-value (blue):" << min_value << "max-value(red):" << max_value;
    }
}

void ModelController::paintGrid(const FloatGrid *grid, const QString &name, const GridViewType view_type, double min_value, double max_value)
{
    if (mViewerWindow) {
        mViewerWindow->paintGrid(grid, name, view_type, min_value, max_value);
        qDebug() << "painted grid min-value (blue):" << min_value << "max-value(red):" << max_value;
    }
}

void ModelController::setViewport(QPointF center_point, double scale_px_per_m)
{
    if (mViewerWindow)
        mViewerWindow->setViewport(center_point, scale_px_per_m);
}

void ModelController::addLayers(const LayeredGridBase *layers)
{
    qDebug() << layers->names();
}


 

Rev 643	Rev 646
1	Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/modelcontroller.cpp':	1	Redirecting to URL 'https://iland.boku.ac.at/svn/iland/tags/release_1.0/src/core/modelcontroller.cpp':
2	/** ModelController is a helper class used to	2	/** ModelController is a helper class used to
3	control the flow of operations during a model run.	3	control the flow of operations during a model run.
4	Really useful???? or a dispatcher???	4	Really useful???? or a dispatcher???
5	*/	5	*/
6		6
7	#include "global.h"	7	#include "global.h"
8	#include "modelcontroller.h"	8	#include "modelcontroller.h"
9	#include <QObject>	9	#include <QObject>
10		10
11	#include "model.h"	11	#include "model.h"
12	#include "helper.h"	12	#include "helper.h"
13	#include "expression.h"	13	#include "expression.h"
14	#include "expressionwrapper.h"	14	#include "expressionwrapper.h"
15	#include "../output/outputmanager.h"	15	#include "../output/outputmanager.h"
16		16
17	#include "species.h"	17	#include "species.h"
18	#include "speciesset.h"	18	#include "speciesset.h"
19	#include "mapgrid.h"	19	#include "mapgrid.h"
20		20
21	#include "mainwindow.h" // for the debug message buffering	21	#include "mainwindow.h" // for the debug message buffering
22		22
23	ModelController::ModelController()	23	ModelController::ModelController()
24	{	24	{
25	mModel = NULL;	25	mModel = NULL;
26	mPaused = false;	26	mPaused = false;
27	mRunning = false;	27	mRunning = false;
28	mYearsToRun = 0;	28	mYearsToRun = 0;
29	mViewerWindow = 0;	29	mViewerWindow = 0;
30	}	30	}
31		31
32	ModelController::~ModelController()	32	ModelController::~ModelController()
33	{	33	{
34	destroy();	34	destroy();
35	}	35	}
36		36
37	void ModelController::connectSignals()	37	void ModelController::connectSignals()
38	{	38	{
39	if (!mViewerWindow)	39	if (!mViewerWindow)
40	return;	40	return;
41	connect(this,SIGNAL(bufferLogs(bool)), mViewerWindow, SLOT(bufferedLog(bool)));	41	connect(this,SIGNAL(bufferLogs(bool)), mViewerWindow, SLOT(bufferedLog(bool)));
42	}	42	}
43		43
44	/// prepare a list of all (active) species	44	/// prepare a list of all (active) species
45	QHash<QString, QString> ModelController::availableSpecies()	45	QHash<QString, QString> ModelController::availableSpecies()
46	{	46	{
47	QHash<QString, QString> list;	47	QHash<QString, QString> list;
48	if (mModel) {	48	if (mModel) {
49	SpeciesSet *set = mModel->speciesSet();	49	SpeciesSet *set = mModel->speciesSet();
50	if (!set)	50	if (!set)
51	throw IException("there are 0 or more than one species sets.");	51	throw IException("there are 0 or more than one species sets.");
52	foreach (const Species *s, set->activeSpecies()) {	52	foreach (const Species *s, set->activeSpecies()) {
53	list[s->id()] = s->name();	53	list[s->id()] = s->name();
54	}	54	}
55	}	55	}
56	return list;	56	return list;
57	}	57	}
58		58
59	bool ModelController::canCreate()	59	bool ModelController::canCreate()
60	{	60	{
61	if (mModel)	61	if (mModel)
62	return false;	62	return false;
63	return true;	63	return true;
64	}	64	}
65		65
66	bool ModelController::canDestroy()	66	bool ModelController::canDestroy()
67	{	67	{
68	return mModel != NULL;	68	return mModel != NULL;
69	}	69	}
70		70
71	bool ModelController::canRun()	71	bool ModelController::canRun()
72	{	72	{
73	if (mModel && mModel->isSetup())	73	if (mModel && mModel->isSetup())
74	return true;	74	return true;
75	return false;	75	return false;
76	}	76	}
77		77
78	bool ModelController::isRunning()	78	bool ModelController::isRunning()
79	{	79	{
80	return mRunning;	80	return mRunning;
81	}	81	}
82		82
83	bool ModelController::isFinished()	83	bool ModelController::isFinished()
84	{	84	{
85	if (!mModel)	85	if (!mModel)
86	return false;	86	return false;
87	return canRun() && !isRunning() && mFinished;	87	return canRun() && !isRunning() && mFinished;
88	}	88	}
89		89
90	int ModelController::currentYear() const	90	int ModelController::currentYear() const
91	{	91	{
92	return GlobalSettings::instance()->currentYear();	92	return GlobalSettings::instance()->currentYear();
93	}	93	}
94		94
95	void ModelController::setFileName(QString initFileName)	95	void ModelController::setFileName(QString initFileName)
96	{	96	{
97	mInitFile = initFileName;	97	mInitFile = initFileName;
98	try {	98	try {
99	GlobalSettings::instance()->loadProjectFile(mInitFile);	99	GlobalSettings::instance()->loadProjectFile(mInitFile);
100	} catch(const IException &e) {	100	} catch(const IException &e) {
101	QString error_msg = e.message();	101	QString error_msg = e.message();
102	Helper::msg(error_msg);	102	Helper::msg(error_msg);
103	qDebug() << error_msg;	103	qDebug() << error_msg;
104	}	104	}
105	}	105	}
106		106
107	void ModelController::create()	107	void ModelController::create()
108	{	108	{
109	if (!canCreate())	109	if (!canCreate())
110	return;	110	return;
111	emit bufferLogs(true);	111	emit bufferLogs(true);
112		112
113	try {	113	try {
114	DebugTimer::clearAllTimers();	114	DebugTimer::clearAllTimers();
115	mModel = new Model();	115	mModel = new Model();
116	mModel->loadProject();	116	mModel->loadProject();
117	if (!mModel->isSetup())	117	if (!mModel->isSetup())
118	return;	118	return;
119		119
120	// reset clock...	120	// reset clock...
121	GlobalSettings::instance()->setCurrentYear(1); // reset clock	121	GlobalSettings::instance()->setCurrentYear(1); // reset clock
122	// initialization of trees, output on startup	122	// initialization of trees, output on startup
123	mModel->beforeRun();	123	mModel->beforeRun();
124	} catch(const IException &e) {	124	} catch(const IException &e) {
125	QString error_msg = e.message();	125	QString error_msg = e.message();
126	Helper::msg(error_msg);	126	Helper::msg(error_msg);
127	qDebug() << error_msg;	127	qDebug() << error_msg;
128	}	128	}
129	emit bufferLogs(false);	129	emit bufferLogs(false);
130		130
131	qDebug() << "Model created.";	131	qDebug() << "Model created.";
132	}	132	}
133		133
134	void ModelController::destroy()	134	void ModelController::destroy()
135	{	135	{
136	if (canDestroy()) {	136	if (canDestroy()) {
137	delete mModel;	137	delete mModel;
138	mModel = 0;	138	mModel = 0;
139	GlobalSettings::instance()->setCurrentYear(0);	139	GlobalSettings::instance()->setCurrentYear(0);
140	qDebug() << "ModelController: Model destroyed.";	140	qDebug() << "ModelController: Model destroyed.";
141	}	141	}
142	}	142	}
143		143
144	void ModelController::runloop()	144	void ModelController::runloop()
145	{	145	{
146	static QTime sLastTime = QTime::currentTime();	146	static QTime sLastTime = QTime::currentTime();
147	QApplication::processEvents();	147	QApplication::processEvents();
148	if (mPaused)	148	if (mPaused)
149	return;	149	return;
150	bool doStop = false;	150	bool doStop = false;
151	bool hasError = false;	151	bool hasError = false;
152	if (GlobalSettings::instance()->currentYear()<=1) {	152	if (GlobalSettings::instance()->currentYear()<=1) {
153	sLastTime = QTime::currentTime(); // reset clock at the beginning of the simulation	153	sLastTime = QTime::currentTime(); // reset clock at the beginning of the simulation
154	}	154	}
155		155
156	if (!mCanceled && GlobalSettings::instance()->currentYear() < mYearsToRun) {	156	if (!mCanceled && GlobalSettings::instance()->currentYear() < mYearsToRun) {
157	emit bufferLogs(true);	157	emit bufferLogs(true);
158	hasError = runYear(); // do the work	158	hasError = runYear(); // do the work
159	mRunning = true;	159	mRunning = true;
160	emit year(GlobalSettings::instance()->currentYear());	160	emit year(GlobalSettings::instance()->currentYear());
161	if (!hasError) {	161	if (!hasError) {
162	int elapsed = sLastTime.msecsTo(QTime::currentTime());	162	int elapsed = sLastTime.msecsTo(QTime::currentTime());
163	int time=0;	163	int time=0;
164	if (currentYear()%50==0 && elapsed>10000)	164	if (currentYear()%50==0 && elapsed>10000)
165	time = 100; // a 100ms pause...	165	time = 100; // a 100ms pause...
166	if (currentYear()%100==0 && elapsed>10000) {	166	if (currentYear()%100==0 && elapsed>10000) {
167	time = 500; // a 500ms pause...	167	time = 500; // a 500ms pause...
168	}	168	}
169	if (time>0) {	169	if (time>0) {
170	sLastTime = QTime::currentTime(); // reset clock	170	sLastTime = QTime::currentTime(); // reset clock
171	qDebug() << "--- little break ---- (after " << elapsed << "ms).";	171	qDebug() << "--- little break ---- (after " << elapsed << "ms).";
172	}	172	}
173	QTimer::singleShot(time,this, SLOT(runloop()));	173	QTimer::singleShot(time,this, SLOT(runloop()));
174	}	174	}
175	else	175	else
176	doStop = true; // an error occured	176	doStop = true; // an error occured
177		177
178	} else {	178	} else {
179	doStop = true; // all years simulated	179	doStop = true; // all years simulated
180	}	180	}
181		181
182	if (doStop \|\| mCanceled) {	182	if (doStop \|\| mCanceled) {
183	// finished	183	// finished
184	mRunning = false;	184	mRunning = false;
185	GlobalSettings::instance()->outputManager()->save();	185	GlobalSettings::instance()->outputManager()->save();
186	DebugTimer::printAllTimers();	186	DebugTimer::printAllTimers();
187	mFinished = true;	187	mFinished = true;
188	emit bufferLogs(false); // stop buffering	188	emit bufferLogs(false); // stop buffering
189	emit finished(QString());	189	emit finished(QString());
190	}	190	}
191		191
192	QApplication::processEvents();	192	QApplication::processEvents();
193	}	193	}
194		194
195	void ModelController::run(int years)	195	void ModelController::run(int years)
196	{	196	{
197	if (!canRun())	197	if (!canRun())
198	return;	198	return;
199	emit bufferLogs(true); // start buffering	199	emit bufferLogs(true); // start buffering
200		200
201	DebugTimer many_runs(QString("Timer for %1 runs").arg(years));	201	DebugTimer many_runs(QString("Timer for %1 runs").arg(years));
202	mPaused = false;	202	mPaused = false;
203	mFinished = false;	203	mFinished = false;
204	mCanceled = false;	204	mCanceled = false;
205	mYearsToRun = years;	205	mYearsToRun = years;
206	//GlobalSettings::instance()->setCurrentYear(1); // reset clock	206	//GlobalSettings::instance()->setCurrentYear(1); // reset clock
207		207
208	DebugTimer::clearAllTimers();	208	DebugTimer::clearAllTimers();
209		209
210	runloop(); // start the running loop	210	runloop(); // start the running loop
211		211
212	}	212	}
213		213
214	bool ModelController::runYear()	214	bool ModelController::runYear()
215	{	215	{
216	if (!canRun()) return false;	216	if (!canRun()) return false;
217	DebugTimer t("ModelController:runYear");	217	DebugTimer t("ModelController:runYear");
218	qDebug() << "ModelController: run year" << currentYear();	218	qDebug() << "ModelController: run year" << currentYear();
219		219
220	if (GlobalSettings::instance()->settings().paramValueBool("debug_clear"))	220	if (GlobalSettings::instance()->settings().paramValueBool("debug_clear"))
221	GlobalSettings::instance()->clearDebugLists(); // clear debug data	221	GlobalSettings::instance()->clearDebugLists(); // clear debug data
222	bool err=false;	222	bool err=false;
223	try {	223	try {
224	emit bufferLogs(true);	224	emit bufferLogs(true);
225	mModel->runYear();	225	mModel->runYear();
226	fetchDynamicOutput();	226	fetchDynamicOutput();
227	} catch(const IException &e) {	227	} catch(const IException &e) {
228	QString error_msg = e.message();	228	QString error_msg = e.message();
229	Helper::msg(error_msg);	229	Helper::msg(error_msg);
230	qDebug() << error_msg;	230	qDebug() << error_msg;
231	err=true;	231	err=true;
232	}	232	}
233	emit bufferLogs(false);	233	emit bufferLogs(false);
234	return err;	234	return err;
235	}	235	}
236		236
237	bool ModelController::pause()	237	bool ModelController::pause()
238	{	238	{
239	if(!isRunning())	239	if(!isRunning())
240	return mPaused;	240	return mPaused;
241		241
242	if (mPaused) {	242	if (mPaused) {
243	// currently in pause - mode -> continue	243	// currently in pause - mode -> continue
244	mPaused = false;	244	mPaused = false;
245	QTimer::singleShot(0,this, SLOT(runloop())); // continue loop	245	QTimer::singleShot(0,this, SLOT(runloop())); // continue loop
246	} else {	246	} else {
247	// currently running -> set to pause mode	247	// currently running -> set to pause mode
248	GlobalSettings::instance()->outputManager()->save();	248	GlobalSettings::instance()->outputManager()->save();
249	mPaused = true;	249	mPaused = true;
250	emit bufferLogs(false);	250	emit bufferLogs(false);
251	}	251	}
252	return mPaused;	252	return mPaused;
253	}	253	}
254		254
255	void ModelController::cancel()	255	void ModelController::cancel()
256	{	256	{
257	mCanceled = true;	257	mCanceled = true;
258	}	258	}
259		259
260	QMutex error_mutex;	260	QMutex error_mutex;
261	void ModelController::throwError(const QString msg)	261	void ModelController::throwError(const QString msg)
262	{	262	{
263	QMutexLocker lock(&error_mutex); // serialize access	263	QMutexLocker lock(&error_mutex); // serialize access
264	qDebug() << "ModelController: throwError reached:";	264	qDebug() << "ModelController: throwError reached:";
265	qDebug() << msg;	265	qDebug() << msg;
266	emit bufferLogs(false);	266	emit bufferLogs(false);
267	emit bufferLogs(true); // start buffering again	267	emit bufferLogs(true); // start buffering again
268		268
269	throw IException(msg); // raise error again	269	throw IException(msg); // raise error again
270		270
271	}	271	}
272	//////////////////////////////////////	272	//////////////////////////////////////
273	// dynamic outut	273	// dynamic outut
274	//////////////////////////////////////	274	//////////////////////////////////////
275	//////////////////////////////////////	275	//////////////////////////////////////
276	void ModelController::setupDynamicOutput(QString fieldList)	276	void ModelController::setupDynamicOutput(QString fieldList)
277	{	277	{
278	mDynFieldList.clear();	278	mDynFieldList.clear();
279	if (!fieldList.isEmpty()) {	279	if (!fieldList.isEmpty()) {
280	QRegExp rx("((?:\\[.+\\]\|\\w+)\\.\\w+)");	280	QRegExp rx("((?:\\[.+\\]\|\\w+)\\.\\w+)");
281	int pos=0;	281	int pos=0;
282	while ((pos = rx.indexIn(fieldList, pos)) != -1) {	282	while ((pos = rx.indexIn(fieldList, pos)) != -1) {
283	mDynFieldList.append(rx.cap(1));	283	mDynFieldList.append(rx.cap(1));
284	pos += rx.matchedLength();	284	pos += rx.matchedLength();
285	}	285	}
286		286
287	//mDynFieldList = fieldList.split(QRegExp("(?:\\[.+\\]\|\\w+)\\.\\w+"), QString::SkipEmptyParts);	287	//mDynFieldList = fieldList.split(QRegExp("(?:\\[.+\\]\|\\w+)\\.\\w+"), QString::SkipEmptyParts);
288	mDynFieldList.prepend("count");	288	mDynFieldList.prepend("count");
289	mDynFieldList.prepend("year"); // fixed fields.	289	mDynFieldList.prepend("year"); // fixed fields.
290	}	290	}
291	mDynData.clear();	291	mDynData.clear();
292	mDynData.append(mDynFieldList.join(";"));	292	mDynData.append(mDynFieldList.join(";"));
293	}	293	}
294		294
295	QString ModelController::dynamicOutput()	295	QString ModelController::dynamicOutput()
296	{	296	{
297	return mDynData.join("\n");	297	return mDynData.join("\n");
298	}	298	}
299		299
300	const QStringList aggList = QStringList() << "mean" << "sum" << "min" << "max" << "p25" << "p50" << "p75" << "p5"<< "p10" << "p90" << "p95";	300	const QStringList aggList = QStringList() << "mean" << "sum" << "min" << "max" << "p25" << "p50" << "p75" << "p5"<< "p10" << "p90" << "p95";
301	void ModelController::fetchDynamicOutput()	301	void ModelController::fetchDynamicOutput()
302	{	302	{
303	if (mDynFieldList.isEmpty())	303	if (mDynFieldList.isEmpty())
304	return;	304	return;
305	DebugTimer t("dynamic output");	305	DebugTimer t("dynamic output");
306	QStringList var;	306	QStringList var;
307	QString lastVar = "";	307	QString lastVar = "";
308	QVector<double> data;	308	QVector<double> data;
309	AllTreeIterator at(mModel);	309	AllTreeIterator at(mModel);
310	TreeWrapper tw;	310	TreeWrapper tw;
311	int var_index;	311	int var_index;
312	StatData stat;	312	StatData stat;
313	double value;	313	double value;
314	QStringList line;	314	QStringList line;
315	Expression custom_expr;	315	Expression custom_expr;
316	bool simple_expression;	316	bool simple_expression;
317	foreach (QString field, mDynFieldList) {	317	foreach (QString field, mDynFieldList) {
318	if (field=="count" \|\| field=="year")	318	if (field=="count" \|\| field=="year")
319	continue;	319	continue;
320	if (field.count()>0 && field.at(0)=='[') {	320	if (field.count()>0 && field.at(0)=='[') {
321	QRegExp rex("\\[(.+)\\]\\.(\\w+)");	321	QRegExp rex("\\[(.+)\\]\\.(\\w+)");
322	rex.indexIn(field);	322	rex.indexIn(field);
323	var = rex.capturedTexts();	323	var = rex.capturedTexts();
324	var.pop_front(); // drop first element (contains the full string)	324	var.pop_front(); // drop first element (contains the full string)
325	simple_expression = false;	325	simple_expression = false;
326	} else {	326	} else {
327	var = field.split(QRegExp("\\W+"), QString::SkipEmptyParts);	327	var = field.split(QRegExp("\\W+"), QString::SkipEmptyParts);
328	simple_expression = true;	328	simple_expression = true;
329	}	329	}
330	if (var.count()!=2)	330	if (var.count()!=2)
331	throw IException(QString("Invalid variable name for dynamic output:") + field);	331	throw IException(QString("Invalid variable name for dynamic output:") + field);
332	if (var.first()!=lastVar) {	332	if (var.first()!=lastVar) {
333	// load new field	333	// load new field
334	data.clear();	334	data.clear();
335	at.reset(); var_index = 0;	335	at.reset(); var_index = 0;
336	if (simple_expression) {	336	if (simple_expression) {
337	var_index = tw.variableIndex(var.first());	337	var_index = tw.variableIndex(var.first());
338	if (var_index<0)	338	if (var_index<0)
339	throw IException(QString("Invalid variable name for dynamic output:") + var.first());	339	throw IException(QString("Invalid variable name for dynamic output:") + var.first());
340		340
341	} else {	341	} else {
342	custom_expr.setExpression(var.first());	342	custom_expr.setExpression(var.first());
343	custom_expr.setModelObject(&tw);	343	custom_expr.setModelObject(&tw);
344	}	344	}
345	while (Tree *t = at.next()) {	345	while (Tree *t = at.next()) {
346	tw.setTree(t);	346	tw.setTree(t);
347	if (simple_expression)	347	if (simple_expression)
348	value = tw.value(var_index);	348	value = tw.value(var_index);
349	else	349	else
350	value = custom_expr.execute();	350	value = custom_expr.execute();
351	data.push_back(value);	351	data.push_back(value);
352	}	352	}
353	stat.setData(data);	353	stat.setData(data);
354	}	354	}
355	// fetch data	355	// fetch data
356	var_index = aggList.indexOf(var[1]);	356	var_index = aggList.indexOf(var[1]);
357	switch (var_index) {	357	switch (var_index) {
358	case 0: value = stat.mean(); break;	358	case 0: value = stat.mean(); break;
359	case 1: value = stat.sum(); break;	359	case 1: value = stat.sum(); break;
360	case 2: value = stat.min(); break;	360	case 2: value = stat.min(); break;
361	case 3: value = stat.max(); break;	361	case 3: value = stat.max(); break;
362	case 4: value = stat.percentile25(); break;	362	case 4: value = stat.percentile25(); break;
363	case 5: value = stat.median(); break;	363	case 5: value = stat.median(); break;
364	case 6: value = stat.percentile75(); break;	364	case 6: value = stat.percentile75(); break;
365	case 7: value = stat.percentile(5); break;	365	case 7: value = stat.percentile(5); break;
366	case 8: value = stat.percentile(10); break;	366	case 8: value = stat.percentile(10); break;
367	case 9: value = stat.percentile(90); break;	367	case 9: value = stat.percentile(90); break;
368	case 10: value = stat.percentile(95); break;	368	case 10: value = stat.percentile(95); break;
369	default: throw IException(QString("Invalid aggregate expression for dynamic output: %1\nallowed:%2")	369	default: throw IException(QString("Invalid aggregate expression for dynamic output: %1\nallowed:%2")
370	.arg(var[1]).arg(aggList.join(" ")));	370	.arg(var[1]).arg(aggList.join(" ")));
371	}	371	}
372	line+=QString::number(value);	372	line+=QString::number(value);
373	}	373	}
374	line.prepend( QString::number(data.size()) );	374	line.prepend( QString::number(data.size()) );
375	line.prepend( QString::number(GlobalSettings::instance()->currentYear()) );	375	line.prepend( QString::number(GlobalSettings::instance()->currentYear()) );
376	mDynData.append(line.join(";"));	376	mDynData.append(line.join(";"));
377	}	377	}
378		378
379	void ModelController::saveScreenshot(QString file_name)	379	void ModelController::saveScreenshot(QString file_name)
380	{	380	{
381	if (!mViewerWindow)	381	if (!mViewerWindow)
382	return;	382	return;
383	QImage img = mViewerWindow->screenshot();	383	QImage img = mViewerWindow->screenshot();
384	img.save(file_name);	384	img.save(file_name);
385	}	385	}
386		386
387	void ModelController::paintMap(MapGrid *map, double min_value, double max_value)	387	void ModelController::paintMap(MapGrid *map, double min_value, double max_value)
388	{	388	{
389	if (mViewerWindow) {	389	if (mViewerWindow) {
390	mViewerWindow->paintGrid(map, "", GridViewRainbow, min_value, max_value);	390	mViewerWindow->paintGrid(map, "", GridViewRainbow, min_value, max_value);
391	qDebug() << "painted map grid" << map->name() << "min-value (blue):" << min_value << "max-value(red):" << max_value;	391	qDebug() << "painted map grid" << map->name() << "min-value (blue):" << min_value << "max-value(red):" << max_value;
392	}	392	}
393	}	393	}
394		394
395	void ModelController::paintGrid(const FloatGrid *grid, const QString &name, const GridViewType view_type, double min_value, double max_value)	395	void ModelController::paintGrid(const FloatGrid *grid, const QString &name, const GridViewType view_type, double min_value, double max_value)
396	{	396	{
397	if (mViewerWindow) {	397	if (mViewerWindow) {
398	mViewerWindow->paintGrid(grid, name, view_type, min_value, max_value);	398	mViewerWindow->paintGrid(grid, name, view_type, min_value, max_value);
399	qDebug() << "painted grid min-value (blue):" << min_value << "max-value(red):" << max_value;	399	qDebug() << "painted grid min-value (blue):" << min_value << "max-value(red):" << max_value;
400	}	400	}
401	}	401	}
402		402
403	void ModelController::setViewport(QPointF center_point, double scale_px_per_m)	403	void ModelController::setViewport(QPointF center_point, double scale_px_per_m)
404	{	404	{
405	if (mViewerWindow)	405	if (mViewerWindow)
406	mViewerWindow->setViewport(center_point, scale_px_per_m);	406	mViewerWindow->setViewport(center_point, scale_px_per_m);
-		407	}
-		408
-		409	void ModelController::addLayers(const LayeredGridBase *layers)
-		410	{
-		411	qDebug() << layers->names();
407	}	412	}
408		413
409		414
410		415

Subversion Repositories public iLand

(root)/src/core/modelcontroller.cpp @ 1222 - Rev 643 → 646