binary_neuron.h

Go to the documentation of this file.

/*
 *  binary_neuron.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 BINARY_NEURON_H
#define BINARY_NEURON_H

#include "nest.h"
#include "event.h"
#include "archiving_node.h"
#include "ring_buffer.h"
#include "connection.h"
#include "universal_data_logger.h"
#include "recordables_map.h"
#include "exp_randomdev.h"
#include <cmath>

namespace nest{
  
  class Network;

  template<class TGainfunction>
  class binary_neuron : public Archiving_Node
  {
    
  public:
    
    binary_neuron();
    binary_neuron(const binary_neuron&);

    using Node::handle;
    using Node::handles_test_event;

    port send_test_event(Node&, rport, synindex, bool);
    
    void handle(SpikeEvent &);
    void handle(CurrentEvent &);
    void handle(DataLoggingRequest &);
    
    port handles_test_event(SpikeEvent &, rport);
    port handles_test_event(CurrentEvent &, rport);
    port handles_test_event(DataLoggingRequest &, rport);

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

  private:

    void init_state_(const Node& proto);
    void init_buffers_();
    void calibrate();

    // gain function functor
    // must have an double_t operator(double_t) defined
    TGainfunction gain_;

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

    // The next two classes need to be friends to access the State_ class/member
    friend class RecordablesMap<binary_neuron<TGainfunction> >;
    friend class UniversalDataLogger<binary_neuron<TGainfunction> >;
    
    // ---------------------------------------------------------------- 

    struct Parameters_ {
      double_t tau_m_;

      Parameters_();  

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

    struct State_ {
      bool y_;   
      double h_;   
      double last_in_gid_;   
      Time t_next_; 
      Time t_last_in_spike_; 

      State_();    
      
      void get(DictionaryDatum&, const Parameters_&) const;
      void set(const DictionaryDatum&, const Parameters_&);
    };    

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

    struct Buffers_ {
      Buffers_(binary_neuron&);
      Buffers_(const Buffers_&, binary_neuron&);

      RingBuffer spikes_;
      RingBuffer currents_;


      UniversalDataLogger<binary_neuron> logger_;
     };
    
    // ---------------------------------------------------------------- 

    struct Variables_ {
      librandom::RngPtr rng_; // random number generator of my own thread
      librandom::ExpRandomDev exp_dev_;  // random deviate generator
    };

    // Access functions for UniversalDataLogger -------------------------------
    
    double_t get_output_state__() const { return S_.y_; }

    double_t get_input__() const { return S_.h_; }

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

    Parameters_ P_;
    State_      S_;
    Variables_  V_;
    Buffers_    B_;
    static RecordablesMap<binary_neuron<TGainfunction> > recordablesMap_;

  };


template<class TGainfunction>
inline
port binary_neuron<TGainfunction>::send_test_event(Node& target, rport receptor_type, synindex, bool)
{
  SpikeEvent e;
  e.set_sender(*this);

  return target.handles_test_event(e, receptor_type);
}

template<class TGainfunction>
inline
port binary_neuron<TGainfunction>::handles_test_event(SpikeEvent&, rport receptor_type)
{
  if (receptor_type != 0)
    throw UnknownReceptorType(receptor_type, get_name());
  return 0;
}

template<class TGainfunction>
inline
port binary_neuron<TGainfunction>::handles_test_event(CurrentEvent&, rport receptor_type)
{
  if (receptor_type != 0)
    throw UnknownReceptorType(receptor_type, get_name());
  return 0;
}
 
template<class TGainfunction>
inline
port binary_neuron<TGainfunction>::handles_test_event(DataLoggingRequest& dlr,
                                                      rport receptor_type)
{
  if (receptor_type != 0)
    throw UnknownReceptorType(receptor_type, get_name());
  return B_.logger_.connect_logging_device(dlr, recordablesMap_);
}

template<class TGainfunction>
inline
void binary_neuron<TGainfunction>::get_status(DictionaryDatum &d) const
{
  P_.get(d);
  S_.get(d, P_);
  Archiving_Node::get_status(d);
  (*d)[names::recordables] = recordablesMap_.get_list();

  gain_.get(d);
}

template<class TGainfunction>
inline
void binary_neuron<TGainfunction>::set_status(const DictionaryDatum &d)
{
  Parameters_ ptmp = P_;  // temporary copy in case of errors
  ptmp.set(d);                       // throws if BadProperty
  State_      stmp = S_;  // temporary copy in case of errors
  stmp.set(d, ptmp);                 // throws if BadProperty

  // We now know that (ptmp, stmp) are consistent. We do not 
  // write them back to (P_, S_) before we are also sure that 
  // the properties to be set in the parent class are internally 
  // consistent.
  Archiving_Node::set_status(d);

  // if we get here, temporaries contain consistent set of properties
  P_ = ptmp;
  S_ = stmp;

  gain_.set(d);
}

} // namespace

#endif /* #ifndef BINARY_NEURON_H */