SeqSynHandler.h

Go to the documentation of this file.

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           Copyright (C) 2016 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/

#ifndef _SEQ_SYN_HANDLER_H
#define _SEQ_SYN_HANDLER_H

class SeqSynHandler: public SynHandlerBase
{
    public:
        SeqSynHandler();
        ~SeqSynHandler();
        SeqSynHandler& operator=( const SeqSynHandler& other );

        // Over-ridden virtual functions
        void vSetNumSynapses( unsigned int num );
        unsigned int vGetNumSynapses() const;
        Synapse* vGetSynapse( unsigned int i );
        void vProcess( const Eref& e, ProcPtr p );
        void vReinit( const Eref& e, ProcPtr p );

        unsigned int addSynapse();
        void dropSynapse( unsigned int droppedSynNumber );
        void addSpike( unsigned int index, double time, double weight );
        double getTopSpike( unsigned int index ) const;
        // New fields.
        void setKernelEquation( string eq );
        string getKernelEquation() const;
        void setKernelWidth( unsigned int v );
        unsigned int getKernelWidth() const;
        void setSeqDt( double v );
        double getSeqDt() const;
        void setHistoryTime( double v );
        double getHistoryTime() const;
        void setBaseScale( double v );
        double getBaseScale() const;
        void setSequenceScale( double v );
        double getSequenceScale() const;
        void setSynapseOrder( vector< unsigned int> v );
        vector< unsigned int> getSynapseOrder() const;
        void setSynapseOrderOption( int v );
        int getSynapseOrderOption() const;
        double getSeqActivation() const; // summed activation of syn chan
        void setPlasticityScale( double v );
        double getPlasticityScale() const;
        void setSequencePower( double v );
        double getSequencePower() const;
        vector< double > getWeightScaleVec() const;
        vector< double > getKernel() const;
        vector< double > getHistory() const;

        // Utility func
        int numHistory() const;
        void refillSynapseOrder( unsigned int newSize );
        void fixSynapseOrder();
        static const Cinfo* initCinfo();
    private:
        void updateKernel();
        /*
         * Here I would like to put in a sparse matrix.
         * Each timestep is a row
         * Each column is a neuron
         * Each value is the weight, though I could also look this up.
         * I need to make it a circular buffer.
         * The 'addRow' function inserts the non-zero entries representing
         *  neurons that are active on this timestep. As a circular buffer
         *  this needs to do some allocation juggling.
         * Need a new function similar to computeRowRate, basically a
         * dot product of input vector with specified row.
         * Then run through all available places.
         */
        string kernelEquation_;
        unsigned int kernelWidth_; // Width in terms of number of synapses

        double historyTime_;
        double seqDt_;  // Time step for successive entries in kernel
        double baseScale_;
        double sequenceScale_;

        double plasticityScale_;

        double sequencePower_;

        // Some readonly fields
        double seqActivation_; // global activation if sequence recognized

        // Weight scaling based on individual synapse sequence tuning.
        vector< double > weightScaleVec_;

        // Tracks the spikes that came in recently, as input to correlation
        // analysis for sequence recognition.
        vector< double > latestSpikes_;

        vector< vector<  double > > kernel_; 
        RollingMatrix history_; 

        vector< unsigned int > synapseOrder_;

        int synapseOrderOption_;

        vector< Synapse > synapses_;
        priority_queue< PreSynEvent, vector< PreSynEvent >, CompareSynEvent > events_;


};

#endif // _SEQ_SYN_HANDLER_H