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-2017 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/distribution/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 {
        return myVehicleDict.begin();
    }


    constVehIt loadedVehEnd() const {
        return myVehicleDict.end();
    }




    void vehicleDeparted(const SUMOVehicle& v);




    int getLoadedVehicleNo() const {
        return myLoadedVehNo;
    }


    int getEndedVehicleNo() const {
        return myEndedVehNo;
    }


    int getRunningVehicleNo() const {
        return myRunningVehNo;
    }


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


    int getQuota(double frac = -1) const;


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


    int getCollisionCount() const {
        return myCollisions;
    }

    int getTeleportsJam() const {
        return myTeleportsJam;
    }

    int getTeleportsYield() const {
        return myTeleportsYield;
    }

    int getTeleportsWrongLane() const {
        return myTeleportsWrongLane;
    }

    int getTeleportCount() const;

    int getEmergencyStops() const {
        return myEmergencyStops;
    }


    double getTotalDepartureDelay() const {
        return myTotalDepartureDelay;
    }


    double getTotalTravelTime() const {
        return myTotalTravelTime;
    }




    bool addVType(MSVehicleType* vehType);

    /*
     * @param[in] vehType The vehicle type to remove
     * @return Whether the vehicle type could be removed
     */
    void removeVType(const 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);

    /* @brief returns a vehicle of the given lines that is waiting for a for a person or a container at this edge at the given positions
     * @param[in] edge The edge at which the vehicle is positioned.
     * @param[in] lines The set of lines from which at least one must correspond to the line of the vehicle
     * @param[in] position The vehicle shall be positioned in the interval [position - t, position + t], where t is some tolerance
     * @param[in] ridingID The id of the person or container that wants to ride
     */
    SUMOVehicle* getWaitingVehicle(const MSEdge* const edge, const std::set<std::string>& lines, const double position, const std::string ridingID);

    void registerOneWaitingForPerson() {
        myWaitingForPerson++;
    }

    void unregisterOneWaitingForPerson() {
        myWaitingForPerson--;
    }

    void registerOneWaitingForContainer() {
        myWaitingForContainer++;
    }

    void unregisterOneWaitingForContainer() {
        myWaitingForContainer--;
    }

    void registerCollision() {
        myCollisions++;
    }

    void registerTeleportJam() {
        myTeleportsJam++;
    }

    void registerTeleportYield() {
        myTeleportsYield++;
    }

    void registerTeleportWrongLane() {
        myTeleportsWrongLane++;
    }

    void registerEmergencyStop() {
        myEmergencyStops++;
    }


    void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime);

    void saveState(OutputDevice& out);

    void discountStateLoaded(bool removed = false) {
        if (removed) {
            myRunningVehNo--;
            myDiscarded++;
            myEndedVehNo++;
        } else {
            myLoadedVehNo--;
        }
    }


    void abortWaiting();

    SUMOTime computeRandomDepartOffset() const;

    double getMaxSpeedFactor() const {
        return myMaxSpeedFactor;
    }

    double getMinDeceleration() const {
        return myMinDeceleration;
    }

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

protected:

    int myLoadedVehNo;

    int myRunningVehNo;

    int myEndedVehNo;

    int myDiscarded;

    int myCollisions;

    int myTeleportsJam;

    int myTeleportsYield;

    int myTeleportsWrongLane;

    int myEmergencyStops;




    double myTotalDepartureDelay;

    double 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;

    bool myDefaultPedTypeMayBeDeleted;

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

    int myWaitingForPerson;

    int myWaitingForContainer;

    double myScale;

    SUMOTime myMaxRandomDepartOffset;

    double myMaxSpeedFactor;

    double myMinDeceleration;

private:
    MSVehicleControl(const MSVehicleControl& s);

    MSVehicleControl& operator=(const MSVehicleControl& s);


};


#endif

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