D:/~Research/Code/C++/EvolveTraffic/IDMParameterSet.cpp

Go to the documentation of this file.

// IDMParameterSet.cpp : implementation file
//

#include "stdafx.h"
#include "EvolveTraffic.h"
#include "IDMParameterSet.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// CIDMParameterSet

IMPLEMENT_SERIAL(CIDMParameterSet, CObject, VERSION_NUMBER)

CIDMParameterSet::CIDMParameterSet()
{
        buildParamSet();
}

CIDMParameterSet::CIDMParameterSet(WORD id)
{
        m_VehicleTypeID = id;
        buildParamSet();
}

CIDMParameterSet::~CIDMParameterSet()
{

}

CIDMParameterSet::CIDMParameterSet(const CIDMParameterSet& ParamSet)
{
        setAll(ParamSet);
}

// CIDMParameterSet diagnostics

#ifdef _DEBUG
void CIDMParameterSet::AssertValid() const
{
        CObject::AssertValid();
}

void CIDMParameterSet::Dump(CDumpContext& dc) const
{
        CObject::Dump(dc);
}
#endif //_DEBUG

// CIDMParameterSet serialization

void CIDMParameterSet::Serialize(CArchive& ar)
{               
        m_T                     .Serialize(ar);
        m_A                     .Serialize(ar);
        m_B                     .Serialize(ar);
        m_S0            .Serialize(ar);
        m_S1            .Serialize(ar);
        m_V0            .Serialize(ar);
        m_Delta         .Serialize(ar);
        m_Polite        .Serialize(ar);
        m_Bias          .Serialize(ar);
        m_DeltaAth      .Serialize(ar);

        if (ar.IsStoring())
                ar << m_VehicleTypeID;
        else
                ar >> m_VehicleTypeID;
}

// CIDMParameterSet implementation

// To avoid duplication of copy constructor and operator= functions
void CIDMParameterSet::setAll(const CIDMParameterSet &ParamSet)
{
        this->m_T               = ParamSet.m_T;
        this->m_A               = ParamSet.m_A;
        this->m_B               = ParamSet.m_B;
        this->m_S0              = ParamSet.m_S0;
        this->m_S1              = ParamSet.m_S1;
        this->m_V0              = ParamSet.m_V0;
        this->m_Delta   = ParamSet.m_Delta;
        this->m_Polite  = ParamSet.m_Polite;
        this->m_Bias    = ParamSet.m_Bias;
        this->m_DeltaAth= ParamSet.m_DeltaAth;
        
        this->m_VehicleTypeID = ParamSet.getVehicleTypeID();
}

void CIDMParameterSet::buildParamSet()
{
        // Set each of the parameters of the IDM model
        // Note appropriate default values are specified in the 
        // CDistribution(WORD id) constructor
        m_T                     .setID(IDM_PARAM_T);
        m_A                     .setID(IDM_PARAM_A);
        m_B                     .setID(IDM_PARAM_B);
        m_S0            .setID(IDM_PARAM_S0);
        m_S1            .setID(IDM_PARAM_S1);
        m_V0            .setID(IDM_PARAM_V0);
        m_Delta         .setID(IDM_PARAM_DELTA);
        m_Polite        .setID(IDM_PARAM_POLITE);
        m_Bias          .setID(IDM_PARAM_BIAS);
        m_DeltaAth      .setID(IDM_PARAM_DELTAATH);
}

CIDMParameterSet& CIDMParameterSet::operator=(const CIDMParameterSet &ParamSet)
{
        setAll(ParamSet);
        return *this;
}

void CIDMParameterSet::set_T(CParameter* param)
{
        m_T = *param;
}

CParameter* CIDMParameterSet::get_T()
{
        return &m_T;
}

void CIDMParameterSet::set_A(CParameter* param)
{
        m_A = *param;
}

CParameter* CIDMParameterSet::get_A()
{
        return &m_A;
}

void CIDMParameterSet::set_B(CParameter* param)
{
        m_B = *param;
}

CParameter* CIDMParameterSet::get_B()
{
        return &m_B;
}

void CIDMParameterSet::set_S0(CParameter* param)
{
        m_S0 = *param;
}

CParameter* CIDMParameterSet::get_S0()
{
        return &m_S0;
}

void CIDMParameterSet::set_S1(CParameter* param)
{
        m_S1 = *param;
}

CParameter* CIDMParameterSet::get_S1()
{
        return &m_S1;
}

void CIDMParameterSet::set_V0(CParameter* param)
{
        m_V0 = *param;
}

CParameter* CIDMParameterSet::get_V0()
{
        return &m_V0;
}

void CIDMParameterSet::set_Delta(CParameter* param)
{
        m_Delta = *param;
}

CParameter* CIDMParameterSet::get_Delta()
{
        return &m_Delta;
}

void CIDMParameterSet::set_Polite(CParameter* param)
{
        m_Polite = *param;
}

CParameter* CIDMParameterSet::get_Polite()
{
        return &m_Polite;
}

void CIDMParameterSet::set_Bias(CParameter* param)
{
        m_Bias = *param;
}

CParameter* CIDMParameterSet::get_Bias()
{
        return &m_Bias;
}

void CIDMParameterSet::set_DeltaAth(CParameter* param)
{
        m_DeltaAth = *param;
}

CParameter* CIDMParameterSet::get_DeltaAth()
{
        return &m_DeltaAth;
}

void CIDMParameterSet::setVehicleTypeID(int id)
{
        m_VehicleTypeID = id;
}

int CIDMParameterSet::getVehicleTypeID() const
{
        return m_VehicleTypeID;
}

// This function generates an IDM and returns it.
// Usually to be called by a vehicle.
IDM CIDMParameterSet::Generate()
{
        IDM tempIDM;
        
        tempIDM.set_T           (m_T            .Generate() );
        tempIDM.set_A           (m_A            .Generate() );
        tempIDM.set_B           (m_B            .Generate() );
        tempIDM.set_S0          (m_S0           .Generate() );
        tempIDM.set_S1          (m_S1           .Generate() );
        tempIDM.set_V0          (m_V0           .Generate() );
        tempIDM.set_Delta       (m_Delta        .Generate() );
        tempIDM.set_Polite      (m_Polite       .Generate() );
        tempIDM.set_Bias        (m_Bias         .Generate() );
        tempIDM.set_DeltaAth(m_DeltaAth .Generate() );

        return tempIDM;
}

---