iaf_psc_alpha_multisynapse.h

Go to the documentation of this file.

/*
 *  iaf_psc_alpha_multisynapse.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_MULTISYNAPSE_H
#define IAF_PSC_ALPHA_MULTISYNAPSE_H
 
// Generated includes:
#include <sstream>
 
// Includes from nestkernel:
#include "archiving_node.h"
#include "connection.h"
#include "event.h"
#include "nest_types.h"
#include "recordables_map.h"
#include "ring_buffer.h"
#include "universal_data_logger.h"
 
namespace nest
{
 
/* BeginUserDocs: neuron, integrate-and-fire, current-based, hard threshold
 
Short description
+++++++++++++++++
 
Leaky integrate-and-fire neuron model with multiple ports
 
Description
+++++++++++
 
``iaf_psc_alpha_multisynapse`` is a direct extension of ``iaf_psc_alpha``.
On the postsynaptic side, there can be arbitrarily many synaptic
time constants (``iaf_psc_alpha`` has exactly two: ``tau_syn_ex`` and ``tau_syn_in``).
 
This can be reached by specifying separate receptor ports, each for
a different time constant. The port number has to match the respective
``receptor_type`` in the connectors.
 
.. note::
 
   If ``tau_m`` is very close to ``tau_syn_ex`` or ``tau_syn_in``, the model
   will numerically behave as if ``tau_m`` is equal to ``tau_syn_ex`` or
   ``tau_syn_in``, respectively, to avoid numerical instabilities.
 
   For implementation details see the
   `IAF Integration Singularity notebook <../model_details/IAF_Integration_Singularity.ipynb>`_.
 
Sends
+++++
 
SpikeEvent
 
Receives
++++++++
 
SpikeEvent, CurrentEvent, DataLoggingRequest
 
See also
++++++++
 
iaf_psc_alpha, iaf_psc_delta, iaf_psc_exp, iaf_cond_exp, iaf_psc_exp_multisynapse
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: iaf_psc_alpha_multisynapse
 
EndUserDocs */
 
void register_iaf_psc_alpha_multisynapse( const std::string& name );
 
class iaf_psc_alpha_multisynapse : public ArchivingNode
{
 
public:
  iaf_psc_alpha_multisynapse();
  iaf_psc_alpha_multisynapse( const iaf_psc_alpha_multisynapse& );
 
  using Node::handle;
  using Node::handles_test_event;
 
  size_t send_test_event( Node&, size_t, synindex, bool ) override;
 
  void handle( SpikeEvent& ) override;
  void handle( CurrentEvent& ) override;
  void handle( DataLoggingRequest& ) override;
 
  size_t handles_test_event( SpikeEvent&, size_t ) override;
  size_t handles_test_event( CurrentEvent&, size_t ) override;
  size_t handles_test_event( DataLoggingRequest&, size_t ) override;
 
  void get_status( Dictionary& ) const override;
  void set_status( const Dictionary& ) override;
 
private:
  void init_buffers_() override;
  void pre_run_hook() override;
 
  void update( Time const&, const long, const long ) override;
 
  // The next two classes need to be friends to access the State_ class/member
  friend class DynamicRecordablesMap< iaf_psc_alpha_multisynapse >;
  friend class DynamicUniversalDataLogger< iaf_psc_alpha_multisynapse >;
  friend class DataAccessFunctor< iaf_psc_alpha_multisynapse >;
 
  // ----------------------------------------------------------------
 
  struct Parameters_
  {
    double Tau_;
 
    double C_;
 
    double refractory_time_;
 
    double E_L_;
 
    double I_e_;
 
    double V_reset_;
 
    double Theta_;
 
    double LowerBound_;
 
    std::vector< double > tau_syn_;
 
    // boolean flag which indicates whether the neuron has connections
    bool has_connections_;
 
    size_t n_receptors_() const;  
 
    Parameters_();  
 
    void get( Dictionary& ) const;  
 
    double set( const Dictionary&, Node* node );
  };  // Parameters_
 
  // ----------------------------------------------------------------
 
  struct State_
  {
    enum StateVecElems
    {
      V_M = 0,
      I,     // 1
      I_SYN  // 2
    };
 
    static const size_t NUMBER_OF_FIXED_STATES_ELEMENTS = I_SYN;  // V_M, I
    static const size_t NUM_STATE_ELEMENTS_PER_RECEPTOR = 1;      // I_SYN
 
    double I_const_;  
    std::vector< double > y1_syn_;
    std::vector< double > y2_syn_;
    double V_m_;
 
    int refractory_steps_;  
 
    State_();  
 
    void get( Dictionary&, const Parameters_& ) const;
 
    void set( const Dictionary&, const Parameters_&, const double, Node* );
  };  // State_
 
  // ----------------------------------------------------------------
 
  struct Buffers_
  {
    Buffers_( iaf_psc_alpha_multisynapse& );
    Buffers_( const Buffers_&, iaf_psc_alpha_multisynapse& );
 
    std::vector< RingBuffer > spikes_;
    RingBuffer currents_;
 
    DynamicUniversalDataLogger< iaf_psc_alpha_multisynapse > logger_;
  };
 
  // ----------------------------------------------------------------
 
  struct Variables_
  {
    std::vector< double > PSCInitialValues_;
    int RefractoryCounts_;
 
    std::vector< double > P11_syn_;
    std::vector< double > P21_syn_;
    std::vector< double > P22_syn_;
    std::vector< double > P31_syn_;
    std::vector< double > P32_syn_;
 
    double P30_;
    double P33_;
 
    unsigned int receptor_types_size_;
 
  };  // Variables
 
  // Data members -----------------------------------------------------------
 
  Parameters_ P_;
  State_ S_;
  Variables_ V_;
  Buffers_ B_;
  DynamicRecordablesMap< iaf_psc_alpha_multisynapse > recordablesMap_;
 
  // Data Access Functor getter
  DataAccessFunctor< iaf_psc_alpha_multisynapse > get_data_access_functor( size_t elem );
  inline double
  get_state_element( size_t elem )
  {
    if ( elem == State_::V_M )
    {
      return S_.V_m_ + P_.E_L_;
    }
    else if ( elem == State_::I )
    {
      return std::accumulate( S_.y2_syn_.begin(), S_.y2_syn_.end(), 0.0 );
    }
    else
    {
      return S_.y2_syn_[ elem - S_.NUMBER_OF_FIXED_STATES_ELEMENTS ];
    }
  };
 
  // Utility function that inserts the synaptic conductances to the
  // recordables map
 
  std::string get_i_syn_name( size_t elem );
  void insert_current_recordables( size_t first = 0 );
};
 
inline size_t
iaf_psc_alpha_multisynapse::Parameters_::n_receptors_() const
{
  return tau_syn_.size();
}
 
inline size_t
iaf_psc_alpha_multisynapse::send_test_event( Node& target, size_t receptor_type, synindex, bool )
{
  SpikeEvent e;
  e.set_sender( *this );
 
  return target.handles_test_event( e, receptor_type );
}
 
inline size_t
iaf_psc_alpha_multisynapse::handles_test_event( CurrentEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
iaf_psc_alpha_multisynapse::handles_test_event( DataLoggingRequest& dlr, size_t 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_multisynapse::get_status( Dictionary& d ) const
{
  P_.get( d );
  S_.get( d, P_ );
  ArchivingNode::get_status( d );
 
  d[ names::recordables ] = recordablesMap_.get_list();
}
 
}  // namespace
 
#endif /* #ifndef IAF_PSC_ALPHA_MULTISYNAPSE_H */