CurrentStimulus.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "IMovableItemCallback.h"
#include "ISimGUICallback.h"
#include "AnimatBase.h"

#include "Node.h"
#include "Link.h"
#include "IPhysicsMovableItem.h"
#include "IPhysicsBody.h"
#include "BoundingBox.h"
#include "MovableItem.h"
#include "BodyPart.h"
#include "Gain.h"
#include "Adapter.h"
#include "Joint.h"
#include "ReceptiveField.h"
#include "ContactSensor.h"
#include "RigidBody.h"
#include "Structure.h"
#include "NeuralModule.h"
#include "NervousSystem.h"
#include "Organism.h"
#include "ActivatedItem.h"
#include "ActivatedItemMgr.h"
#include "DataChartMgr.h"
#include "ExternalStimuliMgr.h"
#include "ExternalStimulus.h"
#include "ExternalInputStimulus.h"
#include "CurrentStimulus.h"
#include "KeyFrame.h"
#include "SimulationRecorder.h"
#include "OdorType.h"
#include "Odor.h"
#include "Light.h"
#include "LightManager.h"
#include "Simulator.h"

namespace AnimatSim
{
        namespace ExternalStimuli
        {
CurrentStimulus::CurrentStimulus()
{
        m_lpNode = NULL;
        m_lpExternalCurrent = NULL;
        m_fltCycleOnDuration = 0;
        m_fltCycleOffDuration = 0;
        m_fltBurstOnDuration = 0;
        m_fltBurstOffDuration = 0;
        m_lCycleOnDuration = 0;
        m_lCycleOffDuration = 0;
        m_lBurstOnDuration = 0;
        m_lBurstOffDuration = 0;
        m_fltCurrentOn = (float) 10e-9;
        m_fltCurrentOff = 0;
        m_fltCurrentBurstOff = 0;
        m_fltActiveCurrent = m_fltCurrentOn;
        m_fltInitialActiveCurrent = m_fltActiveCurrent;
        m_lCycleStart = 0;
        m_lBurstStart = 0;
        m_bCycleOn = true;
        m_bBurstOn = true;
        m_lpCurrentOnEval = NULL;
        m_iType = AL_TONIC_CURRENT;
}

CurrentStimulus::~CurrentStimulus()
{

try
{
        m_lpNode = NULL;
        m_lpExternalCurrent = NULL;
        if(m_lpCurrentOnEval) 
                delete m_lpCurrentOnEval;

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

//int CurrentStimulus::Type() {return m_iType;}

std::string CurrentStimulus::Type() {return "CurrentStimulus";}

void CurrentStimulus::Type(std::string strType)
{
        m_strType = Std_ToUpper(Std_Trim(strType));
        if(m_strType == "TONIC")
                m_iType = AL_TONIC_CURRENT;
        else if(m_strType == "REPETITIVE")
                m_iType = AL_REPETITIVE_CURRENT;
        else if(m_strType == "BURST")
                m_iType = AL_BURST_CURRENT;
        else
                THROW_PARAM_ERROR(Al_Err_lInvalidCurrentType, Al_Err_strInvalidCurrentType, "Type", strType);
}

void CurrentStimulus::AlwaysActive(bool bVal)
{
        ActivatedItem::AlwaysActive(bVal);

        //If we have always active then we need to reset some of the durations to make sure
        //they last for a very long time.
        if(m_bAlwaysActive)
        {
                if(m_iType == AL_TONIC_CURRENT)
                {
                        m_fltCycleOnDuration = 10000;
                        m_fltBurstOnDuration = 10000;
                }
                else if(m_iType == AL_REPETITIVE_CURRENT)
                        m_fltBurstOnDuration = 10000;
        }
}
float CurrentStimulus::CurrentOn() {return m_fltCurrentOn;}

void CurrentStimulus::CurrentOn(float fltVal)
{m_fltCurrentOn = fltVal;}

float CurrentStimulus::CurrentOff() {return m_fltCurrentOff;}

void CurrentStimulus::CurrentOff(float fltVal) {m_fltCurrentOff = fltVal;}

float CurrentStimulus::CurrentBurstOff() {return m_fltCurrentBurstOff;}

void CurrentStimulus::CurrentBurstOff(float fltVal) {m_fltCurrentBurstOff = fltVal;}

float CurrentStimulus::CycleOnDuration() {return m_fltCycleOnDuration;}

void CurrentStimulus::CycleOnDuration(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "CycleOnDuration", false);
        m_fltCycleOnDuration = fltVal;
        m_lCycleOnDuration = (long) (m_fltCycleOnDuration / m_lpSim->TimeStep() + 0.5);
}

float CurrentStimulus::CycleOffDuration() {return m_fltCycleOffDuration;}

void CurrentStimulus::CycleOffDuration(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "CycleOffDuration", true);
        m_fltCycleOffDuration = fltVal;
        m_lCycleOffDuration = (long) (m_fltCycleOffDuration / m_lpSim->TimeStep() + 0.5);
}

float CurrentStimulus::BurstOnDuration() {return m_fltBurstOnDuration;}
                        
void CurrentStimulus::BurstOnDuration(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "BurstOnDuration", false);
        m_fltBurstOnDuration = fltVal;
        m_lBurstOnDuration = (long) (m_fltBurstOnDuration / m_lpSim->TimeStep() + 0.5);
}

float CurrentStimulus::BurstOffDuration() {return m_fltBurstOffDuration;}

void CurrentStimulus::BurstOffDuration(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "BurstOffDuration", true);
        m_fltBurstOffDuration = fltVal;
        m_lBurstOffDuration = (long) (m_fltBurstOffDuration / m_lpSim->TimeStep() + 0.5);
}

std::string CurrentStimulus::TargetNodeID() {return m_strTargetNodeID;}

void CurrentStimulus::TargetNodeID(std::string strID)
{
        if(Std_IsBlank(strID))
                THROW_PARAM_ERROR(Al_Err_lInvalidCurrentType, Al_Err_strInvalidCurrentType, "ID", strID);
        m_strTargetNodeID = strID;
}

std::string CurrentStimulus::CurrentEquation() {return m_strCurrentEquation;}

void CurrentStimulus::CurrentEquation(std::string strEquation)
{
        m_strCurrentEquation = strEquation;

        if(!Std_IsBlank(strEquation))
        {

                //Initialize the postfix evaluator.
                if(m_lpCurrentOnEval) 
                        {delete m_lpCurrentOnEval; m_lpCurrentOnEval = NULL;}

                m_lpCurrentOnEval = new CStdPostFixEval;

                m_lpCurrentOnEval->AddVariable("t");
                m_lpCurrentOnEval->Equation(strEquation);
                m_lpCurrentOnEval->SetVariable("t", 0);
                m_fltActiveCurrent = m_lpCurrentOnEval->Solve();
        }
        else
        {
                //Remove the current eval.
                if(m_lpCurrentOnEval) 
                        {delete m_lpCurrentOnEval; m_lpCurrentOnEval = NULL;}

                m_fltActiveCurrent = m_fltCurrentOn;
        }

        m_fltInitialActiveCurrent = m_fltActiveCurrent;
}


void CurrentStimulus::Initialize()
{
        ExternalStimulus::Initialize();

        //Lets try and get the node we will dealing with.
        m_lpNode = dynamic_cast<Node *>(m_lpSim->FindByID(m_strTargetNodeID));
        if(!m_lpNode)
                THROW_PARAM_ERROR(Al_Err_lNodeNotFound, Al_Err_strNodeNotFound, "ID: ", m_strTargetNodeID);

        m_lpExternalCurrent = m_lpNode->GetDataPointer("ExternalCurrent");

        if(!m_lpExternalCurrent)
                THROW_TEXT_ERROR(Al_Err_lDataPointNotFound, Al_Err_strDataPointNotFound, 
                ("Stimulus: " + m_strID + "Node: " + m_strTargetNodeID + " DataType: ExternalCurrent"));
}

float CurrentStimulus::GetCurrentOn()
{
        if(m_lpCurrentOnEval)
        {
                m_lpCurrentOnEval->SetVariable("t", (m_lpSim->Time()-m_fltStartTime) );
                return 1e-9*m_lpCurrentOnEval->Solve();
        }
        else
                return m_fltCurrentOn;

}

void CurrentStimulus::SetSliceData()
{
        ActivatedItem::SetSliceData();

        m_lCycleOnDuration = (long) (m_fltCycleOnDuration / m_lpSim->TimeStep() + 0.5);
        m_lCycleOffDuration = (long) (m_fltCycleOffDuration / m_lpSim->TimeStep() + 0.5);
        m_lBurstOnDuration = (long) (m_fltBurstOnDuration / m_lpSim->TimeStep() + 0.5);
        m_lBurstOffDuration = (long) (m_fltBurstOffDuration / m_lpSim->TimeStep() + 0.5);
}

void CurrentStimulus::Activate()
{
        ExternalStimulus::Activate();

        //Start a cycle and a burst.
        m_fltActiveCurrent = GetCurrentOn();

        m_lCycleStart = m_lpSim->TimeSlice();
        m_lBurstStart = m_lCycleStart;

        *m_lpExternalCurrent = *m_lpExternalCurrent + m_fltActiveCurrent;
}

void CurrentStimulus::StepSimulation()
{
        long lCycleDiff = m_lpSim->TimeSlice() - m_lCycleStart;
        long lBurstDiff = m_lpSim->TimeSlice() - m_lBurstStart;

        if(m_bBurstOn)
        {
                if( (m_bCycleOn && (lCycleDiff >= m_lCycleOnDuration)) )
                {
                        m_bCycleOn = false;
                        m_lCycleStart = m_lpSim->TimeSlice();
                        
                        *m_lpExternalCurrent = *m_lpExternalCurrent - m_fltActiveCurrent;
                        m_fltActiveCurrent = m_fltCurrentOff;
                        *m_lpExternalCurrent = *m_lpExternalCurrent + m_fltActiveCurrent;
                }
                else if( (!m_bCycleOn && (lCycleDiff >= m_lCycleOffDuration)) )
                {
                        m_bCycleOn = true;
                        m_lCycleStart = m_lpSim->TimeSlice();

                        *m_lpExternalCurrent = *m_lpExternalCurrent - m_fltActiveCurrent;
                        m_fltActiveCurrent = GetCurrentOn();
                        *m_lpExternalCurrent = *m_lpExternalCurrent + m_fltActiveCurrent;
                }
        }

        if( (m_bBurstOn && (lBurstDiff >= m_lBurstOnDuration)) )
        {
                m_bCycleOn = false;
                m_bBurstOn = false;
                m_lBurstStart = m_lpSim->TimeSlice();

                *m_lpExternalCurrent = *m_lpExternalCurrent - m_fltActiveCurrent;
                m_fltActiveCurrent = m_fltCurrentBurstOff;
                *m_lpExternalCurrent = *m_lpExternalCurrent + m_fltActiveCurrent;
        }
        else if( (!m_bBurstOn && (lBurstDiff >= m_lBurstOffDuration)) )
        {
                m_bCycleOn = true;
                m_bBurstOn = true;
                m_lBurstStart = m_lpSim->TimeSlice();
                m_lCycleStart = m_lBurstStart;

                *m_lpExternalCurrent = *m_lpExternalCurrent - m_fltActiveCurrent;
                m_fltActiveCurrent = GetCurrentOn();
                *m_lpExternalCurrent = *m_lpExternalCurrent + m_fltActiveCurrent;
        }
        else if(m_iType == AL_TONIC_CURRENT && m_lpCurrentOnEval)
        {
                *m_lpExternalCurrent = *m_lpExternalCurrent - m_fltActiveCurrent;
                m_fltActiveCurrent = GetCurrentOn();
                *m_lpExternalCurrent = *m_lpExternalCurrent + m_fltActiveCurrent;
        }

}

void CurrentStimulus::Deactivate()
{               
        ExternalStimulus::Deactivate();
        *m_lpExternalCurrent = *m_lpExternalCurrent - m_fltActiveCurrent;
}

void CurrentStimulus::ResetSimulation()
{
        ExternalStimulus::ResetSimulation();

        m_bCycleOn = true;
        m_bBurstOn = true;
        m_lCycleStart = 0;
        m_lBurstStart = 0;
        m_fltActiveCurrent = m_fltInitialActiveCurrent;
}

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

        if(strType == "ACTIVECURRENT")
                lpData = &m_fltActiveCurrent;
        else
                THROW_TEXT_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "StimulusName: " + STR(m_strName) + "  DataType: " + strDataType);

        return lpData;
} 

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

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

        if(strType == "CURRENTON")
        {
                CurrentOn((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "CURRENTOFF")
        {
                CurrentOff((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "CURRENTBURSTOFF")
        {
                CurrentBurstOff((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "CYCLEONDURATION")
        {
                CycleOnDuration((float) atof(strValue.c_str()));
                return true;
        }
        
        if(strType == "CYCLEOFFDURATION")
        {
                CycleOffDuration((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "BURSTONDURATION")
        {
                BurstOnDuration((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "BURSTOFFDURATION")
        {
                BurstOffDuration((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "EQUATION")
        {
                CurrentEquation(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 CurrentStimulus::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        ExternalStimulus::QueryProperties(aryProperties);

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

        aryProperties.Add(new TypeProperty("CurrentOn", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CurrentOff", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CurrentBurstOff", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CycleOnDuration", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CycleOffDuration", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("BurstOnDuration", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("BurstOffDuration", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CurrentEquation", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

void CurrentStimulus::Load(CStdXml &oXml)
{
        ActivatedItem::Load(oXml);

        oXml.IntoElem();  //Into Simulus Element

        Type(oXml.GetChildString("CurrentType", "TONIC"));
        TargetNodeID(oXml.GetChildString("TargetNodeID"));

        CycleOnDuration(oXml.GetChildFloat("CycleOnDuration", m_fltCycleOnDuration));
        CycleOffDuration(oXml.GetChildFloat("CycleOffDuration", m_fltCycleOffDuration));
        BurstOnDuration(oXml.GetChildFloat("BurstOnDuration", m_fltBurstOnDuration));
        BurstOffDuration(oXml.GetChildFloat("BurstOffDuration", m_fltBurstOffDuration));

        CurrentOn(oXml.GetChildFloat("CurrentOn", m_fltCurrentOn));
        CurrentOff(oXml.GetChildFloat("CurrentOff", m_fltCurrentOff));
        CurrentBurstOff(oXml.GetChildFloat("CurrentBurstOff", m_fltCurrentBurstOff));
        
        CurrentEquation(oXml.GetChildString("CurrentOnEquation", ""));

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

        }                       //ExternalStimuli
}                               //VortexAnimatSim