MSLaneChanger.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-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
/****************************************************************************/
// Performs lane changing of vehicles
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "MSLane.h"
#include "MSEdge.h"
#include "MSVehicle.h"
#include <vector>
#include <utils/iodevices/OutputDevice.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSLaneChanger {
public:
    MSLaneChanger(const std::vector<MSLane*>* lanes, bool allowChanging);
 
    virtual ~MSLaneChanger();
 
    void laneChange(SUMOTime t);
 
public:
    struct ChangeElem {
 
        ChangeElem(MSLane* _lane);
 
        void registerHop(MSVehicle* vehicle);
 
        MSVehicle*                lead;
        MSLane*                   lane;
        MSVehicle*                hoppedVeh;
        MSVehicle*                lastBlocked;
        MSVehicle*                firstBlocked;
        MSVehicle*                lastStopped;
 
        double dens;
 
        bool mayChangeRight;
        bool mayChangeLeft;
 
        std::vector<int>          siblings;
 
        // the vehicles in front of the current vehicle (only on the current edge, continously updated during change() )
        MSLeaderInfo ahead;
 
        // the vehicles in front of the current vehicle (including those on the next edge, contiously update during change() ))
        MSLeaderDistanceInfo aheadNext;
 
        std::vector<MSVehicle*>  outsideBounds;
 
    };
 
public:
    typedef std::vector< ChangeElem > Changer;
 
    typedef Changer::iterator ChangerIt;
 
    typedef Changer::const_iterator ConstChangerIt;
 
    Changer& getChanger() {
        return myChanger;
    }
 
 
protected:
    virtual void initChanger();
 
    bool vehInChanger() const {
        // If there is at least one valid vehicle under the veh's in myChanger
        // return true.
        for (ConstChangerIt ce = myChanger.begin(); ce != myChanger.end(); ++ce) {
            if (veh(ce) != 0) {
                return true;
            }
        }
        return false;
    }
 
    MSVehicle* veh(ConstChangerIt ce) const {
        // If ce has a valid vehicle, return it. Otherwise return 0.
        if (!ce->lane->myVehicles.empty()) {
            return ce->lane->myVehicles.back();
        } else {
            return 0;
        }
    }
 
 
    virtual bool change();
 
 
    bool changeOpposite(MSVehicle* vehicle, std::pair<MSVehicle*, double> leader, MSVehicle* lastStopped);
 
    std::pair<MSVehicle* const, double> getOncomingVehicle(const MSLane* opposite, std::pair<MSVehicle*,
            double> neighOncoming, double searchDist, double& vMax, const MSVehicle* overtaken = nullptr,
            MSLane::MinorLinkMode mLinkMode = MSLane::MinorLinkMode::FOLLOW_NEVER);
 
    std::pair<MSVehicle* const, double> getOncomingOppositeVehicle(const MSVehicle* vehicle,
            std::pair<MSVehicle*, double> overtaken, double searchDist);
 
    void registerUnchanged(MSVehicle* vehicle);
 
    void checkTraCICommands(MSVehicle* vehicle);
 
    bool applyTraCICommands(MSVehicle* vehicle);
 
    virtual void updateChanger(bool vehHasChanged);
 
    void updateLanes(SUMOTime t);
 
    ChangerIt findCandidate();
 
    /* @brief check whether lane changing in the given direction is desirable
     * and possible */
    int checkChangeWithinEdge(
        int laneOffset,
        const std::pair<MSVehicle* const, double>& leader,
        const std::vector<MSVehicle::LaneQ>& preb) const;
 
    /* @brief check whether lane changing in the given direction is desirable
     * and possible */
    int checkChange(
        int laneOffset,
        const MSLane* targetLane,
        const std::pair<MSVehicle* const, double>& leader,
        const std::pair<MSVehicle* const, double>& follower,
        const std::pair<MSVehicle* const, double>& neighLead,
        const std::pair<MSVehicle* const, double>& neighFollow,
        const std::vector<MSVehicle::LaneQ>& preb) const;
 
    /* @brief call lanechange model to check the merits of an opposite-direction
     * change and update state accordingly */
    virtual bool checkChangeOpposite(
        MSVehicle* vehicle,
        int laneOffset,
        MSLane* targetLane,
        const std::pair<MSVehicle* const, double>& leader,
        const std::pair<MSVehicle* const, double>& neighLead,
        const std::pair<MSVehicle* const, double>& neighFollow,
        const std::vector<MSVehicle::LaneQ>& preb);
 
 
    /*  @brief start the lane change maneuver (and finish it instantly if gLaneChangeDuration == 0)
     *  @return False when aborting the change due to being remote controlled*/
    bool startChange(MSVehicle* vehicle, ChangerIt& from, int direction);
 
    bool continueChange(MSVehicle* vehicle, ChangerIt& from);
 
    std::pair<MSVehicle* const, double> getRealFollower(const ChangerIt& target) const;
 
    std::pair<MSVehicle* const, double> getRealLeader(const ChangerIt& target) const;
 
    bool mayChange(int direction) const;
 
    static MSVehicle* getCloserFollower(const double maxPos, MSVehicle* follow1, MSVehicle* follow2);
 
    static void computeOvertakingTime(const MSVehicle* vehicle, double vMax, const MSVehicle* leader, double gap, double& timeToOvertake, double& spaceToOvertake);
 
    static std::pair<MSVehicle*, double> getColumnleader(double& maxSpace, MSVehicle* vehicle, std::pair<MSVehicle*, double> leader, double maxLookAhead = std::numeric_limits<double>::max());
 
    static const MSLane* getLaneAfter(const MSLane* lane, const std::vector<MSLane*>& conts, bool allowMinor, bool& contsEnd);
 
    static bool hasOppositeStop(MSVehicle* vehicle);
 
    bool checkOppositeStop(MSVehicle* vehicle, const MSLane* oncomingLane, const MSLane* opposite, std::pair<MSVehicle*, double> leader);
 
    bool avoidDeadlock(MSVehicle* vehicle,
                       std::pair<MSVehicle*, double> neighLead,
                       std::pair<MSVehicle*, double> overtaken,
                       std::pair<MSVehicle*, double> leader);
 
    bool resolveDeadlock(MSVehicle* vehicle,
                         std::pair<MSVehicle* const, double> leader,
                         std::pair<MSVehicle*, double> neighLead,
                         std::pair<MSVehicle*, double> overtaken);
 
    bool yieldToDeadlockOncoming(const MSVehicle* vehicle, const MSVehicle* stoppedNeigh, double dist);
 
    bool yieldToOppositeWaiting(const MSVehicle* vehicle, const MSVehicle* stoppedNeigh, double dist, SUMOTime deltaWait = 0);
 
    double computeSafeOppositeLength(MSVehicle* vehicle, double oppositeLength, const MSLane* source, double usableDist,
                                     std::pair<MSVehicle*, double> oncoming, double vMax, double oncomingSpeed,
                                     std::pair<MSVehicle*, double> neighLead,
                                     std::pair<MSVehicle*, double> overtaken,
                                     std::pair<MSVehicle*, double> neighFollow,
                                     double surplusGap, const MSLane* opposite,
                                     bool canOvertake);
 
    // @brief compute distance that can safely be driven on the opposite side
    static double computeSurplusGap(const MSVehicle* vehicle, const MSLane* opposite, std::pair<MSVehicle*, double> oncoming, double timeToOvertake,
                                    double spaceToOvertake, double& oncomingSpeed, bool oncomingOpposite = false);
 
    // @brief find hilltop within searchDistance
    static bool foundHilltop(MSVehicle* vehicle, bool foundHill, double searchDist, const std::vector<MSLane*>& bestLanes, int view, double pos, double lastMax, double hilltopThreshold);
 
    static std::vector<MSVehicle::LaneQ> getBestLanesOpposite(MSVehicle* vehicle, const MSLane* stopLane, double oppositeLength);
 
    static double getMaxOvertakingSpeed(const MSVehicle* vehicle, double maxSpaceToOvertake);
 
protected:
    Changer   myChanger;
 
    ChangerIt myCandi;
 
    /* @brief Whether vehicles may start to change lanes on this edge
     * (finishing a change in progress is always permitted) */
    const bool myAllowsChanging;
 
    const bool myChangeToOpposite;
 
private:
    MSLaneChanger();
 
    MSLaneChanger(const MSLaneChanger&);
 
    MSLaneChanger& operator=(const MSLaneChanger&);
};