RandomNeuron.cpp

Go to the documentation of this file.

#include "StdAfx.h"

#include "Synapse.h"
#include "Neuron.h"
#include "RandomNeuron.h"
#include "FiringRateModule.h"

namespace FiringRateSim
{
        namespace Neurons
        {

RandomNeuron::RandomNeuron()
{
        //decide randomly whether it starts high or low.
        if(Std_IRand(0, 100) > 50) 
                m_iIntrinsicTypeDefault=IH_CURRENT;
        else
                m_iIntrinsicTypeDefault=IL_CURRENT;

        m_fltITime=0;
        m_iIntrinsicType = m_iIntrinsicTypeDefault;
        m_fltIntrinsic=0;
        m_fltIl=0;
        m_fltIlinit = 0;

        m_lpCurrentGraph = NULL;
        m_lpBurstGraph = NULL;
        m_lpIBurstGraph = NULL;
}

RandomNeuron::~RandomNeuron()
{

try
{
        if(m_lpCurrentGraph) delete m_lpCurrentGraph;
        if(m_lpBurstGraph) delete m_lpBurstGraph;
        if(m_lpIBurstGraph) delete m_lpIBurstGraph;
}
catch(...)
{Std_TraceMsg(0, "Caught Error in desctructor of RandomNeuron\r\n", "", -1, false, true);}
}

float RandomNeuron::ITime()
{return m_fltITime;}

void RandomNeuron::ITime(float fltVal)
{
        m_fltITime=fltVal;
}

unsigned char RandomNeuron::IntrinsicType()
{return m_iIntrinsicType;}

void RandomNeuron::IntrinsicType(unsigned char iVal)
{
        m_iIntrinsicType=iVal;
}

float RandomNeuron::IntrinsicCurrent()
{return m_fltIntrinsic;}

void RandomNeuron::IntrinsicCurrent(float fltVal)
{
        m_fltIntrinsic=fltVal;
}

float RandomNeuron::Il()
{return m_fltIl;}

void RandomNeuron::Il(float fltVal)
{
        m_fltIl=fltVal;
}

float RandomNeuron::Ilinit()
{return m_fltIlinit;}

void RandomNeuron::Ilinit(float fltVal)
{
        m_fltIlinit=fltVal;
        m_fltIl = m_fltIlinit;
}

unsigned char RandomNeuron::NeuronType()
{return RANDOM_NEURON;}

void RandomNeuron::Copy(CStdSerialize *lpSource)
{
        Neuron::Copy(lpSource);

        RandomNeuron *lpOrig = dynamic_cast<RandomNeuron *>(lpSource);

        m_fltITime = lpOrig->m_fltITime;
        m_iIntrinsicTypeDefault = lpOrig->m_iIntrinsicTypeDefault;
        m_iIntrinsicType = lpOrig->m_iIntrinsicType;
        m_fltIntrinsic = lpOrig->m_fltIntrinsic;
        m_fltIlinit = lpOrig->m_fltIlinit;
        m_fltIl = lpOrig->m_fltIl;

        if(m_lpCurrentGraph)
        {
                delete m_lpCurrentGraph;
                m_lpCurrentGraph = NULL;
        }

        if(lpOrig->m_lpCurrentGraph)
                m_lpCurrentGraph = dynamic_cast<AnimatSim::Gains::Gain *>(lpOrig->m_lpCurrentGraph->Clone());

        if(m_lpBurstGraph)
        {
                delete m_lpBurstGraph;
                m_lpBurstGraph = NULL;
        }

        if(lpOrig->m_lpBurstGraph)
                m_lpBurstGraph = dynamic_cast<AnimatSim::Gains::Gain *>(lpOrig->m_lpBurstGraph->Clone());

        if(m_lpIBurstGraph)
        {
                delete m_lpIBurstGraph;
                m_lpIBurstGraph = NULL;
        }

        if(lpOrig->m_lpIBurstGraph)
                m_lpIBurstGraph = dynamic_cast<AnimatSim::Gains::Gain *>(lpOrig->m_lpIBurstGraph->Clone());
}

void RandomNeuron::CurrentDistribution(AnimatSim::Gains::Gain *lpGain)
{
        if(lpGain)
        {
                if(m_lpCurrentGraph) 
                        {delete m_lpCurrentGraph; m_lpCurrentGraph = NULL;}
                m_lpCurrentGraph = lpGain;
        }
}

void RandomNeuron::CurrentDistribution(std::string strXml)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("CurrentGraph");
        CurrentDistribution(AnimatSim::Gains::LoadGain(m_lpSim, "CurrentGraph", oXml));
}

void RandomNeuron::BurstLengthDistribution(AnimatSim::Gains::Gain *lpGain)
{
        if(lpGain)
        {
                if(m_lpBurstGraph) 
                        {delete m_lpBurstGraph; m_lpBurstGraph = NULL;}
                m_lpBurstGraph = lpGain;
        }
}

void RandomNeuron::BurstLengthDistribution(std::string strXml)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("BurstGraph");
        BurstLengthDistribution(AnimatSim::Gains::LoadGain(m_lpSim, "BurstGraph", oXml));
}

void RandomNeuron::InterbusrtLengthDistribution(AnimatSim::Gains::Gain *lpGain)
{
        if(lpGain)
        {
                if(m_lpIBurstGraph) 
                        {delete m_lpIBurstGraph; m_lpIBurstGraph = NULL;}
                m_lpIBurstGraph = lpGain;
        }
}

void RandomNeuron::InterbusrtLengthDistribution(std::string strXml)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("InterBurstGraph");
        InterbusrtLengthDistribution(AnimatSim::Gains::LoadGain(m_lpSim, "InterBurstGraph", oXml));
}

void RandomNeuron::HighCurrentOn()
{
        double dblRand;

        m_iIntrinsicType=IH_CURRENT;

        //Lets get a random number for the time it will be high.
        dblRand = Std_DRand(0, 100);

        //Now run it through the random variable equation to get the actual value.
        m_fltITime = m_lpBurstGraph->CalculateGain((float) dblRand);  

        //Lets get a random number for the current to use.
        dblRand = Std_DRand(0, 100);

        //Now run it through the random variable equation to get the actual value.
        m_fltIntrinsic =  m_lpCurrentGraph->CalculateGain((float) dblRand); 
}

void RandomNeuron::LowCurrentOn()
{
        double dblRand;

        m_iIntrinsicType=IL_CURRENT;
        m_fltIntrinsic=m_fltIl;

        //Lets get a random number for the time it will be low.
        dblRand = Std_DRand(0, 100);

        //Now run it through the random variable equation to get the actual value.
        m_fltITime = m_lpIBurstGraph->CalculateGain((float) dblRand); 
}

void RandomNeuron::ResetSimulation()
{
        Neuron::ResetSimulation();

        m_fltITime=0;
        m_iIntrinsicType = m_iIntrinsicTypeDefault;
        m_fltIntrinsic=0;
        m_fltIl=m_fltIlinit;
}

float RandomNeuron::CalculateIntrinsicCurrent(FiringRateModule *lpModule, float fltInputCurrent)
{

        m_fltITime-=lpModule->TimeStep();

        if(m_fltITime<0)
        {
                if(m_iIntrinsicType==IH_CURRENT)
                        LowCurrentOn();
                else
                        HighCurrentOn();
        }

        return m_fltIntrinsic;
}

long RandomNeuron::CalculateSnapshotByteSize()
{
        //We need bytes for the internal state variables for this neuron.
        return (Neuron::CalculateSnapshotByteSize() + sizeof(m_fltITime) + sizeof(m_iIntrinsicType));
}

void RandomNeuron::SaveKeyFrameSnapshot(byte *aryBytes, long &lIndex)
{
        Neuron::SaveKeyFrameSnapshot(aryBytes, lIndex);

        memcpy((void *) (aryBytes+lIndex), (void *)&m_fltITime, sizeof(m_fltITime));
  lIndex += sizeof(m_fltITime);

        memcpy((void *) (aryBytes+lIndex), (void *)&m_iIntrinsicType, sizeof(m_iIntrinsicType));
  lIndex += sizeof(m_iIntrinsicType);
}

void RandomNeuron::LoadKeyFrameSnapshot(byte *aryBytes, long &lIndex)
{
        Neuron::LoadKeyFrameSnapshot(aryBytes, lIndex);

        memcpy((void *)&m_fltITime, (void *) (aryBytes+lIndex), sizeof(m_fltITime));
  lIndex += sizeof(m_fltITime);

        memcpy((void *)&m_iIntrinsicType, (void *) (aryBytes+lIndex), sizeof(m_iIntrinsicType));
  lIndex += sizeof(m_iIntrinsicType);
}

#pragma region DataAccesMethods

bool RandomNeuron::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);

        if(Neuron::SetData(strDataType, strValue, false))
                return true;

        if(strType == "IL")
        {
                Ilinit(atof(strValue.c_str()));
                return true;
        }

        if(strType == "CURRENTDISTRIBUTION")
        {
                CurrentDistribution(strValue);
                return true;
        }

        if(strType == "BURSTLENGTHDISTRIBUTION")
        {
                BurstLengthDistribution(strValue);
                return true;
        }

        if(strType == "INTERBURSTLENGTHDISTRIBUTION")
        {
                InterbusrtLengthDistribution(strValue);
                return true;
        }


        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "Data Type", strDataType);

        return false;
}

void RandomNeuron::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        Neuron::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("Il", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CurrentDistribution", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("BurstLengthDistribution", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("InterbusrtLengthDistribution", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
}

#pragma endregion

void RandomNeuron::Load(CStdXml &oXml)
{

        Neuron::Load(oXml);

        oXml.IntoElem();  //Into Neuron Element

        Ilinit(oXml.GetChildFloat("Il"));

        CurrentDistribution(AnimatSim::Gains::LoadGain(m_lpSim, "CurrentGraph", oXml));
        BurstLengthDistribution(AnimatSim::Gains::LoadGain(m_lpSim, "BurstGraph", oXml));
        InterbusrtLengthDistribution(AnimatSim::Gains::LoadGain(m_lpSim, "InterBurstGraph", oXml));

        oXml.OutOfElem(); //OutOf Neuron Element
}

        }                       //Neurons
}                               //FiringRateSim