MSNet.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 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 simulated network and simulation performer
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <typeinfo>
#include <vector>
#include <map>
#include <string>
#include <fstream>
#include <iostream>
#include <cmath>
#include <iomanip>
#include <memory>
#include <utils/common/SUMOTime.h>
#include <utils/common/UtilExceptions.h>
#include <utils/common/NamedObjectCont.h>
#include <utils/common/NamedRTree.h>
#include <utils/router/SUMOAbstractRouter.h>
#include <mesosim/MESegment.h>
#include "MSRouterDefs.h"
#include "MSJunction.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSEdgeControl;
class MSEventControl;
class MSVehicleControl;
class MSJunctionControl;
class MSInsertionControl;
class SUMORouteLoaderControl;
class MSTransportableControl;
class MSTransportable;
class MSVehicle;
class MSRoute;
class MSLane;
class MSTLLogicControl;
class MSTrafficLightLogic;
class MSDetectorControl;
class ShapeContainer;
class MSDynamicShapeUpdater;
class PolygonDynamics;
class MSEdgeWeightsStorage;
class SUMOVehicle;
class SUMOTrafficObject;
class MSTractionSubstation;
class MSStoppingPlace;
template<class E, class L, class N, class V>
class IntermodalRouter;
template<class E, class L, class N, class V>
class PedestrianRouter;
class OptionsCont;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSNet : public Parameterised {
public:
    enum SimulationState {
        SIMSTATE_LOADING,
        SIMSTATE_RUNNING,
        SIMSTATE_END_STEP_REACHED,
        SIMSTATE_NO_FURTHER_VEHICLES,
        SIMSTATE_CONNECTION_CLOSED,
        SIMSTATE_ERROR_IN_SIM,
        SIMSTATE_INTERRUPTED,
        SIMSTATE_TOO_MANY_TELEPORTS
    };
 
    struct Collision {
        std::string victim;
        std::string colliderType;
        std::string victimType;
        double colliderSpeed;
        double victimSpeed;
        Position colliderFront;
        Position victimFront;
        Position colliderBack;
        Position victimBack;
        std::string type;
        const MSLane* lane;
        double pos;
        SUMOTime time;
        SUMOTime continuationTime;
    };
 
    typedef std::map<std::string, std::vector<Collision> > CollisionMap;
    typedef std::map<const MSEdge*, RouterProhibition> Prohibitions;
 
public:
    static MSNet* getInstance();
 
    virtual bool isGUINet() const {
        return false;
    }
 
    static void initStatic();
 
    static void cleanupStatic();
 
 
    static bool hasInstance() {
        return myInstance != nullptr;
    }
 
 
    MSNet(MSVehicleControl* vc, MSEventControl* beginOfTimestepEvents,
          MSEventControl* endOfTimestepEvents,
          MSEventControl* insertionEvents,
          ShapeContainer* shapeCont = nullptr);
 
 
    virtual ~MSNet();
 
 
    void closeBuilding(const OptionsCont& oc, MSEdgeControl* edges, MSJunctionControl* junctions,
                       SUMORouteLoaderControl* routeLoaders, MSTLLogicControl* tlc,
                       std::vector<SUMOTime> stateDumpTimes, std::vector<std::string> stateDumpFiles,
                       bool hasInternalLinks,
                       bool junctionHigherSpeeds,
                       const MMVersion& version);
 
 
    bool hasPermissions() const {
        return myHavePermissions;
    }
 
 
    void setPermissionsFound() {
        myHavePermissions = true;
    }
 
 
    void addRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed);
 
 
    const std::map<SUMOVehicleClass, double>* getRestrictions(const std::string& id) const;
 
    double getPreference(const std::string& routingType, const SUMOVTypeParameter& pars) const;
 
    void addPreference(const std::string& routingType, SUMOVehicleClass svc, double prio);
    void addPreference(const std::string& routingType, std::string vType, double prio);
 
    void addMesoType(const std::string& typeID, const MESegment::MesoEdgeType& edgeType);
 
    const MESegment::MesoEdgeType& getMesoType(const std::string& typeID);
 
    static void clearAll();
 
    bool hasFlow(const std::string& id) const;
 
    SimulationState simulate(SUMOTime start, SUMOTime stop);
 
 
    void simulationStep(const bool onlyMove = false);
 
    void loadRoutes();
 
 
    const std::string generateStatistics(const SUMOTime start, const long now);
 
    void writeCollisions() const;
 
    void writeStatistics(const SUMOTime start, const long now) const;
 
    void writeSummaryOutput(bool finalStep = false);
 
    void closeSimulation(SUMOTime start, const std::string& reason = "");
 
 
    SimulationState simulationState(SUMOTime stopTime) const;
 
 
    SimulationState adaptToState(const SimulationState state, const bool isLibsumo = false) const;
 
 
    static std::string getStateMessage(SimulationState state);
 
 
    inline SUMOTime getCurrentTimeStep() const {
        return myStep;
    }
 
 
    inline void setCurrentTimeStep(const SUMOTime step) {
        myStep = step;
    }
 
 
    void clearState(const SUMOTime step, bool quickReload = false);
 
 
    SUMOTime getLoaderTime() const;
 
    void setLoaderTime(SUMOTime time);
 
    SUMOTime getStateLoaderTime() const {
        return myStateLoaderTime;
    }
 
    void writeOutput();
 
 
    bool logSimulationDuration() const;
 
 
 
 
 
    void preSimStepOutput() const;
 
 
    void postSimStepOutput() const;
    //}
 
 
 
 
    MSVehicleControl& getVehicleControl() {
        return *myVehicleControl;
    }
 
 
    virtual MSTransportableControl& getPersonControl();
 
    bool hasPersons() const {
        return myPersonControl != nullptr;
    }
 
    virtual MSTransportableControl& getContainerControl();
 
    bool hasContainers() const {
        return myContainerControl != nullptr;
    }
 
 
    MSEdgeControl& getEdgeControl() {
        return *myEdges;
    }
 
 
    MSInsertionControl& getInsertionControl() {
        return *myInserter;
    }
 
 
    MSDetectorControl& getDetectorControl() {
        return *myDetectorControl;
    }
 
 
    MSTLLogicControl& getTLSControl() {
        return *myLogics;
    }
 
 
    MSJunctionControl& getJunctionControl() {
        return *myJunctions;
    }
 
 
    MSEventControl* getBeginOfTimestepEvents() {
        return myBeginOfTimestepEvents;
    }
 
 
    MSEventControl* getEndOfTimestepEvents() {
        return myEndOfTimestepEvents;
    }
 
 
    MSEventControl* getInsertionEvents() {
        return myInsertionEvents;
    }
 
 
    ShapeContainer& getShapeContainer() {
        return *myShapeContainer;
    }
 
    MSDynamicShapeUpdater* getDynamicShapeUpdater() {
        return myDynamicShapeUpdater.get();
    }
 
    MSDynamicShapeUpdater* makeDynamicShapeUpdater();
 
    MSEdgeWeightsStorage& getWeightsStorage();
 
 
    bool addStoppingPlace(SumoXMLTag category, MSStoppingPlace* stop);
 
 
    bool addTractionSubstation(MSTractionSubstation* substation);
 
 
    MSStoppingPlace* getStoppingPlace(const std::string& id, const SumoXMLTag category) const;
 
    MSStoppingPlace* getStoppingPlace(const std::string& id) const;
 
    std::string getStoppingPlaceID(const MSLane* lane, const double pos, const SumoXMLTag category) const;
 
    /* @brief returns all stopping places of that category with the same (non-empty) name attribute
     */
    const std::vector<MSStoppingPlace*>& getStoppingPlaceAlternatives(const std::string& name, SumoXMLTag category) const;
 
    const NamedObjectCont<MSStoppingPlace*>& getStoppingPlaces(SumoXMLTag category) const;
 
    void writeChargingStationOutput() const;
 
    void writeRailSignalBlocks() const;
 
    virtual void createTLWrapper(MSTrafficLightLogic*) {};
 
    void writeOverheadWireSegmentOutput() const;
 
    void writeSubstationOutput() const;
 
    virtual bool isSelected(const MSTrafficLightLogic*) const {
        return false;
    }
    virtual void updateGUI() const { }
 
    SUMOTime loadState(const std::string& fileName, const bool catchExceptions);
 
    void quickReload();
 
 
    enum class VehicleState {
        BUILT,
        DEPARTED,
        STARTING_TELEPORT,
        ENDING_TELEPORT,
        ARRIVED,
        NEWROUTE,
        STARTING_PARKING,
        ENDING_PARKING,
        STARTING_STOP,
        ENDING_STOP,
        COLLISION,
        EMERGENCYSTOP,
        MANEUVERING
    };
 
 
    class VehicleStateListener {
    public:
        VehicleStateListener() { }
 
        virtual ~VehicleStateListener() { }
 
        virtual void vehicleStateChanged(const SUMOVehicle* const vehicle, VehicleState to, const std::string& info = "") = 0;
 
    };
 
 
    void addVehicleStateListener(VehicleStateListener* listener);
 
 
    void removeVehicleStateListener(VehicleStateListener* listener);
 
 
    void informVehicleStateListener(const SUMOVehicle* const vehicle, VehicleState to, const std::string& info = "");
 
 
 
    enum class TransportableState {
        PERSON_DEPARTED,
        PERSON_ARRIVED,
        CONTAINER_DEPARTED,
        CONTAINER_ARRIVED
    };
 
 
    class TransportableStateListener {
    public:
        TransportableStateListener() { }
 
        virtual ~TransportableStateListener() { }
 
        virtual void transportableStateChanged(const MSTransportable* const transportable, TransportableState to, const std::string& info = "") = 0;
 
    };
 
 
    void addTransportableStateListener(TransportableStateListener* listener);
 
 
    void removeTransportableStateListener(TransportableStateListener* listener);
 
 
    void informTransportableStateListener(const MSTransportable* const transportable, TransportableState to, const std::string& info = "");
 
 
    bool registerCollision(const SUMOTrafficObject* collider, const SUMOTrafficObject* victim, const std::string& collisionType, const MSLane* lane, double pos);
 
    const CollisionMap& getCollisions() const {
        return myCollisions;
    }
 
 
    static double getTravelTime(const MSEdge* const e, const SUMOVehicle* const v, double t);
 
 
    static double getEffort(const MSEdge* const e, const SUMOVehicle* const v, double t);
 
 
    /* @brief get the router, initialize on first use
     * @param[in] prohibited The vector of forbidden edges (optional)
     */
    MSVehicleRouter& getRouterTT(int rngIndex, const Prohibitions& prohibited = {}) const;
    MSVehicleRouter& getRouterEffort(int rngIndex, const Prohibitions& prohibited = {}) const;
    MSPedestrianRouter& getPedestrianRouter(int rngIndex, const Prohibitions& prohibited = {}) const;
    MSTransportableRouter& getIntermodalRouter(int rngIndex, const int routingMode = 0, const Prohibitions& prohibited = {}) const;
 
    void resetIntermodalRouter() const;
 
    static void adaptIntermodalRouter(MSTransportableRouter& router);
 
 
    bool hasInternalLinks() const {
        return myHasInternalLinks;
    }
 
    bool hasJunctionHigherSpeeds() const {
        return myJunctionHigherSpeeds;
    }
 
    bool hasElevation() const {
        return myHasElevation;
    }
 
    bool hasPedestrianNetwork() const {
        return myHasPedestrianNetwork;
 
    }
    bool hasBidiEdges() const {
        return myHasBidiEdges;
    }
 
    MMVersion getNetworkVersion() const {
        return myVersion;
    }
 
    bool warnOnce(const std::string& typeAndID);
 
    void interrupt() {
        myAmInterrupted = true;
    }
 
    bool isInterrupted() const {
        return myAmInterrupted;
    }
 
    virtual bool skipFinalReset() const {
        return false;
    }
 
    MSMapMatcher* getMapMatcher() const;
 
    MSTractionSubstation* findTractionSubstation(const std::string& substationId);
 
    static const std::string STAGE_EVENTS;
    static const std::string STAGE_MOVEMENTS;
    static const std::string STAGE_LANECHANGE;
    static const std::string STAGE_INSERTIONS;
    static const std::string STAGE_REMOTECONTROL;
 
protected:
    bool checkElevation();
 
    bool checkWalkingarea();
 
    bool checkBidiEdges();
 
    void removeOutdatedCollisions();
 
    void postMoveStep();
 
protected:
    static MSNet* myInstance;
 
    SUMORouteLoaderControl* myRouteLoaders;
 
    SUMOTime myStep;
 
    /* @brief the time for rejecting vehicle that departed in the past are were already loaded.
     * When not loading state, this value is the simulation begin time.
     * When loading state, this is the time up to which vehicles have been
     * loaded before saving state. This is typically after the state time.
     * The state will include vehicles up to this time and they should not be
     * loaded again from a route file. Uniqueness of ids is not a sufficient
     * guard against loading again because these vehicles could arrive shortly after state loading. */
    SUMOTime myStateLoaderTime;
 
    bool myStepCompletionMissing = false;
 
    int myMaxTeleports;
 
    bool myAmInterrupted;
 
 
 
 
    MSVehicleControl* myVehicleControl;
    MSTransportableControl* myPersonControl;
    MSTransportableControl* myContainerControl;
    MSEdgeControl* myEdges;
    MSJunctionControl* myJunctions;
    MSTLLogicControl* myLogics;
    MSInsertionControl* myInserter;
    MSDetectorControl* myDetectorControl;
    MSEventControl* myBeginOfTimestepEvents;
    MSEventControl* myEndOfTimestepEvents;
    MSEventControl* myInsertionEvents;
    ShapeContainer* myShapeContainer;
    MSEdgeWeightsStorage* myEdgeWeights;
 
 
 
 
    bool myLogExecutionTime;
 
    bool myLogStepNumber;
    int myLogStepPeriod;
 
    long myTraCIStepDuration = 0, mySimStepDuration = 0;
 
    long mySimBeginMillis;
 
    long myTraCIMillis;
 
    long long int myVehiclesMoved;
    long long int myPersonsMoved;
    //}
 
 
 
 
    std::vector<SUMOTime> myStateDumpTimes;
    std::vector<std::string> myStateDumpFiles;
    std::vector<std::string> myPeriodicStateFiles;
    SUMOTime myStateDumpPeriod;
    std::string myStateDumpPrefix;
    std::string myStateDumpSuffix;
 
 
 
    bool myHavePermissions;
 
    std::map<std::string, std::map<SUMOVehicleClass, double> > myRestrictions;
 
    std::map<SUMOVehicleClass, std::map<std::string, double> > myVClassPreferences;
    std::map<std::string, std::map<std::string, double> > myVTypePreferences;
 
    std::map<std::string, MESegment::MesoEdgeType> myMesoEdgeTypes;
 
    bool myHasInternalLinks;
 
    bool myJunctionHigherSpeeds;
 
    bool myHasElevation;
 
    bool myHasPedestrianNetwork;
 
    bool myHasBidiEdges;
 
    MMVersion myVersion;
 
    SUMOTime myEdgeDataEndTime;
 
    std::map<SumoXMLTag, NamedObjectCont<MSStoppingPlace*> > myStoppingPlaces;
 
    std::map<SumoXMLTag, std::map<std::string, std::vector<MSStoppingPlace*> > > myNamedStoppingPlaces;
 
    std::vector<MSTractionSubstation*> myTractionSubstations;
 
    std::vector<VehicleStateListener*> myVehicleStateListeners;
 
    std::vector<TransportableStateListener*> myTransportableStateListeners;
 
    CollisionMap myCollisions;
 
#ifdef HAVE_FOX
    FXMutex myVehicleStateListenerMutex;
 
    FXMutex myTransportableStateListenerMutex;
#endif
    static const NamedObjectCont<MSStoppingPlace*> myEmptyStoppingPlaceCont;
    static const std::vector<MSStoppingPlace*> myEmptyStoppingPlaceVector;
 
    std::map<std::string, bool> myWarnedOnce;
 
    /* @brief The router instance for routing by trigger and by traci
     * @note MSDevice_Routing has its own instance since it uses a different weight function
     * @note we provide one member for every switchable router type
     * because the class structure makes it inconvenient to use a superclass
     */
    mutable std::map<int, MSVehicleRouter*> myRouterTT;
    mutable std::map<int, MSVehicleRouter*> myRouterEffort;
    mutable std::map<int, MSPedestrianRouter*> myPedestrianRouter;
    mutable std::map<int, MSTransportableRouter*> myIntermodalRouter;
 
    mutable std::pair<bool, NamedRTree> myLanesRTree;
 
    std::unique_ptr<MSDynamicShapeUpdater> myDynamicShapeUpdater;
 
private:
    MSNet(const MSNet&);
 
    MSNet& operator=(const MSNet&);
 
 
};