poisson_dbl_exp_neuron.h

/*
 * This file is part of SPORE.
 *
 * Copyright (C) 2016, the SPORE team (see AUTHORS).
 *
 * SPORE 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.
 *
 * SPORE 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 SPORE.  If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information see: https://github.com/IGITUGraz/spore-nest-module
 *
 * File:   poisson_dbl_exp_neuron.h
 * Author: Hsieh, Kappel
 *
 * This file is based on pp_psc_delta.h which is part of NEST
 * (Copyright (C) 2004 The NEST Initiative).
 * See: http://nest-initiative.org/
 */

#ifndef POISSON_DBL_EXP_NEURON_H
#define POISSON_DBL_EXP_NEURON_H

#include "nest.h"
#include "event.h"
#include "ring_buffer.h"
#include "poisson_randomdev.h"
#include "gamma_randomdev.h"
#include "universal_data_logger.h"

#include "tracing_node.h"


namespace spore
{

class PoissonDblExpNeuron : public TracingNode
{
public:

    PoissonDblExpNeuron();
    PoissonDblExpNeuron(const PoissonDblExpNeuron&);

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

    nest::port send_test_event(nest::Node&, nest::rport, nest::synindex, bool);

    void handle(nest::SpikeEvent &);
    void handle(nest::CurrentEvent &);
    void handle(nest::DataLoggingRequest &);

    nest::port handles_test_event(nest::SpikeEvent&, nest::rport);
    nest::port handles_test_event(nest::CurrentEvent&, nest::rport);
    nest::port handles_test_event(nest::DataLoggingRequest&, nest::rport);

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

private:

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

    void update(nest::Time const &, const long, const long);

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

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

    struct Parameters_
    {
        double tau_rise_exc_;

        double tau_fall_exc_;

        double tau_rise_inh_;

        double tau_fall_inh_;

        double input_conductance_;

        double dead_time_;

        bool dead_time_random_;

        long dead_time_shape_;

        bool with_reset_;

        double c_1_;

        double c_2_;

        double c_3_;

        double I_e_;

        double t_ref_remaining_;

        double target_rate_;

        double target_adaptation_speed_;

        Parameters_(); 

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

    struct State_
    {
        double u_rise_exc_; 
        double u_fall_exc_; 
        double u_rise_inh_; 
        double u_fall_inh_; 
        double u_membrane_; 
        double input_current_; 
        double adaptive_threshold_; 
        int r_; 

        State_(); 

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

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

        nest::RingBuffer exc_spikes_;
        nest::RingBuffer inh_spikes_;
        nest::RingBuffer currents_;

        nest::UniversalDataLogger<PoissonDblExpNeuron> logger_;
    };

    struct Variables_
    {
        double decay_rise_exc_;
        double decay_fall_exc_;
        double decay_rise_inh_;
        double decay_fall_inh_;
        double norm_exc_;
        double norm_inh_;
        double h_; 
        double dt_rate_; 

        librandom::RngPtr rng_; // random number generator of my own thread
        librandom::PoissonRandomDev poisson_dev_; // random deviate generator
        librandom::GammaRandomDev gamma_dev_; // random deviate generator

        int DeadTimeCounts_;

    };

    // Access functions for UniversalDataLogger


    double get_V_m_() const
    {
        return S_.u_membrane_;
    }


    double get_E_sfa_() const
    {
        return S_.adaptive_threshold_;
    }

    Parameters_ P_;
    State_ S_;
    Variables_ V_;
    Buffers_ B_;
    static nest::RecordablesMap<PoissonDblExpNeuron> recordablesMap_;
};

inline
nest::port PoissonDblExpNeuron::send_test_event(nest::Node& target, nest::rport receptor_type, nest::synindex, bool)
{
    nest::SpikeEvent e;
    e.set_sender(*this);

    return target.handles_test_event(e, receptor_type);
}

inline
nest::port PoissonDblExpNeuron::handles_test_event(nest::SpikeEvent&, nest::rport receptor_type)
{
    if ((receptor_type != 0) && (receptor_type != 1))
    {
        throw nest::UnknownReceptorType(receptor_type, get_name());
    }

    return receptor_type;
}

inline
nest::port PoissonDblExpNeuron::handles_test_event(nest::CurrentEvent&, nest::rport receptor_type)
{
    if (receptor_type != 0)
    {
        throw nest::UnknownReceptorType(receptor_type, get_name());
    }

    return 0;
}

inline
nest::port PoissonDblExpNeuron::handles_test_event(nest::DataLoggingRequest &dlr,
                                                   nest::rport receptor_type)
{
    if (receptor_type != 0)
    {
        throw nest::UnknownReceptorType(receptor_type, get_name());
    }

    return B_.logger_.connect_logging_device(dlr, recordablesMap_);
}

inline
void PoissonDblExpNeuron::get_status(DictionaryDatum &d) const
{
    P_.get(d);
    S_.get(d, P_);

    (*d)[nest::names::recordables] = recordablesMap_.get_list();
}

inline
void PoissonDblExpNeuron::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;
}

}

#endif