NemoWrapper.h

Go to the documentation of this file.

#ifndef NEMOWRAPPER_H
#define NEMOWRAPPER_H

//SpikeStream includes
#include "AbstractDeviceManager.h"
#include "AbstractSimulation.h"
#include "ArchiveDao.h"
#include "ArchiveInfo.h"
#include "NetworkDao.h"
#include "ParameterInfo.h"
#include "Pattern.h"
#include "SpikeStreamTypes.h"

//Qt includes
#include <QHash>
#include <QMutex>
#include <QThread>

//Nemo includes
#include "nemo.h"

//Other includes
#include <vector>
using namespace std;


namespace spikestream {

        class NemoWrapper : public QThread, public AbstractSimulation {
                Q_OBJECT

                public:
                        NemoWrapper();
                        ~NemoWrapper();
                        void addDeviceManager(AbstractDeviceManager* deviceManager);
                        void cancelLoading();
                        void cancelResetWeights();
                        void cancelSaveWeights();
                        void clearWaitForGraphics() { waitForGraphics = false; }
                        unsigned getArchiveID() { return archiveInfo.getID(); }
                        int getCurrentTask() { return currentTaskID; }
                        QString getErrorMessage() { return errorMessage; }
                        QList<neurid_t> getFiringNeuronIDs() { return firingNeuronList; }
                        nemo_configuration_t getNemoConfig(){ return nemoConfig; }
                        unsigned getSTDPFunctionID() { return stdpFunctionID; }
                        timestep_t getTimeStep() { return timeStepCounter; }
                        unsigned getUpdateInterval_ms() { return this->updateInterval_ms; }
                        unsigned getWaitInterval_ms() { return waitInterval_ms; }
                        bool isError() { return error; }
                        bool isMonitorFiringNeurons() { return monitorFiringNeurons; }
                        bool isMonitorWeights() { return monitorWeights; }
                        bool isWaitForGraphics()  { return waitForGraphics; }
                        bool isWeightsReset() { return weightsReset; }
                        bool isWeightsSaved() { return weightsSaved; }
                        bool isSimulationLoaded() { return simulationLoaded; }
                        bool isSimulationRunning();
                        void resetWeights();
                        void run();
                        void saveWeights();
                        void setArchiveMode(bool mode, const QString& archiveDescription = "");
                        void setFrameRate(unsigned int frameRate);
                        void setInjectCurrent(unsigned neuronGroupID, double percentage, double current, bool sustain);
                        void setFiringNeuronIDs(QList<neurid_t>& neurIDList);
                        void setInjectCurrentNeuronIDs(QList<neurid_t>& neurIDList, double current);
                        void setInjectNoise(unsigned neuronGroupID, double percentage, bool sustain);
                        void setFiringInjectionPattern(const Pattern& pattern, unsigned neuronGroupID, bool sustain);
                        void setCurrentInjectionPattern(const Pattern& pattern, float current, unsigned neuronGroupID, bool sustain);
                        void setMonitor(bool mode);
                        void setMonitorNeurons(bool firing, bool membranePotential);
                        void setNemoConfig(nemo_configuration_t nemoConfig) { this->nemoConfig = nemoConfig; }
                        void setMonitorWeights(bool enable);
                        void setNeuronParameters(unsigned neuronGroupID, QHash<QString, double> parameterMap);
                        void setSynapseParameters(unsigned connectionGroupID, QHash<QString, double> parameterMap);
                        void setSTDPFunctionID(unsigned stdpFunctionID) { this->stdpFunctionID = stdpFunctionID; }
                        void setSustainNoise(bool sustain) { this->sustainNoise = sustain; this->sustainCurrent = sustain; }
                        void setSustainPattern(bool sustainPattern) { this->sustainPattern = sustainPattern; }
                        void setUpdateFiringNeurons(bool updateFiringNeurons){ this->updateFiringNeurons = updateFiringNeurons; }
                        void setWaitInterval(unsigned waitInterval_ms) { this->waitInterval_ms = waitInterval_ms; }
                        void playSimulation();
                        void stepSimulation();
                        void stopSimulation();
                        void unloadSimulation();



                        static const int NO_TASK_DEFINED = 0;

                        static const int RESET_WEIGHTS_TASK = 1;

                        static const int RUN_SIMULATION_TASK = 2;

                        static const int SAVE_WEIGHTS_TASK = 3;

                        static const int SET_NEURON_PARAMETERS_TASK = 4;

                        static const int STEP_SIMULATION_TASK = 5;


                signals:
                        void progress(int stepsComplete, int totalSteps);
                        void simulationStopped();
                        void timeStepChanged(unsigned int timeStep);
                        void timeStepChanged(unsigned int timeStep, const QList<unsigned>& neuronIDList);
                        void timeStepChanged(unsigned int timeStep, const QHash<unsigned, float>& membranePotentialMap);


                private slots:
                        void updateProgress(int stepsComplete, int totalSteps);


                private:
                        //======================  VARIABLES  ========================
                        NetworkDao* networkDao;

                        ArchiveDao* archiveDao;

                        ArchiveInfo archiveInfo;

                        int currentTaskID;

                        bool simulationLoaded;

                        bool archiveMode;

                        bool monitorFiringNeurons;

                        bool monitorMembranePotential;

                        bool monitorWeights;

                        bool monitor;

                        bool updateFiringNeurons;

                        unsigned int timeStepCounter;

                        bool error;

                        QString errorMessage;

                        bool stopThread;

                        nemo_configuration_t nemoConfig;

                        nemo_simulation_t nemoSimulation;

                        unsigned updateInterval_ms;

                        unsigned waitInterval_ms;

                        bool waitForGraphics;

                        QMutex mutex;

                        QMutex runMutex;

                        unsigned stdpFunctionID;

                        QList<neurid_t> firingNeuronList;

                        QHash<unsigned, unsigned> injectNoiseMap;

                        bool sustainNoise;

                        QHash<unsigned, QPair<unsigned, double> > injectCurrentMap;

                        bool sustainCurrent;

                        QList<neurid_t> neuronIDsToFire;

                        QHash<neurid_t, double> neuronIDCurrentMap;

                        QHash<unsigned, float> membranePotentialMap;

                        QHash<unsigned, synapse_id*> volatileConGrpMap;

                        QList<unsigned> preSynapticNeuronIDs;

                        bool weightsSaved;

                        bool weightsReset;

                        bool weightSaveCancelled;

                        bool weightResetCancelled;

                        float stdpReward;

                        timestep_t applySTDPInterval;

                        unsigned neuronGroupID;

                        QHash<QString, double> neuronParameterMap;

                        vector<unsigned> injectionPatternVector;

                        vector<unsigned> injectionCurrentNeurIDVector;

                        vector<float> injectionCurrentVector;

                        bool sustainPattern;

                        unsigned patternNeuronGroupID;

                        QList<AbstractDeviceManager*> deviceManagerList;


                        //======================  METHODS  ========================
                        unsigned addInjectCurrentNeuronIDs();
                        unsigned addInjectFiringNeuronIDs();
                        void checkNemoOutput(nemo_status_t result, const QString& errorMessage);
                        void clearError();
                        void fillInjectNoiseArray(unsigned*& array, int* arraySize);
                        void getMembranePotential();
                        void loadNemo();
                        void resetNemoWeights();
                        void runNemo();
                        void saveNemoWeights();
                        void setError(const QString& errorMessage);
                        void setExcitatoryNeuronParameters(NeuronGroup* neuronGroup);
                        void setInhibitoryNeuronParameters(NeuronGroup* neuronGroup);
                        void setNeuronParametersInNemo();
                        void stepNemo();
                        void unloadNemo();
                        void updateNetworkWeights();
        };

}

#endif//NEMOWRAPPER_H