AbstractNeurer.h

Go to the documentation of this file.

 
#ifndef AbstractNeurer_h
#define AbstractNeurer_h
 
#include "Project.h"
#include "scGridPoint.h"
#include "NeurerConfig.h"
 
using namespace sc_core; using namespace std;
//#include "AbstractNeurerConnection.h"
class scSynapticConnect; class scAxonalConnect;
 
typedef vector <scSynapticConnect*>  scSynapticConnects_t;
typedef vector <scAxonalConnect*>  scAxonalConnects_t;
 
class NeurerProcessor;
class Spike;
class QSettings;
 
typedef enum
{
    nsb_Resting,    
    nsb_Triggering, 
    nsb_Charging,   
    nsb_Discharging, 
    nsb_Firing, 
    nsb_Max, 
}  NeurerOperatingBit_t;
 
 
class AbstractNeurer :  public scHThread
{
    friend class scSynapticConnect;
//    friend class AbstractNeurerState;
  public:
    // Constructor declaration:
    AbstractNeurer(const sc_core::sc_module_name nm, // Just the systemC name
//                    NeurerProcessor* Processor, // The present system is prepared for one topology only, but ...
                   scGridPoint* GP, SC_HTHREAD_ID_TYPE ID,
              bool StandAlone = true
            );
    ~AbstractNeurer(void);
        SC_HAS_PROCESS(AbstractNeurer);  // We have the constructor in the .cpp file
      // Directly HW-related functionality
        void
    Initialize_method(void);
 /*       void
     CreateNeurons(void);*/
        void
    Reset(void);
        bool
    IsMetaInstructionFetched(void)
    {assert(0);//return fetch.Stage.hi0 ==  (itype_t) I_QT;
            return false;
        }
        bool
    doFetchInstruction(void//SC_WORD_TYPE Instr
                         ) // The actual fetching; does not generate an event
{assert(0); return false;
    }
        bool
    doExecuteInstruction(void){assert(0); return false;}
        void
    doExecuteMetaInstruction()
        {assert(0);
            }
        NeurerProcessor*
    Processor_Get(void);
 
        void
    doQTERM(void)
       {assert(0);  }
       bool
   IsMetaInstructionReceived(void)
       {assert(0);  return false;}
        string
    StringOfName_Get(void){   return Owner_Get()->StringOfName_Get(ID_Get());}
        string
    PrologString_Get(void);
        scGridPoint*
    Parent_Get(void) { return  dynamic_cast<scGridPoint*>(scHThread::Parent_Get());}    
        scAxonalConnect*
    AxonalConnection_Get(unsigned int i)
    {   assert(i<m_Axons.size());
        return m_Axons[i];
    }
        scSynapticConnect*
    SynapticConnection_Get(unsigned int i)
    {   assert(i<m_Synapses.size());
        return m_Synapses[i];
    }
        void
    ConnectTo(AbstractNeurer* A);
        void
    ConnectFrom(scSynapticConnect* A);
        scSynapticConnect*
    FindSynapseFrom(AbstractNeurer* A);  
        scAxonalConnect*
    FindAxonTo(AbstractNeurer* A); // Return axonal connect to A, or NULL
 
       struct{
        sc_core::sc_event
            ActionPotential,
            Reset       
            ,Trigger 
            ,Charge  
            ,Discharge 
            , Leaking        
            ,Spiking        
            ,Recalculate    
        ;
        }EVENT_NEURER;  
        void
    Integrate_method(void);
        void    
    LeakingPeriod_Set(short unsigned int P);
        short unsigned int
    LeakingPeriod_Get(void){ return mLeakingPeriod;}
        void
    SynchronFrequency_Set(sc_core::sc_event* F){ mSynchronFrequency = F;
                                                 mSynchronFrequency->notify();
                                               }
        void
    Reset_method(void);       //Puts the neurer in its initial state
        void    
    ActionPotential_method(void);
        void
    Trigger_method(void);  // Puts the neurer in synaptic-aware more
        void
    Charge_method(void);  // Accumulates charge on the membrane, synaptic-unaware
        void
    Discharge_method(void); // Sends the spike to the axon
        int
    IntegratedCurrentInPeriod(int FromTime, int ToTime,
                                  int FromValue, int ToValue)
        {   assert(FromTime<ToTime);
            int Average = (FromValue + ToValue)/2;
            float TimeDiff = ToTime - FromTime;
            return TimeDiff*Average;
        }
        int
        NeurerCondensatorCapacity_Get(void)
        {
            return mNoOfSynapticPoints// The number of synaptic points
                    * 10 // Synaptic area, u^2
                    * .01 // The capacity of a single synapsis, a neuronal condensator
                    * THOUSAND; //The result is in  pF
        }
         void
    IncreaseActionPotentialWithCharge(int C)
        {
            mRunningCharge += C
  //                   /NeurerCondensatorCapacity_Get()
                    ;    // Add the actual contribution
             // it is in uV*usec == 10^{-12}F == 10^{-3}pC
        }
         int64_t
    RunningCharge_Get(){ return mRunningCharge;}
        void
    AddChargeContribution(int32_t C);
        void Spiking_method(void);
        int32_t AxonsNo_Get(void)
    {return m_Axons.size();} 
        int32_t SynapsesNo_Get(void)
    { return m_Synapses.size();} 
        void
    ReadSettings(string Group, QSettings* settings);
//        void setState(AbstractNeurer AN, AbstractNeurerState S);
//#if BIOLOGICAL_NEURON
        int32_t
        MembraneRestingPotential_Get()
        {
            return mMembraneRestingPotential;
        }
        int32_t
        MembraneRestingPotential_Set(int32_t NewPot)
        {
            mMembraneRestingPotential = NewPot;
        }
        int32_t
        MembranePotentialOffset_Get()
        {
 
        }
        void
        MembranePotentialContribution_Add(int32_t NewContrib);
        bool
        MembraneSynapticContribution_Add(int32_t NewContrib);
//#endif //BIOLOGICAL_NEURON
        void
    NeurerStateBit_Set(NeurerOperatingBit_t B, bool V)
    {
        assert(B < gob_Max);
        if(B==nsb_Resting) mOperatingState = 0; // Clear all other bits if resting
        mOperatingState[B] = V;
    }
        bool
    NeurerStateBit_Get(NeurerOperatingBit_t B)
        {   assert(B < gob_Max);
            return mOperatingState[B];
        }
 
protected:
 
        std::bitset<nsb_Max>
    mOperatingState; 
//        AbstractNeurerState *mState;   //!< Stores the actual working state
    void
        State_Set();
/*        void    /// Make the actual inspection; overwritten in subclasses
    doInspect(vector<int32_t>& in, vector<int32_t>& out);*/
        void Leaking_method(void);
        void Recalculate_method(void);
 
        scAxonalConnects_t
    m_Axons; 
//        vector <SynapticConnect_t>
        scSynapticConnects_t
    m_Synapses; 
       void
    AxonalConnectionAdd_To(AbstractNeurer* AC);
       void
    Fire(void);
        short unsigned int
    mLeakingPeriod;
        void
    Resynchronize_method(void);
        sc_core::sc_time
    LocalTime_Get(void);
        sc_core::sc_event*
    mSynchronFrequency; 
        sc_core::sc_time
    mSynchronOffset;    
        int
    mNoOfSynapticPoints; 
        int64_t     // Where the calculation of charge contributions is summed
    mRunningCharge;
        // Floating points have a default -1 … 1 range, but can take any integral limits
//        typedef saturating::type<float, -10, 200> ActionPotential_t;
 //       saturating::type<float, -10, 200>
        int32_t     
    mMembranePotential;
        int32_t     
    mMembranePotentialOffset;
        ActionPotential*
    mActionPotential;
        Spike*
    mSpike;
        int
    mSpikeTime; 
        int
    mSpikeAmplitude; 
        int
    mSpikeIndex;    
        uint16_t
    mTimeFactor, mAmplitudeFactor; 
        // Fix beginning of current action potential to current simuated time
        sc_core::sc_time
    ActionTime_Get();  // Return current time relative to zje beginnin gof the action potential
        void
    ActionPotentialTimeBegin_Set(void);
        sc_core::sc_time
    mActionPotentialStartAtMembrane1, mActionPotentialStartAtMembrane2;
#if BIOLOGICAL_NEURON
 //   #if !USE_INDIVIDUAL_RESTING_POTENTIAL
 //      static int
   // #endif // USE_INDIVIDUAL_RESTING_POTENTIAL
        int32_t   
        mMembraneRestingPotential;
#endif //
        //Just working variables, cross-action potential phases
    bool    // Remember if the last time, the membrane was within tolerance
        mBelowThresholdPreviously,
        mNearRestingPreviously;
        sc_core::sc_time    
    mActionPotentialBegin;
}; // of AbstractNeurer
#endif // AbstractNeurer_h