MSLane.h

Go to the documentation of this file.

/****************************************************************************/
// Representation of a lane in the micro simulation
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
// Copyright (C) 2001-2013 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 MSLane_h
#define MSLane_h


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

#include <vector>
#include <deque>
#include <cassert>
#include <utils/common/Named.h>
#include <utils/common/Parameterised.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/SUMOVehicle.h>
#include <utils/common/NamedRTree.h>
#include <utils/geom/PositionVector.h>
#include "MSLinkCont.h"
#include "MSMoveReminder.h"
#ifndef NO_TRACI
#include <traci-server/TraCIServerAPI_Lane.h>
#endif


// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSVehicle;
class MSLaneChanger;
class MSLink;
class MSVehicleTransfer;
class MSVehicleControl;
class OutputDevice;


// ===========================================================================
// class definitions
// ===========================================================================
class MSLane : public Named, public Parameterised {
public:
    friend class MSLaneChanger;

    friend class MSXMLRawOut;

    friend class MSQueueExport;


    typedef std::vector< MSVehicle* > VehCont;

    struct VehPosition : public std::binary_function < const MSVehicle*, SUMOReal, bool > {
        bool operator()(const MSVehicle* cmp, SUMOReal pos) const;
    };

public:
    MSLane(const std::string& id, SUMOReal maxSpeed, SUMOReal length, MSEdge* const edge,
           unsigned int numericalID, const PositionVector& shape, SUMOReal width,
           SVCPermissions permissions);


    virtual ~MSLane();




    void addLink(MSLink* link);




    virtual void addMoveReminder(MSMoveReminder* rem);


    inline const std::vector< MSMoveReminder* >& getMoveReminders() const {
        return myMoveReminders;
    }




    bool insertVehicle(MSVehicle& v);


    virtual bool isInsertionSuccess(MSVehicle* vehicle, SUMOReal speed, SUMOReal pos,
                                    bool recheckNextLanes,
                                    MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);

    bool checkFailure(MSVehicle* aVehicle, SUMOReal& speed, SUMOReal& dist, const SUMOReal nspeed, const bool patchSpeed, const std::string errorMsg) const;
    bool pWagGenericInsertion(MSVehicle& veh, SUMOReal speed, SUMOReal maxPos, SUMOReal minPos);
    bool pWagSimpleInsertion(MSVehicle& veh, SUMOReal speed, SUMOReal maxPos, SUMOReal minPos);
    bool maxSpeedGapInsertion(MSVehicle& veh, SUMOReal mspeed);

    bool freeInsertion(MSVehicle& veh, SUMOReal speed,
                       MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);


    void forceVehicleInsertion(MSVehicle* veh, SUMOReal pos);




    SUMOReal setPartialOccupation(MSVehicle* v, SUMOReal leftVehicleLength);


    void resetPartialOccupation(MSVehicle* v);


    MSVehicle* getPartialOccupator() const {
        return myInlappingVehicle;
    }


    SUMOReal getPartialOccupatorEnd() const {
        return myInlappingVehicleEnd;
    }


    std::pair<MSVehicle*, SUMOReal> getLastVehicleInformation() const;




    unsigned int getVehicleNumber() const {
        return (unsigned int) myVehicles.size();
    }


    virtual const VehCont& getVehiclesSecure() const {
        return myVehicles;
    }


    virtual void releaseVehicles() const { }





    inline size_t getNumericalID() const {
        return myNumericalID;
    }


    inline const PositionVector& getShape() const {
        return myShape;
    }

    /* @brief fit the given lane position to a visibly suitable geometry position
     * (lane length might differ from geometry length) */
    inline SUMOReal interpolateLanePosToGeometryPos(SUMOReal lanePos) const {
        return lanePos * myLengthGeometryFactor;
    }

    /* @brief fit the given lane position to a visibly suitable geometry position
     * and return the coordinates */
    inline const Position geometryPositionAtOffset(SUMOReal offset) const {
        return myShape.positionAtOffset(interpolateLanePosToGeometryPos(offset));
    }

    /* @brief fit the given geomtry position to a valid lane position
     * (lane length might differ from geometry length) */
    inline SUMOReal interpolateGeometryPosToLanePos(SUMOReal geometryPos) const {
        return geometryPos / myLengthGeometryFactor;
    }

    inline SUMOReal getVehicleMaxSpeed(const SUMOVehicle* const veh) const {
        return myMaxSpeed * veh->getChosenSpeedFactor();
    }


    inline SUMOReal getSpeedLimit() const {
        return myMaxSpeed;
    }


    inline SUMOReal getLength() const {
        return myLength;
    }


    inline SVCPermissions getPermissions() const {
        return myPermissions;
    }


    SUMOReal getWidth() const {
        return myWidth;
    }




    virtual void planMovements(const SUMOTime t);

    virtual bool executeMovements(SUMOTime t, std::vector<MSLane*>& into);

    virtual bool integrateNewVehicle(SUMOTime t);



    virtual void detectCollisions(SUMOTime timestep, int stage);


    virtual bool appropriate(const MSVehicle* veh);


    const MSLinkCont& getLinkCont() const;


    bool empty() const {
        assert(myVehBuffer.size() == 0);
        return myVehicles.empty();
    }

    void setMaxSpeed(SUMOReal val) {
        myMaxSpeed = val;
    }

    void setLength(SUMOReal val) {
        myLength = val;
    }


    MSEdge& getEdge() const {
        return *myEdge;
    }




    static bool dictionary(const std::string& id, MSLane* lane);


    static MSLane* dictionary(const std::string& id);


    static void clear();


    static size_t dictSize() {
        return myDict.size();
    }


    static void insertIDs(std::vector<std::string>& into);


    template<class RTREE>
    static void fill(RTREE& into);



    virtual MSLinkCont::const_iterator succLinkSec(const SUMOVehicle& veh,
            unsigned int nRouteSuccs,
            const MSLane& succLinkSource,
            const std::vector<MSLane*>& conts) const;


    bool isLinkEnd(MSLinkCont::const_iterator& i) const;

    bool isLinkEnd(MSLinkCont::iterator& i);

    virtual MSVehicle* getLastVehicle() const;
    virtual const MSVehicle* getFirstVehicle() const;




    virtual MSVehicle* removeVehicle(MSVehicle* remVehicle, MSMoveReminder::Notification notification);

    PositionVector myShape;



    void leftByLaneChange(MSVehicle* v);
    void enteredByLaneChange(MSVehicle* v);


    MSLane* getParallelLane(int offset) const;


    inline void setPermissions(SVCPermissions permissions) {
        myPermissions = permissions;
    }


    inline bool allowsVehicleClass(SUMOVehicleClass vclass) const {
        return (myPermissions & vclass) == vclass;
    }

    void addIncomingLane(MSLane* lane, MSLink* viaLink);


    struct IncomingLaneInfo {
        MSLane* lane;
        SUMOReal length;
        MSLink* viaLink;
    };

    const std::vector<IncomingLaneInfo>& getIncomingLanes() const {
        return myIncomingLanes;
    }


    void addApproachingLane(MSLane* lane);
    bool isApproachedFrom(MSEdge* const edge);
    bool isApproachedFrom(MSEdge* const edge, MSLane* const lane);



    std::pair<MSVehicle* const, SUMOReal> getFollowerOnConsecutive(SUMOReal dist, SUMOReal seen,
            SUMOReal leaderSpeed, SUMOReal backOffset, SUMOReal predMaxDecel) const;


    SUMOReal getMissingRearGap(SUMOReal dist, SUMOReal backOffset,
                               SUMOReal leaderSpeed, SUMOReal leaderMaxDecel) const;


    std::pair<MSVehicle* const, SUMOReal> getLeaderOnConsecutive(SUMOReal dist, SUMOReal seen,
            SUMOReal speed, const MSVehicle& veh, const std::vector<MSLane*>& bestLaneConts) const;


    MSLane* getLogicalPredecessorLane() const;




    SUMOReal getMeanSpeed() const;

    SUMOReal getWaitingSeconds() const;


    SUMOReal getBruttoOccupancy() const;


    SUMOReal getNettoOccupancy() const;


    SUMOReal getBruttoVehLenSum() const;


    SUMOReal getHBEFA_CO2Emissions() const;


    SUMOReal getHBEFA_COEmissions() const;


    SUMOReal getHBEFA_PMxEmissions() const;


    SUMOReal getHBEFA_NOxEmissions() const;


    SUMOReal getHBEFA_HCEmissions() const;


    SUMOReal getHBEFA_FuelConsumption() const;


    SUMOReal getHarmonoise_NoiseEmissions() const;



    void saveState(OutputDevice& out);

    void loadState(std::vector<std::string>& vehIDs, MSVehicleControl& vc);


#ifndef NO_TRACI

    void visit(const TraCIServerAPI_Lane::StoringVisitor& cont) const {
        cont.add(this);
    }
#endif

protected:
    virtual void swapAfterLaneChange(SUMOTime t);

    virtual void incorporateVehicle(MSVehicle* veh, SUMOReal pos, SUMOReal speed,
                                    const MSLane::VehCont::iterator& at,
                                    MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);


protected:
    size_t myNumericalID;

    VehCont myVehicles;

    SUMOReal myLength;

    SUMOReal myWidth;

    MSEdge* myEdge;

    SUMOReal myMaxSpeed;

    VehCont myTmpVehicles;


    std::vector<MSVehicle*> myVehBuffer;

    SVCPermissions myPermissions;

    std::vector<IncomingLaneInfo> myIncomingLanes;
    mutable MSLane* myLogicalPredecessorLane;


    SUMOReal myBruttoVehicleLengthSum;

    SUMOReal myNettoVehicleLengthSum;

    SUMOReal myInlappingVehicleEnd;

    MSVehicle* myInlappingVehicle;


    MSLinkCont myLinks;

    std::map<MSEdge*, std::vector<MSLane*> > myApproachingLanes;

    // precomputed myShape.length / myLength
    const SUMOReal myLengthGeometryFactor;

    typedef std::map< std::string, MSLane* > DictType;

    static DictType myDict;

private:
    std::vector< MSMoveReminder* > myMoveReminders;


    class vehicle_position_sorter {
    public:
        explicit vehicle_position_sorter() { }


        int operator()(MSVehicle* v1, MSVehicle* v2) const;

    };

    class by_connections_to_sorter {
    public:
        explicit by_connections_to_sorter(const MSEdge* const e);

        int operator()(const MSEdge* const e1, const MSEdge* const e2) const;

    private:
        by_connections_to_sorter& operator=(const by_connections_to_sorter&); // just to avoid a compiler warning
    private:
        const MSEdge* const myEdge;
        SUMOReal myLaneDir;
    };

    class edge_finder {
    public:
        edge_finder(MSEdge* e) : myEdge(e) {}
        bool operator()(const IncomingLaneInfo& ili) const {
            return &(ili.lane->getEdge()) == myEdge;
        }
    private:
        edge_finder& operator=(const edge_finder&); // just to avoid a compiler warning
    private:
        const MSEdge* const myEdge;
    };

private:
    MSLane(const MSLane&);

    MSLane& operator=(const MSLane&);


};


#endif

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