void nest::iaf_psc_alpha_mod::handle(SpikeEvent & e) { assert(e.get_delay() > 0); // port 0: spikes are normally handled. if(e.get_rport() == 0 ){ if(e.get_weight() > 0.0) B_.ex_spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); else B_.in_spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); } // port 1: spikes act as modulators for all spikes that arrive at.... if(e.get_rport() == 1 ){ B_.modspikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); } // ....port 2. These weights get modulated. if(e.get_rport() == 2 ){ if(e.get_weight() > 0.0){ double tmpweight = e.get_weight() * (1.0 + S_.ymod_) ; tmpweight = (tmpweight > P_.max_weight_ ? P_.max_weight_ : tmpweight); B_.ex_spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), tmpweight * e.get_multiplicity() ); } else B_.in_spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); } }
void nest::spike_detector::handle( SpikeEvent& e ) { // accept spikes only if detector was active when spike was // emitted if ( device_.is_active( e.get_stamp() ) ) { assert( e.get_multiplicity() > 0 ); long dest_buffer; if ( kernel() .modelrange_manager.get_model_of_gid( e.get_sender_gid() ) ->has_proxies() ) // events from central queue dest_buffer = kernel().event_delivery_manager.read_toggle(); else // locally delivered events dest_buffer = kernel().event_delivery_manager.write_toggle(); for ( int i = 0; i < e.get_multiplicity(); ++i ) { // We store the complete events Event* event = e.clone(); B_.spikes_[ dest_buffer ].push_back( event ); } } }
void nest::iaf_cond_delta::handle(SpikeEvent & e) { assert(e.get_delay() > 0); if(e.get_weight() > 0.0) B_.spikes_ex_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); else B_.spikes_in_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), -e.get_weight() * e.get_multiplicity() ); // note: conductance is positive for both exc and inh synapses but we use the sign of spike event weight to distinguish which kind of synapse it is }
void nest::hh_psc_alpha::handle(SpikeEvent & e) { assert(e.get_delay() > 0); if(e.get_weight() > 0.0) B_.spike_exc_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); else B_.spike_inh_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); // current input, keep negative weight }
void nest::aeif_cond_exp::handle(SpikeEvent &e) { assert ( e.get_delay() > 0 ); if(e.get_weight() > 0.0) B_.spike_exc_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity()); else B_.spike_inh_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), -e.get_weight() * e.get_multiplicity()); // keep conductances positive }
void nest::iaf_tum_2000::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); if ( e.get_weight() >= 0.0 ) B_.spikes_ex_.add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); else B_.spikes_in_.add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::amat2_psc_exp::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); if ( e.get_weight() >= 0.0 ) B_.spikes_ex_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); else B_.spikes_in_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::sli_neuron::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); if ( e.get_weight() > 0.0 ) B_.ex_spikes_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); else B_.in_spikes_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::iaf_cond_exp_sfa_rr::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); if ( e.get_weight() > 0.0 ) B_.spike_exc_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); else B_.spike_inh_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), -e.get_weight() * e.get_multiplicity() ); // ensure conductance is positive }
// function handles exact spike times void nest::iaf_psc_alpha_presc::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); const long_t Tdeliver = e.get_rel_delivery_steps( nest::kernel().simulation_manager.get_slice_origin() ); const double_t spike_weight = V_.PSCInitialValue_ * e.get_weight() * e.get_multiplicity(); const double_t dt = e.get_offset(); // Building the new matrix for the offset of the spike // NOTE: We do not use get matrix, but compute only those // components we actually need for spike registration // needed in any case const double_t ps_e_TauSyn = numerics::expm1( -dt / P_.tau_syn_ ); const double_t ps_e_Tau = numerics::expm1( -dt / P_.tau_m_ ); const double_t ps_P31 = V_.gamma_sq_ * ps_e_Tau - V_.gamma_sq_ * ps_e_TauSyn - dt * V_.gamma_ * ps_e_TauSyn - dt * V_.gamma_; B_.spike_y1_.add_value( Tdeliver, spike_weight * ps_e_TauSyn + spike_weight ); B_.spike_y2_.add_value( Tdeliver, spike_weight * dt * ps_e_TauSyn + spike_weight * dt ); B_.spike_y3_.add_value( Tdeliver, spike_weight * ps_P31 ); }
void nest::volume_transmitter::handle( SpikeEvent& e ) { B_.neuromodulatory_spikes_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), static_cast< double_t >( e.get_multiplicity() ) ); }
void nest::izhikevich::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); B_.spikes_.add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::izhikevich::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); B_.spikes_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::iaf_neuron_dif_alpha::handle(SpikeEvent & e) { assert(e.get_delay() > 0); B_.spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); //std::cout<<"spike handle "<<e.get_stamp().get_ms()<<"\n"; }
void nest::hh_cond_exp_traub::handle(SpikeEvent & e) { assert(e.get_delay() > 0); if(e.get_weight() > 0.0) { B_.spike_exc_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity()); } else { // add with negative weight, ie positive value, since we are changing a // conductance B_.spike_inh_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), -e.get_weight() * e.get_multiplicity()); } }
void iaf_psc_alpha_multisynapse::handle( SpikeEvent& e ) { assert( e.get_delay_steps() > 0 ); B_.spikes_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::aeif_cond_alpha_RK5::handle( SpikeEvent& e ) { assert( e.get_delay_steps() > 0 ); if ( e.get_weight() > 0.0 ) { B_.spike_exc_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); } else { B_.spike_inh_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), -e.get_weight() * e.get_multiplicity() ); } // keep conductances positive }
void nest::iaf_tum_2000::handle( SpikeEvent& e ) { assert( e.get_delay_steps() > 0 ); if ( e.get_weight() >= 0.0 ) { B_.spikes_ex_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); } else { B_.spikes_in_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); } }
void mynest::coronet_neuron::handle(SpikeEvent & e) { assert(e.get_delay() > 0); assert(e.get_rport() < static_cast<int_t>(B_.spike_inputs_.size())); B_.spike_inputs_[e.get_rport()]. add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight() * e.get_multiplicity() ); }
void aeif_cond_alpha_multisynapse::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); assert( ( e.get_rport() > 0 ) && ( ( size_t ) e.get_rport() <= P_.num_of_receptors_ ) ); if ( e.get_weight() > 0.0 ) { B_.spike_exc_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); } else { B_.spike_inh_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), -e.get_weight() * e.get_multiplicity() ); // keep conductances positive } }
void nest::iaf_cond_alpha_mc::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); assert( 0 <= e.get_rport() && e.get_rport() < 2 * NCOMP ); B_.spikes_[ e.get_rport() ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void nest::ht_neuron::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); assert( e.get_rport() < static_cast< int_t >( B_.spike_inputs_.size() ) ); B_.spike_inputs_[ e.get_rport() ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void gif_psc_exp_multisynapse::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); assert( ( e.get_rport() > 0 ) && ( ( size_t ) e.get_rport() <= P_.n_receptors_() ) ); B_.spikes_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void pif_psc_delta_canon_cvv::handle(SpikeEvent & e) { assert(e.get_delay() > 0); /* We need to compute the absolute time stamp of the delivery time of the spike, since spikes might spend longer than min_delay_ in the queue. The time is computed according to Time Memo, Rule 3. */ const long_t Tdeliver = e.get_stamp().get_steps() + e.get_delay() - 1; B_.events_.add_spike(e.get_rel_delivery_steps(network()->get_slice_origin()), Tdeliver, e.get_offset(), e.get_weight() * e.get_multiplicity()); }
void nest::iaf_psc_delta::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); // EX: We must compute the arrival time of the incoming spike // explicity, since it depends on delay and offset within // the update cycle. The way it is done here works, but // is clumsy and should be improved. B_.spikes_.add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); }
void iaf_psc_alpha_multisynapse::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); for ( size_t i = 0; i < P_.num_of_receptors_; ++i ) { if ( P_.receptor_types_[ i ] == e.get_rport() ) { B_.spikes_[ i ].add_value( e.get_rel_delivery_steps( network()->get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); } } }
void iaf_psc_alpha::handle( SpikeEvent& e ) { assert( e.get_delay() > 0 ); const double s = e.get_weight() * e.get_multiplicity(); if ( e.get_weight() > 0.0 ) B_.ex_spikes_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), s ); else B_.in_spikes_.add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), s ); }
void ginzburg::handle(SpikeEvent & e) { assert(e.get_delay() > 0); // The following logic implements the encoding: // A single spike signals a transition to 0 state, two spikes in same time step // signal the transition to 1 state. // // Remember the global id of the sender of the last spike being received // this assumes that several spikes being sent by the same neuron in the same time step // are received consecutively or are conveyed by setting the multiplicity accordingly. long_t m = e.get_multiplicity(); long_t gid = e.get_sender_gid(); const Time &t_spike = e.get_stamp(); if (m == 1) { //multiplicity == 1, either a single 1->0 event or the first or second of a pair of 0->1 events if (gid == S_.last_in_gid_ && t_spike == S_.t_last_in_spike_) { // received twice the same gid, so transition 0->1 // take double weight to compensate for subtracting first event B_.spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), 2.0*e.get_weight()); } else { // count this event negatively, assuming it comes as single event // transition 1->0 B_.spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), -e.get_weight()); } } else // multiplicity != 1 if (m == 2) { // count this event positively, transition 0->1 B_.spikes_.add_value(e.get_rel_delivery_steps(network()->get_slice_origin()), e.get_weight()); } S_.last_in_gid_ = gid; S_.t_last_in_spike_ = t_spike; }
// function handles exact spike times void parrot_neuron_ps::handle( SpikeEvent& e ) { // Repeat only spikes incoming on port 0, port 1 will be ignored if ( 0 == e.get_rport() ) { assert( e.get_delay() > 0 ); // We need to compute the absolute time stamp of the delivery time // of the spike, since spikes might spend longer than min_delay_ // in the queue. The time is computed according to Time Memo, Rule 3. const long_t Tdeliver = e.get_stamp().get_steps() + e.get_delay() - 1; // parrot ignores weight of incoming connection, store multiplicity B_.events_.add_spike( e.get_rel_delivery_steps( nest::kernel().simulation_manager.get_slice_origin() ), Tdeliver, e.get_offset(), static_cast< double_t >( e.get_multiplicity() ) ); } }
void nest::correlospinmatrix_detector::handle( SpikeEvent& e ) { // The receiver port identifies the sending node in our // sender list. const rport curr_i = e.get_rport(); // If this assertion breaks, the sender does not honor the // receiver port during connection or sending. assert( 0 <= curr_i && curr_i <= P_.N_channels_ - 1 ); // accept spikes only if detector was active when spike was emitted Time const stamp = e.get_stamp(); if ( device_.is_active( stamp ) ) { // The following logic implements the decoding // A single spike signals a transition to 0 state, two spikes in same time step // signal the transition to 1 state. // // Remember the global id of the sender of the last spike being received // this assumes that several spikes being sent by the same neuron in the same time step // are received consecutively or are conveyed by setting the multiplicity accordingly. long_t m = e.get_multiplicity(); bool down_transition = false; if ( m == 1 ) { // multiplicity == 1, either a single 1->0 event or the first or second of a pair of 0->1 // events if ( curr_i == S_.last_i_ && stamp == S_.t_last_in_spike_ ) { // received twice the same gid, so transition 0->1 // revise the last event written to the buffer S_.curr_state_[ curr_i ] = true; S_.last_change_[ curr_i ] = stamp.get_steps(); S_.tentative_down_ = false; // previous event was first event of two, so no down transition } else { // count this event negatively, assuming it comes as single event // transition 1->0 // assume it will stay alone, so meaning a down tansition if ( S_.tentative_down_ ) // really was a down transition, because we now have another event { down_transition = true; } S_.tentative_down_ = true; } } else // multiplicity != 1 if ( m == 2 ) { S_.curr_state_[ curr_i ] = true; if ( S_.tentative_down_ ) // really was a down transition, because we now have another double { // event down_transition = true; } S_.curr_state_[ S_.last_i_ ] = false; S_.last_change_[ curr_i ] = stamp.get_steps(); S_.tentative_down_ = false; // previous event was first event of two, so no down transition } if ( down_transition ) // only do something on the downtransitions { long_t i = S_.last_i_; // index of neuron making the down transition long_t t_i_on = S_.last_change_[ i ]; // last time point of change, must have been on const long_t t_i_off = S_.t_last_in_spike_.get_steps(); // throw out all binary pulses from event list that are too old to enter the correlation // window BinaryPulselistType& otherPulses = S_.incoming_; // calculate the minimum of those neurons that switched on and are not off yet // every impulse in the queue that is further in the past than // this minimum - tau_max cannot contribute to the count covariance long_t t_min_on = t_i_on; for ( int n = 0; n < P_.N_channels_; n++ ) { if ( S_.curr_state_[ n ] ) { if ( S_.last_change_[ n ] < t_min_on ) { t_min_on = S_.last_change_[ n ]; } } } const double_t tau_edge = P_.tau_max_.get_steps() + P_.delta_tau_.get_steps(); const delay min_delay = Scheduler::get_min_delay(); while ( !otherPulses.empty() && ( t_min_on - otherPulses.front().t_off_ ) >= tau_edge + min_delay ) otherPulses.pop_front(); // insert new event into history // must happen here so event is taken into account in autocorrelation const BinaryPulse_ bp_i( t_i_on, t_i_off, i ); BinaryPulselistType::iterator insert_pos = std::find_if( S_.incoming_.begin(), S_.incoming_.end(), std::bind2nd( std::greater< BinaryPulse_ >(), bp_i ) ); // insert before the position we have found // if no element greater found, insert_pos == end(), so append at the end of the deque S_.incoming_.insert( insert_pos, bp_i ); // go through history of other binary pulses for ( BinaryPulselistType::const_iterator pulse_j = otherPulses.begin(); pulse_j != otherPulses.end(); ++pulse_j ) { // id of other neuron long_t j = pulse_j->receptor_channel_; long_t t_j_on = pulse_j->t_on_; long_t t_j_off = pulse_j->t_off_; // minimum and maximum time difference in histogram long_t Delta_ij_min = std::max( t_j_on - t_i_off, -P_.tau_max_.get_steps() ); long_t Delta_ij_max = std::min( t_j_off - t_i_on, P_.tau_max_.get_steps() ); long_t t0 = P_.tau_max_.get_steps() / P_.delta_tau_.get_steps(); long_t dt = P_.delta_tau_.get_steps(); // zero time lag covariance long_t l = std::min( t_i_off, t_j_off ) - std::max( t_i_on, t_j_on ); if ( l > 0 ) { S_.count_covariance_[ i ][ j ][ t0 ] += l; if ( i != j ) { S_.count_covariance_[ j ][ i ][ t0 ] += l; } } // non-zero time lag covariance for ( long_t Delta = Delta_ij_min / dt; Delta < 0; Delta++ ) { long_t l = std::min( t_i_off, t_j_off - Delta * dt ) - std::max( t_i_on, t_j_on - Delta * dt ); if ( l > 0 ) { S_.count_covariance_[ i ][ j ][ t0 - Delta ] += l; S_.count_covariance_[ j ][ i ][ t0 + Delta ] += l; } } if ( i != j ) { for ( long_t Delta = 1; Delta <= Delta_ij_max / dt; Delta++ ) { long_t l = std::min( t_i_off, t_j_off - Delta * dt ) - std::max( t_i_on, t_j_on - Delta * dt ); if ( l > 0 ) { S_.count_covariance_[ i ][ j ][ t0 - Delta ] += l; S_.count_covariance_[ j ][ i ][ t0 + Delta ] += l; } } } } // loop over history S_.last_change_[ i ] = t_i_off; } // down transition happened S_.last_i_ = curr_i; S_.t_last_in_spike_ = stamp; } // device active }