MSVehicleControl.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// The class responsible for building and deletion of vehicles
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <cmath>
#include <string>
#include <map>
#include <set>
#ifdef HAVE_FOX
#include <utils/foxtools/fxheader.h>
#include <utils/foxtools/MFXSynchQue.h>
#endif
#include <utils/distribution/RandomDistributor.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/Command.h>
#include <microsim/MSRouterDefs.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class SUMOVehicleParameter;
class MSBaseVehicle;
class MSVehicle;
class MSRoute;
class MSVehicleType;
class OutputDevice;
class MSEdge;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicleControl {
public:
    typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;
 
    enum VehicleDefinitionSource {
        ROUTEFILE,
        STATE,
        TRIGGER,
        LIBSUMO,
        OTHER
    };
 
public:
    MSVehicleControl();
 
 
    virtual ~MSVehicleControl();
 
 
    virtual SUMOVehicle* buildVehicle(SUMOVehicleParameter* defs, ConstMSRoutePtr route,
                                      MSVehicleType* type,
                                      const bool ignoreStopErrors, const VehicleDefinitionSource source = ROUTEFILE,
                                      bool addRouteStops = 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, bool wasKept = false);
 
    void deleteKeptVehicle(SUMOVehicle* veh);
 
    void fixVehicleCounts() {
        myLoadedVehNo++;
        myEndedVehNo++;
        myDiscarded++;
    }
 
    void scheduleVehicleRemoval(SUMOVehicle* veh, bool checkDuplicate = false);
 
 
    void removePending();
 
 
    constVehIt loadedVehBegin() const {
        return myVehicleDict.begin();
    }
 
 
    constVehIt loadedVehEnd() const {
        return myVehicleDict.end();
    }
 
 
    void handleTriggeredDepart(SUMOVehicle* v, bool add);
 
 
    void vehicleDeparted(const SUMOVehicle& v);
 
 
 
 
    int getLoadedVehicleNo() const {
        return myLoadedVehNo;
    }
 
 
    virtual int getHaltingVehicleNo() const;
 
    virtual std::pair<double, double> getVehicleMeanSpeeds() const;
    double getVehicleMeanSpeed() const {
        return getVehicleMeanSpeeds().first;
    }
    double getVehicleMeanSpeedRelative() const {
        return getVehicleMeanSpeeds().second;
    }
 
    int getEndedVehicleNo() const {
        return myEndedVehNo;
    }
 
    int getArrivedVehicleNo() const {
        return myEndedVehNo - myDiscarded;
    }
 
    int getDiscardedVehicleNo() const {
        return myDiscarded;
    }
 
 
    int getRunningVehicleNo() const {
        return myRunningVehNo;
    }
 
 
    int getDepartedVehicleNo() const {
        return myRunningVehNo + myEndedVehNo - myDiscarded;
    }
 
 
    int getQuota(double frac = -1, int loaded = -1) const;
 
 
    int getActiveVehicleCount() const {
        return myLoadedVehNo - (myWaitingForTransportable + myEndedVehNo);
    }
 
    int getTriggeredVehicleCount() const {
        return myWaitingForTransportable;
    }
 
 
    int getCollisionCount() const {
        return myCollisions;
    }
 
    int getTeleportsCollisions() const {
        return myTeleportsCollision;
    }
 
    int getTeleportsJam() const {
        return myTeleportsJam;
    }
 
    int getTeleportsYield() const {
        return myTeleportsYield;
    }
 
    int getTeleportsWrongLane() const {
        return myTeleportsWrongLane;
    }
 
    int getTeleportCount() const;
 
    int getEmergencyStops() const {
        return myEmergencyStops;
    }
 
    int getEmergencyBrakingCount() const {
        return myEmergencyBrakingCount;
    }
 
    int getStoppedVehiclesCount() const {
        return myStoppedVehicles;
    }
 
    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 hasVType(const std::string& id) const;
 
 
    bool hasVTypeDistribution(const std::string& id) const;
 
 
    MSVehicleType* getVType(const std::string& id = DEFAULT_VTYPE_ID, SumoRNG* rng = nullptr, bool readOnly = false);
 
 
    void insertVTypeIDs(std::vector<std::string>& into) const;
 
 
    const std::set<std::string> getVTypeDistributionMembership(const std::string& id) const;
 
    const RandomDistributor<MSVehicleType*>* getVTypeDistribution(const std::string& typeDistID) const;
 
    const std::vector<MSVehicleType*> getPedestrianTypes(void) const;
 
 
    void registerOneWaiting() {
        myWaitingForTransportable++;
    }
 
    void unregisterOneWaiting() {
        myWaitingForTransportable--;
    }
 
    void registerCollision(bool teleport) {
        myCollisions++;
        if (teleport) {
            myTeleportsCollision++;
        }
    }
 
    void registerTeleportJam() {
        myTeleportsJam++;
    }
 
    void registerTeleportYield() {
        myTeleportsYield++;
    }
 
    void registerTeleportWrongLane() {
        myTeleportsWrongLane++;
    }
 
    void registerEmergencyStop() {
        myEmergencyStops++;
    }
 
    void registerEmergencyBraking() {
        myEmergencyBrakingCount++;
    }
 
    void registerStopStarted() {
        myStoppedVehicles++;
    }
 
    void registerStopEnded() {
        myStoppedVehicles--;
    }
 
 
    void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime);
 
    void saveState(OutputDevice& out);
 
    void clearState(const bool reinit);
 
    void discountStateRemoved(int n) {
        myRunningVehNo -= n;
        myDiscarded += n;
        myEndedVehNo += n;
    }
 
 
    void abortWaiting();
 
    double getMaxSpeedFactor() const {
        return myMaxSpeedFactor;
    }
 
    double getMinDeceleration() const {
        return myMinDeceleration;
    }
 
    double getMinDecelerationRail() const {
        return myMinDecelerationRail;
    }
 
    void adaptIntermodalRouter(MSTransportableRouter& router) const;
 
    void setScale(double scale) {
        myScale = scale;
    }
 
    double getScale() const {
        return myScale;
    }
 
private:
    void initDefaultTypes();
 
    bool checkVType(const std::string& id);
 
    bool isPendingRemoval(SUMOVehicle* veh);
 
protected:
    void initVehicle(MSBaseVehicle* built, const bool ignoreStopErrors, bool addRouteStops, const VehicleDefinitionSource source);
 
private:
 
    int myLoadedVehNo;
 
    int myRunningVehNo;
 
    int myEndedVehNo;
 
    int myDiscarded;
 
    int myCollisions;
 
    int myTeleportsCollision;
 
    int myTeleportsJam;
 
    int myTeleportsYield;
 
    int myTeleportsWrongLane;
 
    int myEmergencyStops;
 
    int myEmergencyBrakingCount;
 
    int myStoppedVehicles;
 
 
 
    double myTotalDepartureDelay;
 
    double myTotalTravelTime;
 
 
protected:
 
    typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
    VehicleDictType myVehicleDict;
 
 
private:
    class DeleteKeptVehicle : public Command {
    public:
        DeleteKeptVehicle(SUMOVehicle* veh) : myVehicle(veh) {};
        ~DeleteKeptVehicle() {};
        SUMOTime execute(SUMOTime currentTime);
    private:
        SUMOVehicle* myVehicle;
    private:
        DeleteKeptVehicle& operator=(const DeleteKeptVehicle&) = delete;
    };
 
 
    typedef std::map< std::string, MSVehicleType* > VTypeDictType;
    VTypeDictType myVTypeDict;
 
    typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
    VTypeDistDictType myVTypeDistDict;
 
    std::map<std::string, std::set<std::string>> myVTypeToDist;
 
    std::set<std::string> myReplaceableDefaultVTypes;
 
    int myWaitingForTransportable;
 
    double myScale;
 
    SUMOTime myKeepTime;
 
    double myMaxSpeedFactor;
 
    double myMinDeceleration;
    double myMinDecelerationRail;
 
    std::vector<SUMOVehicle*> myPTVehicles;
 
#ifdef HAVE_FOX
    MFXSynchQue<SUMOVehicle*, std::vector<SUMOVehicle*> > myPendingRemovals;
#else
    std::vector<SUMOVehicle*> myPendingRemovals;
#endif
 
private:
    MSVehicleControl(const MSVehicleControl& s) = delete;
 
    MSVehicleControl& operator=(const MSVehicleControl& s) = delete;
 
 
};