node.h

Go to the documentation of this file.

/*
 *  node.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 NODE_H
#define NODE_H
 
// C++ includes:
#include <bitset>
#include <deque>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
// Includes from nestkernel:
#include "common_synapse_properties.h"
#include "deprecation_warning.h"
#include "event.h"
#include "histentry.h"
#include "nest_names.h"
#include "nest_time.h"
#include "nest_types.h"
#include "secondary_event.h"
 
 
namespace nest
{
class Model;
class ArchivingNode;
class TimeConverter;
class WeightOptimizer;
 
class Node
{
  friend class NodeManager;
  friend class ModelManager;
  friend class proxynode;
  friend class Model;
  friend class SimulationManager;
 
  Node& operator=( const Node& );  
 
public:
  Node();
  Node( Node const& );
  virtual ~Node();
 
  virtual Node*
  clone() const
  {
    return nullptr;
  }
 
  virtual bool has_proxies() const;
 
  virtual bool supports_urbanczik_archiving() const;
 
  virtual bool local_receiver() const;
 
  virtual bool one_node_per_process() const;
 
  virtual bool is_off_grid() const;
 
  virtual bool is_proxy() const;
 
  std::string get_name() const;
 
  virtual std::string get_element_type() const;
 
  size_t get_node_id() const;
 
 
  int get_model_id() const;
 
  bool is_frozen() const;
 
  bool node_uses_wfr() const;
 
  void set_node_uses_wfr( const bool );
 
  void init();
 
  virtual void pre_run_hook() = 0;
 
  virtual void
  calibrate_time( const TimeConverter& )
  {
  }
 
  virtual void
  post_run_cleanup()
  {
  }
 
  virtual void
  finalize()
  {
  }
 
  virtual void update( Time const&, const long, const long ) = 0;
 
  virtual bool wfr_update( Time const&, const long, const long );
 
  virtual void set_status( const Dictionary& ) = 0;
 
  virtual void get_status( Dictionary& ) const = 0;
 
public:
  virtual size_t send_test_event( Node& receiving_node, size_t receptor_type, synindex syn_id, bool dummy_target );
 
  virtual size_t handles_test_event( SpikeEvent&, size_t receptor_type );
  virtual size_t handles_test_event( WeightRecorderEvent&, size_t receptor_type );
  virtual size_t handles_test_event( RateEvent&, size_t receptor_type );
  virtual size_t handles_test_event( DataLoggingRequest&, size_t receptor_type );
  virtual size_t handles_test_event( CurrentEvent&, size_t receptor_type );
  virtual size_t handles_test_event( ConductanceEvent&, size_t receptor_type );
  virtual size_t handles_test_event( DoubleDataEvent&, size_t receptor_type );
  virtual size_t handles_test_event( DSSpikeEvent&, size_t receptor_type );
  virtual size_t handles_test_event( DSCurrentEvent&, size_t receptor_type );
  virtual size_t handles_test_event( GapJunctionEvent&, size_t receptor_type );
  virtual size_t handles_test_event( InstantaneousRateConnectionEvent&, size_t receptor_type );
  virtual size_t handles_test_event( DiffusionConnectionEvent&, size_t receptor_type );
  virtual size_t handles_test_event( DelayedRateConnectionEvent&, size_t receptor_type );
  virtual size_t handles_test_event( LearningSignalConnectionEvent&, size_t receptor_type );
  virtual size_t handles_test_event( SICEvent&, size_t receptor_type );
 
  virtual void sends_secondary_event( GapJunctionEvent& ge );
 
  virtual void sends_secondary_event( InstantaneousRateConnectionEvent& re );
 
  virtual void sends_secondary_event( DiffusionConnectionEvent& de );
 
  virtual void sends_secondary_event( DelayedRateConnectionEvent& re );
 
  virtual void sends_secondary_event( LearningSignalConnectionEvent& re );
 
  virtual void sends_secondary_event( SICEvent& sic );
 
  virtual void register_stdp_connection( double, double );
 
  virtual void register_eprop_connection();
 
  virtual void initialize_update_history();
 
  virtual long get_shift() const;
 
  virtual void write_update_to_history( const long t_previous_update,
    const long t_current_update,
    const bool is_flush_event,
    const bool previous_was_flush_event );
 
  virtual void erase_used_eprop_history();
 
  virtual void erase_used_eprop_history( const long t_spike, const long t_spike_previous );
 
  virtual bool is_eprop_recurrent_node() const;
 
  virtual void handle( SpikeEvent& e );
 
  virtual void handle( WeightRecorderEvent& e );
 
  virtual void handle( RateEvent& e );
 
  virtual void handle( DataLoggingRequest& e );
 
  virtual void handle( DataLoggingReply& e );
 
  virtual void handle( CurrentEvent& e );
 
  virtual void handle( ConductanceEvent& e );
 
  virtual void handle( DoubleDataEvent& e );
 
  virtual void handle( GapJunctionEvent& e );
 
  virtual void handle( InstantaneousRateConnectionEvent& e );
 
  virtual void handle( DiffusionConnectionEvent& e );
 
  virtual void handle( DelayedRateConnectionEvent& e );
 
  virtual void handle( LearningSignalConnectionEvent& e );
 
  virtual void handle( SICEvent& e );
 
  virtual double
  get_Ca_minus() const
  {
    return 0.0;
  }
 
  virtual double
  get_synaptic_elements( std::string ) const
  {
    return 0.0;
  }
 
  virtual int
  get_synaptic_elements_vacant( std::string ) const
  {
    return 0;
  }
 
  virtual int
  get_synaptic_elements_connected( std::string ) const
  {
    return 0;
  }
 
  virtual std::map< std::string, double >
  get_synaptic_elements() const
  {
    return std::map< std::string, double >();
  }
 
  virtual void update_synaptic_elements( double ) {};
 
  virtual void decay_synaptic_elements_vacant() {};
 
  virtual void connect_synaptic_element( std::string, int ) {};
 
  virtual double get_K_value( double t );
 
  virtual double get_LTD_value( double t );
 
  virtual void get_K_values( double t, double& Kminus, double& nearest_neighbor_Kminus, double& Kminus_triplet );
 
  virtual void get_history( double t1,
    double t2,
    std::deque< histentry >::iterator* start,
    std::deque< histentry >::iterator* finish );
 
  // for Clopath synapse
  virtual void get_LTP_history( double t1,
    double t2,
    std::deque< histentry_extended >::iterator* start,
    std::deque< histentry_extended >::iterator* finish );
  // for Urbanczik synapse
  virtual void get_urbanczik_history( double t1,
    double t2,
    std::deque< histentry_extended >::iterator* start,
    std::deque< histentry_extended >::iterator* finish,
    int );
  // make neuron parameters accessible in Urbanczik synapse
  virtual double get_C_m( int comp );
  virtual double get_g_L( int comp );
  virtual double get_tau_L( int comp );
  virtual double get_tau_s( int comp );
  virtual double get_tau_syn_ex( int comp );
  virtual double get_tau_syn_in( int comp );
 
  virtual void compute_gradient( const long t_spike,
    const long t_spike_previous,
    double& z_previous_buffer,
    double& z_bar,
    double& e_bar,
    double& e_bar_reg,
    double& epsilon,
    double& weight,
    const CommonSynapseProperties& cp,
    WeightOptimizer* optimizer,
    bool is_flush_event,
    bool previous_was_flush_event,
    double& sum_grad,
    long& remaining_steps_until_cutoff,
    long& decay_steps );
 
  virtual double compute_gradient( std::vector< long >& presyn_isis,
    const long t_previous_update,
    const long t_previous_trigger_spike,
    const double kappa,
    const bool average_gradient );
 
  virtual void event_hook( DSSpikeEvent& );
 
  virtual void event_hook( DSCurrentEvent& );
 
  void set_thread( size_t );
 
  size_t get_thread() const;
 
  void set_vp( size_t );
 
  size_t get_vp() const;
 
  void set_model_id( int );
 
  void set_initialized();
 
  virtual SignalType
  sends_signal() const
  {
    return SPIKE;
  }
 
  virtual SignalType
  receives_signal() const
  {
    return SPIKE;
  }
 
 
  Dictionary get_status_base();
 
  void set_status_base( const Dictionary& );
 
  bool is_model_prototype() const;
 
  void set_thread_lid( const size_t );
 
  size_t get_thread_lid() const;
 
  virtual void set_local_device_id( const size_t lsdid );
 
  virtual size_t get_local_device_id() const;
 
  DeprecationWarning deprecation_warning;
 
  void set_tmp_nc_index( size_t index );
 
  size_t get_tmp_nc_index();
 
 
private:
  void set_node_id_( size_t );  
 
  virtual Dictionary get_status_dict_();
 
protected:
  virtual void init_state_();
 
  virtual void init_buffers_();
 
  virtual void set_initialized_();
 
  Model& get_model_() const;
 
  void
  set_frozen_( bool frozen )
  {
    frozen_ = frozen;
  }
 
  template < typename ConcreteNode >
  const ConcreteNode& downcast( const Node& );
 
private:
  size_t node_id_;
 
  size_t thread_lid_;
 
  int model_id_;
 
  size_t thread_;       
  size_t vp_;           
  bool frozen_;         
  bool initialized_;    
  bool node_uses_wfr_;  
 
  size_t tmp_nc_index_;
};
 
inline bool
Node::is_frozen() const
{
  return frozen_;
}
 
inline bool
Node::node_uses_wfr() const
{
  return node_uses_wfr_;
}
 
inline bool
Node::supports_urbanczik_archiving() const
{
  return false;
}
 
inline void
Node::set_node_uses_wfr( const bool uwfr )
{
  node_uses_wfr_ = uwfr;
}
 
inline bool
Node::has_proxies() const
{
  return true;
}
 
inline bool
Node::local_receiver() const
{
  return false;
}
 
inline bool
Node::one_node_per_process() const
{
  return false;
}
 
inline bool
Node::is_off_grid() const
{
  return false;
}
 
inline bool
Node::is_proxy() const
{
  return false;
}
 
inline std::string
Node::get_element_type() const
{
  return names::neuron;
}
 
inline size_t
Node::get_node_id() const
{
  return node_id_;
}
 
 
inline void
Node::set_node_id_( size_t i )
{
  node_id_ = i;
}
 
 
inline int
Node::get_model_id() const
{
  return model_id_;
}
 
inline void
Node::set_model_id( int i )
{
  model_id_ = i;
}
 
inline bool
Node::is_model_prototype() const
{
  return vp_ == invalid_thread;
}
 
inline void
Node::set_thread( size_t t )
{
  thread_ = t;
}
 
inline size_t
Node::get_thread() const
{
  return thread_;
}
 
inline void
Node::set_vp( size_t vp )
{
  vp_ = vp;
}
 
inline size_t
Node::get_vp() const
{
  return vp_;
}
 
template < typename ConcreteNode >
const ConcreteNode&
Node::downcast( const Node& n )
{
  ConcreteNode const* tp = dynamic_cast< ConcreteNode const* >( &n );
  assert( tp != 0 );
  return *tp;
}
 
inline void
Node::set_thread_lid( const size_t tlid )
{
  thread_lid_ = tlid;
}
 
inline size_t
Node::get_thread_lid() const
{
  return thread_lid_;
}
 
inline void
Node::set_tmp_nc_index( size_t index )
{
  tmp_nc_index_ = index;
}
 
inline size_t
Node::get_tmp_nc_index()
{
  assert( tmp_nc_index_ != invalid_index );
 
  const auto index = tmp_nc_index_;
  tmp_nc_index_ = invalid_index;
 
  return index;
}
 
 
}  // namespace
 
#endif