diffusion_connection.h

Go to the documentation of this file.

/*
 *  diffusion_connection.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 DIFFUSION_CONNECTION_H
#define DIFFUSION_CONNECTION_H
 
#include "connection.h"
 
namespace nest
{
 
/* BeginUserDocs: synapse, abstract, rate
 
Short description
+++++++++++++++++
 
Synapse type for instantaneous rate connections between neurons of type siegert_neuron
 
Description
+++++++++++
 
``diffusion_connection`` is a connector to create
instantaneous connections between neurons of type ``siegert_neuron``. The
connection type is identical to type ``rate_connection_instantaneous``
for instantaneous rate connections except for the two parameters
``drift_factor`` and ``diffusion_factor`` substituting the parameter weight.
 
These two factor origin from the mean-field reduction of networks of
leaky-integrate-and-fire neurons. In this reduction the input to the
neurons is characterized by its mean and its variance. The mean is
obtained by a sum over presynaptic activities (e.g as in eq.28 in
:footcite:p:`Hahne2017`), where each term of the sum consists of the presynaptic activity
multiplied with the ``drift_factor``. Similarly, the variance is obtained
by a sum over presynaptic activities (e.g as in eq.29 in :footcite:p:`Hahne2017`), where
each term of the sum consists of the presynaptic activity multiplied
with the ``diffusion_factor``. Note that in general the drift and
diffusion factors might differ from the ones given in eq. 28 and 29.,
for example in case of a reduction on the single neuron level or in
case of distributed in-degrees (see discussion in chapter 5.2 of :footcite:p:`Hahne2017`)
 
The values of the parameters delay and weight are ignored for
connections of this type.
 
Transmits
+++++++++
 
DiffusionConnectionEvent
 
References
++++++++++
 
 
.. footbibliography::
 
See also
++++++++
 
siegert_neuron, rate_connection_instantaneous
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: diffusion_connection
 
EndUserDocs */
 
void register_diffusion_connection( const std::string& name );
 
template < typename targetidentifierT >
class diffusion_connection : public Connection< targetidentifierT >
{
public:
  // this line determines which common properties to use
  typedef CommonSynapseProperties CommonPropertiesType;
  typedef Connection< targetidentifierT > ConnectionBase;
 
  static constexpr ConnectionModelProperties properties = ConnectionModelProperties::SUPPORTS_WFR;
 
  diffusion_connection()
    : ConnectionBase()
    , drift_factor_( 1.0 )
    , diffusion_factor_( 1.0 )
  {
  }
 
  std::unique_ptr< SecondaryEvent > get_secondary_event();
 
  // Explicitly declare all methods inherited from the dependent base
  // ConnectionBase.
  // This avoids explicit name prefixes in all places these functions are used.
  // Since ConnectionBase depends on the template parameter, they are not
  // automatically
  // found in the base class.
  using ConnectionBase::get_delay_steps;
  using ConnectionBase::get_rport;
  using ConnectionBase::get_target;
 
  void
  check_connection( Node& s, Node& t, size_t receptor_type, const CommonPropertiesType& )
  {
    DiffusionConnectionEvent ge;
 
    s.sends_secondary_event( ge );
    ge.set_sender( s );
    Connection< targetidentifierT >::target_.set_rport( t.handles_test_event( ge, receptor_type ) );
    Connection< targetidentifierT >::target_.set_target( &t );
  }
 
  bool
  send( Event& e, size_t t, const CommonSynapseProperties& )
  {
    e.set_drift_factor( drift_factor_ );
    e.set_diffusion_factor( diffusion_factor_ );
    e.set_receiver( *get_target( t ) );
    e.set_rport( get_rport() );
    e();
 
    return true;
  }
 
  void get_status( Dictionary& d ) const;
 
  void set_status( const Dictionary& d, ConnectorModel& cm );
 
  void
  set_weight( double )
  {
    throw BadProperty(
      "Please use the parameters drift_factor and "
      "diffusion_factor to specifiy the weights." );
  }
 
  void
  set_delay( double )
  {
    throw BadProperty( "diffusion_connection has no delay." );
  }
 
private:
  double weight_;
  double drift_factor_;
  double diffusion_factor_;
};
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties diffusion_connection< targetidentifierT >::properties;
 
template < typename targetidentifierT >
void
diffusion_connection< targetidentifierT >::get_status( Dictionary& d ) const
{
  ConnectionBase::get_status( d );
  d[ names::weight ] = weight_;
  d[ names::drift_factor ] = drift_factor_;
  d[ names::diffusion_factor ] = diffusion_factor_;
  d[ names::size_of ] = static_cast< long >( sizeof( *this ) );
}
 
template < typename targetidentifierT >
void
diffusion_connection< targetidentifierT >::set_status( const Dictionary& d, ConnectorModel& cm )
{
  // If the delay is set, we throw a BadProperty
  if ( d.known( names::delay ) )
  {
    throw BadProperty( "diffusion_connection has no delay." );
  }
  // If the parameter weight is set, we throw a BadProperty
  if ( d.known( names::weight ) )
  {
    throw BadProperty(
      "Please use the parameters drift_factor and "
      "diffusion_factor to specifiy the weights." );
  }
 
  ConnectionBase::set_status( d, cm );
  d.update_value( names::drift_factor, drift_factor_ );
  d.update_value( names::diffusion_factor, diffusion_factor_ );
}
 
 
template < typename targetidentifierT >
std::unique_ptr< SecondaryEvent >
diffusion_connection< targetidentifierT >::get_secondary_event()
{
  return std::make_unique< DiffusionConnectionEvent >();
}
 
}  // namespace
 
#endif /* #ifndef DIFFUSION_CONNECTION_H */