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

Go to the documentation of this file.

#include "stdafx.h"
#include "Road.h"

#include "ConfigData.h"
extern CConfigData g_ConfigData;

Road::Road()
{
        MIN_SPACE_FOR_NEXT_VEHICLE = g_ConfigData.IDM.MIN_SPACE_FOR_NEXT_VEHICLE;

        m_pIDMParams_Car                = NULL;
        m_pIDMParams_SmallTruck = NULL;
        m_pIDMParams_LargeTruck = NULL;
        m_pIDMParams_Crane              = NULL;
        m_pIDMParams_Lowloader  = NULL;

        m_pFileHandler                  = NULL;

        m_bEndOfFile = false;
}

Road::~Road()
{
        m_pIDMParams_Car                = NULL;
        m_pIDMParams_SmallTruck = NULL;
        m_pIDMParams_LargeTruck = NULL;
        m_pIDMParams_Crane              = NULL;
        m_pIDMParams_Lowloader  = NULL;
}

bool Road::update(double step,const double curTime)
{
        bool SimulationOver = false;
        bool RoadEmpty = false;
        bool DirPosEmpty = false;
        bool DirNegEmpty = false;

        // since there's always one direction
        DirPosEmpty = DirectionPos.update(step, curTime);

        if(m_NoDirections == 2)
                DirNegEmpty = DirectionNeg.update(step, curTime);

        if(DirPosEmpty && DirNegEmpty)
                RoadEmpty = true;

        if(RoadEmpty && m_bEndOfFile)   // if no more vehicles and road is empty
                SimulationOver = true;          // we are finished!

        if(SimulationOver)      // tidy up detector output
        {
                for(int i = 0; i < m_vDetectorsPos.size(); i++)
                        m_vDetectorsPos[i]->EndOutput();
                for(i = 0; i < m_vDetectorsNeg.size(); i++)
                        m_vDetectorsNeg[i]->EndOutput();
        }

        return SimulationOver;                  
}

double Road::init()
{       
        sort(m_vRoadSegmentsPos.begin(), m_vRoadSegmentsPos.end(), RoadSegment::CompareSegments);       
        sort(m_vRoadSegmentsNeg.begin(), m_vRoadSegmentsNeg.end(), RoadSegment::CompareSegments);       

        // Initially set up vehicles and their sim lanes
        m_BufferVehicles = m_pFileHandler->loadTruckGroup(INPUT_FILE_BUFFER_SIZE);
        for(int i = 0; i < m_BufferVehicles.size(); i++)
                MapTrafLaneToSimLane(m_BufferVehicles.at(i));

        // lane vector
        std::vector<int> vLaneLengthsPos(m_NoLanesDirPos,m_RoadLength); // this is for future extension

        // true means positive x-direction
        OutputDetector* pDetDirPos = new OutputDetector(m_LocOutputDetectorDirPos, true, m_pFileHandler);
        DirectionPos.init(true, pDetDirPos, m_AllowLaneChanging, m_RoadLength, m_DriveOnRight);         
        DirectionPos.createLanes(0, vLaneLengthsPos, m_vDetectorsPos, m_vRoadSegmentsPos);
        
        // Using cumulative lane identifiers
        for(i = 0; i < DirectionPos.getNoLanes(); i++)
                m_vLanes.push_back(&DirectionPos.getLane(i));

        if(m_NoDirections == 2)
        {
                // lane vector
                std::vector<int> vLaneLengthsNeg(m_NoLanesDirNeg,m_RoadLength);
                
                // false means the negative x-direction
                OutputDetector* pDetDirNeg = new OutputDetector(m_LocOutputDetectorDirNeg, false, m_pFileHandler);
                DirectionNeg.init(false, pDetDirNeg, m_AllowLaneChanging, m_RoadLength, m_DriveOnRight);
                DirectionNeg.createLanes(m_NoLanesDirPos, vLaneLengthsNeg, m_vDetectorsNeg, m_vRoadSegmentsNeg);

                for(i = 0; i < DirectionNeg.getNoLanes(); i++)
                        m_vLanes.push_back(&DirectionNeg.getLane(i));
        }

        // Return the time of the first truck of the traffic file
        return m_BufferVehicles.front()->getTime();
}

void Road::populate(double step, const double curTime)
{
        bool frontOn = true;
        while(m_BufferVehicles.size() > 0 && frontOn)
        {
                frontOn = false;
                int lane = m_BufferVehicles.front()->getLane() - 1;             // the cumulative lane no of the next truck on the road

                if(m_vLanes.at(lane)->getLastPos() >= MIN_SPACE_FOR_NEXT_VEHICLE)               // If there is space for another vehicle
                {
                        if(m_BufferVehicles.front()->getTime() <= curTime)      // If it is time for the next vehicle
                        {
                                int noVeh = m_vLanes.at(lane)->getNoVeh();              // crashes here sim has fewer lanes than the truck file.

                                // set the driver, roadlength, insert into lane and remove from buffer
                                setIDMDriverModel(m_BufferVehicles.front());
                                m_BufferVehicles.front()->init(m_RoadLength, m_DriveOnRight);
                                m_vLanes.at(lane)->insert(noVeh, m_BufferVehicles.front());
                                m_BufferVehicles.erase(m_BufferVehicles.begin());

                                Vehicle* tempVeh = m_pFileHandler->readLine();
                                m_PercentComplete = m_pFileHandler->getPercentComplete();
                                if(tempVeh != NULL)
                                {
                                        MapTrafLaneToSimLane(tempVeh);
                                        m_BufferVehicles.push_back(tempVeh);
                                }
                                else
                                        m_bEndOfFile = true;
                                frontOn = true;
                        }
                }

        }
}

void Road::MapTrafLaneToSimLane(Vehicle* pVeh)
{
        // first tell the vehicle how many lanes the road has for later use
        pVeh->setTotalNoLanesInRoad(m_NoLanes);

        // then map its current local to global lane number
        if(!pVeh->getDirection())       // only if it's in the negative direction
        {
                int TrafFileNoLanes = m_TrafFileNoLanesDirPos + m_TrafFileNoLanesDirNeg;
                int lanesFromNegVerge = TrafFileNoLanes - pVeh->getLane();
                int newLane = m_NoLanes - lanesFromNegVerge;    // vehicle lane numbers are 1-based
                pVeh->setLane(newLane);
        }
}

void Road::setIDMDriverModel(Vehicle* pVeh)
{
        WORD VEH_ID = pVeh->getID();
        
        switch(VEH_ID)
        {
                case VEH_ID_CAR:
                        pVeh->setDriver( m_pIDMParams_Car->Generate() );
                        break;
                case VEH_ID_SMALLTRUCK:
                        pVeh->setDriver( m_pIDMParams_SmallTruck->Generate() );
                        break;
                case VEH_ID_LARGETRUCK:
                        pVeh->setDriver( m_pIDMParams_LargeTruck->Generate() );
                        break;
                case VEH_ID_CRANE:
                        pVeh->setDriver( m_pIDMParams_Crane->Generate() );
                        break;
                case VEH_ID_LOWLOADER:
                        pVeh->setDriver( m_pIDMParams_Lowloader->Generate() );
                        break;
                default:
                        pVeh->setDriver( m_pIDMParams_Car->Generate() );
        };
}

M2D Road::getVehicles()
{       
        M2D pos;

        M2D temp = DirectionPos.getGlobalPos(); // get DirPos positions
        for(int i = 0; i < m_NoLanesDirPos; i++)                // and add lane by lane
                pos.push_back(temp[i]);

        if(m_NoDirections == 2)         // Uni-directional roads are in Dir1
        {
                temp.clear();
                
                temp = DirectionNeg.getGlobalPos();     // get DirNeg positions
                for(i = 0; i < m_NoLanesDirNeg; i++)            // and add lane by lane
                        pos.push_back(temp[i]);
        }

        return pos;
}

double Road::getLength()
{
        return m_RoadLength;
}

void Road::setNoLanesDirPos(int nlpos)
{
        m_NoLanesDirPos = nlpos;
}

void Road::setNoLanesDirNeg(int nlneg)
{
        m_NoLanesDirNeg = nlneg;
}

void Road::setNoDirections(int nd)
{
        m_NoDirections = nd;
}

void Road::setNoLanes(int nl)
{
        m_NoLanes = nl;
}

void Road::setRoadLength(int L)
{
        m_RoadLength = L;
}

void Road::initTruckGroup(string inFile, string outFile, WORD fileType)
{
        if(fileType == CASTOR)
        {
                m_pFileHandler = new CASTORFile(inFile, outFile);

        }
        else if(fileType == SAFT)
        {
                m_pFileHandler = new SAFTFile(inFile, outFile);
        }
}

void Road::setIDMParams_Car(CIDMParameterSet* Params)
{
        m_pIDMParams_Car = Params;
}

void Road::setIDMParams_SmallTruck(CIDMParameterSet* Params)
{
        m_pIDMParams_SmallTruck = Params;
}

void Road::setIDMParams_LargeTruck(CIDMParameterSet* Params)
{
        m_pIDMParams_LargeTruck = Params;
}

void Road::setIDMParams_Crane(CIDMParameterSet* Params)
{
        m_pIDMParams_Crane = Params;
}

void Road::setIDMParams_Lowloader(CIDMParameterSet* Params)
{
        m_pIDMParams_Lowloader = Params;
}

void Road::setTrafFileNoLanesDirPos(int nl)
{
        m_TrafFileNoLanesDirPos = nl;
}

void Road::setTrafFileNoLanesDirNeg(int nl)
{
        m_TrafFileNoLanesDirNeg = nl;
}

void Road::setLocOuputDetectorDirPos(int loc)
{
        m_LocOutputDetectorDirPos = loc;
}

void Road::setLocOuputDetectorDirNeg(int loc)
{
        // change from overall road coordinates to lane coordinates
        m_LocOutputDetectorDirNeg = m_RoadLength - loc;
}

int Road::getPercentComplete()
{
        return m_PercentComplete;
}

bool Road::getAllowLaneChanging()
{
        return m_AllowLaneChanging;
}

void Road::setAllowLaneChanging(bool status)
{
        m_AllowLaneChanging = status;
}

void Road::setDriveOnRight(bool OnRight)
{
        m_DriveOnRight = OnRight;
}

void Road::passIDMParameters(RoadSegment *segment)
{
        segment->setIDMParams_Car(m_pIDMParams_Car);
        segment->setIDMParams_Crane(m_pIDMParams_Crane);
        segment->setIDMParams_LargeTruck(m_pIDMParams_LargeTruck);
        segment->setIDMParams_Lowloader(m_pIDMParams_Lowloader);
        segment->setIDMParams_SmallTruck(m_pIDMParams_SmallTruck);
}

void Road::SetSegmentFromFeature(CRoadFeature *pFeat)
{
        ASSERT(pFeat->getStart() < pFeat->getEnd());    // should be since done in CRoadFeaturesDlg validation

        switch( pFeat->getType() )
        {
                case FEAT_SPEEDLIMIT:
                        SetSpeedLimitSegment(pFeat);
                        break;
                case FEAT_GRADIENT:     
                        SetGradientSegment(pFeat);
                        break;
                default:
                        break;
        }
        
}

void Road::SetSpeedLimitSegment(CRoadFeature *pFeat)
{
        bool bDirPos = pFeat->getDirPos();
        SpeedLimit* pSL;
        if( bDirPos )
        {
                pSL = new SpeedLimit(pFeat->getStart(), pFeat->getEnd(), pFeat->getValue(), bDirPos);
                m_vRoadSegmentsPos.push_back(pSL);
        }
        else
        {
                int start = pFeat->getStart();
                int end = pFeat->getEnd();

                pSL = new SpeedLimit(m_RoadLength - end, m_RoadLength - start, pFeat->getValue(), bDirPos);
                
                m_vRoadSegmentsNeg.push_back(pSL);
        }
        passIDMParameters(pSL);
}

void Road::SetGradientSegment(CRoadFeature *pFeat)
{
        bool bDirPos = pFeat->getDirPos();
        Gradient* pGr;

        if( bDirPos )
        {
                pGr = new Gradient(pFeat->getStart(), pFeat->getEnd(), pFeat->getValue(), bDirPos);
                m_vRoadSegmentsPos.push_back(pGr);
        }
        else
        {
                int start = pFeat->getStart();
                int end = pFeat->getEnd();

                pGr = new Gradient(m_RoadLength - end, m_RoadLength - start, pFeat->getValue(), bDirPos);
                
                m_vRoadSegmentsNeg.push_back(pGr);
        }
        passIDMParameters(pGr);
}

void Road::SetMetricDetFromStatDet(CStatDetector* pDet, int nLanesPos, int nLanesNeg)
{
        bool bDirPos = pDet->getDirPos();

        if(pDet->getDetectorType() == METRICS_TYPE_LANE_CHANGE)
        {
                LaneChangeDetector* pLCD;
                pLCD = new LaneChangeDetector(  pDet->getStdStrMetricsDir(),
                                                                                pDet->getTimeInterval(),
                                                                                pDet->getLocation(),
                                                                                m_RoadLength,
                                                                                bDirPos,
                                                                                pDet->getVehicleType());
                if( bDirPos )
                        m_vDetectorsPos.push_back(pLCD);
                else
                        m_vDetectorsNeg.push_back(pLCD);
        }
        else
        {
                MetricsDetector* pMD;
                if( bDirPos )
                {
                        pMD = new MetricsDetector(      pDet->getStdStrMetricsDir(),
                                                                                pDet->getDetectorType(), 
                                                                                bDirPos,
                                                                                nLanesPos,
                                                                                pDet->getVehicleType(), 
                                                                                pDet->getTimeInterval(), 
                                                                                pDet->getLocation(), 
                                                                                m_RoadLength);
                        m_vDetectorsPos.push_back(pMD);
                }
                else
                {
                        pMD = new MetricsDetector(      pDet->getStdStrMetricsDir(),
                                                                                pDet->getDetectorType(), 
                                                                                bDirPos,
                                                                                nLanesNeg,
                                                                                pDet->getVehicleType(), 
                                                                                pDet->getTimeInterval(), 
                                                                                m_RoadLength - pDet->getLocation(),     // change from global road to local dirn coords
                                                                                m_RoadLength);                                          // need this to revert filenames to global positions
                        m_vDetectorsNeg.push_back(pMD);
                }
        }
}

void Road::clear()
{
        DirectionPos.clear();
        if(m_NoDirections == 2)
                DirectionNeg.clear();

        delete m_pFileHandler;

        m_vLanes.clear();

        m_BufferVehicles.clear();

        m_vDetectorsPos.clear();
        m_vDetectorsNeg.clear();

        m_vRoadSegmentsPos.clear();
        m_vRoadSegmentsNeg.clear();

        // why don't we just delete these?
        m_pIDMParams_Car                = NULL;
        m_pIDMParams_SmallTruck = NULL;
        m_pIDMParams_LargeTruck = NULL;
        m_pIDMParams_Crane              = NULL;
        m_pIDMParams_Lowloader  = NULL;
}

---