ActionPotential.h

Go to the documentation of this file.

/*  @author János Végh (jvegh)
*  @bug No known bugs.
*/
#ifndef ACTIONPOTENTIAL_H
#define ACTIONPOTENTIAL_H
 
#include "NeurerConfig.h"
#include "Utils.h"
using namespace std;
class AbstractNeurer;
 
struct ActionPotentialPoint{unsigned int Time; signed int Amplitude;};
typedef vector<ActionPotentialPoint>  ActionPotentialVector;
 
 
/*
 * Performing floating calculations is a serious limiting factor of computing simulation.
 * This class uses a special method that the factors are in units of THOUSAND
 * The integer values to be scaled are multiplied by that factor, then divided by THOUSAND
 * If THOUSAND=1024 was selected in the config file, the division is replaced by shifting
 * This leads to 2.4% deviation from the 'true' value, and much quicker operation.
 *
 * Spikes may have two forms, depending on a configurable variable.
 * If SPIKE_DETAILED is true:
 * a real current pulse is delivered, which is integrated in the synapses,
 * (a broken line, with adjustable time and aplitude factors)
 * otherwise only the major information is delived
 *
 * In both cases the arrival time is delivered, per synapses to the spikes
 * (this is the logical time: the message
 * A spike is sent by AbstractNeurer#Fire to all (postsynaptic)  neurons, the synapses of which are listed
 * in AbstractNeurer#m_Axons. The spike message is delivered immediately, but it is put
 * by the destination neuron in a time-ordered queue, where it will seemingly arrive
 * exactly at the wanted time, and will be delivered to the correct synapsys, where
 * it will be processed as described at scSynapticConnect.
 *
 * excitation period 0-2.3; -70 mV--50 mV
 * 0 ms 324, 5 ms 610
 * 0 V 221, -100 mV 504
 * X position: (x-324)*(610-324)/5 == 57.2
 
 * Pont (500,232) ::: (3.077,-3.887)
 * Pont (531,120) ::: (3.618, 35.689)
 
 */
 
class ActionPotential
{
  public:
    ActionPotential(AbstractNeurer* Neurer, const ActionPotentialVector& ActionPotentialForm, sc_core::sc_time T0 ):
    mActionPotentialTable(ActionPotentialForm)  // Sets up the potential form
    ,MyNeurer(Neurer)
    ,mActionPotentialLength(ActionPotentialForm.size()) // Just to know
    {
        mLastTime = sc_core::sc_time((mActionPotentialTable[0].Time-324)/0.572,sc_core::SC_US);
        mActionPotentialIndex = 1;  // The real play starts at point 1
    }
 
    // * For simplicity (and lazyness) the time (X) and voltage (Y) values are calculated as
    // * X position: (x-324)/57.2
    sc_core::sc_time Time_Get(int n)
    {assert(n<mActionPotentialLength);
        sc_core::sc_time mThisTime = sc_core::sc_time((mActionPotentialTable[n].Time-324)/0.572,sc_core::SC_US);   // Return time value to the potential increase
        sc_core::sc_time TDif = ThisTime-mLastTime; mLastTime = ThisTime;
        return TDif;}   // Returm the difference relative to the current time, in usec : the next firing time
    // * Y position: (y-221)*(504-221)/100 = -2.83
    uint32_t Voltage_Get(int n){assert(n<mActionPotentialLength);
         return (-(mActionPotentialTable[n].Amplitude-221)/0.00283 );}
        // The potential contruibution compared to the resting potential
    bool AddVoltageContribution(int32_t dV)
        {MyNeurer->AddVoltageContribution(dV);}
          virtual
    ~ActionPotential(){}
 
protected:
    AbstractNeurer* MyNeurer;   // Which neurons membrane we are contriibuting to
    const ActionPotentialVector& mActionPotentialTable;   // Points to a spike table
    sc_core::sc_time mLastTime;  // Remember the last time, in usec
    int mActionPotentialIndex;  // Just a work wariable, maybe not needed
    int mActionPotentialLength;   // Just to know  size
    sc_core::sc_time TimeBegin; // When the action potential became active
 };
 
#endif // ACTIONPOTENTIAL_H