ppd_sup_generator.h

Go to the documentation of this file.

/*
 *  ppd_sup_generator.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 ppd_sup_generator_H
#define ppd_sup_generator_H

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

/*BeginDocumentation
Name: ppd_sup_generator - simulate the superimposed spike train of a population of Poisson processes with dead time.
Description:

  The ppd_sup_generator generator simulates the pooled spike train of a 
  population of neurons firing independently with Poisson process with dead 
  time statistics. 
  The rate parameter can also be sine-modulated. The generator does not 
  initialize to equilibrium in this case, initial transients might occur.

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

   rate - mean firing rate of the component processes. (double, var)
   dead_time - minimal time between two spikes of the component processes. (double, var)
   n_proc - number of superimposed independent component processes. (long, var)
   frequency - rate modulation frequency. (double, var)
   amplitude - relative rate modulation amplitude. (double, var)

Note:
   The generator has been published in Deger, Helias, Boucsein, Rotter (2011) 
   Statistical properties of superimposed stationary spike trains, 
   Journal of Computational Neuroscience.
   URL: http://www.springerlink.com/content/u75211r381p08301/
   DOI: 10.1007/s10827-011-0362-8

Authors:
   June 2009, Moritz Deger, Moritz Helias

SeeAlso: gamma_sup_generator, poisson_generator_ps, spike_generator, Device, StimulatingDevice
*/


namespace nest{

  class ppd_sup_generator: public Node
  {
    
  public:        
    
    ppd_sup_generator();
    ppd_sup_generator(const ppd_sup_generator&);
    
    bool has_proxies() const {return false;}
    bool is_off_grid() const {return false;}  // does not use 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_;   
      ulong_t                 n_proc_;      
      double_t                frequency_;   
      double_t                amplitude_;   

      size_t num_targets_;

      Parameters_();  

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

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


    class Age_distribution_ {
    
      librandom::BinomialRandomDev bino_dev_;       
      librandom::PoissonRandomDev poisson_dev_;     
      std::vector<ulong_t> occ_refractory_;         
      ulong_t  occ_active_;                         
      size_t activate_;                             
      
      public:
      Age_distribution_(size_t num_age_bins, ulong_t ini_occ_ref, ulong_t ini_occ_act);  
      ulong_t update(double_t hazard_rate, librandom::RngPtr rng);    
    
    };
    
    

    struct Buffers_ {
      std::vector<Age_distribution_> age_distributions_;
      
    };

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

    struct Variables_ {
      double_t                hazard_step_;    
      double_t                hazard_step_t_;  
      double_t                omega_;          

      double_t t_min_active_;  
      double_t t_max_active_;  

    };

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

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

inline
port ppd_sup_generator::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 ppd_sup_generator::get_status(DictionaryDatum &d) const
{
  P_.get(d);
  device_.get_status(d);
}

inline
void ppd_sup_generator::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 //PPD_SUP_GENERATOR_H