spike_detector.h

Go to the documentation of this file.

/*
 *  spike_detector.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 SPIKE_DETECTOR_H
#define SPIKE_DETECTOR_H


#include <vector>
#include "nest.h"
#include "event.h"
#include "node.h"
#include "recording_device.h"
#include "exceptions.h"

/* BeginDocumentation

Name: spike_detector - Device for detecting single spikes.

Description:
The spike_detector device is a recording device. It is used to record
spikes from a single neuron, or from multiple neurons at once. Data
is recorded in memory or to file as for all RecordingDevices. 
By default, GID and time of each spike is recorded.

The spike detector can also record spike times with full precision 
from neurons emitting precisely timed spikes. Set /precise_times to
achieve this.

Any node from which spikes are to be recorded, must be connected to 
the spike detector using a normal connect command. Any connection weight
and delay will be ignored for that connection.

Simulations progress in cycles defined by the minimum delay. During each
cycle, the spike detector records (stores in memory or writes to screen/file) 
the spikes generated during the previous cycle. As a consequence, any 
spikes generated during the cycle immediately preceding the end of the simulation
time will not be recorded. Setting the /stop parameter to at the latest one
min_delay period before the end of the simulation time ensures that all spikes
desired to be recorded, are recorded.

Spike are not necessarily written to file in chronological order.

Receives: SpikeEvent

SeeAlso: spike_detector, Device, RecordingDevice
*/


namespace nest
{

  class Network;

  class spike_detector : public Node
  {
    
  public:        
    
    spike_detector();
    spike_detector(const spike_detector&);
    
    void set_has_proxies(const bool hp);
    bool has_proxies() const { return has_proxies_; }
    bool potential_global_receiver() const {return true;}
    void set_local_receiver(const bool lr);
    bool local_receiver() const {return local_receiver_;} 
    
    using Node::handle;
    using Node::handles_test_event;

    void handle(SpikeEvent &);

    port handles_test_event(SpikeEvent &, rport);

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

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

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

    struct Buffers_ {
      std::vector<std::vector<Event*> > spikes_; 
    };
    
    RecordingDevice device_;
    Buffers_ B_;

    bool user_set_precise_times_;
    bool has_proxies_ ;
    bool local_receiver_;
  };
  
  inline 
  void spike_detector::set_has_proxies(const bool hp)
  {
    has_proxies_ = hp;
  }
  
  inline 
  void spike_detector::set_local_receiver(const bool lr)
  {
    local_receiver_ = lr;
  }
  
  inline
  port spike_detector::handles_test_event(SpikeEvent&, rport receptor_type)
  {
    if (receptor_type != 0)
        throw UnknownReceptorType(receptor_type, get_name());
    return 0;
  }
  
  inline
  void spike_detector::finalize()
  {
    device_.finalize();
  }
    
} // namespace

#endif /* #ifndef SPIKE_DETECTOR_H */