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 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 MSLane_h
#define MSLane_h


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

#include "MSEdge.h"
#include "MSVehicle.h"
#include "MSEdgeControl.h"
#include <bitset>
#include <deque>
#include <vector>
#include <utility>
#include <map>
#include <string>
#include <iostream>
#include "MSNet.h"
#include <utils/geom/Position2DVector.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>


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


// ===========================================================================
// class definitions
// ===========================================================================
class MSLane {
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 Position2DVector &shape,
           const std::vector<SUMOVehicleClass> &allowed,
           const std::vector<SUMOVehicleClass> &disallowed) throw();


    virtual ~MSLane() throw();




    void initialize(MSLinkCont* succs);




    typedef std::vector< MSMoveReminder* > MoveReminderCont;


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


    inline const MoveReminderCont &getMoveReminders() const throw() {
        return myMoveReminders;
    }




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


    virtual bool isEmissionSuccess(MSVehicle* vehicle, SUMOReal speed, SUMOReal pos,
                                   bool recheckNextLanes) throw(ProcessError);


    bool freeEmit(MSVehicle& veh, SUMOReal speed) 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() { }




    const std::string &getID() const throw() {
        return myID;
    }


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


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


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


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


    const std::vector<SUMOVehicleClass> &getAllowedClasses() const throw() {
        return myAllowedClasses;
    }


    const std::vector<SUMOVehicleClass> &getNotAllowedClasses() const throw() {
        return myNotAllowedClasses;
    }




    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 * const getLastVehicle() const;
    virtual const MSVehicle * const getFirstVehicle() const;

    void init(MSEdgeControl &, std::vector<MSLane*>::const_iterator firstNeigh, std::vector<MSLane*>::const_iterator lastNeigh);



    // valid for gui-version only
    virtual GUILaneWrapper *buildLaneWrapper(GUIGlObjectStorage &idStorage);

    virtual MSVehicle *removeFirstVehicle();
    virtual MSVehicle *removeVehicle(MSVehicle *remVehicle);

    Position2DVector myShape;



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


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

    void setAllowedClasses(const std::vector<SUMOVehicleClass> &classes) throw() {
        myAllowedClasses = classes;
    }


    void setNotAllowedClasses(const std::vector<SUMOVehicleClass> &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;
    }

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

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




    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 bool push(MSVehicle* veh);

    virtual MSVehicle* pop(SUMOTime t);

    virtual void swapAfterLaneChange(SUMOTime t);



protected:
    std::string myID;

    size_t myNumericalID;

    VehCont myVehicles;

    SUMOReal myLength;

    MSEdge* myEdge;

    SUMOReal myMaxSpeed;

    VehCont myTmpVehicles;


    SUMOReal myBackDistance;

    std::vector<MSVehicle*> myVehBuffer;

    std::vector<SUMOVehicleClass> myAllowedClasses;

    std::vector<SUMOVehicleClass> myNotAllowedClasses;

    std::vector<IncomingLaneInfo> myIncomingLanes;

    SUMOReal myVehicleLengthSum;

    SUMOReal myInlappingVehicleEnd;

    MSVehicle *myInlappingVehicle;


    std::vector<MSLane*>::const_iterator myFirstNeigh;

    std::vector<MSLane*>::const_iterator myLastNeigh;

    SUMOReal myLeftVehLength;

    MSLinkCont myLinks;

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

    static DictType myDict;

private:
    MoveReminderCont myMoveReminders;


    class vehicle_position_sorter {
    public:
        explicit vehicle_position_sorter() { }


        int operator()(MSVehicle *v1, MSVehicle *v2) const {
            return v1->getPositionOnLane()>v2->getPositionOnLane();
        }

    };


private:
    MSLane(const MSLane&);

    MSLane& operator=(const MSLane&);


};


#endif

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