MSLaneChanger.h

Go to the documentation of this file.

/****************************************************************************/
// Performs lane changing of vehicles
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2002-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 MSLaneChanger_h
#define MSLaneChanger_h


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

#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);

        MSVehicle*                lead;
        MSLane*                   lane;
        MSVehicle*                hoppedVeh;
        MSVehicle*                lastBlocked;
        MSVehicle*                firstBlocked;

        double dens;

        // the vehicles in from of the current vehicle
        MSLeaderInfo ahead;

    };

public:
    typedef std::vector< ChangeElem > Changer;

    typedef Changer::iterator ChangerIt;

    typedef Changer::const_iterator ConstChangerIt;

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();


    virtual bool changeOpposite(std::pair<MSVehicle*, double> leader);

    void registerUnchanged(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>& neighLead,
        const std::pair<MSVehicle* const, double>& neighFollow,
        const std::vector<MSVehicle::LaneQ>& preb) const;

    void 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, const MSVehicle* leader, double gap, double& timeToOvertake, double& spaceToOvertake);

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


#endif

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