simulator.h

Go to the documentation of this file.

#pragma once

// Standard C++ includes
#include <map>
#include <set>
#include <string>
#include <tuple>

// PLOG includes
#include <plog/Severity.h>
#include <plog/Appenders/ConsoleAppender.h>

// SpineML simulator includes
#include "input.h"
#include "inputValue.h"
#include "logOutput.h"
#include "modelProperty.h"

//----------------------------------------------------------------------------
// SpineMLSimulator::Simulator
//----------------------------------------------------------------------------
namespace SpineMLSimulator
{
class Simulator
{
public:
    Simulator(plog::Severity logLevel = plog::warning);
    Simulator(const std::string &experimentXML, const std::string &overrideOutputPath = "", plog::Severity logLevel = plog::warning);
    ~Simulator();

    //------------------------------------------------------------------------
    // Public API
    //------------------------------------------------------------------------
    void load(const std::string &experimentXML, const std::string &overrideOutputPath = "");

    void stepTime();

    const LogOutput::AnalogueExternal *getExternalLogger(const std::string &name) const;

    InputValue::External *getExternalInput(const std::string &name) const;

    double getDT() const{ return m_DT; }

    double getDurationMs() const{ return m_DurationMs; }

    double getInputMs() const{ return m_InputMs; }
    double getSimulateMs() const{ return m_SimulateMs; }
    double getLogMs() const{ return m_LogMs; }

    double getNeuronUpdateTime() const;
    double getInitTime() const;
    double getPresynapticUpdateTime() const;
    double getPostsynapticUpdateTime() const;
    double getSynapseDynamicsTime() const;
    double getInitSparseTime() const;

    unsigned long long calcNumTimesteps() const
    {
        return (unsigned long long)std::ceil(getDurationMs() / getDT());
    }

private:
    //------------------------------------------------------------------------
    // Typedefines
    //------------------------------------------------------------------------
#ifdef _WIN32
    typedef HMODULE LibraryHandle;
#else
    typedef void* LibraryHandle;
#endif

    typedef void (*VoidFunction)(void);

    typedef std::map<std::string, std::pair<std::set<std::string>, std::set<std::string>>> ComponentEventPorts;


    typedef std::tuple<unsigned int*, unsigned int*, unsigned int*, VoidFunction, VoidFunction> NeuronPopSpikeVars;

    //------------------------------------------------------------------------
    // Private functions
    //------------------------------------------------------------------------

    void *getLibrarySymbol(const char *name, bool allowMissing = false) const;


    NeuronPopSpikeVars getNeuronPopSpikeVars(const std::string &popName) const;

    void addPropertiesAndSizes(const filesystem::path &basePath, const pugi::xml_node &node,
                               const pugi::xml_node &modelNode, const std::string &geNNPopName,
                               unsigned int popSize, std::map<std::string, unsigned int> &sizes,
                               const std::vector<unsigned int> *remapIndices = nullptr);

    std::unique_ptr<Input::Base> createInput(const pugi::xml_node &node,
                                             const std::map<std::string, unsigned int> &componentSizes,
                                             const std::map<std::string, std::string> &componentURLs,
                                             const ComponentEventPorts &componentEventPorts);

    std::unique_ptr<LogOutput::Base> createLogOutput(const pugi::xml_node &node, const filesystem::path &logPath,
                                                     const std::map<std::string, unsigned int> &componentSizes,
                                                     const std::map<std::string, std::string> &componentURLs,
                                                     const ComponentEventPorts &componentEventPorts);

    unsigned int getComponentSize(const std::string &componentName,
                                  const std::map<std::string, unsigned int> &componentSizes);

    bool isEventSendPort(const std::string &targetName, const std::string &portName,
                         const std::map<std::string, std::string> &componentURLs,
                         const ComponentEventPorts &componentEventPorts) const;

    bool isEventReceivePort(const std::string &targetName, const std::string &portName,
                            const std::map<std::string, std::string> &componentURLs,
                            const ComponentEventPorts &componentEventPorts) const;

    void addEventPorts(const filesystem::path &basePath, const pugi::xml_node &node,
                       std::map<std::string, std::string> &componentURLs,
                       ComponentEventPorts &componentEventPorts);

    //------------------------------------------------------------------------
    // Members
    //------------------------------------------------------------------------
    LibraryHandle m_ModelLibrary;

    VoidFunction m_StepTime;

    float *m_SimulationTime;

    unsigned long long *m_SimulationTimestep;

    double m_DT;

    double m_DurationMs;

    double m_InputMs;
    double m_SimulateMs;
    double m_LogMs;

    std::vector<std::unique_ptr<LogOutput::Base>> m_Loggers;

    std::vector<std::unique_ptr<Input::Base>> m_Inputs;

    std::map<std::string, std::map<std::string, std::unique_ptr<ModelProperty::Base>>> m_ComponentProperties;

    std::map<std::string, const LogOutput::AnalogueExternal*> m_ExternalLoggers;

    std::map<std::string, InputValue::External*> m_ExternalInputs;

    plog::ConsoleAppender<plog::TxtFormatter> m_ConsoleAppender;
};
}   // namespace SpineMLSimulator