iaf_psc_alpha_presc.h

Go to the documentation of this file.

/*
 *  iaf_psc_alpha_presc.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST 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.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef IAF_PSC_ALPHA_PRESC_H
#define IAF_PSC_ALPHA_PRESC_H

#include "config.h"

#include "nest.h"
#include "event.h"
#include "node.h"
#include "ring_buffer.h"
#include "connection.h"

#include "universal_data_logger.h"

#include <vector>

/*BeginDocumentation
  Name: iaf_psc_alpha_presc - Leaky integrate-and-fire neuron
  with alpha-shape postsynaptic currents; prescient implementation.

  Description: 
  iaf_psc_alpha_presc is the "prescient" implementation of the leaky
  integrate-and-fire model neuron with alpha-shaped postsynaptic
  currents in the sense of [1].  

  PSCs are normalized to an amplitude of 1pA.

  The prescient implementation predicts the effect of spikes arriving
  during a time step by exactly integrating their effect from the
  precise time of spike arrival to the end of the time step.  This is
  exact if the neuron was not refractory at the beginning of the
  interval and remains subthreshold throughout the
  interval. Subthreshold dynamics are integrated using exact integration
  between events [2].

  Parameters: 
  The following parameters can be set in the status dictionary.

 
  V_m          double - Membrane potential in mV 
  E_L          double - Resting membrane potential in mV. 
  V_min        double - Absolute lower value for the membrane potential.
  C_m          double - Capacity of the membrane in pF
  tau_m        double - Membrane time constant in ms.
  t_ref        double - Duration of refractory period in ms. 
  V_th         double - Spike threshold in mV.
  V_reset      double - Reset potential of the membrane in mV.
  tau_syn      double - Rise time of the synaptic alpha function in ms.
  I_e          double - Constant external input current in pA.
  Interpol_Order  int - Interpolation order for spike time: 
                        0-none, 1-linear, 2-quadratic, 3-cubic

  Remarks:
  Please note that this node is capable of sending precise spike times
  to target nodes (on-grid spike time plus offset). If this node is
  connected to a spike_detector, the property "precise_times" of the
  spike_detector has to be set to true in order to record the offsets
  in addition to the on-grid spike times.

  Note:
  tau_m != tau_syn is required by the current implementation to avoid a
  degenerate case of the ODE describing the model [1]. For very similar values,
  numerics will be unstable.
 
  References:
  [1] Morrison A, Straube S, Plesser H E, & Diesmann M (2006) Exact Subthreshold 
  Integration with Continuous Spike Times in Discrete Time Neural Network 
  Simulations. To appear in Neural Computation.
  [2] Rotter S & Diesmann M (1999) Exact simulation of time-invariant linear
  systems with applications to neuronal modeling. Biologial Cybernetics
  81:381-402.
        
  Author: Diesmann, Eppler, Morrison, Plesser, Straube

  Sends: SpikeEvent

  Receives: SpikeEvent, CurrentEvent, DataLoggingRequest
  
  SeeAlso: iaf_psc_alpha, iaf_psc_alpha_canon, iaf_psc_delta_canon

*/ 

namespace nest{

  class iaf_psc_alpha_presc:
  public Node
  {

    class Network;
    
  public:        
    
    iaf_psc_alpha_presc();

    iaf_psc_alpha_presc(const iaf_psc_alpha_presc&);

    using Node::handle;
    using Node::handles_test_event;

    port send_test_event(Node &, rport, synindex, bool);
    
    void handle(SpikeEvent &);
    void handle(CurrentEvent &);
    void handle(DataLoggingRequest &);

    port handles_test_event(SpikeEvent&, rport);
    port handles_test_event(CurrentEvent&, rport);
    port handles_test_event(DataLoggingRequest &, rport);

    bool is_off_grid() const {return true;}  // uses off_grid events

    void get_status(DictionaryDatum &) const;
    void set_status(const DictionaryDatum &) ;

  private:

    void init_state_(const Node& proto);
    void init_buffers_();
    void calibrate();

    void update(Time const & origin, const long_t from, const long_t to);
    

    Time get_spiketime() const;
    void set_spiketime(Time const &);

    double_t update_y3_delta_() const;


    enum interpOrder { NO_INTERPOL, LINEAR, QUADRATIC, CUBIC, END_INTERP_ORDER };

    double_t thresh_find_(const double_t) const;
    double_t thresh_find1_(const double_t) const;
    double_t thresh_find2_(const double_t) const;
    double_t thresh_find3_(const double_t) const;

    // The next two classes need to be friends to access the State_ class/member
    friend class RecordablesMap<iaf_psc_alpha_presc>;
    friend class UniversalDataLogger<iaf_psc_alpha_presc>;

    // ---------------------------------------------------------------- 

    struct Parameters_ {

      double_t tau_m_; 

      double_t tau_syn_;

      double_t c_m_;
    
      double_t t_ref_;

      double_t E_L_;

      double_t I_e_;

      double_t U_th_;

      double_t U_min_;

      double_t U_reset_;

      interpOrder Interpol_;

      Parameters_();  

      void get(DictionaryDatum&) const;  

      double set(const DictionaryDatum&);
    };
    
    // ---------------------------------------------------------------- 

    struct State_ {
      double_t y0_; 
      double_t y1_; 
      double_t y2_; 
      double_t y3_; 
      
      long_t   r_ ; 

      long_t   last_spike_step_;   
      double_t last_spike_offset_; 
      
      State_();  
      
      void get(DictionaryDatum&, const Parameters_&) const;

      void set(const DictionaryDatum&, const Parameters_&, double);
    };
    
    // ---------------------------------------------------------------- 

    struct Buffers_ {
      Buffers_(iaf_psc_alpha_presc&);
      Buffers_(const Buffers_&, iaf_psc_alpha_presc&);

      RingBuffer spike_y1_;  
      RingBuffer spike_y2_;  
      RingBuffer spike_y3_;  
      RingBuffer currents_; 

      UniversalDataLogger<iaf_psc_alpha_presc> logger_;
    };

    // ---------------------------------------------------------------- 

    struct Variables_ { 
      double_t y0_before_; 
      double_t y1_before_; 
      double_t y2_before_; 
      double_t y3_before_; 

      double_t h_ms_;             
      double_t PSCInitialValue_;  
      double_t gamma_;            
      double_t gamma_sq_;         
      double_t expm1_tau_m_;      
      double_t expm1_tau_syn_;    
      double_t P30_;              
      double_t P31_;              
      double_t P32_;              

      long_t   refractory_steps_; 
    };
    
    // Access functions for UniversalDataLogger -------------------------------

    double_t get_V_m_() const { return S_.y3_ + P_.E_L_; }

    // ---------------------------------------------------------------- 

    Parameters_ P_;
    State_      S_;
    Variables_  V_;
    Buffers_    B_;
   static RecordablesMap<iaf_psc_alpha_presc> recordablesMap_;

  };
    
      
 
inline
port nest::iaf_psc_alpha_presc::send_test_event(Node& target, rport receptor_type, synindex, bool)
{
  SpikeEvent e;
  e.set_sender(*this);
  return target.handles_test_event(e, receptor_type);
}
  
inline
port iaf_psc_alpha_presc::handles_test_event(SpikeEvent&, rport receptor_type)
{
  if (receptor_type != 0)
    throw UnknownReceptorType(receptor_type, get_name());
  return 0;
}
 
inline
port iaf_psc_alpha_presc::handles_test_event(CurrentEvent&, rport receptor_type)
{
  if (receptor_type != 0)
    throw UnknownReceptorType(receptor_type, get_name());
  return 0;
}
 
inline
port iaf_psc_alpha_presc::handles_test_event(DataLoggingRequest& dlr, 
                       rport receptor_type)
{
  if (receptor_type != 0)
    throw UnknownReceptorType(receptor_type, get_name());
  return B_.logger_.connect_logging_device(dlr, recordablesMap_);
}

  inline
    void iaf_psc_alpha_presc::get_status(DictionaryDatum &d) const
  {
    P_.get(d);
    S_.get(d, P_);
    (*d)[names::recordables] = recordablesMap_.get_list();
  }
  
  inline
    void iaf_psc_alpha_presc::set_status(const DictionaryDatum &d)
  {
    Parameters_ ptmp = P_;  // temporary copy in case of errors
    const double delta_EL = ptmp.set(d);                       // throws if BadProperty
    State_      stmp = S_;  // temporary copy in case of errors
    stmp.set(d, ptmp, delta_EL);                 // throws if BadProperty
    
    // if we get here, temporaries contain consistent set of properties
    P_ = ptmp;
    S_ = stmp;
  }
  
} // namespace

#endif //IAF_PSC_ALPHA_PRESC_H