Gain.cpp

Go to the documentation of this file.

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

#include <sys/types.h>
#include <sys/stat.h>
#include "Gain.h"
#include "Node.h"
#include "Link.h"
#include "IPhysicsMovableItem.h"
#include "IPhysicsBody.h"
#include "BoundingBox.h"
#include "MovableItem.h"
#include "BodyPart.h"
#include "Joint.h"
#include "ReceptiveField.h"
#include "ContactSensor.h"
#include "RigidBody.h"
#include "Structure.h"
#include "NeuralModule.h"
#include "Adapter.h"
#include "NervousSystem.h"
#include "Organism.h"
#include "ActivatedItem.h"
#include "ActivatedItemMgr.h"
#include "DataChartMgr.h"
#include "ExternalStimuliMgr.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 Gains
        {
Gain::Gain()
{
        m_bUseLimits = false;
        m_fltLowerLimit = 0;
        m_fltLowerOutput = 0;
        m_fltUpperLimit = 0;
        m_fltUpperOutput = 0;
}

Gain::~Gain()
{

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

bool Gain::UseLimits() {return m_bUseLimits;}

void Gain::UseLimits(bool bVal) {m_bUseLimits = bVal;}

float Gain::LowerLimit() {return m_fltLowerLimit;}

void Gain::LowerLimit(float fltVal) 
{
        Std_IsAboveMin(fltVal, m_fltUpperLimit, true, "LowerLimit");
        m_fltLowerLimit = fltVal;
}

float Gain::UpperLimit() {return m_fltUpperLimit;}

void Gain::UpperLimit(float fltVal) 
{
        Std_IsAboveMin(m_fltLowerLimit, fltVal, true, "UpperLimit");
        m_fltUpperLimit = fltVal;
}

float Gain::LowerOutput() {return m_fltLowerOutput;}

void Gain::LowerOutput(float fltVal) {m_fltLowerOutput = fltVal;}

float Gain::UpperOutput() {return m_fltUpperOutput;}

void Gain::Copy(CStdSerialize *lpSource)
{
        AnimatBase::Copy(lpSource);

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

        m_bUseLimits = lpOrig->m_bUseLimits;
        m_fltLowerLimit = lpOrig->m_fltLowerLimit;
        m_fltLowerOutput = lpOrig->m_fltLowerOutput;
        m_fltUpperLimit = lpOrig->m_fltUpperLimit;
        m_fltUpperOutput = lpOrig->m_fltUpperOutput;
}

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

        if(strDataType == "USELIMITS")
        {
                UseLimits(Std_ToBool(strValue));
                return true;
        }

        if(strDataType == "LOWERLIMIT")
        {
                LowerLimit((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "LOWEROUTPUT")
        {
                LowerOutput((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "UPPERLIMIT")
        {
                UpperLimit((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "UPPEROUTPUT")
        {
                UpperOutput((float) 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 Gain::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("UseLimits", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LowerLimit", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LowerOutput", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("UpperLimit", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("UpperOutput", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

void Gain::UpperOutput(float fltVal) {m_fltUpperOutput = fltVal;}

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

        oXml.IntoElem();  //Into Adapter Element

        UseLimits(oXml.GetChildBool("UseLimits", m_bUseLimits));

        if(m_bUseLimits)
        {
                m_fltLowerLimit = oXml.GetChildFloat("LowerLimit");
                m_fltUpperLimit = oXml.GetChildFloat("UpperLimit");
                m_fltLowerOutput = oXml.GetChildFloat("LowerOutput");
                m_fltUpperOutput = oXml.GetChildFloat("UpperOutput");
                
                Std_IsAboveMin(m_fltLowerLimit, m_fltUpperLimit, true, "UpperLimit");
        }

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

Gain ANIMAT_PORT *LoadGain(Simulator *lpSim, std::string strName, CStdXml &oXml)
{
        Gain *lpGain = NULL;

        try
        {
                //Now lets load this Current Graph object.
                oXml.IntoChildElement(strName);
                std::string strModuleName = oXml.GetChildString("ModuleName", "");
                std::string strType = oXml.GetChildString("Type");
                oXml.OutOfElem(); //OutOf Gain Element

                Gain *lpGain = dynamic_cast<AnimatSim::Gains::Gain *>(lpSim->CreateObject(strModuleName, "Gain", strType));
                if(!lpGain)
                        THROW_TEXT_ERROR(Al_Err_lConvertingClassToType, Al_Err_strConvertingClassToType, "CurrentGraph");

                lpGain->SetSystemPointers(lpSim, NULL, NULL, NULL, true);
                lpGain->Load(oXml);

                return lpGain;
        }
        catch(CStdErrorInfo oError)
        {
                if(lpGain)
                        delete lpGain;
                THROW_ERROR(oError.m_lError, oError.m_strError);
                return NULL;
        }
}

        }                       //Gains
}                       //AnimatSim