modenaModel.H

Go to the documentation of this file.

#ifndef __MODENAMODEL_H__
#define __MODENAMODEL_H__

#include <exception>
#include <string>
#include <vector>

#include "modena.h"

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

namespace Modena
{

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

class modenaException
:
    public std::exception
{
    // Private data

    int errorCode_;

public:

    modenaException(int errorCode)
    :
        errorCode_(errorCode)
    {}

    int errorCode() const
    {
        return errorCode_;
    }

    virtual const char*  what() const throw()
    {
        return "Modena Exception";
    }
};


class modenaModel
{
    // Private data

        // Pointer to MoDeNa model
        modena_model_t *model_;

        modena_inputs_t *inputs_;
        modena_outputs_t *outputs_;

public:
 
    // Constructors

        //- Construct from model name
        modenaModel
        (
            const std::string& name
        )
        {
            // Instantiate a model
            model_ = modena_model_new(name.c_str());

            if(modena_error_occurred())
            {
                throw modenaException(modena_error());
            }

            // Allocate memory and fetch arg positions
            inputs_ = modena_inputs_new(model_);
            outputs_ = modena_outputs_new(model_);
        }

    // Destructor

        ~modenaModel()
        {
            modena_inputs_destroy(inputs_);
            modena_outputs_destroy(outputs_);
            modena_model_destroy(model_);
        }

    // Member Functions

        inline size_t inputs_size() const
        {
            return modena_model_inputs_size(model_);
        }

        inline size_t outputs_size() const
        {
            return modena_model_outputs_size(model_);
        }

        inline size_t parameters_size() const
        {
            return modena_model_parameters_size(model_);
        }

        inline size_t inputs_argPos(const std::string& name) const
        {
            return modena_model_inputs_argPos(model_, name.c_str());
        }

        inline size_t outputs_argPos(const std::string& name) const
        {
            return modena_model_outputs_argPos(model_, name.c_str());
        }

        inline void inputs_set(const size_t i, double x) const
        {
            modena_inputs_set(inputs_, i, x);
        }

        inline double outputs_get(const size_t i) const
        {
           return modena_outputs_get(outputs_, i);
        }

        inline void argPos_check() const
        {
            modena_model_argPos_check(model_);
        }

        inline std::vector<std::string> inputs_names() const
        {
            std::vector<std::string> v;

            const char** iNames = modena_model_inputs_names(model_);
            for(int i=0; i<modena_model_inputs_size(model_); i++)
            {
                v.push_back(std::string(iNames[i]));
            }

            return v;
        }

        inline std::vector<std::string> outputs_names() const
        {
            std::vector<std::string> v;

            const char** oNames = modena_model_outputs_names(model_);
            for(int i=0; i<modena_model_outputs_size(model_); i++)
            {
                v.push_back(std::string(oNames[i]));
            }

            return v;
        }

        inline std::vector<std::string> parameters_names() const
        {
            std::vector<std::string> v;

            const char** pNames = modena_model_parameters_names(model_);
            for(int i=0; i<modena_model_parameters_size(model_); i++)
            {
                v.push_back(std::string(pNames[i]));
            }

            return v;
        }

        inline void call() const
        {
            modena_model_call(model_, inputs_, outputs_);

            if(modena_error_occurred())
            {
                throw modenaException(modena_error());
            }
        }

};

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

} // End namespace Modena

#endif /* __MODENAMODEL_H__ */

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