SpikingChemicalSynapse.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "IonChannel.h"
#include "SynapseType.h"
#include "Connexion.h"
#include "CaActivation.h"
#include "Neuron.h"
#include "ElectricalSynapse.h"
#include "NonSpikingChemicalSynapse.h"
#include "SpikingChemicalSynapse.h"
#include "IntegrateFireModule.h"
#include "ClassFactory.h"
#include <time.h>

namespace IntegrateFireSim
{
        namespace Synapses
        {

SpikingChemicalSynapse::SpikingChemicalSynapse() : SynapseType()
{
        m_dEquil = 0;
        m_dSynAmp = 0;  
        m_dDecay = 0;
        m_dFacilD = 0;
        m_dRelFacil = 0;
        m_dFacilDecay = 0;

        m_bVoltDep = false;
        m_dMaxRelCond = 0;
        m_dSatPSPot = 0;
        m_dThreshPSPot = 0;

        m_bHebbian = false;
        m_dMaxAugCond = 0;
        m_dLearningInc = 0;
        m_dLearningTime = 0;
        m_bAllowForget = false;
        m_dForgetTime = 0;
        m_dConsolidation = 0;
}

SpikingChemicalSynapse::~SpikingChemicalSynapse()
{

}

#pragma region Accessor-Mutators

void SpikingChemicalSynapse::EquilibriumPotential(double dVal) {m_dEquil = dVal;}

double SpikingChemicalSynapse::EquilibriumPotential() {return m_dEquil;}

void SpikingChemicalSynapse::SynapticConductance(double dVal) {m_dSynAmp = dVal;}

double SpikingChemicalSynapse::SynapticConductance() {return m_dSynAmp;}

void SpikingChemicalSynapse::DecayRate(double dVal) {m_dDecay = dVal;}

double SpikingChemicalSynapse::DecayRate() {return m_dDecay;}

double SpikingChemicalSynapse::FacilD() {return m_dFacilD;}

void SpikingChemicalSynapse::RelativeFacilitation(double dVal) {m_dRelFacil = dVal;}

double SpikingChemicalSynapse::RelativeFacilitation() {return m_dRelFacil;}

double SpikingChemicalSynapse::RelFacil() {return m_dRelFacil;}

void SpikingChemicalSynapse::FacilitationDecay(double dVal) 
{
        Std_IsAboveMin((double) 0, dVal, true, "FacilitationDecay");
        m_dFacilDecay = dVal;
        m_dFacilD = exp(-m_lpModule->TimeStep()/m_dFacilDecay);
}

double SpikingChemicalSynapse::FacilitationDecay() {return m_dFacilDecay;}

double SpikingChemicalSynapse::FacilDecay() {return m_dFacilDecay;}

void SpikingChemicalSynapse::VoltageDependent(bool bVal) {m_bVoltDep = bVal;}

bool SpikingChemicalSynapse::VoltageDependent() {return m_bVoltDep;}

bool SpikingChemicalSynapse::VoltDep() {return m_bVoltDep;}

void SpikingChemicalSynapse::MaxRelativeConductance(double dVal) {m_dMaxRelCond = dVal;}

double SpikingChemicalSynapse::MaxRelativeConductance() {return m_dMaxRelCond;}

double SpikingChemicalSynapse::MaxGVoltDepRel() {return m_dMaxRelCond;}

void SpikingChemicalSynapse::SaturatePotential(double dVal) {m_dSatPSPot = dVal;}

double SpikingChemicalSynapse::SaturatePotential() {return m_dSatPSPot;}

double SpikingChemicalSynapse::SatPSPot() {return m_dSatPSPot;}

void SpikingChemicalSynapse::ThresholdPotential(double dVal) {m_dThreshPSPot = dVal;}

double SpikingChemicalSynapse::ThresholdPotential() {return m_dThreshPSPot;}

double SpikingChemicalSynapse::ThreshPSPot() {return m_dThreshPSPot;}

void SpikingChemicalSynapse::Hebbian(bool bVal) {m_bHebbian = bVal;}

bool SpikingChemicalSynapse::Hebbian() {return m_bHebbian;}

void SpikingChemicalSynapse::MaxAugmentedConductance(double dVal) {m_dMaxAugCond = dVal;}

double SpikingChemicalSynapse::MaxAugmentedConductance() {return m_dMaxAugCond;}

double SpikingChemicalSynapse::MaxGHebb() {return m_dMaxAugCond;}

void SpikingChemicalSynapse::LearningIncrement(double dVal) {m_dLearningInc = dVal;}

double SpikingChemicalSynapse::LearningIncrement() {return m_dLearningInc;}

double SpikingChemicalSynapse::HebbIncrement() {return m_dLearningInc;}

void SpikingChemicalSynapse::LearningTimeWindow(double dVal) {m_dLearningTime = dVal;}

double SpikingChemicalSynapse::LearningTimeWindow() {return m_dLearningTime;}

double SpikingChemicalSynapse::HebbTimeWindow() {return m_dLearningTime;}

void SpikingChemicalSynapse::AllowForgetting(bool bVal) {m_bAllowForget = bVal;}

bool SpikingChemicalSynapse::AllowForgetting() {return m_bAllowForget;}

bool SpikingChemicalSynapse::AllowForget() {return m_bAllowForget;}

void SpikingChemicalSynapse::ForgettingTimeWindow(double dVal) {m_dForgetTime = dVal;}

double SpikingChemicalSynapse::ForgettingTimeWindow() {return m_dForgetTime;}

double SpikingChemicalSynapse::ForgettingWindow() {return m_dForgetTime;}

void SpikingChemicalSynapse::ConsolidationFactor(double dVal) {m_dConsolidation = dVal;}

double SpikingChemicalSynapse::ConsolidationFactor() {return m_dConsolidation;}

double SpikingChemicalSynapse::Consolidation() {return m_dConsolidation;}

#pragma endregion

#pragma region DataAccesMethods


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

        if(strType == "EQUILIBRIUMPOTENTIAL")
        {
                EquilibriumPotential(atof(strValue.c_str()));
                return true;
        }

        if(strType == "SYNAPTICCONDUCTANCE")
        {
                SynapticConductance(atof(strValue.c_str()));
                return true;
        }

        if(strType == "DECAYRATE")
        {
                DecayRate(atof(strValue.c_str()));
                return true;
        }

        if(strType == "RELATIVEFACILITATION")
        {
                RelativeFacilitation(atof(strValue.c_str()));
                return true;
        }

        if(strType == "FACILITATIONDECAY")
        {
                FacilitationDecay(atof(strValue.c_str()));
                return true;
        }

        if(strType == "VOLTAGEDEPENDENT")
        {
                VoltageDependent(Std_ToBool(strValue));
                return true;
        }

        if(strType == "MAXRELATIVECONDUCTANCE")
        {
                MaxRelativeConductance(atof(strValue.c_str()));
                return true;
        }

        if(strType == "SATURATEPOTENTIAL")
        {
                SaturatePotential(atof(strValue.c_str()));
                return true;
        }

        if(strType == "THRESHOLDPOTENTIAL")
        {
                ThresholdPotential(atof(strValue.c_str()));
                return true;
        }

        if(strType == "HEBBIAN")
        {
                Hebbian(Std_ToBool(strValue));
                return true;
        }

        if(strType == "MAXAUGMENTEDCONDUCTANCE")
        {
                MaxAugmentedConductance(atof(strValue.c_str()));
                return true;
        }

        if(strType == "LEARNINGINCREMENT")
        {
                LearningIncrement(atof(strValue.c_str()));
                return true;
        }

        if(strType == "LEARNINGTIMEWINDOW")
        {
                LearningTimeWindow(atof(strValue.c_str()));
                return true;
        }

        if(strType == "ALLOWFORGETTING")
        {
                AllowForgetting(Std_ToBool(strValue));
                return true;
        }

        if(strType == "FORGETTINGTIMEWINDOW")
        {
                ForgettingTimeWindow(atof(strValue.c_str()));
                return true;
        }

        if(strType == "CONSOLIDATIONFACTOR")
        {
                ConsolidationFactor(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 SpikingChemicalSynapse::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("EquilibriumPotential", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("SynapticConductance", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("DecayRate", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("RelativeFacilitation", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("FacilitationDecay", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("VoltageDependent", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("MaxRelativeConductance", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("SaturatePotential", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("ThresholdPotential", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Hebbian", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("MaxAugmentedConductance", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LearningIncrement", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LearningTimeWindow", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("AllowForgetting", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("ForgettingTimeWindow", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("ConsolidationFactor", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

#pragma endregion

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

        oXml.IntoElem();  //Into SpikingChemSyn Element
        
        EquilibriumPotential(oXml.GetChildDouble("Equil"));
        SynapticConductance(oXml.GetChildDouble("SynAmp"));
        DecayRate(oXml.GetChildDouble("Decay"));
        RelativeFacilitation(oXml.GetChildDouble("RelFacil"));
        FacilitationDecay(oXml.GetChildDouble("FacilDecay"));

        VoltageDependent(oXml.GetChildBool("VoltDep"));
        MaxRelativeConductance(oXml.GetChildDouble("MaxRelCond"));
        SaturatePotential(oXml.GetChildDouble("SatPSPot"));
        ThresholdPotential(oXml.GetChildDouble("ThreshPSPot"));

        Hebbian(oXml.GetChildBool("Hebbian"));
        MaxAugmentedConductance(oXml.GetChildDouble("MaxAugCond"));
        LearningIncrement(oXml.GetChildDouble("LearningInc"));
        LearningTimeWindow(oXml.GetChildDouble("LearningTime"));
        AllowForgetting(oXml.GetChildBool("AllowForget"));
        ForgettingTimeWindow(oXml.GetChildDouble("ForgetTime"));
        ConsolidationFactor(oXml.GetChildDouble("Consolidation"));

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

        }                       //Synapses
}                               //IntegrateFireSim