MSNet.h

Go to the documentation of this file.

/****************************************************************************/
// The simulated network and simulation perfomer
/****************************************************************************/
// 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 MSNet_h
#define MSNet_h


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

#include <typeinfo>
#include <vector>
#include <map>
#include <string>
#include <fstream>
#include <iostream>
#include <cmath>
#include <iomanip>
#include <utils/common/SUMOTime.h>
#include <utils/common/UtilExceptions.h>
#include <utils/common/NamedObjectCont.h>
#include <utils/common/NamedRTree.h>
#include <utils/vehicle/SUMOAbstractRouter.h>
#include <utils/vehicle/PedestrianRouter.h>
#include <microsim/trigger/MSChargingStation.h>
#include "MSParkingArea.h"
#include "MSStoppingPlace.h"


// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSJunction;
class MSEdgeControl;
class MSEventControl;
class MSVehicleControl;
class MSJunctionControl;
class MSInsertionControl;
class SUMORouteLoaderControl;
class MSTransportableControl;
class MSVehicle;
class MSRoute;
class MSLane;
class MSTLLogicControl;
class MSDetectorControl;
class ShapeContainer;
class BinaryInputDevice;
class MSEdgeWeightsStorage;
class SUMOVehicle;

typedef std::vector<MSEdge*> MSEdgeVector;

// ===========================================================================
// class definitions
// ===========================================================================
class MSNet {
public:
    enum SimulationState {
        SIMSTATE_LOADING,
        SIMSTATE_RUNNING,
        SIMSTATE_END_STEP_REACHED,
        SIMSTATE_NO_FURTHER_VEHICLES,
        SIMSTATE_CONNECTION_CLOSED,
        SIMSTATE_ERROR_IN_SIM,
        SIMSTATE_TOO_MANY_TELEPORTS
    };

    //typedef PedestrianRouterDijkstra<MSEdge, MSLane> MSPedestrianRouterDijkstra;
    typedef PedestrianRouterDijkstra<MSEdge, MSLane, MSJunction, MSVehicle> MSPedestrianRouterDijkstra;



public:
    static MSNet* getInstance();


    MSNet(MSVehicleControl* vc, MSEventControl* beginOfTimestepEvents,
          MSEventControl* endOfTimestepEvents, MSEventControl* insertionEvents,
          ShapeContainer* shapeCont = 0);


    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 hasNeighs, bool lefthand,
                       double 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;


    static void clearAll();


    SimulationState simulate(SUMOTime start, SUMOTime stop);


    void simulationStep();


    void loadRoutes();


    void closeSimulation(SUMOTime start);


    SimulationState simulationState(SUMOTime stopTime) const;


    static std::string getStateMessage(SimulationState state);


    inline SUMOTime getCurrentTimeStep() const {
        return myStep;
    }


    inline void setCurrentTimeStep(const SUMOTime step) {
        myStep = step;
    }


    void writeOutput();


    bool logSimulationDuration() const;





    void preSimStepOutput() const;


    void postSimStepOutput() const;
    //}




    MSVehicleControl& getVehicleControl() {
        return *myVehicleControl;
    }


    virtual MSTransportableControl& getPersonControl();

    bool hasPersons() const {
        return myPersonControl != 0;
    }

    virtual MSTransportableControl& getContainerControl();

    bool hasContainers() const {
        return myContainerControl != 0;
    }


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

    MSEdgeWeightsStorage& getWeightsStorage();


    bool addBusStop(MSStoppingPlace* busStop);


    MSStoppingPlace* getBusStop(const std::string& id) const;


    std::string getBusStopID(const MSLane* lane, const double pos) const;



    bool addContainerStop(MSStoppingPlace* containerStop);

    MSStoppingPlace* getContainerStop(const std::string& id) const;

    std::string getContainerStopID(const MSLane* lane, const double pos) const;


    bool addParkingArea(MSParkingArea* parkingArea);

    MSParkingArea* getParkingArea(const std::string& id) const;

    std::string getParkingAreaID(const MSLane* lane, const double pos) const;


    bool addChargingStation(MSChargingStation* chargingStation);

    MSChargingStation* getChargingStation(const std::string& id) const;

    std::string getChargingStationID(const MSLane* lane, const double pos) const;

    void writeChargingStationOutput() const;



    enum VehicleState {
        VEHICLE_STATE_BUILT,
        VEHICLE_STATE_DEPARTED,
        VEHICLE_STATE_STARTING_TELEPORT,
        VEHICLE_STATE_ENDING_TELEPORT,
        VEHICLE_STATE_ARRIVED,
        VEHICLE_STATE_NEWROUTE,
        VEHICLE_STATE_STARTING_PARKING,
        VEHICLE_STATE_ENDING_PARKING,
        VEHICLE_STATE_STARTING_STOP,
        VEHICLE_STATE_ENDING_STOP
    };


    class VehicleStateListener {
    public:
        VehicleStateListener() { }

        virtual ~VehicleStateListener() { }

        virtual void vehicleStateChanged(const SUMOVehicle* const vehicle, VehicleState to) = 0;

    };


    void addVehicleStateListener(VehicleStateListener* listener);


    void removeVehicleStateListener(VehicleStateListener* listener);


    void informVehicleStateListener(const SUMOVehicle* const vehicle, VehicleState to);



    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)
     */
    SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouterTT(
        const MSEdgeVector& prohibited = MSEdgeVector()) const;
    SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouterEffort(
        const MSEdgeVector& prohibited = MSEdgeVector()) const;
    MSPedestrianRouterDijkstra& getPedestrianRouter(const MSEdgeVector& prohibited = MSEdgeVector()) const;


    const NamedRTree& getLanesRTree() const;

    bool hasInternalLinks() const {
        return myHasInternalLinks;
    }

    bool hasNeighs() const {
        return myHasNeighs;
    }

    bool hasElevation() const {
        return myHasElevation;
    }

    bool lefthand() const {
        return myLefthand;
    }

    double version() const {
        return myVersion;
    }

protected:
    bool checkElevation();

    int getHaltingVehicleNumber() const;

    std::pair<double, double> getVehicleMeanSpeeds() const;
    double getVehicleMeanSpeed() const {
        return getVehicleMeanSpeeds().first;
    }
    double getVehicleMeanSpeedRelative() const {
        return getVehicleMeanSpeeds().second;
    }

protected:
    static MSNet* myInstance;

    SUMORouteLoaderControl* myRouteLoaders;

    SUMOTime myStep;

    int myMaxTeleports;




    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;

    long myTraCIStepDuration, mySimStepDuration;

    long mySimBeginMillis;

    long long int myVehiclesMoved;
    //}




    std::vector<SUMOTime> myStateDumpTimes;
    std::vector<std::string> myStateDumpFiles;
    SUMOTime myStateDumpPeriod;
    std::string myStateDumpPrefix;
    std::string myStateDumpSuffix;



    bool myHavePermissions;

    std::map<std::string, std::map<SUMOVehicleClass, double> > myRestrictions;

    bool myHasInternalLinks;

    bool myHasNeighs;

    bool myHasElevation;

    bool myLefthand;

    double myVersion;

    NamedObjectCont<MSStoppingPlace*> myBusStopDict;

    NamedObjectCont<MSStoppingPlace*> myContainerStopDict;

    NamedObjectCont<MSParkingArea*> myParkingAreaDict;

    NamedObjectCont<MSChargingStation*> myChargingStationDict;

    std::vector<VehicleStateListener*> myVehicleStateListeners;


    /* @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 SUMOAbstractRouter<MSEdge, SUMOVehicle>* myRouterTT;
    mutable SUMOAbstractRouter<MSEdge, SUMOVehicle>* myRouterEffort;
    mutable MSPedestrianRouterDijkstra* myPedestrianRouter;


    mutable std::pair<bool, NamedRTree> myLanesRTree;


    static const std::string STAGE_EVENTS;
    static const std::string STAGE_MOVEMENTS;
    static const std::string STAGE_LANECHANGE;
    static const std::string STAGE_INSERTIONS;

private:
    MSNet(const MSNet&);

    MSNet& operator=(const MSNet&);


};


#endif

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