MSTriggeredRerouter.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// Reroutes vehicles passing an edge
/****************************************************************************/
#ifndef MSTriggeredRerouter_h
#define MSTriggeredRerouter_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <string>
#include <vector>
#include <utils/common/Command.h>
#include <microsim/MSMoveReminder.h>
#include "MSTrigger.h"
#include <utils/xml/SUMOSAXHandler.h>
#include <utils/distribution/RandomDistributor.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLane;
class MSRoute;
class SUMOVehicle;


// ===========================================================================
// class definitions
// ===========================================================================
class MSTriggeredRerouter :
    public MSTrigger, public MSMoveReminder,
    public SUMOSAXHandler {

    friend class GUIEdge; // dynamic instantiation

public:
    MSTriggeredRerouter(const std::string& id,
                        const MSEdgeVector& edges,
                        double prob, const std::string& file, bool off,
                        SUMOTime timeThreshold,
                        const std::string& vTypes);


    virtual ~MSTriggeredRerouter();

    typedef std::pair<MSParkingArea*, bool> ParkingAreaVisible;

    struct RerouteInterval {
        long long id;
        SUMOTime begin;
        SUMOTime end;
        MSEdgeVector closed;
        std::vector<MSLane*> closedLanes;
        MSEdgeVector closedLanesAffected;
        RandomDistributor<MSEdge*> edgeProbs;
        RandomDistributor<const MSRoute*> routeProbs;
        SVCPermissions permissions;
        RandomDistributor<ParkingAreaVisible> parkProbs;
    };

    bool notifyEnter(SUMOVehicle& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);


    bool notifyMove(SUMOVehicle& veh, double oldPos, double newPos, double newSpeed);

    bool notifyLeave(SUMOVehicle& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);

    const RerouteInterval* getCurrentReroute(SUMOTime time, SUMOVehicle& veh) const;

    SUMOTime setPermissions(const SUMOTime currentTime);

    const RerouteInterval* getCurrentReroute(SUMOTime time) const;

    void setUserMode(bool val);

    void setUserUsageProbability(double prob);

    bool inUserMode() const;

    double getProbability() const;

    double getUserProbability() const;

    double getWeight(SUMOVehicle& veh, const std::string param, const double defaultWeight) const;

    MSParkingArea* rerouteParkingArea(const MSTriggeredRerouter::RerouteInterval* rerouteDef,
                                      SUMOVehicle& veh, bool& newDestination) const;


protected:


    virtual void myStartElement(int element,
                                const SUMOSAXAttributes& attrs);


    virtual void myEndElement(int element);

    bool vehicleApplies(const SUMOVehicle& veh) const;


protected:
    std::vector<RerouteInterval> myIntervals;

    double myProbability, myUserProbability;

    bool myAmInUserMode;

    // @brief waiting time threshold for activation
    SUMOTime myTimeThreshold;

    std::set<std::string> myVehicleTypes;



    SUMOTime myCurrentIntervalBegin, myCurrentIntervalEnd;
    MSEdgeVector myCurrentClosed;
    std::vector<MSLane*> myCurrentClosedLanes;
    SVCPermissions myCurrentPermissions;
    RandomDistributor<ParkingAreaVisible> myCurrentParkProb;
    RandomDistributor<MSEdge*> myCurrentEdgeProb;
    RandomDistributor<const MSRoute*> myCurrentRouteProb;


    static MSEdge mySpecialDest_keepDestination;
    static MSEdge mySpecialDest_terminateRoute;

private:
    MSTriggeredRerouter(const MSTriggeredRerouter&);

    MSTriggeredRerouter& operator=(const MSTriggeredRerouter&);


};


#endif

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