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.sourceforge.net/
// Copyright (C) 2001-2011 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 MSLane_h
#define MSLane_h


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

#include "MSEdge.h"
#include "MSLinkCont.h"
#include "MSVehicle.h"
#include <bitset>
#include <deque>
#include <vector>
#include <utility>
#include <map>
#include <string>
#include <iostream>
#include "MSNet.h"
#include <utils/geom/PositionVector.h>
#include <utils/geom/Line.h>
#include <utils/geom/GeomHelper.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/Named.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSLaneChanger;
class MSLink;
class MSMoveReminder;
class GUILaneWrapper;
class MSVehicleTransfer;
class OutputDevice;


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

    friend class GUILaneWrapper;

    friend class MSXMLRawOut;

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

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


    virtual ~MSLane() throw();




    void initialize(MSLinkCont* succs);

    void addLink(MSLink* link);




    virtual void addMoveReminder(MSMoveReminder* rem) throw();


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




    bool insertVehicle(MSVehicle& v) throw(ProcessError);


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

    bool pWagGenericInsertion(MSVehicle& veh, SUMOReal speed, SUMOReal maxPos, SUMOReal minPos) throw();
    bool pWagSimpleInsertion(MSVehicle& veh, SUMOReal speed, SUMOReal maxPos, SUMOReal minPos) throw();
    bool maxSpeedGapInsertion(MSVehicle& veh, SUMOReal mspeed) throw();

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


    void forceVehicleInsertion(MSVehicle* veh, SUMOReal pos) throw();




    SUMOReal setPartialOccupation(MSVehicle* v, SUMOReal leftVehicleLength) throw();


    void resetPartialOccupation(MSVehicle* v) throw();


    MSVehicle* getPartialOccupator() const throw() {
        return myInlappingVehicle;
    }


    SUMOReal getPartialOccupatorEnd() const throw() {
        return myInlappingVehicleEnd;
    }


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




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


    virtual const std::deque< MSVehicle* > &getVehiclesSecure() const throw() {
        return myVehicles;
    }


    virtual void releaseVehicles() const throw() { }





    size_t getNumericalID() const throw() {
        return myNumericalID;
    }


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


    SUMOReal getMaxSpeed() const throw() {
        return myMaxSpeed;
    }


    SUMOReal getLength() const throw() {
        return myLength;
    }


    const SUMOVehicleClasses& getAllowedClasses() const throw() {
        return myAllowedClasses;
    }


    const SUMOVehicleClasses& getNotAllowedClasses() const throw() {
        return myNotAllowedClasses;
    }


    SUMOReal getWidth() const throw() {
        return myWidth;
    }




    virtual bool moveCritical(SUMOTime t);

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

    virtual bool integrateNewVehicle(SUMOTime t);



    virtual void detectCollisions(SUMOTime timestep);


    virtual bool appropriate(const MSVehicle* veh);


    const MSLinkCont& getLinkCont() const;


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

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

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


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

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

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

    static void clear();

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

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

    typedef std::deque< MSVehicle* > VehCont;

    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;




    // valid for gui-version only
    virtual GUILaneWrapper* buildLaneWrapper(unsigned int index);

    virtual MSVehicle* removeVehicle(MSVehicle* remVehicle);

    PositionVector myShape;



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


    MSLane* getLeftLane() const;
    MSLane* getRightLane() const;

    void setAllowedClasses(const SUMOVehicleClasses& classes) throw() {
        myAllowedClasses = classes;
    }


    void setNotAllowedClasses(const SUMOVehicleClasses& classes) throw() {
        myNotAllowedClasses = classes;
    }


    bool allowsVehicleClass(SUMOVehicleClass vclass) const;

    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;


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


    MSLane* getLogicalPredecessorLane() const throw();




    SUMOReal getMeanSpeed() const throw();


    SUMOReal getOccupancy() const throw();


    SUMOReal getVehLenSum() const throw();


    SUMOReal getHBEFA_CO2Emissions() const throw();


    SUMOReal getHBEFA_COEmissions() const throw();


    SUMOReal getHBEFA_PMxEmissions() const throw();


    SUMOReal getHBEFA_NOxEmissions() const throw();


    SUMOReal getHBEFA_HCEmissions() const throw();


    SUMOReal getHBEFA_FuelConsumption() const throw();


    SUMOReal getHarmonoise_NoiseEmissions() const throw();


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


protected:
    size_t myNumericalID;

    VehCont myVehicles;

    SUMOReal myLength;

    SUMOReal myWidth;

    MSEdge* myEdge;

    SUMOReal myMaxSpeed;

    VehCont myTmpVehicles;


    SUMOReal myBackDistance;

    std::vector<MSVehicle*> myVehBuffer;

    SUMOVehicleClasses myAllowedClasses;

    SUMOVehicleClasses myNotAllowedClasses;

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


    SUMOReal myVehicleLengthSum;

    SUMOReal myInlappingVehicleEnd;

    MSVehicle* myInlappingVehicle;


    SUMOReal myLeftVehLength;

    MSLinkCont myLinks;

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



    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 {
            return v1->getPositionOnLane()>v2->getPositionOnLane();
        }

    };

    class by_connections_to_sorter {
    public:
        explicit by_connections_to_sorter(const MSEdge* const e)
            : myEdge(e), myLaneDir(e->getLanes()[0]->getShape().getBegLine().atan2PositiveAngle()) { }

        int operator()(const MSEdge* const e1, const MSEdge* const e2) const {
            const std::vector<MSLane*>* ae1 = e1->allowedLanes(*myEdge);
            const std::vector<MSLane*>* ae2 = e2->allowedLanes(*myEdge);
            SUMOReal s1 = 0;
            if (ae1!=0&&ae1->size()!=0) {
                s1 = (SUMOReal) ae1->size() + GeomHelper::getMinAngleDiff((*ae1)[0]->getShape().getBegLine().atan2PositiveAngle(), myLaneDir) / PI / 2.;
            }
            SUMOReal s2 = 0;
            if (ae2!=0&&ae2->size()!=0) {
                s2 = (SUMOReal) ae2->size() + GeomHelper::getMinAngleDiff((*ae2)[0]->getShape().getBegLine().atan2PositiveAngle(), myLaneDir) / PI / 2.;
            }
            return s1<s2;
        }

    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

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