#include <SeqSynHandler.h>

Inheritance diagram for SeqSynHandler:

Collaboration diagram for SeqSynHandler:

Public Member Functions
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)

void	fixSynapseOrder ()

double	getBaseScale () const

vector< double >	getHistory () const

double	getHistoryTime () const

vector< double >	getKernel () const

string	getKernelEquation () const

unsigned int	getKernelWidth () const

double	getPlasticityScale () const

double	getSeqActivation () const

double	getSeqDt () const

double	getSequencePower () const

double	getSequenceScale () const

vector< unsigned int >	getSynapseOrder () const

int	getSynapseOrderOption () const

double	getTopSpike (unsigned int index) const

vector< double >	getWeightScaleVec () const

int	numHistory () const

SeqSynHandler &	operator= (const SeqSynHandler &other)

void	refillSynapseOrder (unsigned int newSize)

	SeqSynHandler ()

void	setBaseScale (double v)

void	setHistoryTime (double v)

void	setKernelEquation (string eq)

void	setKernelWidth (unsigned int v)

void	setPlasticityScale (double v)

void	setSeqDt (double v)

void	setSequencePower (double v)

void	setSequenceScale (double v)

void	setSynapseOrder (vector< unsigned int > v)

void	setSynapseOrderOption (int v)

unsigned int	vGetNumSynapses () const

Synapse *	vGetSynapse (unsigned int i)

void	vProcess (const Eref &e, ProcPtr p)

void	vReinit (const Eref &e, ProcPtr p)

void	vSetNumSynapses (unsigned int num)

	~SeqSynHandler ()

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 Member Functions
void	updateKernel ()

Private Attributes
double	baseScale_
	Scaling factor for baseline synaptic responses. More...

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

RollingMatrix	history_
	Kernel for seq selectivity. More...

double	historyTime_
	Time to store history. KernelDt defines num of rows. More...

vector< vector< double > >	kernel_

string	kernelEquation_

unsigned int	kernelWidth_

vector< double >	latestSpikes_

double	plasticityScale_

double	seqActivation_

double	seqDt_

double	sequencePower_

double	sequenceScale_
	Scaling factor for sequence recognition responses. More...

vector< unsigned int >	synapseOrder_
	Rows = time; cols = synInputs. More...

int	synapseOrderOption_

vector< Synapse >	synapses_

vector< double >	weightScaleVec_

Detailed Description

This handles synapses organized sequentially. The parent class SimpleSynHandler deals with the mechanics of data arrival. Here the algorithm is 0. Assume all synaptic input comes on a linear dendrite.

Maintain a history of depth D for synaptic activity. May be simplest to do as event list (sparse matrix) rather than full matrix.
Maintain a kernel of how to weight time and space
Here we have various options 3.1 At each spike event, decide how to weight it based on history. 3.2 At each timestep, compute an effective Gk and send to activation. This will be moderately nasty to compute

Definition at line 26 of file SeqSynHandler.h.

Constructor & Destructor Documentation

SeqSynHandler::SeqSynHandler ( )

Definition at line 209 of file SeqSynHandler.cpp.

References history_, numHistory(), and RollingMatrix::resize().

     :
         kernelEquation_( "" ),
         kernelWidth_( 5 ),
         historyTime_( 2.0 ),
         seqDt_ ( 1.0 ),
         baseScale_( 0.0 ),
         sequenceScale_( 1.0 ),
         plasticityScale_( 0.0 ),
         sequencePower_( 1.0 ),
         seqActivation_( 0.0 ),
         synapseOrderOption_( -1 ) // sequential ordering
 {
     history_.resize( numHistory(), 0 );
 }

Here is the call graph for this function:

SeqSynHandler::~SeqSynHandler ( )

Definition at line 225 of file SeqSynHandler.cpp.

226 { ; }

Member Function Documentation

void SeqSynHandler::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 502 of file SeqSynHandler.cpp.

References events_, latestSpikes_, synapseOrder_, and synapses_.

 {
     assert( index < synapses_.size() );
     events_.push( PreSynEvent( index, time, weight ) );
     // Strictly speaking this isn't right. If we have a long time lag
     // then the correct placement of the spike may be in another time
     // slice. For now, to get it going for LIF neurons, this will do.
     // Even in the general case we will probably have a very wide window
     // for the latestSpikes slice.
     //
     // Here we reorder the entries in latestSpikes by the synapse order.
     latestSpikes_[ synapseOrder_[index] ] += weight;
 }

unsigned int SeqSynHandler::addSynapse ( )

virtual

Adds a new synapse, returns its index.

Implements SynHandlerBase.

Definition at line 523 of file SeqSynHandler.cpp.

References synapses_.

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

void SeqSynHandler::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 531 of file SeqSynHandler.cpp.

References synapses_.

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

void SeqSynHandler::fixSynapseOrder ( )

Definition at line 276 of file SeqSynHandler.cpp.

References synapseOrder_.

Referenced by refillSynapseOrder(), and setSynapseOrder().

 {
     unsigned int sz = synapseOrder_.size();
     vector< unsigned int > availableEntries( sz );
     iota( availableEntries.begin(), availableEntries.end(), 0 );
     for( unsigned int i = 0; i < sz; ++i ) {
         if ( synapseOrder_[i] < sz )
             availableEntries[ synapseOrder_[i] ] = sz;
     }
     vector< unsigned int > ae;
     for( unsigned int i = 0; i < sz; ++i )
         if ( availableEntries[i] < sz )
             ae.push_back( availableEntries[i] );
 
     auto jj = ae.begin();
     for( unsigned int i = 0; i < sz; ++i ) {
         if ( synapseOrder_[i] >= sz )
             synapseOrder_[i] = *jj++;
     }
 }

Here is the caller graph for this function:

double SeqSynHandler::getBaseScale ( ) const

Definition at line 409 of file SeqSynHandler.cpp.

References baseScale_.

Referenced by initCinfo().

 {
     return baseScale_;
 }

Here is the caller graph for this function:

vector< double > SeqSynHandler::getHistory ( ) const

Definition at line 464 of file SeqSynHandler.cpp.

References RollingMatrix::get(), history_, numHistory(), and vGetNumSynapses().

Referenced by initCinfo().

 {
     int nh = numHistory();
     int numX = vGetNumSynapses();
     vector< double > ret( numX * nh, 0.0 );
     vector< double >::iterator k = ret.begin();
     for ( int i = 0; i < nh; ++i ) {
         for ( int j = 0; j < numX; ++j )
             *k++ = history_.get( i, j );
     }
     return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double SeqSynHandler::getHistoryTime ( ) const

Definition at line 399 of file SeqSynHandler.cpp.

References historyTime_.

Referenced by initCinfo().

 {
     return historyTime_;
 }

Here is the caller graph for this function:

vector< double > SeqSynHandler::getKernel ( ) const

Definition at line 454 of file SeqSynHandler.cpp.

References kernel_, and numHistory().

Referenced by initCinfo().

 {
     int nh = numHistory();
     vector< double > ret;
     for ( int i = 0; i < nh; ++i ) {
         ret.insert( ret.end(), kernel_[i].begin(), kernel_[i].end() );
     }
     return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

string SeqSynHandler::getKernelEquation ( ) const

Definition at line 364 of file SeqSynHandler.cpp.

References kernelEquation_.

Referenced by initCinfo().

 {
     return kernelEquation_;
 }

Here is the caller graph for this function:

unsigned int SeqSynHandler::getKernelWidth ( ) const

Definition at line 375 of file SeqSynHandler.cpp.

References kernelWidth_.

Referenced by initCinfo().

 {
     return kernelWidth_;
 }

Here is the caller graph for this function:

double SeqSynHandler::getPlasticityScale ( ) const

Definition at line 429 of file SeqSynHandler.cpp.

References plasticityScale_.

Referenced by initCinfo().

 {
     return plasticityScale_;
 }

Here is the caller graph for this function:

double SeqSynHandler::getSeqActivation ( ) const

Definition at line 424 of file SeqSynHandler.cpp.

References seqActivation_.

Referenced by initCinfo().

 {
     return seqActivation_;
 }

Here is the caller graph for this function:

double SeqSynHandler::getSeqDt ( ) const

Definition at line 387 of file SeqSynHandler.cpp.

References seqDt_.

Referenced by initCinfo().

 {
     return seqDt_;
 }

Here is the caller graph for this function:

double SeqSynHandler::getSequencePower ( ) const

Definition at line 439 of file SeqSynHandler.cpp.

References sequencePower_.

Referenced by initCinfo().

 {
     return sequencePower_;
 }

Here is the caller graph for this function:

double SeqSynHandler::getSequenceScale ( ) const

Definition at line 419 of file SeqSynHandler.cpp.

References sequenceScale_.

Referenced by initCinfo().

 {
     return sequenceScale_;
 }

Here is the caller graph for this function:

vector< unsigned int > SeqSynHandler::getSynapseOrder ( ) const

Definition at line 484 of file SeqSynHandler.cpp.

References synapseOrder_.

Referenced by initCinfo().

 {
     return synapseOrder_;
 }

Here is the caller graph for this function:

int SeqSynHandler::getSynapseOrderOption ( ) const

Definition at line 495 of file SeqSynHandler.cpp.

References synapseOrderOption_.

Referenced by initCinfo().

 {
     return synapseOrderOption_;
 }

Here is the caller graph for this function:

double SeqSynHandler::getTopSpike ( unsigned int index ) const

virtual

Implements SynHandlerBase.

Definition at line 516 of file SeqSynHandler.cpp.

References events_.

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

vector< double > SeqSynHandler::getWeightScaleVec ( ) const

Definition at line 449 of file SeqSynHandler.cpp.

References weightScaleVec_.

Referenced by initCinfo().

 {
     return weightScaleVec_;
 }

Here is the caller graph for this function:

const Cinfo * SeqSynHandler::initCinfo ( )

static

Definition at line 20 of file SeqSynHandler.cpp.

References getBaseScale(), getHistory(), getHistoryTime(), getKernel(), getKernelEquation(), getKernelWidth(), SynHandlerBase::getNumSynapses(), getPlasticityScale(), getSeqActivation(), getSeqDt(), getSequencePower(), getSequenceScale(), SynHandlerBase::getSynapse(), getSynapseOrder(), getSynapseOrderOption(), getWeightScaleVec(), Synapse::initCinfo(), SynHandlerBase::initCinfo(), seqSynHandlerCinfo, setBaseScale(), setHistoryTime(), setKernelEquation(), setKernelWidth(), SynHandlerBase::setNumSynapses(), setPlasticityScale(), setSeqDt(), setSequencePower(), setSequenceScale(), setSynapseOrder(), and setSynapseOrderOption().

 {
     static string doc[] =
     {
         "Name", "SeqSynHandler",
         "Author", "Upi Bhalla",
         "Description",
         "The SeqSynHandler handles synapses that recognize sequentially "
             "ordered input, where the ordering is both in space and time. "
             "It assumes that the N input synapses are ordered and "
             "equally spaced along a single linear vector.\n "
             "To do this it maintains a record of recent synaptic input, "
             "for a duration of *historyTime*, at a time interval *seqDt*. "
             "*SeqDt* is typically longer than the simulation "
             "timestep *dt* for the synapse, and cannot be shorter. "
             "*SeqDt* should represent the characteristic time of advance "
             "of the sequence. \n"
             "The SeqSynHandler uses a 2-D kernel to define how to recognize"
             " a sequence, with dependence both on space and history. "
             "This kernel is defined by the *kernelEquation* as a "
             "mathematical expression in x (synapse number) and t (time)."
             "It computes a vector with the local *response* term for each "
             "point along all inputs, by taking a 2-d convolution of the "
             "kernel with the history[time][synapse#] matrix."
             "\nThe local response can affect the synapse in three ways: "
             "1. It can sum the entire response vector, scale by the "
             "*sequenceScale* term, and send to the synapse as a steady "
             "activation. Consider this a cell-wide immediate response to "
             "a sequence that it likes.\n"
             "2. It do an instantaneous scaling of the weight of each "
             "individual synapse by the corresponding entry in the response "
             "vector. It uses the *plasticityScale* term to do this. "
             "Consider "
             "this a short-term plasticity effect on specific synapses. \n"
             "3. It can do long-term plasticity of each individual synapse "
             "using the matched local entries in the response vector and "
             "individual synapse history as inputs to the learning rule. "
             "This is not yet implemented.\n"
             "In addition to all these, the SeqSynHandler can act just like "
             "a regular synapse, where it responds to individual synaptic "
             "input according to the weight of the synapse. The size of "
             "this component of the output is scaled by *baseScale*\n"
     };
 
     static FieldElementFinfo< SynHandlerBase, Synapse > synFinfo(
         "synapse",
         "Sets up field Elements for synapse",
         Synapse::initCinfo(),
         &SynHandlerBase::getSynapse,
         &SynHandlerBase::setNumSynapses,
         &SynHandlerBase::getNumSynapses
     );
 
     static ValueFinfo< SeqSynHandler, string > kernelEquation(
             "kernelEquation",
             "Equation in x and t to define kernel for sequence recognition",
             &SeqSynHandler::setKernelEquation,
             &SeqSynHandler::getKernelEquation
     );
     static ValueFinfo< SeqSynHandler, unsigned int > kernelWidth(
             "kernelWidth",
             "Width of kernel, i.e., number of synapses taking part in seq.",
             &SeqSynHandler::setKernelWidth,
             &SeqSynHandler::getKernelWidth
     );
     static ValueFinfo< SeqSynHandler, double > seqDt(
             "seqDt",
             "Characteristic time for advancing the sequence.",
             &SeqSynHandler::setSeqDt,
             &SeqSynHandler::getSeqDt
     );
     static ValueFinfo< SeqSynHandler, double > historyTime(
             "historyTime",
             "Duration to keep track of history of inputs to all synapses.",
             &SeqSynHandler::setHistoryTime,
             &SeqSynHandler::getHistoryTime
     );
     static ValueFinfo< SeqSynHandler, double > baseScale(
             "baseScale",
             "Basal scaling factor for regular synaptic activation.",
             &SeqSynHandler::setBaseScale,
             &SeqSynHandler::getBaseScale
     );
     static ValueFinfo< SeqSynHandler, double > sequenceScale(
             "sequenceScale",
             "Scaling factor for sustained activation of synapse by seq",
             &SeqSynHandler::setSequenceScale,
             &SeqSynHandler::getSequenceScale
     );
     static ValueFinfo< SeqSynHandler, vector< unsigned int > > synapseOrder(
             "synapseOrder",
             "Mapping of synapse input order to spatial order on syn array."
             "Entries in this vector are indices which must remain smaller "
             "than numSynapses. The system will fix up if you mess up. "
             "It does not insist on unique mappings, but these are "
             "desirable as outcome is undefined for repeated entries.",
             &SeqSynHandler::setSynapseOrder,
             &SeqSynHandler::getSynapseOrder
     );
     static ValueFinfo< SeqSynHandler, int > synapseOrderOption(
             "synapseOrderOption",
             "How to do the synapse order remapping. This rule stays in "
             "place and guarantees safe mappings even if the number of "
             "synapses is altered. Options:\n"
             "-2: User ordering.\n"
             "-1: Sequential ordering, 0 to numSynapses-1.\n"
             "0: Random ordering using existing system seed.\n"
             ">0: Random ordering using seed specified by this number\n"
             "Default is -1, sequential ordering.",
             &SeqSynHandler::setSynapseOrderOption,
             &SeqSynHandler::getSynapseOrderOption
     );
     static ReadOnlyValueFinfo< SeqSynHandler, double > seqActivation(
             "seqActivation",
             "Reports summed activation of synaptic channel by sequence",
             &SeqSynHandler::getSeqActivation
     );
     static ValueFinfo< SeqSynHandler, double > plasticityScale(
             "plasticityScale",
             "Scaling factor for doing plasticity by scaling each synapse by response vector",
             &SeqSynHandler::setPlasticityScale,
             &SeqSynHandler::getPlasticityScale
     );
 
     static ValueFinfo< SeqSynHandler, double > sequencePower(
             "sequencePower",
             "Exponent for the outcome of the sequential calculations. "
             "This is needed because linear summation of terms in the kernel"
             "means that a brief stong sequence match is no better than lots"
             "of successive low matches. In other words, 12345 is no better"
             "than 11111. Using an exponent lets us select the former."
             "Defaults to 1.0.",
             &SeqSynHandler::setSequencePower,
             &SeqSynHandler::getSequencePower
     );
 
     static ReadOnlyValueFinfo< SeqSynHandler, vector< double > >
             weightScaleVec(
             "weightScaleVec",
             "Vector of  weight scaling for each synapse",
             &SeqSynHandler::getWeightScaleVec
     );
     static ReadOnlyValueFinfo< SeqSynHandler, vector< double > > kernel(
             "kernel",
             "All entries of kernel, as a linear vector",
             &SeqSynHandler::getKernel
     );
     static ReadOnlyValueFinfo< SeqSynHandler, vector< double > > history(
             "history",
             "All entries of history, as a linear vector",
             &SeqSynHandler::getHistory
     );
 
     static Finfo* seqSynHandlerFinfos[] = {
         &synFinfo,                  // FieldElement
         &kernelEquation,            // Field
         &kernelWidth,               // Field
         &seqDt,                     // Field
         &historyTime,               // Field
         &sequenceScale,             // Field
         &baseScale,                 // Field
         &synapseOrder,              // Field
         &synapseOrderOption,        // Field
         &seqActivation,             // ReadOnlyField
         &plasticityScale,           // Field
         &sequencePower,             // Field
         &weightScaleVec,            // ReadOnlyField
         &kernel,                    // ReadOnlyField
         &history                    // ReadOnlyField
     };
 
     static Dinfo< SeqSynHandler > dinfo;
     static Cinfo seqSynHandlerCinfo (
         "SeqSynHandler",
         SynHandlerBase::initCinfo(),
         seqSynHandlerFinfos,
         sizeof( seqSynHandlerFinfos ) / sizeof ( Finfo* ),
         &dinfo,
         doc,
         sizeof( doc ) / sizeof( string )
     );
 
     return &seqSynHandlerCinfo;
 }

Here is the call graph for this function:

int SeqSynHandler::numHistory ( ) const

Definition at line 601 of file SeqSynHandler.cpp.

References historyTime_, and seqDt_.

Referenced by getHistory(), getKernel(), SeqSynHandler(), setHistoryTime(), setSeqDt(), updateKernel(), vProcess(), and vSetNumSynapses().

 {
     return static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
 }

Here is the caller graph for this function:

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

Definition at line 229 of file SeqSynHandler.cpp.

References events_, and synapses_.

 {
     synapses_ = ssh.synapses_;
     for ( vector< Synapse >::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();
 
     return *this;
 }

void SeqSynHandler::refillSynapseOrder ( unsigned int newSize )

Definition at line 309 of file SeqSynHandler.cpp.

References fixSynapseOrder(), moose::mtrand(), moose::mtseed(), synapseOrder_, and synapseOrderOption_.

Referenced by setSynapseOrderOption(), and vSetNumSynapses().

 {
     if ( synapseOrderOption_ <= -2 ) { // User order
         synapseOrder_.resize( newSize, newSize );
         fixSynapseOrder();
     } else if ( synapseOrderOption_ == -1 ) { // Ordered
         synapseOrder_.resize( newSize );
         for ( unsigned int i = 0 ; i < newSize; ++i )
             synapseOrder_[i] = i;
     } else {
         synapseOrder_.resize( newSize );
         if ( synapseOrderOption_ > 0 ) { // Specify seed explicitly
                     moose::mtseed( synapseOrderOption_ );
         }
         vector< double > x;
         for ( unsigned int i = 0; i < newSize; ++i )
             x.push_back( moose::mtrand() );
         auto idx = sort_indexes< double >( x );
         for ( unsigned int i = 0; i < newSize; ++i )
             synapseOrder_[i] = idx[i];
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::setBaseScale ( double v )

Definition at line 404 of file SeqSynHandler.cpp.

References baseScale_.

Referenced by initCinfo().

 {
     baseScale_ = v;
 }

Here is the caller graph for this function:

void SeqSynHandler::setHistoryTime ( double v )

Definition at line 392 of file SeqSynHandler.cpp.

References history_, historyTime_, numHistory(), RollingMatrix::resize(), updateKernel(), and vGetNumSynapses().

Referenced by initCinfo().

 {
     historyTime_ = v;
     history_.resize( numHistory(), vGetNumSynapses() );
     updateKernel();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::setKernelEquation ( string eq )

Definition at line 358 of file SeqSynHandler.cpp.

References kernelEquation_, and updateKernel().

Referenced by initCinfo().

 {
     kernelEquation_ = eq;
     updateKernel();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::setKernelWidth ( unsigned int v )

Definition at line 369 of file SeqSynHandler.cpp.

References kernelWidth_, and updateKernel().

Referenced by initCinfo().

 {
     kernelWidth_ = v;
     updateKernel();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::setPlasticityScale ( double v )

Definition at line 434 of file SeqSynHandler.cpp.

References plasticityScale_.

Referenced by initCinfo().

 {
     plasticityScale_ = v;
 }

Here is the caller graph for this function:

void SeqSynHandler::setSeqDt ( double v )

Definition at line 380 of file SeqSynHandler.cpp.

References history_, numHistory(), RollingMatrix::resize(), seqDt_, updateKernel(), and vGetNumSynapses().

Referenced by initCinfo().

 {
     seqDt_ = v;
     updateKernel();
     history_.resize( numHistory(), vGetNumSynapses() );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::setSequencePower ( double v )

Definition at line 444 of file SeqSynHandler.cpp.

References sequencePower_.

Referenced by initCinfo().

 {
     sequencePower_ = v;
 }

Here is the caller graph for this function:

void SeqSynHandler::setSequenceScale ( double v )

Definition at line 414 of file SeqSynHandler.cpp.

References sequenceScale_.

Referenced by initCinfo().

 {
     sequenceScale_ = v;
 }

Here is the caller graph for this function:

void SeqSynHandler::setSynapseOrder ( vector< unsigned int > v )

Definition at line 477 of file SeqSynHandler.cpp.

References fixSynapseOrder(), synapseOrder_, and synapseOrderOption_.

Referenced by initCinfo().

 {
     synapseOrder_ = v;
     fixSynapseOrder();
     synapseOrderOption_ = -2; // Set the flag to say it is User defined.
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::setSynapseOrderOption ( int v )

Definition at line 489 of file SeqSynHandler.cpp.

References refillSynapseOrder(), synapseOrder_, and synapseOrderOption_.

Referenced by initCinfo().

 {
     synapseOrderOption_ = v;
     refillSynapseOrder( synapseOrder_.size() );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SeqSynHandler::updateKernel ( )

private

Definition at line 332 of file SeqSynHandler.cpp.

References historyTime_, kernel_, kernelEquation_, kernelWidth_, M_E, M_PI, numHistory(), and seqDt_.

Referenced by setHistoryTime(), setKernelEquation(), setKernelWidth(), setSeqDt(), and vSetNumSynapses().

 {
     if ( kernelEquation_ == "" || seqDt_ < 1e-9 || historyTime_ < 1e-9 )
         return;
     double x = 0;
     double t = 0;
     mu::Parser p;
     p.DefineVar("x", &x);
     p.DefineVar("t", &t);
     p.DefineConst(_T("pi"), (mu::value_type)M_PI);
     p.DefineConst(_T("e"), (mu::value_type)M_E);
     p.SetExpr( kernelEquation_ );
     kernel_.clear();
     int nh = numHistory();
     kernel_.resize( nh );
     for ( int i = 0; i < nh; ++i ) {
         kernel_[i].resize( kernelWidth_ );
         t = i * seqDt_;
         for ( unsigned int j = 0; j < kernelWidth_; ++j ) {
             x = j;
             kernel_[i][j] = p.Eval();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int SeqSynHandler::vGetNumSynapses ( ) const

virtual

Implements SynHandlerBase.

Definition at line 257 of file SeqSynHandler.cpp.

References synapses_.

Referenced by getHistory(), setHistoryTime(), setSeqDt(), and vProcess().

 {
     return synapses_.size();
 }

Here is the caller graph for this function:

Synapse * SeqSynHandler::vGetSynapse ( unsigned int i )

virtual

Implements SynHandlerBase.

Definition at line 262 of file SeqSynHandler.cpp.

References dummy, and synapses_.

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

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

virtual

Implements SynHandlerBase.

Definition at line 538 of file SeqSynHandler.cpp.

References SynHandlerBase::activationOut(), baseScale_, RollingMatrix::correl(), ProcInfo::currTime, ProcInfo::dt, events_, history_, kernel_, latestSpikes_, numHistory(), plasticityScale_, RollingMatrix::rollToNextRow(), seqActivation_, seqDt_, sequencePower_, sequenceScale_, RollingMatrix::sumIntoRow(), vGetNumSynapses(), and weightScaleVec_.

 {
     // Here we look at the correlations and do something with them.
     int nh = numHistory();
 
     // Check if we need to do correlations at all.
     if ( nh > 0 && kernel_.size() > 0 ) {
         // Check if timestep rolls over a seqDt boundary
         if ( static_cast< int >( p->currTime / seqDt_ ) >
                 static_cast< int >( (p->currTime - p->dt) / seqDt_ ) ) {
             history_.rollToNextRow();
             history_.sumIntoRow( latestSpikes_, 0 );
             latestSpikes_.assign( vGetNumSynapses(), 0.0 );
 
             // Build up the sum of correlations over time
             vector< double > correlVec( vGetNumSynapses(), 0.0 );
             for ( int i = 0; i < nh; ++i )
                 history_.correl( correlVec, kernel_[i], i );
             if ( sequenceScale_ > 0.0 ) { // Sum all responses, send to chan
                 seqActivation_ = 0.0;
                 for ( vector< double >::iterator y = correlVec.begin();
                                 y != correlVec.end(); ++y )
                     seqActivation_ += pow( *y, sequencePower_ );
 
                 // We'll use the seqActivation_ to send a special msg.
                 seqActivation_ *= sequenceScale_;
             }
             if ( plasticityScale_ > 0.0 ) { // Short term changes in individual wts
                 weightScaleVec_ = correlVec;
                 for ( vector< double >::iterator y=weightScaleVec_.begin();
                             y != weightScaleVec_.end(); ++y )
                     *y *= plasticityScale_;
             }
         }
     }
 
     // Here we go through the regular synapse activation calculations.
     // We can't leave it to the base class vProcess, because we need
     // to scale the weights individually in some cases.
     double activation = seqActivation_; // Start with seq activation
     if ( plasticityScale_ > 0.0 ) {
         while( !events_.empty() && events_.top().time <= p->currTime ) {
             activation += events_.top().weight * baseScale_ *
                     weightScaleVec_[ events_.top().synIndex ] / p->dt;
             events_.pop();
         }
     } else {
         while( !events_.empty() && events_.top().time <= p->currTime ) {
             activation += baseScale_ * events_.top().weight / p->dt;
             events_.pop();
         }
     }
     if ( activation != 0.0 )
         SynHandlerBase::activationOut()->send( e, activation );
 }

Here is the call graph for this function:

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

virtual

Implements SynHandlerBase.

Definition at line 594 of file SeqSynHandler.cpp.

References events_.

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

void SeqSynHandler::vSetNumSynapses ( unsigned int num )

virtual

Implements SynHandlerBase.

Definition at line 243 of file SeqSynHandler.cpp.

References history_, latestSpikes_, numHistory(), refillSynapseOrder(), RollingMatrix::resize(), synapses_, updateKernel(), and weightScaleVec_.

 {
     unsigned int prevSize = synapses_.size();
     synapses_.resize( v );
     for ( unsigned int i = prevSize; i < v; ++i )
         synapses_[i].setHandler( this );
 
     history_.resize( numHistory(), v );
     latestSpikes_.resize( v, 0.0 );
     weightScaleVec_.resize( v, 0.0 );
     refillSynapseOrder( v );
     updateKernel();
 }

Here is the call graph for this function:

Member Data Documentation

double SeqSynHandler::baseScale_

private

Scaling factor for baseline synaptic responses.

Definition at line 105 of file SeqSynHandler.h.

Referenced by getBaseScale(), setBaseScale(), and vProcess().

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

private

Definition at line 156 of file SeqSynHandler.h.

Referenced by addSpike(), getTopSpike(), operator=(), vProcess(), and vReinit().

RollingMatrix SeqSynHandler::history_

private

Kernel for seq selectivity.

Definition at line 138 of file SeqSynHandler.h.

Referenced by getHistory(), SeqSynHandler(), setHistoryTime(), setSeqDt(), vProcess(), and vSetNumSynapses().

double SeqSynHandler::historyTime_

private

Time to store history. KernelDt defines num of rows.

Definition at line 102 of file SeqSynHandler.h.

Referenced by getHistoryTime(), numHistory(), setHistoryTime(), and updateKernel().

vector< vector< double > > SeqSynHandler::kernel_

private

Definition at line 137 of file SeqSynHandler.h.

Referenced by getKernel(), updateKernel(), and vProcess().

string SeqSynHandler::kernelEquation_

private

Definition at line 98 of file SeqSynHandler.h.

Referenced by getKernelEquation(), setKernelEquation(), and updateKernel().

unsigned int SeqSynHandler::kernelWidth_

private

Definition at line 99 of file SeqSynHandler.h.

Referenced by getKernelWidth(), setKernelWidth(), and updateKernel().

vector< double > SeqSynHandler::latestSpikes_

private

Definition at line 134 of file SeqSynHandler.h.

Referenced by addSpike(), vProcess(), and vSetNumSynapses().

double SeqSynHandler::plasticityScale_

private

Scaling factor for short-term plastic weight changes in each synapse arising from sequential input.

Definition at line 113 of file SeqSynHandler.h.

Referenced by getPlasticityScale(), setPlasticityScale(), and vProcess().

double SeqSynHandler::seqActivation_

private

Definition at line 126 of file SeqSynHandler.h.

Referenced by getSeqActivation(), and vProcess().

double SeqSynHandler::seqDt_

private

Definition at line 103 of file SeqSynHandler.h.

Referenced by getSeqDt(), numHistory(), setSeqDt(), updateKernel(), and vProcess().

double SeqSynHandler::sequencePower_

private

Exponent to use for the outcome of the sequential calculations. This is needed because linear summation of terms in the kernel means that a brief stong sequence match is no better than lots of successive low matches. In other words, 12345 is no better than 11111.

Definition at line 122 of file SeqSynHandler.h.

Referenced by getSequencePower(), setSequencePower(), and vProcess().

double SeqSynHandler::sequenceScale_

private

Scaling factor for sequence recognition responses.

Definition at line 107 of file SeqSynHandler.h.

Referenced by getSequenceScale(), setSequenceScale(), and vProcess().

vector< unsigned int > SeqSynHandler::synapseOrder_

private

Rows = time; cols = synInputs.

Remaps synapse order to avoid correlations based on presynaptic object Id order, or on connection building order. This undesirable ordering occurs even when random synaptic projections are used. User can alter as preferred. This is simply a look up table so that the incoming synapse index is remapped: index_on_Handler = synapseOrder_[original_syn_index] This must only have numbers from zero to numSynapses, and should normally have all the numbers.

Definition at line 149 of file SeqSynHandler.h.

Referenced by addSpike(), fixSynapseOrder(), getSynapseOrder(), refillSynapseOrder(), setSynapseOrder(), and setSynapseOrderOption().