MSVehicleControl.h

Go to the documentation of this file.

/****************************************************************************/
// The class responsible for building and deletion of vehicles
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2014 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSVehicleControl_h
#define MSVehicleControl_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <math.h>
#include <string>
#include <map>
#include <set>
#include <utils/common/RandomDistributor.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>


// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class SUMOVehicleParameter;
class MSVehicle;
class MSRoute;
class MSVehicleType;
class OutputDevice;
class MSEdge;


// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicleControl {
public:
    typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;

public:
    MSVehicleControl();


    virtual ~MSVehicleControl();



    virtual SUMOVehicle* buildVehicle(SUMOVehicleParameter* defs, const MSRoute* route,
                                      const MSVehicleType* type,
                                      const bool ignoreStopErrors, const bool fromRouteFile = true);




    virtual bool addVehicle(const std::string& id, SUMOVehicle* v);


    SUMOVehicle* getVehicle(const std::string& id) const;


    virtual void deleteVehicle(SUMOVehicle* v, bool discard = false);


    void scheduleVehicleRemoval(SUMOVehicle* veh);


    constVehIt loadedVehBegin() const;


    constVehIt loadedVehEnd() const;




    void vehicleDeparted(const SUMOVehicle& v);




    unsigned int getLoadedVehicleNo() const {
        return myLoadedVehNo;
    }


    unsigned int getEndedVehicleNo() const {
        return myEndedVehNo;
    }


    unsigned int getRunningVehicleNo() const {
        return myRunningVehNo;
    }


    unsigned int getDepartedVehicleNo() const {
        return myRunningVehNo + myEndedVehNo - myDiscarded;
    }


    unsigned int getQuota(SUMOReal frac = -1) const;


    int getActiveVehicleCount() const {
        return myLoadedVehNo - (myWaitingForPerson + myEndedVehNo);
    }


    unsigned int getCollisionCount() const {
        return myCollisions;
    }

    unsigned int getTeleportsJam() const {
        return myTeleportsJam;
    }

    unsigned int getTeleportsYield() const {
        return myTeleportsYield;
    }

    unsigned int getTeleportsWrongLane() const {
        return myTeleportsWrongLane;
    }

    unsigned int getTeleportCount() const {
        return myCollisions + myTeleportsJam + myTeleportsYield + myTeleportsWrongLane;
    }

    unsigned int getEmergencyStops() const {
        return myEmergencyStops;
    }


    SUMOReal getTotalDepartureDelay() const {
        return myTotalDepartureDelay;
    }


    SUMOReal getTotalTravelTime() const {
        return myTotalTravelTime;
    }




    bool addVType(MSVehicleType* vehType);


    bool addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*>* vehTypeDistribution);


    bool hasVTypeDistribution(const std::string& id) const;


    MSVehicleType* getVType(const std::string& id = DEFAULT_VTYPE_ID, MTRand* rng = 0);


    void insertVTypeIDs(std::vector<std::string>& into) const;

    void addWaiting(const MSEdge* const edge, SUMOVehicle* vehicle);

    void removeWaiting(const MSEdge* const edge, SUMOVehicle* vehicle);

    SUMOVehicle* getWaitingVehicle(const MSEdge* const edge, const std::set<std::string>& lines);

    void registerOneWaitingForPerson() {
        myWaitingForPerson++;
    }

    void unregisterOneWaitingForPerson() {
        myWaitingForPerson--;
    }

    void registerCollision() {
        myCollisions++;
    }

    void registerTeleportJam() {
        myTeleportsJam++;
    }

    void registerTeleportYield() {
        myTeleportsYield++;
    }

    void registerTeleportWrongLane() {
        myTeleportsWrongLane++;
    }

    void registerEmergencyStop() {
        myEmergencyStops++;
    }


    void setState(int runningVehNo, int endedVehNo, SUMOReal totalDepartureDelay, SUMOReal totalTravelTime);

    void saveState(OutputDevice& out);


    void abortWaiting();

    SUMOTime computeRandomDepartOffset() const;

private:
    bool checkVType(const std::string& id);

protected:

    unsigned int myLoadedVehNo;

    unsigned int myRunningVehNo;

    unsigned int myEndedVehNo;

    unsigned int myDiscarded;

    unsigned int myCollisions;

    unsigned int myTeleportsJam;

    unsigned int myTeleportsYield;

    unsigned int myTeleportsWrongLane;

    unsigned int myEmergencyStops;




    SUMOReal myTotalDepartureDelay;

    SUMOReal myTotalTravelTime;



    typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
    VehicleDictType myVehicleDict;



    typedef std::map< std::string, MSVehicleType* > VTypeDictType;
    VTypeDictType myVTypeDict;

    typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
    VTypeDistDictType myVTypeDistDict;

    bool myDefaultVTypeMayBeDeleted;

    std::map<const MSEdge* const, std::vector<SUMOVehicle*> > myWaiting;

    unsigned int myWaitingForPerson;

    SUMOReal myScale;

    SUMOTime myMaxRandomDepartOffset;


private:
    MSVehicleControl(const MSVehicleControl& s);

    MSVehicleControl& operator=(const MSVehicleControl& s);


};


#endif

/****************************************************************************/