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
 
// C++ includes:
#include <vector>
 
// Includes from nestkernel:
#include "connection.h"
#include "device_node.h"
#include "event.h"
#include "nest_types.h"
#include "random_generators.h"
#include "stimulation_device.h"
 
namespace nest
{
 
/* BeginUserDocs: device, generator
 
Short description
+++++++++++++++++
 
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.
 
.. include:: ../models/stimulation_device.rst
 
rate
    Mean firing rate of the component processes, default: 0 spikes/s
 
dead_time
    Minimal time between two spikes of the component processes, default: 0 ms
 
n_proc
    Number of superimposed independent component processes, default: 1
 
frequency
    Rate modulation frequency, default: 0 Hz
 
relative_amplitude
    Relative rate modulation amplitude, default: 0
 
See also :footcite:p:`Deger2011`.
 
Set parameters from a stimulation backend
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
The parameters in this stimulation device can be updated with input
coming from a stimulation backend. The data structure used for the
update holds one value for each of the parameters mentioned above.
The indexing is as follows:
 
 0. dead_time
 1. rate
 2. n_proc
 3. frequency
 4. relative_amplitude
 
References
++++++++++
 
.. footbibliography::
 
See also
++++++++
 
gamma_sup_generator, poisson_generator_ps, spike_generator
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: ppd_sup_generator
 
EndUserDocs */
 
void register_ppd_sup_generator( const std::string& name );
 
class ppd_sup_generator : public StimulationDevice
{
 
public:
  ppd_sup_generator();
  ppd_sup_generator( const ppd_sup_generator& );
 
  bool is_off_grid() const override;
 
  using Node::event_hook;
 
  size_t send_test_event( Node&, size_t, synindex, bool ) override;
 
  void get_status( Dictionary& ) const override;
  void set_status( const Dictionary& ) override;
 
  StimulationDevice::Type get_type() const override;
  void set_data_from_stimulation_backend( std::vector< double >& input_param ) override;
 
private:
  void init_state_() override;
  void init_buffers_() override;
  void pre_run_hook() override;
 
  void update( Time const&, const long, const long ) override;
 
  void event_hook( DSSpikeEvent& ) override;
 
  // ------------------------------------------------------------
 
  struct Parameters_
  {
    double rate_;           
    double dead_time_;      
    unsigned long n_proc_;  
    double frequency_;      
    double amplitude_;      
 
    size_t num_targets_;
 
    Parameters_();  
 
    void get( Dictionary& ) const;              
    void set( const Dictionary&, Node* node );  
  };
 
  // ------------------------------------------------------------
 
 
  class Age_distribution_
  {
    binomial_distribution bino_dist_;              
    poisson_distribution poisson_dist_;            
    std::vector< unsigned long > occ_refractory_;  
    unsigned long occ_active_;                     
    size_t activate_;                              
 
  public:
    Age_distribution_( size_t num_age_bins, unsigned long ini_occ_ref, unsigned long ini_occ_act );
 
    unsigned long update( double hazard_rate, RngPtr rng );
  };
 
 
  struct Buffers_
  {
    std::vector< Age_distribution_ > age_distributions_;
  };
 
  // ------------------------------------------------------------
 
  struct Variables_
  {
    double hazard_step_;    
    double hazard_step_t_;  
    double omega_;          
 
    double t_min_active_;  
    double t_max_active_;  
  };
 
  // ------------------------------------------------------------
 
  Parameters_ P_;
  Variables_ V_;
  Buffers_ B_;
};
 
inline size_t
ppd_sup_generator::send_test_event( Node& target, size_t receptor_type, synindex syn_id, bool dummy_target )
{
  StimulationDevice::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 size_t 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( Dictionary& d ) const
{
  P_.get( d );
  StimulationDevice::get_status( d );
}
 
inline void
ppd_sup_generator::set_status( const Dictionary& d )
{
  Parameters_ ptmp = P_;  // temporary copy in case of errors
  ptmp.set( d, this );    // 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.
  StimulationDevice::set_status( d );
 
  // if we get here, temporaries contain consistent set of properties
  P_ = ptmp;
}
 
inline bool
ppd_sup_generator::is_off_grid() const
{
  return false;
}
 
inline StimulationDevice::Type
ppd_sup_generator::get_type() const
{
  return StimulationDevice::Type::SPIKE_GENERATOR;
}
 
}  // namespace
 
#endif  // PPD_SUP_GENERATOR_H