poisson_generator_ps.h

Go to the documentation of this file.

/*
 *  poisson_generator_ps.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 POISSON_GENERATOR_PS_H
#define POISSON_GENERATOR_PS_H

#include <vector>
#include "nest.h"
#include "event.h"
#include "node.h"
#include "stimulating_device.h"
#include "scheduler.h"
#include "exp_randomdev.h"
#include "connection.h"

/*BeginDocumentation
Name: poisson_generator_ps - simulate neuron firing with Poisson processes 
(with arbitrary dead time) statistics and exact timing
Description:

  The poisson_generator_ps generator simulates a neuron firing with Poisson 
  statistics (with dead time), ie, exponentially distributed interspike 
  intervals plus constant dead time, spike events have exact timing 
  (i.e. not binned).

Parameters:
   The following parameters appear in the element's status dictionary:

   rate     - mean firing rate. (double, var)
   dead_time - minimal time between two spikes. (double, var)

Note:
   - This generator must be connected to all its targets using the
     same synapse model. Failure to do so will only be detected at
     runtime.
   - This generator has only been validated in a very basic manner.

   Sends: SpikeEvent
   
SeeAlso: poisson_generator, spike_generator, Device, StimulatingDevice
*/

namespace nest{

  class poisson_generator_ps: public Node
  {
    
  public:        
    
    poisson_generator_ps();
    poisson_generator_ps(const poisson_generator_ps&);

    bool has_proxies() const {return false;}
    bool is_off_grid() const {return true;}  // uses off_grid events

    using Node::event_hook;

    port send_test_event(Node&, rport, synindex, bool);

    void get_status(DictionaryDatum &) const;
    void set_status(const DictionaryDatum &);

  private:
    void init_state_(const Node&);
    void init_buffers_();
    void calibrate();

    void update(Time const &, const long_t, const long_t);
    
    void event_hook(DSSpikeEvent&);

    // ------------------------------------------------------------

    struct Parameters_ {
      double_t                rate_;        
      double_t                dead_time_;   

      size_t num_targets_;

      Parameters_();  

      void get(DictionaryDatum&) const;  
      void set(const DictionaryDatum&);  
    };

    // ------------------------------------------------------------

    struct Buffers_ {
      typedef std::pair<Time, double_t> SpikeTime;

      std::vector<SpikeTime> next_spike_;   
    };

    // ------------------------------------------------------------

    struct Variables_ {
      double_t                inv_rate_ms_; 
      librandom::ExpRandomDev exp_dev_;  

      Time t_min_active_;  
      Time t_max_active_;  

    };

    // ------------------------------------------------------------

    StimulatingDevice<CurrentEvent> device_;
    Parameters_ P_;
    Variables_  V_;
    Buffers_    B_;
  };

inline
  port poisson_generator_ps::send_test_event(Node& target, rport receptor_type, synindex syn_id, bool dummy_target)
  {
    device_.enforce_single_syn_type(syn_id);

    if ( dummy_target )
    {
      DSSpikeEvent e;
      e.set_sender(*this);
      return target.handles_test_event(e, receptor_type);
    }
    else
    {
      SpikeEvent e;
      e.set_sender(*this);
      const port p = target.handles_test_event(e, receptor_type);
      if ( p != invalid_port_ and not is_model_prototype() )
        ++P_.num_targets_;     // count number of targets
      return p;
    }
  }

inline
void poisson_generator_ps::get_status(DictionaryDatum &d) const
{
  P_.get(d);
  device_.get_status(d);
}

inline
void poisson_generator_ps::set_status(const DictionaryDatum &d)
{
  Parameters_ ptmp = P_;  // temporary copy in case of errors
  ptmp.set(d);               // throws if BadProperty

  // We now know that ptmp is consistent. We do not write it back
  // to P_ before we are also sure that the properties to be set
  // in the parent class are internally consistent.
  device_.set_status(d);

  // if we get here, temporaries contain consistent set of properties
  P_ = ptmp;
}

} // namespace

#endif //POISSON_GENERATOR_PS_H