---

dneuron.h

Go to the documentation of this file.

#ifndef __dneuron_h
#define __dneuron_h

#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <math.h>
#include <queue>
#include <iostream>
#include <iomanip>

#include "dsched.h"
#include "func.h"

namespace punnets_common {

const int debug_precision = 5;

typedef unsigned long long u_int64_t;


extern u_int64_t totalfire;

extern u_int64_t totalpulse;

extern u_int64_t totalpartition;

extern u_int64_t totalpartition_nonewton[4];


extern u_int64_t totalpartition_newton[4];


extern u_int64_t totalpeaksearch[3];

extern u_int64_t totalpeakenclosing;

extern u_int64_t totalrescheduled;

extern u_int64_t totalfiltered_maxgrad;

extern u_int64_t totalfiltered_incontinuity;

extern u_int64_t totalfiltered_nextpulse;


//const bool global_debug = true;
//const bool force_global_debug = true;

const real epsilon = 1e-10;

class tsynapse_base;



template <bool d>
class debugflag;


template <> class debugflag<false> 
{ 
public: 
    bool getDeb() const { return false; } 
    void setDeb(bool) { std::cout << "No Debug" << std::endl; } 
};


template <> class debugflag<true> 
{ 
protected: 
    bool debug;  
public: 
    debugflag() { debug = false; } 
    bool getDeb() const { return debug; } 
    void setDeb(bool b) { debug = b; } 
};



class tneuron_base
{
protected:
    std::string name;
    mutable tqueue _queue;

public:
    tneuron_base(std::string iname = "")
        : name(iname) { }
    virtual ~tneuron_base() { }
    const std::string &getName() const { return name; }
    
    virtual void pulseArrive(
                    tscheduler &scheduler, 
                    ntime_t current_time, 
                    real pulse_level) = 0;
    virtual void pulseArrive(
                    tscheduler &/*scheduler*/, 
                    ntime_t /*current_time*/, 
                    message_base * /*mess*/) { }
    virtual void pulseArrive(
                    tscheduler &/*scheduler*/, 
                    ntime_t /*current_time*/, 
                    func_base * /*func*/) { }

    virtual void addSynapse(tsynapse_base *) { }

    virtual real getCurrentSigLevel(ntime_t /*current_time*/) { return 0.0; };
    virtual real getCurrentThrLevel(ntime_t /*current_time*/) { return 0.0; };
    virtual real getCurrentExtInput(ntime_t /*current_time*/) { return 0.0; }

    virtual ntime_t getLastFire() const { return 0; }
    virtual ntime_t getLastSimulate() const { return 0; }
    virtual int getLastSimulateType() const { return 0; }

    virtual tqueue *queue() const { return &_queue; }

    virtual const char *getClassName() const { return "tneuron_base"; };
};


/*************************************************************************/



class tsynapse_base : public taction
{
protected:
    ntime_t ndelay;

public:
    tsynapse_base(ntime_t idelay) : taction(), ndelay(idelay) { }
    ntime_t getDelay() const { return ndelay; }
    virtual real getWeight()   const { return 0; }

    virtual void setSrc(tneuron_base &) { }
    virtual tneuron_base &getSrc() const { throw "ERROR"; }
    virtual tneuron_base &getDest() const { throw "ERROR"; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time) = 0;

    virtual const char *getClassName() const { return "tsynapse_base"; };
};

} // namespace punnets_common
namespace punnets_private {
using namespace punnets_common;



template <bool debug>
class tsynapse : public tsynapse_base, public debugflag<debug>
{
protected:
    tneuron_base *src;
    tneuron_base *dest;
    real weight;

public:
    tsynapse(tneuron_base &isrc, tneuron_base &idest, ntime_t idelay, real iweight)
        : tsynapse_base(idelay), src(&isrc), dest(&idest), weight(iweight) { }
    tsynapse(tneuron_base &idest, ntime_t idelay, real iweight)
        : tsynapse_base(idelay), src(NULL), dest(&idest), weight(iweight) { }
    virtual ~tsynapse() { }

    virtual void setSrc(tneuron_base &isrc) { src = &isrc; }

    virtual real getWeight()   const { return weight; }
    virtual tneuron_base &getSrc() const { if( src == NULL ) throw "ERROR"; return *src; }
    virtual tneuron_base &getDest() const { return *dest; }

    void addWeight(real delta_w)    { weight += delta_w; }
    void addDelay(ntime_t delta_d)  { ndelay += delta_d; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
    {
        if( getDeb() )
            std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << dest->getName() << 
                " Pulse Arrived from " << src->getName() << " (delay=" << ndelay << ", w=" << weight << ")" << std::endl;
        dest->pulseArrive( scheduler, current_time, weight );
    }

    virtual tqueue *queue() const { return dest->queue(); }
};



template <bool debug>
class tsynapse_message : public tsynapse_base, public debugflag<debug>
{
protected:
    tneuron_base *src;
    tneuron_base *dest;
    message_base *mess;

public:
    tsynapse_message(tneuron_base &isrc, tneuron_base &idest, real idelay, message_base *imess)
        : tsynapse_base(idelay), src(&isrc), dest(&idest), mess(imess) { }
    tsynapse_message(tneuron_base &idest, real idelay, message_base *imess)
        : tsynapse_base(idelay), src(NULL), dest(&idest), mess(imess) { }
    virtual ~tsynapse_message() { delete mess; }

    virtual void setSrc(tneuron_base &isrc) { src = &isrc; }

    virtual tneuron_base &getSrc() const { if( src == NULL ) throw "ERROR"; return *src; }
    virtual tneuron_base &getDest() const { return *dest; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
    {
        if( getDeb() )
            std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << dest->getName() << 
            " Pulse Arrived from " << src->getName() << std::endl;
        dest->pulseArrive( scheduler, current_time, mess );
    }
};



template <bool debug>
class tsynapse_fatigue : public tsynapse_base, public debugflag<debug>
{
protected:
    tneuron_base *src;
    tneuron_base *dest;
    real weight;
    ntime_t last_fire;
    real last_weight;

    static const ntime_t recover_hv_period = 2000;
    static const real    fire_ratio = 0.002;

public:
    tsynapse_fatigue(tneuron_base &isrc, tneuron_base &idest, real idelay, real iweight)
        : tsynapse_base(idelay), src(&isrc), dest(&idest), weight(iweight / fire_ratio), last_fire( -Infinity ), last_weight(weight) { }
    tsynapse_fatigue(tneuron_base &idest, real idelay, real iweight)
        : tsynapse_base(idelay), src(NULL), dest(&idest), weight(iweight / fire_ratio), last_fire( -Infinity ), last_weight(weight) { }
    virtual ~tsynapse_fatigue() { }

    virtual real getWeight()   const { return weight; }
    virtual tneuron_base &getSrc() const { if( src == NULL ) throw "ERROR"; return *src; }
    virtual tneuron_base &getDest() const { return *dest; }

    void addWeight(real delta_w)    { weight += delta_w; }
    void addDelay(ntime_t delta_d)  { ndelay += delta_d; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
    {
        real this_weight = weight + (last_weight - weight) * exp( (current_time - last_fire) * (-M_LN2 / recover_hv_period) );
        if( getDeb() )
            std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << dest->getName() << 
            " Pulse Arrived from " << src->getName() << "(" << this_weight * fire_ratio << "/" << weight << ")" << std::endl;
        dest->pulseArrive( scheduler, current_time, this_weight * fire_ratio );
        last_fire = current_time;
        last_weight = this_weight * (1.0 - fire_ratio);
    }

    virtual const char *getClassName() const { return "tsynapse_fatigue"; };
};


/*************************************************************************/



template <bool debug>
class tneuron : public tneuron_base, public taction, public debugflag<debug>
{
protected:

    real sig_level;
    ntime_t last_simulate;
    ntime_t last_fire;
    std::vector<tsynapse_base *> synapses;

    void fire(tscheduler &scheduler, ntime_t current_time);

    static const ntime_t def_sig_hv_period = 2.0;
    static const ntime_t def_thr_hv_period = 0.5;
    static const real def_min_threshold    = 1.0;
    static const real def_max_threshold    = 11.0;

    ntime_t sig_hv_period;
    ntime_t thr_hv_period;
    real min_threshold;
    real max_threshold;
    static const real sig_converge_level = 0.0;

    real coeff_sigdecay;
    real coeff_thrdecay;

    void simulateElapse( ntime_t current_time )
    {
        sig_level = sig_converge_level +
                    ( ( sig_level - sig_converge_level ) 
                      * exp( (current_time - last_simulate) * coeff_sigdecay ) );
        last_simulate = current_time;
    }
    virtual void scheduleFire( tscheduler &scheduler, ntime_t current_time, bool resched = true );

public:
    tneuron(std::string iname = "", 
                     ntime_t isig_hv_period = def_sig_hv_period, 
                     ntime_t ithr_hv_period = def_thr_hv_period,
                     real imin_threshold = def_min_threshold,
                     real imax_threshold = def_max_threshold );
    virtual ~tneuron();

    virtual real getCurrentSigLevel(ntime_t current_time)
        { simulateElapse( current_time ); return sig_level; }

    virtual real getCurrentThrLevel(ntime_t current_time) 
        {
            return min_threshold + 
                   ( (max_threshold - min_threshold) 
                     * exp( (current_time - last_fire) * coeff_thrdecay ) );
        }

    virtual void pulseArrive(
                    tscheduler &scheduler, 
                    ntime_t current_time, 
                    real pulse_level)
        { totalpulse++; simulateElapse( current_time ); sig_level += pulse_level; scheduleFire( scheduler, current_time ); }

    virtual void addSynapse(tsynapse_base *s) 
        { synapses.push_back(s); s->setSrc(*this); }
    virtual void eraseSynapse(tsynapse_base *s) 
        { remove( synapses.begin(), synapses.end(), s); }

    virtual ntime_t getLastFire() const { return last_fire; }
    virtual ntime_t getLastSimulate() const { return last_simulate; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
        { 
        if( getDeb() )
            std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << getName() << 
                " Pulse arrived (loopback)" << std::endl;
        simulateElapse(current_time); scheduleFire(scheduler, current_time, false); };

    virtual const char *getClassName() const { return "tneuron"; };

    virtual tqueue *queue() const { return &_queue; }

    const std::vector<tsynapse_base *> &getSynapses() { return synapses; }
};

/*************************************************************************/


template <bool debug>
class tneuron_ext_const : public tneuron<debug>
{
protected:
    static const real def_ext_input            = 0.0;
    real ext_input;
    real sig_converge_level;

    void simulateElapse( ntime_t current_time )
    {
        sig_level = sig_converge_level +
                    ( ( sig_level - sig_converge_level ) 
                      * exp( (current_time - last_simulate) * coeff_sigdecay ) );
        last_simulate = current_time;
    }
    virtual void scheduleFire( tscheduler &scheduler, ntime_t current_time, bool resched = true );

public:
    tneuron_ext_const(std::string iname = "", 
                     ntime_t isig_hv_period = def_sig_hv_period, 
                     ntime_t ithr_hv_period = def_thr_hv_period,
                     real imin_threshold = def_min_threshold,
                     real imax_threshold = def_max_threshold,
                     real iext_input = def_ext_input ) 
        : tneuron<debug>( iname, isig_hv_period, ithr_hv_period, imin_threshold, imax_threshold ),
          ext_input(iext_input), sig_converge_level(iext_input / coeff_sigdecay) { }
    virtual ~tneuron_ext_const() { }    

    virtual real getCurrentSigLevel(ntime_t current_time)
        { simulateElapse( current_time ); return sig_level; }

    real getExtInput() { return ext_input; }
    virtual real getCurrentExtInput(ntime_t /*current_time*/) { return ext_input; }
    void setExtInput(tscheduler &scheduler, ntime_t current_time, real val) 
        { simulateElapse( current_time ); ext_input = val; sig_converge_level = ext_input / coeff_sigdecay; scheduleFire( scheduler, current_time ); }
    real getConvergeLevel() { return sig_converge_level; }
    void setConvergeLevel(tscheduler &scheduler, ntime_t current_time, real val) 
        { simulateElapse( current_time ); sig_converge_level = val; ext_input = sig_converge_level * coeff_sigdecay; scheduleFire( scheduler, current_time ); }

    virtual const char *getClassName() const { return "tneuron_ext_const"; };
};


/*************************************************************************/


template <bool debug>
class tneuron_ext : public tneuron_base, public taction, public debugflag<debug>
{
protected:
    std::vector<tsynapse_base *> synapses;
    std::vector<func_base *> exts;
    func_delta_int *pulses;
    ntime_t last_simulate;
    ntime_t last_fire;
    ntime_t loopback;

    real lambda;

    int last_simulate_type; 


    void fire(tscheduler &scheduler, ntime_t current_time);

    real calcSignal( ntime_t current_time );

    virtual void scheduleFire( tscheduler &scheduler, ntime_t current_time, bool resched = true );

    bool sendMessage(ntime_t t, message_base *mess);
    bool broadcastMessage(ntime_t t, message_base *mess);

public:
    tneuron_ext(std::string iname = "", real sig_hv_period = 1.0);
    virtual ~tneuron_ext();

    virtual real getCurrentSigLevel(ntime_t current_time)
        { return calcSignal(current_time); }

    virtual real getCurrentThrLevel(ntime_t /*current_time*/) 
        { return 0.0; }

    virtual void pulseArrive(
                    tscheduler &scheduler, 
                    ntime_t current_time, 
                    real pulse_level);

    virtual void pulseArrive(
                    tscheduler &scheduler, 
                    ntime_t current_time, 
                    message_base *mess);

    virtual void pulseArrive(
                    tscheduler &scheduler, 
                    ntime_t current_time, 
                    func_base *func);

    virtual void addSynapse(tsynapse_base *s) 
        { synapses.push_back(s); s->setSrc(*this); }
    virtual void eraseSynapse(tsynapse_base *s) 
        { remove( synapses.begin(), synapses.end(), s); }
    virtual void addExt(func_base *s) 
        {   s->setLambda(lambda);
            s->setZeroPoint(last_fire);
            exts.push_back(s); }

    virtual ntime_t getLastFire() const { return last_fire; }
    virtual ntime_t getLastSimulate() const { return last_simulate; }
    virtual int getLastSimulateType() const { return last_simulate_type; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
        { 
            if( getDeb() )
                std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << getName() << 
                " Pulse arrived (loopback)" << std::endl;
            if( current_time == loopback )
                scheduleFire(scheduler, current_time, false);
            else 
            { 
                if( getDeb() )
                    std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << getName() << 
                        " Pulse loopback ignored loopback=" << loopback << ", diff=" << std::setprecision(10) << loopback - current_time << std::endl;
            }
        };

    virtual const char *getClassName() const { return "tneuron_ext"; };

    const std::vector<tsynapse_base *> &getSynapses() { return synapses; }

    virtual tqueue *queue() const { return tneuron_base::queue(); }

    void setLoopBack(tscheduler &scheduler, ntime_t schedule_time)
    {
        loopback = schedule_time;
        if( schedule_time < mak::Infinity )
            scheduler.scheduleEvent( schedule_time, *this );
    }

};



template <bool debug>
class tsynapse_addfunc : public tsynapse_base, public debugflag<debug>
{
protected:
    tneuron_base *src;
    tneuron_ext<debug> *dest;
    func_base *func;
    message_base *mess;
    real lev;

public:
    tsynapse_addfunc(tneuron_base &isrc, tneuron_ext<debug> &idest, real idelay, func_base *ifunc, message_base *imess = NULL, real ilev = 0.0)
        : tsynapse_base(idelay), src(&isrc), dest(&idest), func(ifunc), mess(imess), lev(ilev) { }
    tsynapse_addfunc(tneuron_ext<debug> &idest, real idelay, func_base *ifunc, message_base *imess = NULL, real ilev = 0.0)
        : tsynapse_base(idelay), src(NULL), dest(&idest), func(ifunc), mess(imess), lev(ilev) { }
    virtual ~tsynapse_addfunc() { }

    virtual void setSrc(tneuron_base &isrc) { src = &isrc; }

//  virtual real getWeight()   const { return weight; }
    virtual tneuron_base &getSrc() const { if( src == NULL ) throw "ERROR"; return *src; }
    virtual tneuron_ext<debug> &getDest() const { return *dest; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
    {
        if( getDeb() )
            std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << dest->getName() << " Pulse Arrived (func) from " << src->getName() << std::endl;
        func_base *f = func->clone();
        if( mess )
            f->processMessage( current_time, *mess );
        dest->addExt(f);
        dest->pulseArrive( scheduler, current_time, lev );
    }

    virtual tqueue *queue() const { return dest->queue(); }
};

template <bool debug>
class tsynapse_messfunc : public tsynapse_base, public debugflag<debug>
{
protected:
    tneuron_base *src;
    tneuron_ext<debug> *dest;
    func_base *func;
    message_base *mess;
    real lev;

public:
    tsynapse_messfunc(tneuron_base &isrc, tneuron_ext<debug> &idest, real idelay, func_base *ifunc, message_base *imess, real ilev=0.0)
        : tsynapse_base(idelay), src(&isrc), dest(&idest), func(ifunc), mess(imess), lev(ilev) { dest->addExt(func); }
    tsynapse_messfunc(tneuron_ext<debug> &idest, real idelay, func_base *ifunc, message_base *imess, real ilev=0.0)
        : tsynapse_base(idelay), src(NULL), dest(&idest), func(ifunc), mess(imess), lev(ilev) { dest->addExt(func); }
    virtual ~tsynapse_messfunc() { }

    virtual void setSrc(tneuron_base &isrc) { src = &isrc; }

//  virtual real getWeight()   const { return weight; }
    virtual tneuron_base &getSrc() const { if( src == NULL ) throw "ERROR"; return *src; }
    virtual tneuron_ext<debug> &getDest() const { return *dest; }

    virtual void activate(tscheduler &scheduler, ntime_t current_time)
    {
        if( getDeb() )
            std::cout << std::setw(9) << std::setiosflags(std::ios::fixed) << std::setprecision(debug_precision) << current_time << " " << dest->getName() << " Pulse Arrived (func) from " << src->getName() << std::endl;
        func->processMessage( current_time, *mess );
//      cout << f->getDescription() << endl;
        dest->pulseArrive( scheduler, current_time, lev );
    }
    virtual tqueue *queue() const { return dest->queue(); }
};


}

namespace punnets_common {
taction &makePulse( tneuron_base &idest, real ilevel );
taction &makePulse( tneuron_base &idest, message_base *message );
template <bool b>
taction &setExtInput( punnets_private::tneuron_ext_const<b> &idest, real ilevel );
}


namespace punnets {
typedef class punnets_private::tsynapse<true>         tsynapse;
typedef class punnets_private::tsynapse_message<true> tsynapse_message;
typedef class punnets_private::tsynapse_fatigue<true> tsynapse_fatigue;
typedef class punnets_private::tsynapse_addfunc<true>    tsynapse_addfunc;
typedef class punnets_private::tsynapse_messfunc<true>    tsynapse_messfunc;

typedef class punnets_private::tneuron<true>           tneuron;
typedef class punnets_private::tneuron_ext_const<true> tneuron_ext_const;
typedef class punnets_private::tneuron_ext<true>       tneuron_ext;

}   // namespace punnets


namespace punnets_nodebug {
typedef class punnets_private::tsynapse<false>         tsynapse;
typedef class punnets_private::tsynapse_message<false> tsynapse_message;
typedef class punnets_private::tsynapse_fatigue<false> tsynapse_fatigue;
typedef class punnets_private::tsynapse_addfunc<false>    tsynapse_addfunc;
typedef class punnets_private::tsynapse_messfunc<false>    tsynapse_messfunc;

typedef class punnets_private::tneuron<false>           tneuron;
typedef class punnets_private::tneuron_ext_const<false> tneuron_ext_const;
typedef class punnets_private::tneuron_ext<false>       tneuron_ext;

}

#endif

---