relaxos_van_der_pol.h

Go to the documentation of this file.

/*
 *  relaxos_van_der_pol.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 RELAXOS_VAN_DER_POL_H
#define RELAXOS_VAN_DER_POL_H

#include "nest.h"
#include "event.h"
#include "archiving_node.h"
#include "connection.h"
#include "universal_data_logger.h"


namespace nest {
  class Network;

  class relaxos_van_der_pol: public Archiving_Node {
    public:
      relaxos_van_der_pol();
      relaxos_van_der_pol(const relaxos_van_der_pol&);

      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&);
      void init_buffers_();
      void update(Time const &, const long_t, const long_t);
      void calibrate();

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

      struct Parameters_ {
        double_t Mu_;
        double_t I_ext_;
        double_t EPSP_;
        double_t IPSP_;
        double_t y_init;

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

      struct State_ {
        double_t y;

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

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

        RingBuffer ex_currents;
        RingBuffer in_currents;
        RingBuffer in_spikes;

        UniversalDataLogger<relaxos_van_der_pol> logger_;
      };

      struct Variables_ {
        double_t Y_init;
      };

      Parameters_ P_;
      State_ S_;
      Buffers_ B_;
      Variables V_;

      static RecordablesMap<relaxos_van_der_pol> recordablesMap_;
  };

  inline
  port nest::relaxos_van_der_pol::send_test_event(Node& target, rport receptor_type, synindex, bool)
  {
    //
  }

  inline
  port relaxos_van_der_pol::handles_test_event(SpikeEvent&, rport receptor_type)
  {
    //
  }

  inline
  port relaxos_van_der_pol::handles_test_event(CurrentEvent&, rport receptor_type)
  {
    //
  }

  inline
  port relaxos_van_der_pol::handles_test_event(DataLoggingRequest& dlr, rport receptor_type)
  {
    //
  }

  inline
  void relaxos_van_der_pol::get_status(DictionaryDatum &d) const
  {
    //
  }

  inline
  void relaxos_van_der_pol::set_status(const DictionaryDatum &d)
  {
    //
  }

} // namespace

#endif