#include <STDPSynHandler.h>

Inheritance diagram for STDPSynHandler:

Collaboration diagram for STDPSynHandler:

Public Member Functions
void	addPostSpike (const Eref &e, double time)

void	addSpike (unsigned int index, double time, double weight)

unsigned int	addSynapse ()
	Adds a new synapse, returns its index. More...

void	dropSynapse (unsigned int droppedSynNumber)

double	getAMinus () const

double	getAMinus0 () const

double	getAPlus0 () const

double	getTauMinus () const

double	getTauPlus () const

double	getTopSpike (unsigned int index) const

double	getWeightMax () const

double	getWeightMin () const

STDPSynHandler &	operator= (const STDPSynHandler &other)

void	setAMinus (double v)

void	setAMinus0 (double v)

void	setAPlus0 (double v)

void	setTauMinus (double v)

void	setTauPlus (double v)

void	setWeightMax (double v)

void	setWeightMin (double v)

	STDPSynHandler ()

unsigned int	vGetNumSynapses () const

STDPSynapse *	vGetSynapse (unsigned int i)

void	vProcess (const Eref &e, ProcPtr p)

void	vReinit (const Eref &e, ProcPtr p)

void	vSetNumSynapses (unsigned int num)

	~STDPSynHandler ()

Public Member Functions inherited from SynHandlerBase
unsigned int	getNumSynapses () const

Synapse *	getSynapse (unsigned int i)

void	process (const Eref &e, ProcPtr p)

bool	rangeWarning (const string &field, double value)

void	reinit (const Eref &e, ProcPtr p)

void	setNumSynapses (unsigned int num)

	SynHandlerBase ()

virtual	~SynHandlerBase ()

Static Public Member Functions
static const Cinfo *	initCinfo ()

Static Public Member Functions inherited from SynHandlerBase
static SrcFinfo1< double > *	activationOut ()

static const Cinfo *	initCinfo ()

Private Attributes
double	aMinus0_

double	aMinus_

double	aPlus0_

priority_queue< PreSynEvent, vector< PreSynEvent > , CompareSynEvent >	events_

priority_queue< PostSynEvent, vector< PostSynEvent > , ComparePostSynEvent >	postEvents_

vector< STDPSynapse >	synapses_

double	tauMinus_

double	tauPlus_

double	weightMax_

double	weightMin_

Detailed Description

This handles simple synapses without plasticity. It uses a priority queue to manage them. This gets inefficient for large numbers of synapses but is pretty robust.

Definition at line 61 of file STDPSynHandler.h.

Constructor & Destructor Documentation

STDPSynHandler::STDPSynHandler ( )

Definition at line 132 of file STDPSynHandler.cpp.

References aMinus0_, aMinus_, aPlus0_, tauMinus_, tauPlus_, weightMax_, and weightMin_.

 {
     aMinus_ = 0.0;
     tauMinus_ = 1.0;
     aMinus0_ = 0.0;
     tauPlus_ = 1.0;
     aPlus0_ = 0.0;
     weightMin_ = 0.0;
     weightMax_ = 0.0;
 }

STDPSynHandler::~STDPSynHandler ( )

Definition at line 143 of file STDPSynHandler.cpp.

144 { ; }

Member Function Documentation

void STDPSynHandler::addPostSpike	(	const Eref &	e,
		double	time
	)

Definition at line 200 of file STDPSynHandler.cpp.

References postEvents_.

Referenced by initCinfo().

 {
     postEvents_.push( PostSynEvent( time ) );
 }

Here is the caller graph for this function:

void STDPSynHandler::addSpike	(	unsigned int	index,
		double	time,
		double	weight
	)

virtual

Record arrival of a new spike event. The 'time' is time for eventual arrival of the spike, and is typically well in the future. The index specifies which synapse the spike came to.

Implements SynHandlerBase.

Definition at line 186 of file STDPSynHandler.cpp.

References events_, and synapses_.

 {
     assert( index < synapses_.size() );
     events_.push( PreSynEvent( index, time, weight ) );
 }

unsigned int STDPSynHandler::addSynapse ( )

virtual

Adds a new synapse, returns its index.

Implements SynHandlerBase.

Definition at line 304 of file STDPSynHandler.cpp.

References synapses_.

 {
     unsigned int newSynIndex = synapses_.size();
     synapses_.resize( newSynIndex + 1 );
     synapses_[newSynIndex].setHandler( this );
     return newSynIndex;
 }

void STDPSynHandler::dropSynapse ( unsigned int droppedSynNumber )

virtual

Drops an existing synapse, triggered by deleteMsg of an input to the child synapse. This is a little messy because we can't change the indices of the other synapses. The Handler has to figure out how to handle the 'holes' in its array of synapses.

Implements SynHandlerBase.

Definition at line 313 of file STDPSynHandler.cpp.

References synapses_.

 {
     assert( msgLookup < synapses_.size() );
     synapses_[msgLookup].setWeight( -1.0 );
 }

double STDPSynHandler::getAMinus ( ) const

Definition at line 334 of file STDPSynHandler.cpp.

References aMinus_.

Referenced by initCinfo().

 {
     return aMinus_;
 }

Here is the caller graph for this function:

double STDPSynHandler::getAMinus0 ( ) const

Definition at line 324 of file STDPSynHandler.cpp.

References aMinus0_.

Referenced by initCinfo().

 {
     return aMinus0_;
 }

Here is the caller graph for this function:

double STDPSynHandler::getAPlus0 ( ) const

Definition at line 355 of file STDPSynHandler.cpp.

References aPlus0_.

Referenced by initCinfo().

 {
     return aPlus0_;
 }

Here is the caller graph for this function:

double STDPSynHandler::getTauMinus ( ) const

Definition at line 345 of file STDPSynHandler.cpp.

References tauMinus_.

Referenced by initCinfo().

 {
     return tauMinus_;
 }

Here is the caller graph for this function:

double STDPSynHandler::getTauPlus ( ) const

Definition at line 366 of file STDPSynHandler.cpp.

References tauPlus_.

Referenced by initCinfo().

 {
     return tauPlus_;
 }

Here is the caller graph for this function:

double STDPSynHandler::getTopSpike ( unsigned int index ) const

virtual

Implements SynHandlerBase.

Definition at line 193 of file STDPSynHandler.cpp.

References events_.

 {
     if ( events_.empty() )
         return 0.0;
     return events_.top().time;
 }

double STDPSynHandler::getWeightMax ( ) const

Definition at line 376 of file STDPSynHandler.cpp.

References weightMax_.

Referenced by initCinfo().

 {
     return weightMax_;
 }

Here is the caller graph for this function:

double STDPSynHandler::getWeightMin ( ) const

Definition at line 386 of file STDPSynHandler.cpp.

References weightMin_.

Referenced by initCinfo().

 {
     return weightMin_;
 }

Here is the caller graph for this function:

const Cinfo * STDPSynHandler::initCinfo ( )

static

Definition at line 18 of file STDPSynHandler.cpp.

References addPostSpike(), getAMinus(), getAMinus0(), getAPlus0(), SynHandlerBase::getNumSynapses(), SynHandlerBase::getSynapse(), getTauMinus(), getTauPlus(), getWeightMax(), getWeightMin(), STDPSynapse::initCinfo(), SynHandlerBase::initCinfo(), setAMinus(), setAMinus0(), setAPlus0(), SynHandlerBase::setNumSynapses(), setTauMinus(), setTauPlus(), setWeightMax(), setWeightMin(), and synHandlerCinfo.

 {
     static string doc[] =
     {
         "Name", "STDPSynHandler",
         "Author", "Aditya Gilra",
         "Description",
         "The STDPSynHandler handles synapses with spike timing dependent plasticity (STDP). "
         "It uses two priority queues to manage pre and post spikes."
     };
 
     static ValueFinfo< STDPSynHandler, double > aMinus(
         "aMinus",
         "aMinus is a post-synaptic variable that keeps a decaying 'history' of previous post-spike(s)"
         "and is used to update the synaptic weight when a pre-synaptic spike appears."
         "It determines the t_pre > t_post (pre after post) part of the STDP window.",
         &STDPSynHandler::setAMinus,
         &STDPSynHandler::getAMinus
     );
 
     static ValueFinfo< STDPSynHandler, double > aMinus0(
         "aMinus0",
         "aMinus0 is added to aMinus on every pre-spike",
         &STDPSynHandler::setAMinus0,
         &STDPSynHandler::getAMinus0
     );
 
     static ValueFinfo< STDPSynHandler, double > tauMinus(
         "tauMinus",
         "aMinus decays with tauMinus time constant",
         &STDPSynHandler::setTauMinus,
         &STDPSynHandler::getTauMinus
     );
 
     static ValueFinfo< STDPSynHandler, double > aPlus0(
         "aPlus0",
         "aPlus0 is added to aPlus on every pre-spike",
         &STDPSynHandler::setAPlus0,
         &STDPSynHandler::getAPlus0
     );
 
     static ValueFinfo< STDPSynHandler, double > tauPlus(
         "tauPlus",
         "aPlus decays with tauPlus time constant",
         &STDPSynHandler::setTauPlus,
         &STDPSynHandler::getTauPlus
     );
 
     static ValueFinfo< STDPSynHandler, double > weightMax(
         "weightMax",
         "an upper bound on the weight",
         &STDPSynHandler::setWeightMax,
         &STDPSynHandler::getWeightMax
     );
 
     static ValueFinfo< STDPSynHandler, double > weightMin(
         "weightMin",
         "a lower bound on the weight",
         &STDPSynHandler::setWeightMin,
         &STDPSynHandler::getWeightMin
     );
 
     static DestFinfo addPostSpike( "addPostSpike",
         "Handles arriving spike messages from post-synaptic neuron, inserts into postEvent queue.",
         new EpFunc1< STDPSynHandler, double >( &STDPSynHandler::addPostSpike ) );
 
     static FieldElementFinfo< SynHandlerBase, STDPSynapse > synFinfo(
         "synapse",
         "Sets up field Elements for synapse",
         STDPSynapse::initCinfo(),
         /*
            below SynHandlerBase::getSynapse is a function that returns Synapse*,
            but I need to cast the returned pointer to an STDPSynapse*.
            Since I take the address (&) of SynHandlerBase::getSynapse
            which is: Synapse* (SynHandlerBase::*)(unsigned int),
            I need to cast the address of the function to:
            STDPSynapse* (SynHandlerBase::*)(unsigned int).
 
            This is required to put STDPSynapse in above FieldElementFinfo definition,
            see FieldElementFinfo template class in basecode/FieldElementFinfo.h
         */
         (STDPSynapse* (SynHandlerBase::*)(unsigned int)) &SynHandlerBase::getSynapse,
         &SynHandlerBase::setNumSynapses,
         &SynHandlerBase::getNumSynapses
     );
 
     static Finfo* STDPSynHandlerFinfos[] = {
         &synFinfo,          // FieldElement
         &addPostSpike,      // DestFinfo
         &aMinus0,           // Field
         &aMinus,            // Field
         &tauMinus,          // Field
         &aPlus0,            // Field
         &tauPlus,           // Field
         &weightMax,         // Field
         &weightMin          // Field
     };
 
     static Dinfo< STDPSynHandler > dinfo;
     static Cinfo synHandlerCinfo (
         "STDPSynHandler",
         SynHandlerBase::initCinfo(),
         STDPSynHandlerFinfos,
         sizeof( STDPSynHandlerFinfos ) / sizeof ( Finfo* ),
         &dinfo,
         doc,
         sizeof( doc ) / sizeof( string )
     );
 
     return &synHandlerCinfo;
 }

Here is the call graph for this function:

STDPSynHandler & STDPSynHandler::operator= ( const STDPSynHandler & other )

Definition at line 146 of file STDPSynHandler.cpp.

References events_, postEvents_, and synapses_.

 {
     synapses_ = ssh.synapses_;
     for ( vector< STDPSynapse >::iterator
                     i = synapses_.begin(); i != synapses_.end(); ++i )
             i->setHandler( this );
 
     // For no apparent reason, priority queues don't have a clear operation.
     while( !events_.empty() )
         events_.pop();
 
     while( !postEvents_.empty() )
         postEvents_.pop();
 
     return *this;
 }

void STDPSynHandler::setAMinus ( double v )

Definition at line 329 of file STDPSynHandler.cpp.

References aMinus_.

Referenced by initCinfo().

 {
     aMinus_ = v;
 }

Here is the caller graph for this function:

void STDPSynHandler::setAMinus0 ( double v )

Definition at line 319 of file STDPSynHandler.cpp.

References aMinus0_.

Referenced by initCinfo().

 {
     aMinus0_ = v;
 }

Here is the caller graph for this function:

void STDPSynHandler::setAPlus0 ( double v )

Definition at line 350 of file STDPSynHandler.cpp.

References aPlus0_.

Referenced by initCinfo().

 {
     aPlus0_ = v;
 }

Here is the caller graph for this function:

void STDPSynHandler::setTauMinus ( double v )

Definition at line 339 of file STDPSynHandler.cpp.

References SynHandlerBase::rangeWarning(), and tauMinus_.

Referenced by initCinfo().

 {
     if ( rangeWarning( "tauMinus", v ) ) return;
     tauMinus_ = v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void STDPSynHandler::setTauPlus ( double v )

Definition at line 360 of file STDPSynHandler.cpp.

References SynHandlerBase::rangeWarning(), and tauPlus_.

Referenced by initCinfo().

 {
     if ( rangeWarning( "tauPlus", v ) ) return;
     tauPlus_ = v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void STDPSynHandler::setWeightMax ( double v )

Definition at line 371 of file STDPSynHandler.cpp.

References weightMax_.

Referenced by initCinfo().

 {
     weightMax_ = v;
 }

Here is the caller graph for this function:

void STDPSynHandler::setWeightMin ( double v )

Definition at line 381 of file STDPSynHandler.cpp.

References weightMin_.

Referenced by initCinfo().

 {
     weightMin_ = v;
 }

Here is the caller graph for this function:

unsigned int STDPSynHandler::vGetNumSynapses ( ) const

virtual

Implements SynHandlerBase.

Definition at line 171 of file STDPSynHandler.cpp.

References synapses_.

 {
     return synapses_.size();
 }

STDPSynapse * STDPSynHandler::vGetSynapse ( unsigned int i )

virtual

Implements SynHandlerBase.

Definition at line 176 of file STDPSynHandler.cpp.

References dummy, and synapses_.

 {
     static STDPSynapse dummy;
     if ( i < synapses_.size() )
         return &synapses_[i];
     cout << "Warning: STDPSynHandler::getSynapse: index: " << i <<
         " is out of range: " << synapses_.size() << endl;
     return &dummy;
 }

void STDPSynHandler::vProcess	(	const Eref &	e,
		ProcPtr	p
	)

virtual

Implements SynHandlerBase.

Definition at line 205 of file STDPSynHandler.cpp.

References SynHandlerBase::activationOut(), aMinus0_, aMinus_, aPlus0_, ProcInfo::currTime, ProcInfo::dt, events_, STDPSynapse::getAPlus(), Synapse::getWeight(), postEvents_, STDPSynapse::setAPlus(), Synapse::setWeight(), synapses_, PreSynEvent::synIndex, tauMinus_, tauPlus_, SynEvent::weight, weightMax_, and weightMin_.

 {
     double activation = 0.0;
 
     // process pre-synaptic spike events for activation and STDP
     while( !events_.empty() && events_.top().time <= p->currTime ) {
         PreSynEvent currEvent = events_.top();
 
         unsigned int synIndex = currEvent.synIndex;
         // Warning, coder! 'STDPSynapse currSyn = synapses_[synIndex];' is wrong,
         // it creates a new, shallow-copied object.
         // We want only to point to the same object.
         STDPSynapse* currSynPtr = &synapses_[synIndex];
 
         // activate the synapse for every pre-spike
         // If the synapse has a delay, the weight could be updated during the delay!
         // currEvent.weight is the weight before the delay!
         // Might be better to use currSynPtr->getWeight()
         //      or even the latest updated weight below?!
         // Using currSynPtr->getWeight().
         // However, the weight update is done
         //          after sending the current weight to activation
 
         // See: http://www.genesis-sim.org/GENESIS/Hyperdoc/Manual-26.html#synchan
         // Send out weight / dt for every spike
         //      Since it is an impulse active only for one dt,
         //      need to send it divided by dt.
         // Can connect activation to SynChan (double exp)
         //      or to LIF as an impulse to voltage.
         //activation += currEvent.weight / p->dt;
         activation += currSynPtr->getWeight() / p->dt;
 
         // Maintain 'history' of pre-spikes in Aplus
         // Add aPlus0 to the aPlus for this synapse due to pre-spike
         currSynPtr->setAPlus( currSynPtr->getAPlus() + aPlus0_ );
 
         // Change weight by aMinus_ at each pre-spike
         // clip weight within [weightMin,weightMax]
         double newWeight = currEvent.weight + aMinus_;
         newWeight = std::max(weightMin_, std::min(newWeight, weightMax_));
         currSynPtr->setWeight( newWeight );
 
         events_.pop();
     }
     if ( activation != 0.0 )
         SynHandlerBase::activationOut()->send( e, activation );
 
     // process post-synaptic spike events for STDP
     while( !postEvents_.empty() && postEvents_.top().time <= p->currTime ) {
         // Add aMinus0 to the aMinus for this synapse
         aMinus_ += aMinus0_;
 
         // Change weight of all synapses by aPlus_ at each post-spike
         for (unsigned int i=0; i<synapses_.size(); i++) {
             // since aPlus_, tauPlus_ are private inside STDPSynapse,
             //   we use the set, get functions
             // Warning, coder! 'STDPSynapse currSyn = synapses_[i];' is wrong,
             // it creates a new, shallow-copied object.
             // We want only to point to the same object.
             STDPSynapse* currSynPtr = &synapses_[i];
             // clip weight within [weightMin,weightMax]
             double newWeight = currSynPtr->getWeight() + currSynPtr->getAPlus();
             newWeight = std::max(weightMin_, std::min(newWeight, weightMax_));
             currSynPtr->setWeight( newWeight );
         }
 
         postEvents_.pop();
     }
 
     // modify aPlus and aMinus at every time step
     // Future: I could make this event-driven. Would be faster.
     // Or have a field to set it to event-driven or continuous.
     double dt_ = p->dt;
     // decay aPlus for all pre-synaptic inputs
     for (unsigned int i=0; i<synapses_.size(); i++) {
         // forward Euler
         // since aPlus_, tauPlus_ are private inside STDPSynapse,
         //   we use the set, get functions
         // Warning, coder! 'STDPSynapse currSyn = synapses_[i];' is wrong,
         // it creates a new, shallow-copied object.
         // We want only to point to the same object.
         STDPSynapse* currSynPtr = &synapses_[i];
         currSynPtr->setAPlus( currSynPtr->getAPlus() * (1.0 - dt_/tauPlus_) );
     }
     // decay aMinus for this STDPSynHandler which sits on the post-synaptic compartment
     // forward Euler
     aMinus_ -= aMinus_/tauMinus_*dt_;
 
 }

Here is the call graph for this function:

void STDPSynHandler::vReinit	(	const Eref &	e,
		ProcPtr	p
	)

virtual

Implements SynHandlerBase.

Definition at line 295 of file STDPSynHandler.cpp.

References events_, and postEvents_.

 {
     // For no apparent reason, priority queues don't have a clear operation.
     while( !events_.empty() )
         events_.pop();
     while( !postEvents_.empty() )
         postEvents_.pop();
 }

void STDPSynHandler::vSetNumSynapses ( unsigned int num )

virtual

Implements SynHandlerBase.

Definition at line 163 of file STDPSynHandler.cpp.

References synapses_.

 {
     unsigned int prevSize = synapses_.size();
     synapses_.resize( v );
     for ( unsigned int i = prevSize; i < v; ++i )
         synapses_[i].setHandler( this );
 }