ROEdge.h

Go to the documentation of this file.

/****************************************************************************/
// A basic edge for routing applications
/****************************************************************************/
// 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 ROEdge_h
#define ROEdge_h


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

#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <utils/common/Named.h>
#include <utils/common/ValueTimeLine.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/SUMOVTypeParameter.h>
#include "RONode.h"
#include "ROVehicle.h"


// ===========================================================================
// class declarations
// ===========================================================================
class ROLane;
class ROVehicle;


// ===========================================================================
// class definitions
// ===========================================================================
class ROEdge : public Named {
public:
    enum EdgeType {
        ET_NORMAL,
        ET_DISTRICT,
        ET_SOURCE,
        ET_SINK,
        ET_INTERNAL
    };


    ROEdge(const std::string& id, RONode* from, RONode* to, unsigned int index, const int priority);


    virtual ~ROEdge();




    virtual void addLane(ROLane* lane);


    virtual void addFollower(ROEdge* s, std::string dir = "");


    void setType(EdgeType type);


    void buildTimeLines(const std::string& measure);





    EdgeType getType() const {
        return myType;
    }


    SUMOReal getLength() const {
        return myLength;
    }

    unsigned int getNumericalID() const {
        return myIndex;
    }


    SUMOReal getSpeed() const {
        return mySpeed;
    }


    unsigned int getLaneNo() const {
        return (unsigned int) myLanes.size();
    }


    RONode* getFromNode() const {
        return myFromNode;
    }


    RONode* getToNode() const {
        return myToNode;
    }


    bool isConnectedTo(const ROEdge* const e) const {
        return std::find(myFollowingEdges.begin(), myFollowingEdges.end(), e) != myFollowingEdges.end();
    }


    inline bool prohibits(const ROVehicle* const vehicle) const {
        const SUMOVehicleClass vclass = vehicle->getVClass();
        return (myCombinedPermissions & vclass) != vclass;
    }

    inline SVCPermissions getPermissions() const {
        return myCombinedPermissions;
    }


    bool allFollowersProhibit(const ROVehicle* const vehicle) const;





    void addEffort(SUMOReal value, SUMOReal timeBegin, SUMOReal timeEnd);


    void addTravelTime(SUMOReal value, SUMOReal timeBegin, SUMOReal timeEnd);


    unsigned int getNoFollowing() const;


    ROEdge* getFollower(unsigned int pos) const {
        return myFollowingEdges[pos];
    }


    unsigned int getNumApproaching() const;


    ROEdge* getApproaching(unsigned int pos) const {
        return myApproachingEdges[pos];
    }


    SUMOReal getEffort(const ROVehicle* const veh, SUMOReal time) const;


    SUMOReal getTravelTime(const ROVehicle* const veh, SUMOReal time) const;


    SUMOReal getTravelTime(const SUMOReal maxSpeed, SUMOReal time) const;


    SUMOReal getMinimumTravelTime(const ROVehicle* const veh) const;


    SUMOReal getCOEffort(const ROVehicle* const veh, SUMOReal time) const;
    SUMOReal getCO2Effort(const ROVehicle* const veh, SUMOReal time) const;
    SUMOReal getPMxEffort(const ROVehicle* const veh, SUMOReal time) const;
    SUMOReal getHCEffort(const ROVehicle* const veh, SUMOReal time) const;
    SUMOReal getNOxEffort(const ROVehicle* const veh, SUMOReal time) const;
    SUMOReal getFuelEffort(const ROVehicle* const veh, SUMOReal time) const;
    SUMOReal getNoiseEffort(const ROVehicle* const veh, SUMOReal time) const;


    SUMOReal getDistanceTo(const ROEdge* other) const;


    static ROEdge* dictionary(size_t index);

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

    static void setTimeLineOptions(
        bool useBoundariesOnOverrideTT,
        bool useBoundariesOnOverrideE,
        bool interpolate) {
        myUseBoundariesOnOverrideTT = useBoundariesOnOverrideTT;
        myUseBoundariesOnOverrideE = useBoundariesOnOverrideE;
        myInterpolate = interpolate;
    }

    int getPriority() const {
        return myPriority;
    }

protected:
    bool getStoredEffort(SUMOReal time, SUMOReal& ret) const;



protected:
    RONode* const myFromNode, * const myToNode;

    const unsigned int myIndex;

    const int myPriority;

    SUMOReal mySpeed;

    SUMOReal myLength;


    mutable ValueTimeLine<SUMOReal> myTravelTimes;
    bool myUsingTTTimeLine;
    static bool myUseBoundariesOnOverrideTT;

    mutable ValueTimeLine<SUMOReal> myEfforts;
    bool myUsingETimeLine;
    static bool myUseBoundariesOnOverrideE;

    static bool myInterpolate;

    static bool myHaveEWarned;
    static bool myHaveTTWarned;

    std::vector<ROEdge*> myFollowingEdges;

    std::vector<ROEdge*> myApproachingEdges;

    EdgeType myType;

    std::vector<ROLane*> myLanes;

    SVCPermissions myCombinedPermissions;

    static std::vector<ROEdge*> myEdges;


private:
    SUMOReal getTravelTime(SUMOReal time) const;

private:
    ROEdge(const ROEdge& src);

    ROEdge& operator=(const ROEdge& src);

};


#endif

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