spin_detector.h

Go to the documentation of this file.

/*
 *  spin_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 SPIN_DETECTOR_H
#define SPIN_DETECTOR_H


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

/* BeginDocumentation

Name: spin_detector - Device for detecting single spikes.

Description:
The spin_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 spin_detector : public Node
  {
    
  public:        
    
    spin_detector();
    spin_detector(const spin_detector&);
    
    bool has_proxies() const { return false; }
    bool local_receiver() const {return true;} 

    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_;
    index last_in_gid_;
    Time t_last_in_spike_;
    bool user_set_precise_times_;
  };

  inline
  port spin_detector::handles_test_event(SpikeEvent&, rport receptor_type)
  {
    if (receptor_type != 0)
        throw UnknownReceptorType(receptor_type, get_name());
    return 0;
  }
  
  inline
  void spin_detector::finalize()
  {
    device_.finalize();
  }
    
} // namespace

#endif /* #ifndef SPIN_DETECTOR_H */