iaf_chxk_2008.h

Go to the documentation of this file.

/*
 *  iaf_chxk_2008.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_CHXK_2008_H
#define IAF_CHXK_2008_H

#include "config.h"

#ifdef HAVE_GSL

#include "nest.h"
#include "event.h"
#include "archiving_node.h"
#include "ring_buffer.h"
#include "connection.h"
#include "universal_data_logger.h"
#include "recordables_map.h"

#include <gsl/gsl_errno.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_odeiv.h>

/* BeginDocumentation
Name: iaf_chxk_2008 - Conductance based leaky integrate-and-fire neuron model used in
Casti et al 2008.

Description:
iaf_chxk_2008 is an implementation of a spiking neuron using IAF dynamics with
conductance-based synapses [1]. It is modeled after iaf_cond_alpha with the addition
of after hyperpolarization current instead of a membrane potential reset.
Incoming spike events induce a post-synaptic change
of conductance modeled by an alpha function. The alpha function
is normalized such that an event of weight 1.0 results in a peak current of 1 nS
at t = tau_syn.

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

V_m        double - Membrane potential in mV 
E_L        double - Leak reversal potential in mV.
C_m        double - Capacity of the membrane in pF
V_th       double - Spike threshold in mV.
E_ex       double - Excitatory reversal potential in mV.
E_in       double - Inhibitory reversal potential in mV.
g_L        double - Leak conductance in nS.
tau_ex     double - Rise time of the excitatory synaptic alpha function in ms.
tau_in     double - Rise time of the inhibitory synaptic alpha function in ms.
I_e        double - Constant input current in pA.
tau_ahp    double - Afterhyperpolarization (AHP) time constant in ms.
E_ahp      double - AHP potential in mV.
g_ahp      double - AHP conductance in nS.
ahp_bug    bool   - Defaults to false. If true, behaves like original model implementation.

References:
[1] Casti A, Hayot F, Xiao Y, and Kaplan E (2008) A simple model of retina-LGN transmission.
    J Comput Neurosci 24:235-252.

Sends: SpikeEvent

Receives: SpikeEvent, CurrentEvent

Author: Heiberg

SeeAlso: iaf_cond_alpha
*/

namespace nest
{
  extern "C"
  int iaf_chxk_2008_dynamics (double, const double*, double*, void*);

  class iaf_chxk_2008 : public Archiving_Node
  {
    
    // Boilerplate function declarations --------------------------------

  public:
    
    iaf_chxk_2008();
    iaf_chxk_2008(const iaf_chxk_2008&);
    ~iaf_chxk_2008();

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

    port send_test_event(Node&, rport, synindex, bool);

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

    port handles_test_event(SpikeEvent&, rport);
    port handles_test_event(CurrentEvent&, rport);
    port handles_test_event(DataLoggingRequest&, rport);
    
    void handle(SpikeEvent&);
    void handle(CurrentEvent&);
    void handle(DataLoggingRequest&); 
        
    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 &, const long_t, const long_t);

    // END Boilerplate function declarations ----------------------------

    // Friends --------------------------------------------------------

    // make dynamics function quasi-member
    friend int iaf_chxk_2008_dynamics(double, const double*, double*, void*);

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

  private:

    // Parameters class ------------------------------------------------- 

    struct Parameters_ {
      double_t V_th;        
      double_t g_L;         
      double_t C_m;         
      double_t E_ex;        
      double_t E_in;        
      double_t E_L;         
      double_t tau_synE;    
      double_t tau_synI;    
      double_t I_e;         
      double_t tau_ahp;     
      double_t g_ahp;       
      double_t E_ahp;       
      bool ahp_bug;         
      Parameters_();        

      void get(DictionaryDatum&) const;  
      void set(const DictionaryDatum&);  
    };
    
    // State variables class -------------------------------------------- 

  public:
    struct State_ {
      
      enum StateVecElems { V_M = 0,
               DG_EXC, G_EXC,     
               DG_INH, G_INH,
               DG_AHP, G_AHP,
               STATE_VEC_SIZE };

      double_t y[STATE_VEC_SIZE];
  
      int_t    r;

      State_(const Parameters_&);  
      State_(const State_&);
      State_& operator=(const State_&);

      void get(DictionaryDatum&) const;  

      void set(const DictionaryDatum&, const Parameters_&);
    };    
  private:

    // Buffers class -------------------------------------------------------- 

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

      UniversalDataLogger<iaf_chxk_2008> logger_;

      RingBuffer spike_exc_;
      RingBuffer spike_inh_;
      RingBuffer currents_;

      /* GSL ODE stuff */
      gsl_odeiv_step*    s_;    
      gsl_odeiv_control* c_;    
      gsl_odeiv_evolve*  e_;    
      gsl_odeiv_system   sys_;  
      
      // IntergrationStep_ should be reset with the neuron on ResetNetwork,
      // but remain unchanged during calibration. Since it is initialized with
      // step_, and the resolution cannot change after nodes have been created,
      // it is safe to place both here.
      double_t step_;           
      double   IntegrationStep_;

      double_t I_stim_;
    };
    
    // Variables class ------------------------------------------------------- 
    
    struct Variables_ { 
      double_t PSConInit_E; 
      
      double_t PSConInit_I;    
      
      double_t PSConInit_AHP;
    };
    
    // Access functions for UniversalDataLogger -------------------------------
    
    template <State_::StateVecElems elem>
    double_t get_y_elem_() const { return S_.y[elem]; }
    
    double_t get_r_() const { return Time::get_resolution().get_ms() * S_.r; }

    double_t get_I_syn_exc_() const { return S_.y[State_::G_EXC] * (S_.y[State_::V_M] - P_.E_ex); }
    double_t get_I_syn_inh_() const { return S_.y[State_::G_INH] * (S_.y[State_::V_M] - P_.E_in); }
    double_t get_I_ahp_() const { return S_.y[State_::G_AHP] * (S_.y[State_::V_M] - P_.E_ahp); }


    // Data members ----------------------------------------------------------- 

    // keep the order of these lines, seems to give best performance
    Parameters_ P_;
    State_      S_;
    Variables_  V_;
    Buffers_    B_;

    static RecordablesMap<iaf_chxk_2008> recordablesMap_;
  };
  

  // Boilerplate inline function definitions ----------------------------------

  inline
  port iaf_chxk_2008::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_chxk_2008::handles_test_event(SpikeEvent&, rport receptor_type)
  {
    if (receptor_type != 0)
      throw UnknownReceptorType(receptor_type, get_name());
    return 0;
  }
 
  inline
  port iaf_chxk_2008::handles_test_event(CurrentEvent&, rport receptor_type)
  {
    if (receptor_type != 0)
      throw UnknownReceptorType(receptor_type, get_name());
    return 0;
  }
 
  inline
  port iaf_chxk_2008::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_chxk_2008::get_status(DictionaryDatum &d) const
  {
    P_.get(d);
    S_.get(d);
    Archiving_Node::get_status(d);

    (*d)[names::recordables] = recordablesMap_.get_list();
  }

  inline
  void iaf_chxk_2008::set_status(const DictionaryDatum &d)
  {
    Parameters_ ptmp = P_;  // temporary copy in case of errors
    ptmp.set(d);                       // throws if BadProperty
    State_      stmp = S_;  // temporary copy in case of errors
    stmp.set(d, ptmp);                 // throws if BadProperty

    // We now know that (ptmp, stmp) are consistent. We do not 
    // write them back to (P_, S_) before we are also sure that 
    // the properties to be set in the parent class are internally 
    // consistent.
    Archiving_Node::set_status(d);

    // if we get here, temporaries contain consistent set of properties
    P_ = ptmp;
    S_ = stmp;
  }

} // namespace


#endif //HAVE_GSL
#endif //IAF_CHXK_2008_H