event.h

Go to the documentation of this file.

/*
 *  event.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 EVENT_H
#define EVENT_H
 
// C++ includes:
#include <algorithm>
#include <cassert>
#include <cstring>
#include <memory>
#include <vector>
 
// Includes from nestkernel:
#include "exceptions.h"
#include "nest_time.h"
#include "nest_types.h"
#include "spike_data.h"
#include "vp_manager.h"
 
namespace nest
{
 
class Node;
 
class Event
{
 
public:
  Event();
 
  virtual ~Event()
  {
  }
 
  virtual Event* clone() const = 0;
 
  virtual void operator()() = 0;
 
  void set_receiver( Node& );
 
  Node& get_receiver() const;
 
  size_t get_receiver_node_id() const;
 
  Node& get_sender() const;
 
  void set_sender( Node& );
 
  size_t get_sender_node_id() const;
 
  size_t retrieve_sender_node_id_from_source_table() const;
 
  void set_sender_node_id( const size_t );
 
  void set_sender_node_id_info( const size_t tid, const synindex syn_id, const size_t lcid );
 
  Time const& get_stamp() const;
 
  void set_delay_steps( long );
 
  long get_delay_steps() const;
 
  long get_rel_delivery_steps( const Time& t ) const;
 
  size_t get_port() const;
 
  size_t get_rport() const;
 
  void set_port( size_t p );
 
  void set_rport( size_t p );
 
  double get_offset() const;
 
  void set_offset( double t );
 
  double get_weight() const;
 
  void set_weight( double t );
 
  virtual void set_drift_factor( double ) {};
 
  virtual void set_diffusion_factor( double ) {};
 
  bool sender_is_valid() const;
 
  bool receiver_is_valid() const;
 
  bool is_valid() const;
 
  void set_stamp( Time const& );
 
  void set_flush_event_flag( bool is_flush_event );
 
  bool is_flush_event();
 
protected:
  size_t sender_node_id_;        
  SpikeData sender_spike_data_;  
  // The original formulation used references to Nodes as
  // members, however, in order to avoid the reference of reference
  // problem, we store sender and receiver as pointers and use
  // references in the interface.
  // Thus, we can still ensure that the pointers are never nullptr.
  Node* sender_;    
  Node* receiver_;  
 
 
  size_t p_;
 
  size_t rp_;
 
  long d_;
 
  Time stamp_;
 
  mutable long stamp_steps_;
 
  double offset_;
 
  double w_;
};
 
 
// Built-in event types
class SpikeEvent : public Event
{
public:
  SpikeEvent();
  void operator()() override;
  SpikeEvent* clone() const override;
 
  void set_multiplicity( size_t );
  size_t get_multiplicity() const;
 
protected:
  size_t multiplicity_;
};
 
inline SpikeEvent::SpikeEvent()
  : multiplicity_( 1 )
{
}
 
inline SpikeEvent*
SpikeEvent::clone() const
{
  return new SpikeEvent( *this );
}
 
inline void
SpikeEvent::set_multiplicity( size_t multiplicity )
{
  multiplicity_ = multiplicity;
}
 
inline size_t
SpikeEvent::get_multiplicity() const
{
  return multiplicity_;
}
 
 
class WeightRecorderEvent : public Event
{
public:
  WeightRecorderEvent();
  WeightRecorderEvent* clone() const override;
  void operator()() override;
 
  size_t get_receiver_node_id() const;
 
  void set_receiver_node_id( size_t );
 
protected:
  size_t receiver_node_id_;  
};
 
inline WeightRecorderEvent::WeightRecorderEvent()
  : receiver_node_id_( 0 )
{
}
 
inline WeightRecorderEvent*
WeightRecorderEvent::clone() const
{
  return new WeightRecorderEvent( *this );
}
 
inline void
WeightRecorderEvent::set_receiver_node_id( size_t node_id )
{
  receiver_node_id_ = node_id;
}
 
inline size_t
WeightRecorderEvent::get_receiver_node_id() const
{
  return receiver_node_id_;
}
 
 
class DSSpikeEvent : public SpikeEvent
{
public:
  void operator()() override;
};
 
class RateEvent : public Event
{
  double r_;
 
public:
  void operator()() override;
  RateEvent* clone() const override;
 
  void set_rate( double );
  double get_rate() const;
};
 
inline RateEvent*
RateEvent::clone() const
{
  return new RateEvent( *this );
}
 
inline void
RateEvent::set_rate( double r )
{
  r_ = r;
}
 
inline double
RateEvent::get_rate() const
{
  return r_;
}
 
class CurrentEvent : public Event
{
  double c_;
 
public:
  void operator()() override;
  CurrentEvent* clone() const override;
 
  void set_current( double );
  double get_current() const;
};
 
inline CurrentEvent*
CurrentEvent::clone() const
{
  return new CurrentEvent( *this );
}
 
inline void
CurrentEvent::set_current( double c )
{
  c_ = c;
}
 
inline double
CurrentEvent::get_current() const
{
  return c_;
}
 
class DSCurrentEvent : public CurrentEvent
{
public:
  void operator()() override;
};
 
class DataLoggingRequest : public Event
{
public:
  DataLoggingRequest();
 
  DataLoggingRequest( const Time&, const std::vector< std::string >& );
 
  DataLoggingRequest( const Time&, const Time&, const std::vector< std::string >& );
 
  DataLoggingRequest* clone() const override;
 
  void operator()() override;
 
  const Time& get_recording_interval() const;
 
  const Time& get_recording_offset() const;
 
  const std::vector< std::string >& record_from() const;
 
private:
  Time recording_interval_;
 
  Time recording_offset_;
  std::vector< std::string > const* const record_from_;
};
 
inline DataLoggingRequest::DataLoggingRequest()
  : Event()
  , recording_interval_( Time::neg_inf() )
  , recording_offset_( Time::ms( 0. ) )
  , record_from_( 0 )
{
}
 
inline DataLoggingRequest::DataLoggingRequest( const Time& rec_int, const std::vector< std::string >& recs )
  : Event()
  , recording_interval_( rec_int )
  , record_from_( &recs )
{
}
 
inline DataLoggingRequest::DataLoggingRequest( const Time& rec_int,
  const Time& rec_offset,
  const std::vector< std::string >& recs )
  : Event()
  , recording_interval_( rec_int )
  , recording_offset_( rec_offset )
  , record_from_( &recs )
{
}
 
 
inline DataLoggingRequest*
DataLoggingRequest::clone() const
{
  return new DataLoggingRequest( *this );
}
 
inline const Time&
DataLoggingRequest::get_recording_interval() const
{
  // During simulation, events are created without recording interval
  // information. On these, get_recording_interval() must not be called.
  assert( recording_interval_.is_finite() );
 
  return recording_interval_;
}
 
inline const Time&
DataLoggingRequest::get_recording_offset() const
{
  assert( recording_offset_.is_finite() );
  return recording_offset_;
}
 
inline const std::vector< std::string >&
DataLoggingRequest::record_from() const
{
  // During simulation, events are created without recordables
  // information. On these, record_from() must not be called.
  assert( record_from_ );
 
  return *record_from_;
}
 
class DataLoggingReply : public Event
{
public:
  typedef std::vector< double > DataItem;
 
  struct Item
  {
    Item( size_t n )
      : data( n, std::numeric_limits< double >::max() )
      , timestamp( Time::neg_inf() )
    {
    }
    DataItem data;
    Time timestamp;
  };
 
  typedef std::vector< Item > Container;
 
  DataLoggingReply( const Container& );
 
  void operator()() override;
 
  const Container&
  get_info() const
  {
    return info_;
  }
 
private:
  DataLoggingReply( const DataLoggingReply& );
 
  DataLoggingReply*
  clone() const override
  {
    assert( false );
    return nullptr;
  }
 
  const Container& info_;
};
 
inline DataLoggingReply::DataLoggingReply( const Container& d )
  : Event()
  , info_( d )
{
}
 
class ConductanceEvent : public Event
{
  double g_;
 
public:
  void operator()() override;
  ConductanceEvent* clone() const override;
 
  void set_conductance( double );
  double get_conductance() const;
};
 
inline ConductanceEvent*
ConductanceEvent::clone() const
{
  return new ConductanceEvent( *this );
}
 
inline void
ConductanceEvent::set_conductance( double g )
{
  g_ = g;
}
 
inline double
ConductanceEvent::get_conductance() const
{
  return g_;
}
 
 
template < typename D >
class DataEvent : public Event
{
  std::shared_ptr< D > data_;
 
public:
  void set_pointer( D& data );
  std::shared_ptr< D > get_pointer() const;
};
 
template < typename D >
inline void
DataEvent< D >::set_pointer( D& data )
{
  data_ = data;
}
 
template < typename D >
inline std::shared_ptr< D >
DataEvent< D >::get_pointer() const
{
  return data_;
}
 
class DoubleDataEvent : public DataEvent< double >
{
public:
  void operator()() override;
  DoubleDataEvent* clone() const override;
};
 
inline DoubleDataEvent*
DoubleDataEvent::clone() const
{
  return new DoubleDataEvent( *this );
}
 
//*************************************************************
// Inline implementations.
 
inline bool
Event::sender_is_valid() const
{
  return sender_;
}
 
inline bool
Event::receiver_is_valid() const
{
  return receiver_;
}
 
inline bool
Event::is_valid() const
{
  return ( sender_is_valid() and receiver_is_valid() and d_ > 0 );
}
 
inline void
Event::set_receiver( Node& r )
{
  receiver_ = &r;
}
 
inline void
Event::set_sender( Node& s )
{
  sender_ = &s;
}
 
inline void
Event::set_sender_node_id( const size_t node_id )
{
  sender_node_id_ = node_id;
}
 
inline void
Event::set_sender_node_id_info( const size_t tid, const synindex syn_id, const size_t lcid )
{
  // lag and offset of SpikeData are not used here
  sender_spike_data_.set( tid, syn_id, lcid, 0, 0.0 );
}
 
inline Node&
Event::get_receiver() const
{
  assert( receiver_ );
  return *receiver_;
}
 
inline Node&
Event::get_sender() const
{
  assert( sender_ );
  return *sender_;
}
 
inline size_t
Event::get_sender_node_id() const
{
  assert( sender_node_id_ > 0 );
  return sender_node_id_;
}
 
inline double
Event::get_weight() const
{
  return w_;
}
 
inline void
Event::set_weight( double w )
{
  w_ = w;
}
 
inline Time const&
Event::get_stamp() const
{
  return stamp_;
}
 
inline void
Event::set_stamp( Time const& s )
{
  stamp_ = s;
  stamp_steps_ = 0;  // setting stamp_steps to zero indicates
                     // stamp_steps needs to be recalculated from
                     // stamp_ next time it is needed (e.g., in
                     // get_rel_delivery_steps)
}
 
inline void
Event::set_flush_event_flag( bool is_flush_event )
{
  sender_spike_data_.set_flush_event_flag( is_flush_event );
}
 
inline bool
Event::is_flush_event()
{
  return sender_spike_data_.is_flush_event();
}
 
inline long
Event::get_delay_steps() const
{
  return d_;
}
 
inline long
Event::get_rel_delivery_steps( const Time& t ) const
{
  if ( stamp_steps_ == 0 )
  {
    stamp_steps_ = stamp_.get_steps();
  }
  return stamp_steps_ + d_ - 1 - t.get_steps();
}
 
inline void
Event::set_delay_steps( long d )
{
  d_ = d;
}
 
inline double
Event::get_offset() const
{
  return offset_;
}
 
inline void
Event::set_offset( double t )
{
  offset_ = t;
}
 
inline size_t
Event::get_port() const
{
  return p_;
}
 
inline size_t
Event::get_rport() const
{
  return rp_;
}
 
inline void
Event::set_port( size_t p )
{
  p_ = p;
}
 
inline void
Event::set_rport( size_t rp )
{
  rp_ = rp;
}
}
 
#endif /* EVENT_H */