gamma_sup_generator.h

Go to the documentation of this file.

/*
 *  gamma_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 GAMMA_SUP_GENERATOR_H
#define GAMMA_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: gamma_sup_generator - simulate the superimposed spike train of a population of gamma process.
Description:

  The gamma_sup_generator generator simulates the pooled spike train of a 
  population of neurons firing independently with gamma process statistics. 

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

   rate - mean firing rate of the component processes. (double, var)
   gamma_shape - shape paramter of component gamma processes. (long, var)
   n_proc - number of superimposed independent component processes. (long, 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

Author:
   Jan 2011, Moritz Deger

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

namespace nest{

  class gamma_sup_generator: public Node
  {
    
  public:        
    
    gamma_sup_generator();
    gamma_sup_generator(const gamma_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_;        
      ulong_t                 gamma_shape_;       
      ulong_t                 n_proc_;      

      size_t num_targets_;

      Parameters_();  

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

    // ------------------------------------------------------------
    
    class Internal_states_ {
    
      librandom::BinomialRandomDev bino_dev_;       
      librandom::PoissonRandomDev poisson_dev_;     
      std::vector<ulong_t> occ_;                    
      
      public:
      Internal_states_(size_t num_bins, ulong_t ini_occ_ref, ulong_t ini_occ_act);  
      ulong_t update(double_t transition_prob, librandom::RngPtr rng);    
    
    };
    

    struct Buffers_ {
      std::vector<Internal_states_> internal_states_;
      
    };

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

    struct Variables_ {
      double_t                transition_prob_;  

      double_t t_min_active_;  
      double_t t_max_active_;  

    };

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

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

inline
port gamma_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_)
      ++P_.num_targets_;     // count number of targets
    return p;
  }
}

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

inline
void gamma_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