MSLaneChanger.h

Go to the documentation of this file.

/****************************************************************************/
// Performs lane changing of vehicles
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 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 <vector>
#include <utils/iodevices/OutputDevice.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSVehicle;


// ===========================================================================
// class definitions
// ===========================================================================
class MSLaneChanger {
public:
    MSLaneChanger(std::vector<MSLane*>* lanes);

    ~MSLaneChanger();

    void laneChange(SUMOTime t);

public:
    struct ChangeElem {
        MSVehicle*                follow;
        MSVehicle*                lead;
        MSLane*                   lane;
        MSLane::VehCont::reverse_iterator veh;
        MSVehicle*                hoppedVeh;
        MSVehicle*                lastBlocked;

        SUMOReal dens;

    };

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

    typedef Changer::iterator ChangerIt;

    typedef Changer::const_iterator ConstChangerIt;

protected:
    void initChanger();

    bool vehInChanger() const throw() {
        // 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 throw() {
        // If ce has a valid vehicle, return it. Otherwise return 0.
        if (ce->veh != ce->lane->myVehicles.rend()) {
            return *(ce->veh);
        }
        return 0;
    }


    bool change();

    void updateChanger(bool vehHasChanged);

    void updateLanes(SUMOTime t);

    ChangerIt findCandidate();

    int change2right(
        const std::pair<MSVehicle * const, SUMOReal> &leader,
        const std::pair<MSVehicle * const, SUMOReal> &rLead,
        const std::pair<MSVehicle * const, SUMOReal> &rFollow,
        const std::vector<MSVehicle::LaneQ> &preb) const throw();

    int change2left(
        const std::pair<MSVehicle * const, SUMOReal> &leader,
        const std::pair<MSVehicle * const, SUMOReal> &rLead,
        const std::pair<MSVehicle * const, SUMOReal> &rFollow,
        const std::vector<MSVehicle::LaneQ> &preb) const throw();

    void setOverlap(const std::pair<MSVehicle * const, SUMOReal> &neighLead,
                    const std::pair<MSVehicle * const, SUMOReal> &neighFollow,
                    /*const ChangerIt &target,*/ int &blocked) const throw();

    void setIsSafeChange(const std::pair<MSVehicle * const, SUMOReal> &neighLead,
                         const std::pair<MSVehicle * const, SUMOReal> &neighFollow,
                         const ChangerIt &target, int &blocked) const throw();

    int advan2right(
        const std::pair<MSVehicle * const, SUMOReal> &leader,
        const std::pair<MSVehicle * const, SUMOReal> &rLead,
        const std::pair<MSVehicle * const, SUMOReal> &rFollow,
        int blocked,
        const std::vector<MSVehicle::LaneQ> &preb) const throw();

    int advan2left(
        const std::pair<MSVehicle * const, SUMOReal> &leader,
        const std::pair<MSVehicle * const, SUMOReal> &rLead,
        const std::pair<MSVehicle * const, SUMOReal> &rFollow,
        int blocked,
        const std::vector<MSVehicle::LaneQ> &preb) const throw();

    bool overlapWithHopped(ChangerIt target) const throw() {
        MSVehicle *v1 = target->hoppedVeh;
        MSVehicle *v2 = veh(myCandi);
        if (v1!=0 && v2!=0) {
            return MSVehicle::overlap(v1, v2);
        }
        return false;
    }

    std::pair<MSVehicle * const, SUMOReal> getRealThisLeader(const ChangerIt &target) const throw();

    std::pair<MSVehicle * const, SUMOReal> getRealFollower(const ChangerIt &target) const throw();
    std::pair<MSVehicle * const, SUMOReal> getRealRightFollower() const throw();
    std::pair<MSVehicle * const, SUMOReal> getRealLeftFollower() const throw();

    std::pair<MSVehicle * const, SUMOReal> getRealLeader(const ChangerIt &target) const throw();
    std::pair<MSVehicle * const, SUMOReal> getRealRightLeader() const throw();
    std::pair<MSVehicle * const, SUMOReal> getRealLeftLeader() const throw();

protected:
    Changer   myChanger;

    ChangerIt myCandi;

private:
    MSLaneChanger();

    MSLaneChanger(const MSLaneChanger&);

    MSLaneChanger& operator=(const MSLaneChanger&);
};


#endif

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