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

#include <cassert>

#include "nest.h"
#include "nest_time.h"
#include "lockptr.h"
#include "exceptions.h"
#include "name.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; 

    Node & get_sender() const;

    void set_sender(Node &);

    index get_sender_gid() const;

    void set_sender_gid(index);
    
    Time const&   get_stamp() const;

    void    set_delay(delay);

    delay get_delay() const;

    delay get_max_delay() const;

    long_t get_rel_delivery_steps(const Time& t) const;

    port    get_port() const;    

    rport    get_rport() const;    

    void    set_port(port p);    
    
    void    set_rport(rport p);    
    
    double_t get_offset() const;

    void     set_offset(double_t t);

    weight get_weight() const;

    void   set_weight(weight t);

    bool is_valid() const;

    void set_stamp(Time const &);
    
  protected:
    index sender_gid_; 
    /*
     * 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 NULL.
     */
    Node * sender_; 
    Node * receiver_; 

    
    
    port p_;

    rport rp_;

    delay d_;

    Time stamp_;

    double offset_;

    weight w_;
  };

  
  // Built-in event types

  class SpikeEvent: public Event
  {
  public:
    SpikeEvent();
    void operator()();
    SpikeEvent* clone() const;
    
    void set_multiplicity(int_t);
    int_t get_multiplicity() const;

  protected:  
    int_t multiplicity_;
  };

  inline
  SpikeEvent::SpikeEvent()
      : multiplicity_(1)
  {}

  inline
  SpikeEvent* SpikeEvent::clone() const
  {
    return new SpikeEvent(*this);
  }

  inline
  void SpikeEvent::set_multiplicity(int_t multiplicity)
  {
    multiplicity_=multiplicity;
  }

  inline
  int_t SpikeEvent::get_multiplicity() const
  {
    return multiplicity_;
  }
  

  class DSSpikeEvent : public SpikeEvent
  {
  public:
    void operator()();
  };

  class RateEvent: public Event
  {
    double_t r_;
  public:
    void operator()();
    RateEvent* clone() const;
    
    void set_rate(double_t);
    double_t get_rate() const;
  };

  inline
  RateEvent* RateEvent::clone() const
  {
    return new RateEvent(*this);
  }
  
  inline
  void RateEvent::set_rate(double_t r)
  {
    r_=r;
  }

  inline
  double_t RateEvent::get_rate() const
  {
    return r_;
  }

  class CurrentEvent: public Event
  {
    double_t c_;
  public:
    void operator()();
    CurrentEvent* clone() const;
    
    void set_current(double_t);
    double_t get_current() const;
  };

  inline
  CurrentEvent* CurrentEvent::clone() const
  {
    return new CurrentEvent(*this);
  }

  inline
  void CurrentEvent::set_current(double_t c)
  {
    c_ = c;
  }

  inline
  double_t CurrentEvent::get_current() const
  {
    return c_;
  }

  class DSCurrentEvent : public CurrentEvent
  {
  public:
    void operator()();
  };

  class DataLoggingRequest : public Event
  {
  public:
    DataLoggingRequest();

    DataLoggingRequest(const Time&, const std::vector<Name>&);

    DataLoggingRequest* clone() const;

    void operator()();
    
    const Time& get_recording_interval() const;

    const std::vector<Name>& record_from() const;
    
  private:
    
    Time recording_interval_;

    std::vector<Name> const * const record_from_;
  };

  inline
  DataLoggingRequest::DataLoggingRequest()
    : Event(), 
      recording_interval_(Time::neg_inf()),
      record_from_(0)
  {}

  inline
  DataLoggingRequest::DataLoggingRequest(const Time& rec_int,
                     const std::vector<Name>& recs)
    : Event(), 
      recording_interval_(rec_int),
      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 std::vector<Name>& DataLoggingRequest::record_from() const 
  { 
    // During simulation, events are created without recordables
    // information. On these, record_from() must not be called.
    assert(record_from_ != 0);

    return *record_from_;
  }

  class DataLoggingReply : public Event
  {
  public:
      typedef std::vector<double_t> DataItem;

      struct Item {
      Item(size_t n) : data(n, std::numeric_limits<double_t>::max()),
                            timestamp(Time::neg_inf()) {}
    DataItem data;
    Time     timestamp;
      };
    
      typedef std::vector<Item> Container;
    
      DataLoggingReply(const Container&);
    
      void operator()();

      const Container& get_info() const { return info_; }

    private:
      DataLoggingReply(const DataLoggingReply&);
    
      DataLoggingReply* clone() const { assert(false); return 0; }

      const Container& info_;
  };
  
  inline
    DataLoggingReply::DataLoggingReply(const Container& d) 
  : Event(), 
    info_(d)
  {}

  class ConductanceEvent: public Event
  {
    double_t g_;
  public:
    void operator()();
    ConductanceEvent* clone() const;
    
    void set_conductance(double_t);
    double_t get_conductance() const;
  };

  inline
  ConductanceEvent* ConductanceEvent::clone() const
  {
    return new ConductanceEvent(*this);
  }

  inline
  void ConductanceEvent::set_conductance(double_t g)
  {
    g_=g;
  }

  inline
  double_t ConductanceEvent::get_conductance() const
  {
    return g_;
  }

  
  template<typename D>
  class DataEvent: public Event
  {
    lockPTR<D> data_;

  public:
    void set_pointer(D &data);
    lockPTR<D> get_pointer() const;
  };

  template<typename D>
  inline
  void DataEvent<D>::set_pointer(D &data)
  {
    data_ = data;
  }

  template<typename D>
  inline
  lockPTR<D> DataEvent<D>::get_pointer() const
  {
    return data_;
  }

  class DoubleDataEvent: public DataEvent<double>
  {
  public:
    void operator()();
    DoubleDataEvent* clone() const;
  };    

  inline
  DoubleDataEvent* DoubleDataEvent::clone() const
  {
    return new DoubleDataEvent(*this);
  }

  //*************************************************************
  // Inline implementations.

  inline
  bool Event::is_valid() const
  {
    return ( (sender_ != NULL) && (receiver_ != NULL) && (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_gid(index gid) 
  {
    sender_gid_ = gid;
  }
 
  inline
  Node & Event::get_receiver(void) const 
  {
    return *receiver_;
  }

  inline
  Node & Event::get_sender(void) const 
  {
    return *sender_;
  }

  inline
  index Event::get_sender_gid(void) const 
  {
    assert(sender_gid_ > 0);
    return sender_gid_;
  }

  inline
  weight Event::get_weight() const
  {
    return w_;
  }

  inline
  void Event::set_weight(weight w)
  {
    w_=w;
  }

  inline
  Time const & Event::get_stamp() const
  { 
    return stamp_;
  }

  inline
  void Event::set_stamp(Time const & s)
  { 
    stamp_ = s;
  }

  inline
  delay Event::get_delay() const
  { 
    return d_;
  }
  
  inline
  long_t Event::get_rel_delivery_steps(const Time& t) const
  {
    return stamp_.get_steps() + d_ - 1 - t.get_steps(); 
  }

  inline
  void Event::set_delay(delay d)
  {
    d_=d;
  }
 
  inline
  double_t Event::get_offset() const
  { 
    return offset_;
  }
  
  inline
  void Event::set_offset(double_t t)
  { 
    offset_=t;
  }
  
  inline
  port Event::get_port() const
  {
    return p_;
  }
  
  inline
  rport Event::get_rport() const
  {
    return rp_;
  }
  
  inline
  void Event::set_port(port p)
  {
    p_=p;
  }

  inline
  void Event::set_rport(rport rp)
  {
    rp_=rp;
  }
}

#endif //EVENT_H