---

neuron.h

/***************************************************************************
                          neuron.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.                                   *
 *                                                                         *
 ***************************************************************************/

/***************************************************************************
    Implement a spiking neuron based on the Integrate-and-fire model.  This
    class class will be converted into an abstract base class in the near
    future and much of the code will be moved to BasicNeuron.
 ***************************************************************************/

#ifndef NEURON_H
#define NEURON_H

using namespace std;
#include <amygdala/types.h>
#include <vector>
#if GCC_VERSION >= 30000
    #include <ext/hash_map>
#else
    #include <hash_map>
#endif
#include <cmath>
#include <amygdala/network.h>
#include <amygdala/mpspikeinput.h>


class MpNetwork;
class Network;
class FunctionLookup;
class SpikeOutput;

enum OutputMode { OFF, OUTPUT_LAYERS, ALL };

class PhysicalProperties {
public:
    PhysicalProperties();
    ~PhysicalProperties();
    void SetLocation(float _newVal[]);
    float * GetLocation(float loc[]);

protected:
    float location[3];
};

//class CompareSynapse;

class Synapse {
public:
    Synapse(Neuron* _postNrn, float _weight, AmTimeInt _delay = 0);
    ~Synapse() {}

    float GetWeight() { return weight; }
    void SetWeight(float _weight) { weight = _weight; }
    const AmTimeInt& GetOffset() const { return offset; }
    AmTimeInt GetDelay() const;
    Neuron* GetPostNeuron() const { return postNrn; }
protected:
    float weight;
    Neuron* postNrn;
    AmTimeInt offset;
    friend class CompareSynapse;
};


class SMPSynapse : public Synapse {
public:
    SMPSynapse(MpSpikeInput *_connector, Neuron* _postNrn, float _weight, AmTimeInt _delay = 0);
    void SpikeEvent();
protected:
    MpSpikeInput *connector;
};


class CompareSynapse {
public:
    CompareSynapse() {}
    ~CompareSynapse() {}
//    bool operator()(const Synapse* lsyn, const Synapse* rsyn) {
//        return lsyn->GetPostNeuron() < rsyn->GetPostNeuron(); }
    bool operator()(const Synapse* lsyn, const Synapse* rsyn) {
        return lsyn->postNrn < rsyn->postNrn; }
};

typedef vector<Synapse*>::iterator SynapseItr;


class Neuron {
public:
    friend void MpSpikeInput::ReadInputBuffer();

    Neuron(AmIdInt neuronId);
    virtual ~Neuron();

    void SetAxonSize(int size);

    int GetAxonSize() const { return axon.size(); }
    vector <SMPSynapse*>::iterator smpaxon_begin() { return smpAxon.begin(); }
    vector <SMPSynapse*>::iterator smpaxon_end() { return smpAxon.end(); }

    AmIdInt GetAxonID(unsigned int index) { return axon[index]->GetPostNeuron()->GetID(); }

    // FIXME: This has to return the normalized weight -- this will return
    // the scaled weight as it is now.  See the source of the old Neuron::GetWeight()
    float GetAxonWeight(unsigned int index) { return axon[index]->GetWeight(); }

    float GetAxonDelay(unsigned int index) { return axon[index]->GetDelay(); }

    void SetParentNet(Network* const ParNet) { SNet = ParNet; }

    AmIdInt GetID() { return(nId); }

    LayerType GetLayerType() { return(layerType); }

    void SetLayerType(LayerType _layerType) { layerType = _layerType; }

    void SetTimeConstants(float synapticConst, float membraneConst);

    float GetMembraneConst() const { return memTimeConst; }

    float GetSynapticConst() const { return synTimeConst; }

    void SetRefractory(float period) { refPeriod = (period * 1000); }

    float GetRefractory() const { return (refPeriod / 1000); }

    void SetLearningConst(float learnConst) { learningConst = learnConst; }

    float GetLearningConst() const { return learningConst; }

    void SetRestPotential(float ptnl) { restPtnl = ptnl; }

    float GetRestPotential() const { return restPtnl; }

    void SetThresholdPotential(float ptnl) { thresholdPtnl = ptnl; }

    float GetThresholdPotential() const { return thresholdPtnl; }

    void TrainingOn(bool mode) { trainingMode = mode; }

    bool IsTraining() const { return trainingMode; }

    void Inhibitory(bool val) { inhibitory = val; }

    bool Inhibitory() const { return inhibitory; }

    static void CaptureOutput(OutputMode mode);

    static void SetSpikeOutput(SpikeOutput* output);

    static SpikeOutput* GetSpikeOutput() { return spikeOutput; }

    static void EnforceSign(bool enforce) { enforceSign = enforce; }

    static bool EnforceSign() { return enforceSign; }

    static bool GetMPMode() { return mpMode; }


    PhysicalProperties * GetPhysicalProperties();

    virtual const char* ClassId() = 0;

    static void EnableSpikeBatching();

    virtual float* InitializeLookupTable(int index) = 0;

    virtual float* GetTableParams(int index, int& numParams) = 0;

    typedef vector<Synapse*>::iterator iterator;
    typedef vector<Synapse*>::const_iterator const_iterator;
    typedef vector<Synapse*>::reverse_iterator reverse_iterator;
    typedef vector<Synapse*>::const_reverse_iterator const_reverse_iterator;

    iterator begin() { return axon.begin(); }
    iterator end() { return axon.end(); }
    const_iterator begin() const { return axon.begin(); }
    const_iterator end() const { return axon.end(); }
    reverse_iterator rbegin() { return axon.rbegin(); }
    reverse_iterator rend() { return axon.rend(); }
    const_reverse_iterator rbegin() const { return axon.rbegin(); }
    const_reverse_iterator rend() const { return axon.rend(); }

protected:
    // Functions:

    static void SetMPMode(bool mode) { mpMode = mode; }

    virtual void InputSpike(SynapseItr& inSynapse,
                            AmTimeInt inTime,
                            unsigned int numSyn = 0) = 0;

    virtual void SetMaxScaledWeight();

    virtual void Train(AmTimeInt& spikeTime);

    void SendSMPSpike(AmTimeInt& now);

    virtual int SetLookupTables(FunctionLookup* funcRef) = 0;

    inline void RoundTime(AmTimeInt& time);

    // Data:
    AmIdInt nId;

    LayerType layerType;
    bool inhibitory;

    static SpikeOutput* spikeOutput;  // Output class shared by all instances of Neuron
    static bool defaultOutputObj;   // Flag indicating that the default amygOutput
                                    // object is being used.
    static bool enforceSign;

    // Time constants
    float memTimeConst;             // Membrane time constant (ms)
    float synTimeConst;             // Synaptic time constant (ms)
    float refPeriod;                // Refractory time period (ms)

    // Learning parameters
    float synPotConst;              // Synaptic potentiation constant
    float synDepConst;              // Synaptic depression constant
    float learningMax;              // Relative time of max weight increase (ms)
    float posLearnTimeConst;        // Positive learning time const (t+) (ms)
    float negLearnTimeConst;        // Negative learning time const (t-) (ms)
    float learningConst;            // Learning constant

    // Potentials have mV units
    float thresholdPtnl;            // Threshold potential (theta)
    float restPtnl;                 // u-r  (unused)
    float membranePtnl;             // u-i  (unused)

    // Needed for calculation of spike times -- see InputSpike() for comments
    float maxThreshCrs;
    float convergeRes;

    /*
     * Times are measured in microseconds since the begining
     * of the simulation. These will eventually be changed
     * to 64-bit integers to allow for longer simulations
     * (32-bit integers will roll over after about an hour).
     */
    AmTimeInt schedSpikeTime;    // time of next scheduled spike
    AmTimeInt spikeTime;         // time of last spike
    AmTimeInt currTime;          // current simulation time - set in InputSpike()
    AmTimeInt inputTime;         // time of last received spike

    static AmTimeInt simStepSize;       // simulation step size in us
    static bool recordOutput;
    static OutputMode outputMode;

    // Also need some vars relevant to the training rule...
    // Get those out of the Hebbian Learning paper
    bool trainingMode;              // Training indicator
    
    Network* SNet;                  // Parent Network

    int axonSize;                   // number of outputs
    //int dendriteSize;               // number of inputs
    int initAxonSize;               // initial size of output
    float maxScaledWeight;          // scaling factor for normalized weights

    vector<Synapse*> axon;

    struct SynapseHist {
        AmTimeInt time;
        Synapse* syn;
    };
    vector<SynapseHist> synapseHist;

    struct InputHist {
        float weight;
        AmTimeInt time;
    };

    vector<InputHist> inputHist;
    unsigned int histBeginIdx;

    vector <SMPSynapse*> smpAxon;

    unsigned int pspLSize;       // array size
    unsigned int pspStepSize;    // size of time increment in pspLookup (in us)

    // Obsolete -- now used as a flag in SetTimeConstants to indicate
    // that the lookup tables have been filled.  A new method
    // for doing that should be developed.
    bool usePspLookup;

    PhysicalProperties physicalProperties;

private:

    void SendSpike(AmTimeInt& now);

    void AddSynapse(Synapse* synapse);

    void AddSMPSynapse(SMPSynapse* synapse);

    void SetTableDimensions(int tblSize, int tblRes);

    void SetDefaults();

    float GetMaxScaledWeight() const { return maxScaledWeight; }

    static bool mpMode;
    static bool spikeDelaysOn;

    friend class Network;
    friend class MpNetwork;
};

inline void Neuron::RoundTime(AmTimeInt& time)
{
    float tmpTime;
    float roundTime;

    tmpTime = float(time) / pspStepSize;
    tmpTime = modff(tmpTime, &roundTime);
    if (tmpTime > 0.5) {
        time = (int(roundTime) * pspStepSize) + pspStepSize;
    }
    else {
        time = int(roundTime) * pspStepSize;
    }
}

#endif

---