omModel.h

Go to the documentation of this file.

 
// Copyright (c) 2013-2015 OpenM++
// This code is licensed under the MIT license (see LICENSE.txt for details)
 
#ifndef OM_H_MODEL_H
#define OM_H_MODEL_H
 
#include <memory>
#include <cfloat>
#include <forward_list>
#include <type_traits>
#include <typeinfo>
#include <vector>
 
#include "omModelRunState.h"
#include "omLog.h"
#include "omError.h"
 
namespace openm
{
    struct RunOptions
    {
        int subValueCount;
 
        int subValueId;
 
        bool useSparse;
 
        double nullValue;
 
        bool isDbMicrodata;
 
        bool isCsvMicrodata;
 
        bool isTraceMicrodata;
 
        int progressPercent;
 
        double progressStep;
 
        RunOptions(void) :
            subValueCount(1),
            subValueId(0),
            useSparse(false),
            nullValue(FLT_MIN),
            isDbMicrodata(false),
            isCsvMicrodata(false),
            isTraceMicrodata(false),
            progressPercent(0),
            progressStep(0.0)
        { }
        ~RunOptions(void) noexcept { }
 
        bool isMicrodata(void) const { return isDbMicrodata || isCsvMicrodata || isTraceMicrodata; }
 
        bool isTextMicrodata(void) const { return isCsvMicrodata || isTraceMicrodata; }
    };
 
    struct IRunOptions
    {
        virtual ~IRunOptions(void) noexcept = 0;
 
        virtual bool isOptionExist(const char * i_key) const noexcept = 0;
 
        virtual std::string strOption(const char * i_key, const std::string & i_default = "") const noexcept = 0;
 
        virtual bool boolOption(const char * i_key) const noexcept = 0;
 
        virtual int boolOptionToInt(const char * i_key) const noexcept = 0;
 
        virtual int intOption(const char * i_key, int i_default) const noexcept = 0;
 
        virtual long long longOption(const char * i_key, long long i_default) const noexcept = 0;
 
        virtual double doubleOption(const char * i_key, double i_default) const noexcept = 0;
 
        virtual std::vector<std::pair<std::string, std::string>> allOptions(void) const noexcept = 0;
    };
 
    struct IRunBase : public IRunOptions
    {
        virtual ~IRunBase(void) noexcept = 0;
 
        virtual int parameterIdByName(const char * i_name) const = 0;
 
        virtual int parameterSubCount(int i_paramId) const = 0;
 
        virtual int parameterSelfSubCount(int i_paramId) const = 0;
 
        virtual int parameterSubValueIndex(int i_paramId, int i_subId) const = 0;
 
        virtual bool isUseSubValue(int i_subId) const = 0;
 
        virtual bool isTableSuppressed(const char * i_name) const = 0;
 
        virtual bool isTableSuppressed(int i_tableId) const = 0;
 
        virtual void readParameter(const char * i_name, int i_subId, const std::type_info & i_type, size_t i_size, void * io_valueArr) = 0;
    };
 
    struct IModel
    {
        virtual ~IModel(void) noexcept = 0;
 
        virtual int subValueCount(void) const noexcept = 0;
 
        virtual int subValueId(void) const noexcept = 0;
 
        virtual int tableIdByName(const char * i_name) const = 0;
 
        virtual bool isSuppressed(const char * i_name) const = 0;
 
        virtual const RunOptions * runOptions(void) const = 0;
 
        virtual int parameterSubValueIndex(const char * i_name) const = 0;
 
        virtual void writeOutputTable(const char * i_name, size_t i_size, std::forward_list<std::unique_ptr<double[]> > & io_accValues) = 0;
 
        virtual void updateProgress(int i_count, double i_value = 0.0) = 0;
 
        virtual void writeDbMicrodata(int i_entityKind, uint64_t i_microdataKey, const void * i_entityThis) = 0;
 
        virtual void writeCsvMicrodata(int i_entityKind, uint64_t i_microdataKey, int i_eventId, bool i_isSameEntity, const void * i_entityThis) = 0;
    };
 
    struct ParameterNameSizeItem
    {
        const char * name;
 
        const std::type_info & typeOf;
 
        const size_t size;
    };
 
    extern const size_t PARAMETER_NAME_ARR_LEN;
 
    extern const ParameterNameSizeItem parameterNameSizeArr[];
 
    struct EntityNameSizeItem
    {
        int entityId;
 
        const char * entity;
 
        int attributeId;
 
        const char * attribute;
 
        const std::type_info & typeOf;
 
        const size_t size;
 
        const ptrdiff_t offset;
 
        static int byName(const char * i_entityName, const char * i_attrName);
    };
 
    extern const size_t ENTITY_NAME_SIZE_ARR_LEN;
 
    extern const EntityNameSizeItem EntityNameSizeArr[];
 
    struct EventIdNameItem; // model events id, name
 
    extern const EventIdNameItem EventIdNameArr[];
 
    extern const size_t EVENT_ID_NAME_ARR_LEN;
 
    struct EventIdNameItem
    {
        int eventId;
 
        const char * eventName;
 
        static const char * byId(int i_eventId);
 
        static bool checkId(int i_eventId)
        {
            return EVENT_ID_NAME_ARR_LEN > 0 &&
                (i_eventId == EventIdNameArr[0].eventId ||
                    (0 < i_eventId + 1 && i_eventId + 1 < (int)EVENT_ID_NAME_ARR_LEN));
        }
    };
 
    #define OM_USE_MICRODATA_EVENTS (EVENT_ID_NAME_ARR_LEN > 1)
 
    extern const char modelUnknownErrorMessage[];
 
    typedef OpenmException<4000, modelUnknownErrorMessage> ModelException;
 
    extern const char simulationUnknownErrorMessage[];
 
    typedef OpenmException<4000, simulationUnknownErrorMessage> SimulationException;
 
    template<typename TVal> std::vector<TVal> read_om_parameter(IRunBase * const i_runBase, const char * i_name)
    {
        int paramId = i_runBase->parameterIdByName(i_name);
        int allCount = i_runBase->parameterSubCount(paramId);       // number of parameter sub-values
        int selfCount = i_runBase->parameterSelfSubCount(paramId);  // number of sub-values for current process
 
        // storage array: parameter values for current process
        // extra parameter value for exchange between root and child process
        std::vector<TVal> valueVec(selfCount);
        TVal extraVal;
        bool isStr = typeid(TVal) == typeid(std::string);    // no default null values for string parameters
 
        // read sub-values and place into storage array or send to child process
        for (int nSub = 0; nSub < allCount; nSub++) {
            try {
                void * pData = &extraVal;
                if (!isStr) {
                    extraVal = std::numeric_limits<TVal>::quiet_NaN();   // set default null value
                }
                i_runBase->readParameter(i_name, nSub, typeid(TVal), 1, pData);
 
                if (allCount <= 1) {
                    valueVec[0] = extraVal;
                }
                else {
                    if (i_runBase->isUseSubValue(nSub)) valueVec[i_runBase->parameterSubValueIndex(paramId, nSub)] = extraVal;
                }
            }
            catch (std::exception & ex) {
                throw ModelException("Failed to read input parameter: %s sub-value [%d]. %s", i_name, nSub, ex.what());
            }
        }
        return valueVec;
    }
 
    template<typename TVal> std::vector<std::unique_ptr<TVal[]>> read_om_parameter(IRunBase * const i_runBase, const char * i_name, size_t i_size)
    {
        int paramId = i_runBase->parameterIdByName(i_name);
        int allCount = i_runBase->parameterSubCount(paramId);       // number of parameter sub-values
        int selfCount = i_runBase->parameterSelfSubCount(paramId);  // number of sub-values for current process
 
        if (i_size <= 0) throw ModelException("invalid size: %zd of parameter %s", i_size, i_name);
 
        // storage array: parameter values for current process
        std::vector<std::unique_ptr<TVal[]>> valueVec(selfCount);
        for (auto & p : valueVec) {
            p.reset(new TVal[i_size]);
        }
 
        std::unique_ptr<TVal> extraVal;  // extra parameter value for exchange between root and child process
        if (allCount > 1) {
            extraVal.reset(new TVal[i_size]);
        }
        bool isStr = typeid(TVal) == typeid(std::string);    // no default null values for string parameters
 
        // read sub-values and place into storage array or send to child process
        for (int nSub = 0; nSub < allCount; nSub++) {
            try {
                void * pData = valueVec[0].get();
                if (allCount > 1) {
                    pData =
                        i_runBase->isUseSubValue(nSub) ?
                        valueVec[i_runBase->parameterSubValueIndex(paramId, nSub)].get() :
                        extraVal.get();
                }
                // set default null values and read parameter
                if (!isStr) {
                    std::fill(static_cast<TVal *>(pData), &(static_cast<TVal *>(pData))[i_size], std::numeric_limits<TVal>::quiet_NaN());
                }
                i_runBase->readParameter(i_name, nSub, typeid(TVal), i_size, pData);
            }
            catch (std::exception & ex) {
                throw ModelException("Failed to read input parameter: %s sub-value [%d]. %s", i_name, nSub, ex.what());
            }
        }
        return valueVec;
    }
}
 
//
// modeling library import and export
//
#ifdef __cplusplus
    extern "C" {
#endif
 
extern const char * OM_MODEL_NAME;
 
extern const char * OM_MODEL_DIGEST;
 
int main(int argc, char ** argv);
 
typedef void(*OM_RUN_ONCE_HANDLER)(openm::IRunBase * const i_runBase);
extern OM_RUN_ONCE_HANDLER RunOnceHandler;
 
typedef void(*OM_RUN_INIT_HANDLER)(openm::IRunBase * const i_runBase);
extern OM_RUN_INIT_HANDLER RunInitHandler;
 
typedef void(*OM_STARTUP_HANDLER)(openm::IModel * const i_model);
extern OM_STARTUP_HANDLER ModelStartupHandler;
 
typedef void (*OM_EVENT_LOOP_HANDLER)(openm::IModel * const i_model);
extern OM_EVENT_LOOP_HANDLER RunModelHandler;
 
typedef void (*OM_SHUTDOWN_HANDLER)(openm::IModel * const i_model);
extern OM_SHUTDOWN_HANDLER ModelShutdownHandler;
 
typedef void(*OM_RUN_SHUTDOWN_HANDLER)(bool i_isError, openm::IRunBase * const i_runBase);
extern OM_RUN_SHUTDOWN_HANDLER RunShutdownHandler;
 
extern openm::IModelRunState * theModelRunState;
 
#ifdef __cplusplus
    }
#endif
 
#endif  // OM_H_MODEL_H