OdorType.cpp

Go to the documentation of this file.

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

#include "Node.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 "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 Environment
        {
OdorType::OdorType()
{
        m_fltDiffusionConstant = 1;
}

OdorType::~OdorType()
{

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

float OdorType::DiffusionConstant() {return m_fltDiffusionConstant;};

void OdorType::DiffusionConstant(float fltVal, bool bUseScaling) 
{
        Std_IsAboveMin((float) 0, fltVal, true, "Diffusion Constant");

        if(bUseScaling)
                fltVal = fltVal/(m_lpSim->DistanceUnits()*m_lpSim->DistanceUnits()); //Our diffusion constant is in m^2/s. We need to convert its distance units appropriately.

        m_fltDiffusionConstant = fltVal;
};

Odor *OdorType::FindOdorSource(std::string strOdorID, bool bThrowError)
{
        Odor *lpOdor = NULL;
        CStdMap<std::string, Odor *>::iterator oPos;
        oPos = m_aryOdorSources.find(Std_CheckString(strOdorID));

        if(oPos != m_aryOdorSources.end())
                lpOdor =  oPos->second;
        else if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lOdorIDNotFound, Al_Err_strOdorIDNotFound, "OdorID", strOdorID);

        return lpOdor;
}

void OdorType::AddOdorSource(Odor *lpOdor)
{
        if(!FindOdorSource(lpOdor->ID(), false))
        {
                m_aryOdorSources.Add(lpOdor->ID(), lpOdor);
        }
}

float OdorType::CalculateOdorValue(CStdFPoint &oSensorPos)
{
        //Loop through each of the associated odors and calculate the value for each one.
        CStdMap<std::string, Odor *>::iterator oIterator;
        Odor *lpOdor = NULL;
        float fltVal = 0;

        for(oIterator=m_aryOdorSources.begin(); 
            oIterator!=m_aryOdorSources.end(); 
                        ++oIterator)
        {
                lpOdor = oIterator->second;
                fltVal += lpOdor->CalculateOdorValue(this, oSensorPos);
        }

        return fltVal;
}

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

        if(AnimatBase::SetData(strType, strValue, false))
                return true;

        if(strType == "DIFFUSIONCONSTANT")
        {
                DiffusionConstant((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 OdorType::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

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

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

        oXml.IntoElem();  //Into Joint Element

        DiffusionConstant(oXml.GetChildFloat("DiffusionConstant", m_fltDiffusionConstant));

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

        }                       // Environment
}                       //AnimatSim