Synapse.cpp

Go to the documentation of this file.

#include "StdAfx.h"

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

namespace FiringRateSim
{
        namespace Synapses
        {

Synapse::Synapse()
{
        m_lpFRModule = NULL;

        m_lpFromNeuron = NULL;
        m_lpToNeuron = NULL;
        m_fltWeight=0;
        m_fltModulation=0;
        m_strType = "REGULAR";
        m_bHasDelay = false;
        m_fltDelayInterval = 0;
}

Synapse::~Synapse()
{

try
{
        m_arySynapses.RemoveAll();
}
catch(...)
{Std_TraceMsg(0, "Caught Error in desctructor of Synapse\r\n", "", -1, false, true);}
}

float Synapse::Weight()
{return m_fltWeight;}

void Synapse::Weight(float fltVal)
{m_fltWeight=fltVal;}

bool Synapse::HasDelay() {return m_bHasDelay;}

void Synapse::HasDelay(bool bVal) 
{
        m_bHasDelay = bVal;
        SetDelayBufferSize();
}

float Synapse::DelayInterval() {return m_fltDelayInterval;}

void Synapse::DelayInterval(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "DelayInterval", true);
        m_fltDelayInterval = fltVal;
        SetDelayBufferSize();
}

void Synapse::TimeStepModified()
{
        SetDelayBufferSize();
}

void Synapse::SetDelayBufferSize()
{
        if(m_bHasDelay && m_lpFRModule)
        {
                float fltTimeStep = m_lpFRModule->TimeStep();

                if(fltTimeStep > 0)
                {
                        int iLength = (int) (m_fltDelayInterval/fltTimeStep);
                        m_aryDelayBuffer.SetSize(iLength);
                }
        }
        else
                m_aryDelayBuffer.RemoveAll();
}

void Synapse::Process(float &fltCurrent)
{
        fltCurrent+=CalculateCurrent(); 
}

float Synapse::CalculateCurrent()
{
        //int i=5;
        //if(Std_ToLower(m_strID) == "3ce79124-1a4b-4a34-8399-56dfe1814515")
        //      i=6;

        float fltI = (this->FromNeuron()->FiringFreq(m_lpFRModule) * this->Weight() * this->CalculateModulation(m_lpFRModule) );

        if(m_bHasDelay)
        {
                float fltNextI = m_aryDelayBuffer.GetHead();
                //Now set the current value into the buffer.
                m_aryDelayBuffer.AddEnd(fltI);
                return fltNextI;
        }
        else
                return fltI;
}

float *Synapse::WeightPointer()
{return &m_fltWeight;}

float Synapse::Modulation()
{return m_fltModulation;}

float *Synapse::ModulationPointer()
{return &m_fltModulation;}

Synapse *Synapse::GetCompoundSynapse(short iCompoundIndex)
{

        if( iCompoundIndex<0 || iCompoundIndex>=m_arySynapses.GetSize() ) 
                THROW_ERROR(Std_Err_lInvalidIndex, Std_Err_strInvalidIndex);
        return m_arySynapses[iCompoundIndex];
}

void Synapse::AddSynapse(std::string strXml, bool bDoNotInit)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("CompoundSynapse");

        Synapse *lpSynapse = LoadSynapse(oXml);

        if(!bDoNotInit)
                lpSynapse->Initialize();
}

void Synapse::RemoveSynapse(std::string strID, bool bThrowError)
{
        int iPos = FindSynapseListPos(strID, bThrowError);
        m_arySynapses.RemoveAt(iPos);
}

int Synapse::FindSynapseListPos(std::string strID, bool bThrowError)
{
        std::string sID = Std_ToUpper(Std_Trim(strID));

        int iCount = m_arySynapses.GetSize();
        for(int iIndex=0; iIndex<iCount; iIndex++)
                if(m_arySynapses[iIndex]->ID() == sID)
                        return iIndex;

        if(bThrowError)
                THROW_TEXT_ERROR(Nl_Err_lSynapseNotFound, Nl_Err_strSynapseNotFound, "ID");

        return -1;
}

float Synapse::CalculateModulation(FiringRateModule *m_lpFRModule)
{
        m_fltModulation=1;
        int iCount, iIndex;
        Synapse *lpSynapse=NULL;

        iCount = m_arySynapses.GetSize();
        for(iIndex=0; iIndex<iCount; iIndex++)
        {
                lpSynapse = m_arySynapses[iIndex];
                m_fltModulation*=lpSynapse->CalculateModulation(m_lpFRModule);
        }

        return m_fltModulation;
}


void Synapse::Initialize()
{
        Link::Initialize();

        m_lpFromNeuron = dynamic_cast<Neuron *>(m_lpSim->FindByID(m_strFromID));
        if(!m_lpFromNeuron)
                THROW_PARAM_ERROR(Al_Err_lNodeNotFound, Al_Err_strNodeNotFound, "ID: ", m_strFromID);

        int iCount = m_arySynapses.GetSize();
        for(int iIndex=0; iIndex<iCount; iIndex++)
                m_arySynapses[iIndex]->Initialize();

        SetDelayBufferSize();
}

void Synapse::SetSystemPointers(Simulator *m_lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify)
{
        Link::SetSystemPointers(m_lpSim, lpStructure, lpModule, lpNode, false);

        m_lpFRModule = dynamic_cast<FiringRateModule *>(lpModule);

        if(bVerify) VerifySystemPointers();
}

void Synapse::VerifySystemPointers()
{
        Link::VerifySystemPointers();

        if(!m_lpFRModule)
                THROW_PARAM_ERROR(Al_Err_lUnableToCastNeuralModuleToDesiredType, Al_Err_strUnableToCastNeuralModuleToDesiredType, "ID: ", m_lpFRModule->ID());

        if(!m_lpOrganism) 
                THROW_PARAM_ERROR(Al_Err_lConvertingClassToType, Al_Err_strConvertingClassToType, "Link: ", m_strID);
}

#pragma region DataAccesMethods

float *Synapse::GetDataPointer(const std::string &strDataType)
{
        std::string strType = Std_CheckString(strDataType);

        if(strType == "WEIGHT")
                return &m_fltWeight;
        else if(strType == "MODULATION")
                return &m_fltModulation;

        return NULL;
}

bool Synapse::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);
                
        if(Link::SetData(strDataType, strValue, false))
                return true;

        if(strType == "WEIGHT")
        {
                Weight(atof(strValue.c_str()));
                return true;
        }

        if(strType == "HASDELAY")
        {
                HasDelay(Std_ToBool(strValue));
                return true;
        }

        if(strType == "DELAYINTERVAL")
        {
                DelayInterval(atof(strValue.c_str()));
                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 Synapse::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        Link::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("Modulation", AnimatPropertyType::Float, AnimatPropertyDirection::Get));

        aryProperties.Add(new TypeProperty("Weight", AnimatPropertyType::Float, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("HasDelay", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("DelayInterval", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

bool Synapse::AddItem(const std::string &strItemType, const std::string &strXml, bool bThrowError, bool bDoNotInit)
{
        std::string strType = Std_CheckString(strItemType);

        if(strType == "SYNAPSE")
        {
                AddSynapse(strXml, bDoNotInit);
                return true;
        }


        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidItemType, Al_Err_strInvalidItemType, "Item Type", strItemType);

        return false;
}

bool Synapse::RemoveItem(const std::string &strItemType, const std::string &strID, bool bThrowError)
{
        std::string strType = Std_CheckString(strItemType);

        if(strType == "SYNAPSE")
        {
                RemoveSynapse(strID, bThrowError);
                return true;
        }

        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidItemType, Al_Err_strInvalidItemType, "Item Type", strItemType);

        return false;
}

#pragma endregion

void Synapse::ResetSimulation()
{
        int iSize = m_aryDelayBuffer.GetSize();
        for(int iIdx=0; iIdx<iSize; iIdx++)
                m_aryDelayBuffer[iIdx] = 0;

        int iCount = m_arySynapses.GetSize();
        for(int iIndex=0; iIndex<iCount; iIndex++)
                m_arySynapses[iIndex]->ResetSimulation();
}

void Synapse::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);

        m_lpToNeuron = dynamic_cast<Neuron *>(m_lpNode);
        if(!m_lpToNeuron)
                THROW_PARAM_ERROR(Al_Err_lUnableToCastNodeToDesiredType, Al_Err_strUnableToCastNodeToDesiredType, "ID: ", m_lpNode->ID());

        oXml.IntoElem();  //Into Synapse Element

        m_strFromID = oXml.GetChildString("FromID");
        if(Std_IsBlank(m_strFromID)) 
                THROW_TEXT_ERROR(Std_Err_lBlankAttrib, Std_Err_strBlankAttrib, "Attribute: FromID");

        m_bEnabled = oXml.GetChildBool("Enabled", true);
        m_fltWeight = oXml.GetChildFloat("Weight");

        m_bHasDelay = oXml.GetChildBool("HasDelay", m_bHasDelay);
        m_fltDelayInterval = oXml.GetChildFloat("DelayInterval", m_fltDelayInterval);

        m_arySynapses.RemoveAll();

        //*** Begin Loading CompoundSynapses. *****
        if(oXml.FindChildElement("CompoundSynapses", false))
        {
                oXml.IntoChildElement("CompoundSynapses");

                int iCount = oXml.NumberOfChildren();
                for(int iIndex=0; iIndex<iCount; iIndex++)
                {
                        oXml.FindChildByIndex(iIndex);
                        LoadSynapse(oXml);
                }

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


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

Synapse *Synapse::LoadSynapse(CStdXml &oXml)
{
        Synapse *lpSynapse=NULL;
        std::string strType;

try
{
        oXml.IntoElem();  //Into Synapse Element
        strType = oXml.GetChildString("Type");
        oXml.OutOfElem(); //OutOf Synapse Element

        lpSynapse = dynamic_cast<Synapse *>(m_lpSim->CreateObject(Nl_NeuralModuleName(), "Synapse", strType));
        if(!lpSynapse)
                THROW_TEXT_ERROR(Al_Err_lConvertingClassToType, Al_Err_strConvertingClassToType, "Synapse");

        lpSynapse->SetSystemPointers(m_lpSim, m_lpStructure, m_lpFRModule, m_lpNode, true);
        lpSynapse->Load(oXml);
        m_arySynapses.Add(lpSynapse);

        return lpSynapse;
}
catch(CStdErrorInfo oError)
{
        if(lpSynapse) delete lpSynapse;
        RELAY_ERROR(oError);
        return NULL;
}
catch(...)
{
        if(lpSynapse) delete lpSynapse;
        THROW_ERROR(Std_Err_lUnspecifiedError, Std_Err_strUnspecifiedError);
        return NULL;
}
}

        }                       //Synapses
}                               //FiringRateSim