CsNeuralModule.cpp

Go to the documentation of this file.

#include "StdAfx.h"

#include "CsNeuralModule.h"
#include "CsClassFactory.h"

namespace AnimatCarlSim
{
CsNeuralModule::CsNeuralModule()
{
        m_lpClassFactory =  new AnimatCarlSim::CsClassFactory;
        m_lpSNN = NULL;
        m_iSimMode = GPU_MODE;
        m_fltTimeStep = 0.001f;
        m_bWaitingForPhysicsToCatchUp = false;
        m_bWaitingForNeuralToCatchUp = false;
        m_fltNeuralTime = 0;
}

CsNeuralModule::~CsNeuralModule()
{

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

std::string CsNeuralModule::ModuleName() {return "AnimatCarlSimCUDA";};

void CsNeuralModule::SimMode(int iMode)
{
        if(!iMode)
                m_iSimMode = CPU_MODE;
        else
                m_iSimMode = GPU_MODE;
}

int CsNeuralModule::SimMode() {return m_iSimMode;}

unsigned int CsNeuralModule::SimulationStepInterval()
{
        unsigned int iInterval = 1;
        if( m_lpSim->MinTimeStep() > 0)
                iInterval = (unsigned int) ((((float) (CARLSIM_STEP_SIZE*CARLSIM_STEP_INCREMENT)) / m_lpSim->MinTimeStep())+0.5);
        return iInterval;
}


CsConnectionGenerator *CsNeuralModule::FindConnectionGenerator(std::string strID, bool bThrowError)
{
        CsConnectionGenerator *lpItem = NULL;
        CStdMap<std::string, CsConnectionGenerator *>::iterator oPos;
        oPos = m_aryGenerators.find(Std_CheckString(strID));

        if(oPos != m_aryGenerators.end())
                lpItem =  oPos->second;
        else if(bThrowError)
                THROW_TEXT_ERROR(Cs_Err_lConnectionGeneratorIDNotFound, Cs_Err_strConnectionGeneratorIDNotFound, " Connection Generator ID: " + strID);

        return lpItem;
}

void CsNeuralModule::AddConnectionGenerator(std::string strID, CsConnectionGenerator *lpGen)
{
        if(lpGen)
        {
                if(!FindConnectionGenerator(strID, false))
                        m_aryGenerators.Add(strID, lpGen);
        }
}

void CsNeuralModule::Kill(bool bState)
{
        int iCount = m_aryNeuronGroups.GetSize();
        for(int iIndex=0; iIndex<iCount; iIndex++)
                if(m_aryNeuronGroups[iIndex])
                        m_aryNeuronGroups[iIndex]->Kill(bState);
}

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

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

        if(bThrowError)
                THROW_TEXT_ERROR(Cs_Err_lNeuronNotFound, Cs_Err_strNeuronNotFound, "ID");

        return -1;
}

void CsNeuralModule::SetCARLSimulation()
{
        if(m_lpSNN)
        {
                delete m_lpSNN;
                m_lpSNN = NULL;
        }

        m_aryGenerators.RemoveAll();

        m_lpSNN = new CpuSNN(m_strID.c_str());
        
        m_lpSNN->setStepFeedback(this);

        //Go through each of the neuron group items and set them up
        int iCount = m_aryNeuronGroups.GetSize();
        for(int iIndex=0; iIndex<iCount; iIndex++)
                if(m_aryNeuronGroups[iIndex])
                        m_aryNeuronGroups[iIndex]->SetCARLSimulation();

        //Then go through each of the connections and set them up
        iCount = m_arySynapses.GetSize();
        for(int iIndex=0; iIndex<iCount; iIndex++)
                if(m_arySynapses[iIndex])
                        m_arySynapses[iIndex]->SetCARLSimulation();

        //Now run through each of the connection generators and set them up.
        CsConnectionGenerator *lpGen = NULL;
        CStdPtrMap<std::string, CsConnectionGenerator>::iterator oPos;
        for(oPos=m_aryGenerators.begin(); oPos!=m_aryGenerators.end(); ++oPos)
        {
                lpGen = oPos->second;
                lpGen->SetCARLSimulation();
        }

        //m_iSimMode = CPU_MODE;

        //Initalize the network
        m_lpSNN->runNetwork(0, 0, m_iSimMode);
}

bool CsNeuralModule::stepUpdate(CpuSNN* s, int step)
{
        
        //If we have been told to pause then lets loop till we can continue
        while(m_bPauseThread || m_lpSim->Paused())
        {
                m_bThreadPaused = true;

                //If we have been told to stop then exit immediately
                if(m_bStopThread)
                        return true;

                boost::this_thread::sleep(boost::posix_time::microseconds(1000));
        }

        //Otherwise keep going.
        return false;
}

void CsNeuralModule::updateMonitors(CpuSNN* s, int step)
{
        //If stop threads has been set then just exit out of here.
        if(m_bStopThread)
                return;

        m_fltNeuralTime = (float) ((step+1)*CARLSIM_STEP_INCREMENT);
        if(!m_bWaitingForNeuralToCatchUp && m_lpSim->Time() < m_fltNeuralTime)
                WaitForPhysicsToCatchUp();
}

void CsNeuralModule::WaitForPhysicsToCatchUp()
{
        m_bWaitingForPhysicsToCatchUp = true;

        while(m_lpSim->Time() <= m_fltNeuralTime)
        {
                if(m_bStopThread || m_bWaitingForNeuralToCatchUp)
                        return;

                if(m_bPauseThread)
                        m_bThreadPaused = true;
        }

        m_bWaitingForPhysicsToCatchUp = false;

        //std::string strMessage = "P:: Neural: " + STR(m_fltNeuralTime) + ", Physics: " + STR(m_lpSim->Time()) + "\r\n";
        //OutputDebugString(strMessage.c_str());
        //std::cout << "Neural: " << m_fltNeuralTime << ", Physics: " << m_lpSim->Time() << "\r\n";
}


void CsNeuralModule::WaitForNeuralToCatchUp()
{
        m_bWaitingForNeuralToCatchUp = true;

        while(m_fltNeuralTime <= m_lpSim->Time())
        {
                if(m_bStopThread || m_bWaitingForPhysicsToCatchUp)
                        return;
        }

        m_bWaitingForNeuralToCatchUp = false;

        //std::string strMessage = "N:: Neural: " + STR(m_fltNeuralTime) + ", Physics: " + STR(m_lpSim->Time()) + "\r\n";
        //OutputDebugString(strMessage.c_str());
        //std::cout << "Neural: " << m_fltNeuralTime << ", Physics: " << m_lpSim->Time() << "\r\n";
}

void CsNeuralModule::StepThread()
{
        if(m_lpSNN)
                m_lpSNN->runNetwork(100, 0, m_iSimMode);
}

void CsNeuralModule::CloseThread()
{
                m_bWaitingForPhysicsToCatchUp = false;
        m_bWaitingForNeuralToCatchUp = false;

}

void CsNeuralModule::SimStarting()
{
        NeuralModule::SimStarting();

        //Do not do this again if the thread is already running. For example, if we pause the sim and hit play again.
        if(!m_bThreadProcessing)
        {
                //Only bother running the simulation if there are some synpases in it.
                if(m_arySynapses.size() > 0)
                {
                        SetCARLSimulation();
                        StartThread();
                }
        }
}

void CsNeuralModule::SimStopping()
{
        NeuralModule::SimStopping();

        ShutdownThread();
}

void CsNeuralModule::ResetSimulation()
{
        NeuralModule::ResetSimulation();

        m_fltNeuralTime = 0;

        ShutdownThread();

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

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

void CsNeuralModule::Initialize()
{
        NeuralModule::Initialize();

        Organism *lpOrganism = dynamic_cast<Organism *>(m_lpStructure);
        if(!lpOrganism) 
                THROW_TEXT_ERROR(Al_Err_lConvertingClassToType, Al_Err_strConvertingClassToType, "Organism");

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

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

void CsNeuralModule::StepSimulation()
{
        NeuralModule::StepSimulation();

        if(m_bThreadProcessing && !m_bWaitingForPhysicsToCatchUp && m_fltNeuralTime < m_lpSim->Time())
                WaitForNeuralToCatchUp();
}

#pragma region DataAccesMethods

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

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

        if(strType == "TIMESTEP")
        {
                TimeStep(atof(strValue.c_str()));
                return true;
        }

        if(strType == "SIMMODE")
        {
                SimMode(atoi(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 CsNeuralModule::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        NeuralModule::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("TimeStep", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("SimMode", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
}

void CsNeuralModule::AddNeuronGroup(std::string strXml, bool bDoNotInit)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("NeuronGroup");

        CsNeuronGroup *lpNeuron = LoadNeuronGroup(oXml);
        if(!bDoNotInit)
                lpNeuron->Initialize();
}

void CsNeuralModule::RemoveNeuronGroup(std::string strID, bool bThrowError)
{
        int iPos = FindNeuronGroupListPos(strID, bThrowError);
        m_aryNeuronGroups.RemoveAt(iPos);
}

CStdPtrArray<CsSynapseGroup> *CsNeuralModule::GetSynapses()
{return &m_arySynapses;}


void CsNeuralModule::AddSynapse(CsSynapseGroup *lpSynapse)
{
        if(!lpSynapse) 
                THROW_ERROR(Cs_Err_lSynapseToAddNull, Cs_Err_strSynapseToAddNull);
        m_arySynapses.Add(lpSynapse);
}

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

        CsSynapseGroup *lpSynapse = LoadSynapse(oXml);
        if(!bDoNotInit)
                lpSynapse->Initialize();
}

void CsNeuralModule::RemoveSynapse(int iIndex)
{
        if( iIndex<0 || iIndex>=m_arySynapses.GetSize() ) 
                THROW_ERROR(Std_Err_lInvalidIndex, Std_Err_strInvalidIndex);
        m_arySynapses.RemoveAt(iIndex);
}

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

CsSynapseGroup *CsNeuralModule::GetSynapse(int iIndex)
{
        if( iIndex<0 || iIndex>=m_arySynapses.GetSize() ) 
                THROW_ERROR(Std_Err_lInvalidIndex, Std_Err_strInvalidIndex);
        return m_arySynapses[iIndex];
}

int CsNeuralModule::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(Cs_Err_lSynapseNotFound, Cs_Err_strSynapseNotFound, "ID");

        return -1;
}

int CsNeuralModule::TotalSynapses()
{return m_arySynapses.GetSize();}

void CsNeuralModule::ClearSynapses()
{m_arySynapses.RemoveAll();}

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

        if(strType == "NEURONGROUP")
        {
                AddNeuronGroup(strXml, bDoNotInit);
                return true;
        }
        else 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 CsNeuralModule::RemoveItem(const std::string &strItemType, const std::string &strID, bool bThrowError)
{
        std::string strType = Std_CheckString(strItemType);

        if(strType == "NEURONGROUP")
        {
                RemoveNeuronGroup(strID, bThrowError);
                return true;
        }
        else 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 CsNeuralModule::Load(CStdXml &oXml)
{
        VerifySystemPointers();

        CStdXml oNetXml;

        m_arySourceAdapters.RemoveAll();
        m_aryTargetAdapters.RemoveAll();

        oXml.IntoElem();  //Into NeuralModule Element

        LoadNetworkXml(oXml);

        oXml.OutOfElem(); //OutOf NeuralModule Element

        TRACE_DEBUG("Finished loading nervous system config file.");
}

void CsNeuralModule::LoadNetworkXml(CStdXml &oXml)
{
        short iNeuron, iTotalNeurons;
                
        m_aryNeuronGroups.RemoveAll();

        ID(oXml.GetChildString("ID", m_strID));
        Type(oXml.GetChildString("Type", m_strType));
        Name(oXml.GetChildString("Name", m_strName));
        SimMode(oXml.GetChildInt("SimMode", m_iSimMode));

        //This will add this object to the object list of the simulation.
        m_lpSim->AddToObjectList(this);

        //*** Begin Loading Neurons groups. *****
        oXml.IntoChildElement("NeuronGroups");

        iTotalNeurons = oXml.NumberOfChildren();
        for(iNeuron=0; iNeuron<iTotalNeurons; iNeuron++)
        {
                oXml.FindChildByIndex(iNeuron);
                LoadNeuronGroup(oXml);
        }

        oXml.OutOfElem();
        //*** End Loading Neurons groups. *****

        //*** Begin Loading Synapses. *****
        if(oXml.FindChildElement("Synapses", false))
        {
                oXml.IntoElem();  //Into Synapses Element

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

                oXml.OutOfElem();
        }
        //*** End Loading Synapses. *****

}

CsNeuronGroup *CsNeuralModule::LoadNeuronGroup(CStdXml &oXml)
{
        CsNeuronGroup *lpNeuron=NULL;
        std::string strType;

try
{
        //Now lets get the index and type of this neuron
        oXml.IntoElem();  //Into Neuron Element
        strType = oXml.GetChildString("Type");
        oXml.OutOfElem();  //OutOf Neuron Element

        lpNeuron = dynamic_cast<CsNeuronGroup *>(m_lpSim->CreateObject("AnimatCarlSimCUDA", "Neuron", strType));
        if(!lpNeuron)
                THROW_TEXT_ERROR(Al_Err_lConvertingClassToType, Al_Err_strConvertingClassToType, "Neuron");

        lpNeuron->SetSystemPointers(m_lpSim, m_lpStructure, this, NULL, true);
        lpNeuron->Load(oXml);
        
        m_aryNeuronGroups.Add(lpNeuron);
        return lpNeuron;
}
catch(CStdErrorInfo oError)
{
        if(lpNeuron) delete lpNeuron;
        RELAY_ERROR(oError);
        return NULL;
}
catch(...)
{
        if(lpNeuron) delete lpNeuron;
        THROW_ERROR(Std_Err_lUnspecifiedError, Std_Err_strUnspecifiedError);
        return NULL;
}
}

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

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

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

        lpSynapse->SetSystemPointers(m_lpSim, m_lpStructure, this, NULL, true);
        lpSynapse->Load(oXml);
        AddSynapse(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;
}
}

}                               //AnimatCarlSim