PLAdditiveKernelSpikeResponse.h

#ifndef AdditiveKernelSpikeResponseBase_H_
#define AdditiveKernelSpikeResponseBase_H_

#include "EvSimObject.h"
#include "DirectEventSender.h"
#include "SharedArray.h"
#include "SharedArrayTypes.h"
#include "SpikeResponse.h"
#include "EvSimObjectTypeUtils.h"

#include <queue>
#include <vector>


class PLAdditiveKernelSpikeResponse : public SpikeResponse, public DirectEventSender {

    EV_SIM_OBJECT( PLAdditiveKernelSpikeResponse )

public:

    PLAdditiveKernelSpikeResponse() : resp_shape_amplitudes(0), resp_shape_timepoints(0) {};


    PLAdditiveKernelSpikeResponse(const SharedArray<double> &resp_shape_amplitudes,
                                  const SharedArray<double> &resp_shape_timepoints)
        : resp_shape_amplitudes(resp_shape_amplitudes.get()),
          resp_shape_timepoints(resp_shape_timepoints.get())
    {}

    virtual ~PLAdditiveKernelSpikeResponse();


    void setResponseKernel(const SharedArray<double> &resp_shape_amplitudes,
                           const SharedArray<double> &resp_shape_timepoints)
    {                           
        this->resp_shape_amplitudes = resp_shape_amplitudes.get();
        this->resp_shape_timepoints = resp_shape_timepoints.get();
    }

    virtual unsigned numInputPorts() const
    {
        return 2;
    };

    virtual unsigned numOutputPorts() const
    {
        return 1;
    };


    virtual PortType getInputPortType(port_id_t p) const
    {
        if (p < 2)
            return eventPortDirect;
        return portUndefined;
    };

    virtual PortType getOutputPortType(port_id_t p) const
    {
        if (p == 0)
            return eventPortDirect;
        return portUndefined;
    };

    virtual void reset(SimContext &sim_ctxt);

    virtual double getSlope() {return slope;};

    virtual void postAddedInNetwork(EvSimNetwork &net, EvSimObject::ID self);
    
    virtual void eventHit(SimContext & sim_info, Time time, port_id_t port);

    virtual void updateState(SimContext &sim_info, Time time, update_id_t upd_id);

protected:
    class ResponseKernel {

    public:
        ResponseKernel(const vector<double> * resp_amplitudes, const vector<double> * resp_shape_timepoints);
        
        ~ResponseKernel();
        
        void trigger(Time time);
        
        void update(Time time);
        
        bool isFinished() const;

        double r;
        double slope;
        Time next_expected_time;
        
    protected:
        static const unsigned RESPONSE_NOT_ACTIVE = ~(0u);
        
        void updateResponse(Time time);
        
        const vector<double> * resp_shape_amplitudes;
        const vector<double> * resp_shape_timepoints;
        unsigned curr_timepoint;
    };

        class CompareResponseKernel {
        public:
                bool operator()(ResponseKernel const * left, ResponseKernel const * right) const {
                        return left->next_expected_time > right->next_expected_time;
                }
        };

    std::priority_queue<ResponseKernel*, std::vector<ResponseKernel*>, CompareResponseKernel > response_queue;
    
    const vector<double> * resp_shape_amplitudes;
    const vector<double> * resp_shape_timepoints;

    Time cur_time;
    double slope;
};

#endif /* AdditiveKernelSpikeResponseBase_H_ */