---

network.h

/***************************************************************************
                          network.h  -  description
                             -------------------
    copyright            : (C) 2001, 2002 by Matt Grover
    email                : mgrover@amygdala.org
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef NETWORK_H
#define NETWORK_H

using namespace std;

#include <amygdala/types.h>
// check for g++ version 3.0.0 or higher
#if GCC_VERSION >= 30000
    #include <ext/hash_map>
#else
    #include <hash_map>
#endif
#include <string>
#include <queue>
#include <amygdala/mpspikeinput.h>


enum NEvent { NOACTION, RMSPIKE, SPIKE, INPUTSPIKE, RESPIKE };
class Neuron;
class FunctionLookup;
class Layer;
class SpikeInput;
class Synapse;


class Network {
public:
    //friend void Neuron::SendSpike(AmTimeInt& now);
    friend class Neuron;
    friend void MpSpikeInput::ReadInputBuffer();

    Network();
    virtual ~Network();

    void ScheduleNEvent(NEvent eventType,
                        AmTimeInt eventTime,
                        Neuron* reqNrn);
    void ScheduleNEvent(NEvent eventType,
                        AmTimeInt eventTime,
                        AmIdInt reqNrnId);

    Neuron* AddNeuron(NeuronRole nRole, AmIdInt nId);

    Neuron* AddNeuron(NeuronRole nRole, Neuron* nrn);

    bool ConnectNeurons(AmIdInt preSynapticNeuron,
                        AmIdInt postSynapticNeuron,
                        float weight,
                        AmTimeInt delay=0);

    bool ConnectNeurons(Neuron* preSynapticNeuron,
                        Neuron* postSynapticNeuron,
                        float weight,
                        AmTimeInt delay=0);

    void Run(AmTimeInt maxRunTime);

    int Size() { return net.size(); }

    int LayerCount() { return layers.size(); }

    typedef hash_map<AmIdInt, Neuron*>::const_iterator const_iterator;

    const_iterator begin() const { return net.begin(); }

    const_iterator end() const { return net.end(); }

    typedef hash_map<unsigned int, Layer*>::iterator layer_iterator;

    layer_iterator layer_begin() { return layers.begin(); }

    layer_iterator layer_end() { return layers.end(); }

    void AddLayer(Layer* newLayer);

    AmIdInt MaxNeuronId() { return (nextNeuronId - 1); }

    bool Layered() { return isLayered; }

    static void SetTimeStepSize(AmTimeInt stepSize);

    static AmTimeInt TimeStepSize() { return simStepSize; }

    static AmTimeInt SimTime() { return simTime; }

    Neuron* GetNeuron(AmIdInt nId) { return net[nId]; }

    SpikeInput* GetSpikeInput() { return spikeInput; }

    void SetSpikeInput(SpikeInput* sIn);

    bool StreamingInput() { return streamingInput; }

    void StreamingInput(bool streaming) { streamingInput = streaming; }

    static void ResetSimTime();

    void SetTrainingMode(bool tMode);

    bool GetTrainingMode() const { return trainingMode; }

    Layer * GetLayer(AmIdInt layerId);

    void EnableSpikeBatching() { spikeDelaysOn = true; }

protected:
    void ScheduleSpikeDelay(vector<Synapse*>& axon);

    virtual void IncrementSimTime();

    int pspLSize;                   // Size of lookup tables
    int pspLRes;                    // Lookup table timestep resolution
    static AmTimeInt simStepSize;

    int netSize;
    bool streamingInput;

    AmIdInt nextNeuronId;
    unsigned int nextLayerId;

    FunctionLookup* functionRef;    // Container for lookup tables
    SpikeInput* spikeInput;

    hash_map<AmIdInt, Neuron*> net;     // Neurons that make up net. Key is neuron ID.

    hash_map<unsigned int, Layer*> layers; // layer container

    struct SpikeRequest {
        AmTimeInt spikeTime;     // Desired time of spike
        AmTimeInt requestTime;   // Time SpikeRequest was entered in queue
        unsigned int requestOrder;  // Entry number within a given time step.
        Neuron* requestor;          // Neuron scheduling spike
        // operator< overloaded to make the priority_queue happy
        bool operator<(const SpikeRequest& sr) const
        {
            if(spikeTime != sr.spikeTime) {
                return spikeTime>sr.spikeTime;
            }
            else if(requestTime != sr.requestTime) {
                return requestTime>sr.requestTime;
            }
            else {
                return requestOrder<sr.requestOrder;
            }
        }
    };

    priority_queue<SpikeRequest> eventQ;    // Main event queue
    priority_queue<SpikeRequest> inputQ;    // Queue of inputs into network
    vector< vector<Synapse*> > delayedSpikeQ;
    AmTimeInt currSpikeDelayOffset;
    AmTimeInt maxOffset;
    bool spikeDelaysOn;
    AmTimeInt maxSpikeDelay;
    Synapse* maxSpikeDelaySyn;
    static AmTimeInt simTime;               // Current simulation time
    static unsigned int runCount;           // number of Network objects calling Run()
    unsigned int spikeBatchCount;

    inline void IncrementDelayOffset();

private:
    void SendDelayedSpikes();

    void SetDefaults();

    void InitializeDelayedSpikeQ();

    unsigned int eventRequestCount;         // Counter for SpikeRequest.requestOrder
    bool isLayered;
    bool trainingMode;
};

#endif

---