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

#ifndef GLOBALSETTINGS_H
#define GLOBALSETTINGS_H

#include <QtCore>
#include <QtSql>
#include <QtSql/QSqlDatabase>

#include "global.h"
#include "settingmetadata.h"
#include "xmlhelper.h"
// The favorite random number generator:
// use either the MersenneTwister or the WELLS algoritm:
// #include "randomwell.h"
// #include "../3rdparty/MersenneTwister.h"
// use faster method to concatenate strings (see qt - documentation on QString)
#define QT_USE_FAST_CONCATENATION
#define QT_USE_FAST_OPERATOR_PLUS

typedef QList<QVariant> DebugList;

class Model;
class OutputManager;
class ModelController; // forward
class SystemStatistics;
class QJSEngine; // forward

/// General settings and globally available data
class GlobalSettings
{
public:
    // singleton-access
    static GlobalSettings *instance() { if (mInstance) return mInstance; mInstance = new GlobalSettings(); return mInstance; }
    ~GlobalSettings();
    // Access
    // model and clock
    Model *model() const { return mModel; }
    ModelController *controller() const { return mModelController; }

    void setModel(Model *model) {mModel = model; }
    void setModelController(ModelController *mc) {mModelController = mc; }

    int currentYear() const { return mRunYear; }
    void setCurrentYear(const int year) { mRunYear = year; }

    /// access the global QScriptEngine used throughout the model
    /// for all Javascript related functionality.
    QString executeJavascript(const QString &command);
    /// execute a javasript function in the global context
    QString executeJSFunction(const QString function_name);
    QJSEngine *scriptEngine() const { return mScriptEngine; }
    void resetScriptEngine(); ///< re-creates the script engine (when the Model is re-created)

    // system statistics
    SystemStatistics *systemStatistics() { return mSystemStatistics; }

    // debugging fain grained debug outputs
    enum DebugOutputs { dTreeNPP=1, dTreePartition=2, dTreeGrowth=4,
                        dStandGPP=8, dWaterCycle=16, dDailyResponses=32,
                        dEstablishment=64, dSaplingGrowth=128, dCarbonCycle=256,
                        dPerformance=512}; ///< defines available debug output types.
    void setDebugOutput(const int debug) { mDebugOutputs = GlobalSettings::DebugOutputs(debug); }
    void setDebugOutput(const DebugOutputs dbg, const bool enable=true); ///< enable/disable a specific output type.
    bool isDebugEnabled(const DebugOutputs dbg) {return int(dbg) & mDebugOutputs;} ///< returns true, if a specific debug outut type is enabled.
    int currentDebugOutput() const { return mDebugOutputs; }
    QString debugOutputName(const DebugOutputs d); ///< returns the name attached to 'd' or an empty string if not found
    DebugOutputs debugOutputId(const QString debug_name); ///< returns the DebugOutputs bit or 0 if not found
    DebugList &debugList(const int ID, const DebugOutputs dbg); ///< returns a ref to a list ready to be filled with debug output of a type/id combination.
    const QList<const DebugList*> debugLists(const int ID, const DebugOutputs dbg); ///< return a list of debug outputs
    QStringList debugListCaptions(const DebugOutputs dbg); ///< returns stringlist of captions for a specific output type
    QList<QPair<QString, QVariant> > debugValues(const int ID); ///< all debug values for object with given ID
    void clearDebugLists(); ///< clear all debug data
    QStringList debugDataTable(GlobalSettings::DebugOutputs type, const QString separator, const QString fileName=QString()); ///< output for all available items (trees, ...) in table form

    // database access functions
    QSqlDatabase dbin() { return QSqlDatabase::database("in"); }
    QSqlDatabase dbout() { return QSqlDatabase::database("out"); }
    QSqlDatabase dbclimate() { return QSqlDatabase::database("climate"); }

    // setting-meta-data
    /// access an individual SettingMetaData named @p name.
    const SettingMetaData *settingMetaData(const QString &name); // unused??
    /// retrieve the default value of the setting @p name.
    QVariant settingDefaultValue(const QString &name); // unused?
    QList<QString> settingNames() { return mSettingMetaData.keys(); } ///< retrieve list of all names of settings.

    // path and directory
    QString path(const QString &fileName, const QString &type="home");
    bool fileExists(const QString &fileName, const QString &type="home");

    // xml project file
    const XmlHelper &settings() const { return mXml; }

    // setup and maintenance

    // xml project settings
    void loadProjectFile(const QString &fileName);

    // meta data of settings
    void loadSettingsMetaDataFromFile(const QString &fileName);
    void loadSettingsMetaDataFromXml(const QDomElement &topNode);

    // Database connections
    bool setupDatabaseConnection(const QString& dbname, const QString &fileName, bool fileMustExist);
    void clearDatabaseConnections(); ///< shutdown and clear connections
    // output manager
    OutputManager *outputManager() { return mOutputManager; }

    // path
    void setupDirectories(QDomElement pathNode, const QString &projectFilePath);
    void printDirectories() const;


private:
    GlobalSettings(); // private ctor
    static GlobalSettings *mInstance;
    Model *mModel;
    ModelController *mModelController;
    OutputManager *mOutputManager;
    QJSEngine *mScriptEngine;
    int mRunYear;
    SystemStatistics *mSystemStatistics;

    // special debug outputs
    QMultiHash<int, DebugList> mDebugLists;
    int mDebugOutputs; // "bitmap" of enabled debugoutputs.

    SettingMetaDataList mSettingMetaData; ///< storage container (QHash) for settings.
    QHash<QString, QString> mFilePath; ///< storage for file paths

    XmlHelper mXml; ///< xml-based hierarchical settings
};

// constants
// We assume:
// Light-Grid: 2x2m
// Height-Grid: 10x10m
// Resource-Unit: 100x100m
const int cPxSize = 2; // size of light grid (m)
const int cRUSize = 100; // size of resource unit (m)
const double cRUArea = 10000.; // area of a resource unit (m2)
const int cHeightSize = 10; // size of a height grid pixel (m)
const int cPxPerHeight = 5; // 10 / 2 LIF pixels per height pixel
const int cPxPerRU = 50; // 100/2
const int cHeightPerRU = 10; // 100/10 height pixels per resource unit
const int cPxPerHectare = 2500; // pixel/ha ( 10000 / (2*2) )
const double cHeightPixelArea = 100.; // 100m2 area of a height pixel

// other constants
const double biomassCFraction = 0.5; // fraction of (dry) biomass which is carbon
const double cAutotrophicRespiration = 0.47;

/// shortcut to the GlobalSettings Singleton object.
#define Globals (GlobalSettings::instance())

// provide a hashing function for the QPoint type (needed from stand init functions, ABE, ...)
inline uint qHash(const QPoint &key)
{
    return qHash(key.x()) ^ qHash(key.y());
}
#endif // GLOBALSETTINGS_H