ROEdge.h

Go to the documentation of this file.

/****************************************************************************/
// A basic edge for routing applications
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2002-2014 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/StdDefs.h>
#include <utils/common/ValueTimeLine.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/emissions/PollutantsInterface.h>
#include <utils/vehicle/SUMOVTypeParameter.h>
#include "RONode.h"
#include "ROVehicle.h"


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


// ===========================================================================
// class definitions
// ===========================================================================
class ROEdge : public Named {
public:
    enum EdgeType {
        ET_NORMAL,
        ET_DISTRICT,
        ET_SOURCE,
        ET_SINK,
        ET_WALKINGAREA,
        ET_CROSSING,
        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 addSuccessor(ROEdge* s, std::string dir = "");


    void setType(EdgeType type);

    inline bool isInternal() const {
        return myType == ET_INTERNAL;
    }

    inline bool isCrossing() const {
        return myType == ET_CROSSING;
    }

    inline bool isWalkingArea() const {
        return myType == ET_WALKINGAREA;
    }

    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 getNumSuccessors() const;


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


    unsigned int getNumPredecessors() const;


    ROEdge* getPredecessor(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;


    static inline SUMOReal getEffortStatic(const ROEdge* const edge, const ROVehicle* const veh, SUMOReal time) {
        return edge->getEffort(veh, time);
    }


    static inline SUMOReal getTravelTimeStatic(const ROEdge* const edge, const ROVehicle* const veh, SUMOReal time) {
        return edge->getTravelTime(veh, time);
    }


    inline SUMOReal getMinimumTravelTime(const ROVehicle* const veh) const {
        return myLength / MIN2(veh->getType()->maxSpeed, veh->getChosenSpeedFactor() * mySpeed);
    }


    template<PollutantsInterface::EmissionType ET>
    static SUMOReal getEmissionEffort(const ROEdge* const edge, const ROVehicle* const veh, SUMOReal time) {
        SUMOReal ret = 0;
        if (!edge->getStoredEffort(time, ret)) {
            const SUMOVTypeParameter* const type = veh->getType();
            const SUMOReal vMax = MIN2(type->maxSpeed, edge->mySpeed);
            const SUMOReal accel = type->get(SUMO_ATTR_ACCEL, SUMOVTypeParameter::getDefaultAccel(type->vehicleClass)) * type->get(SUMO_ATTR_SIGMA, SUMOVTypeParameter::getDefaultImperfection(type->vehicleClass)) / 2.;
            ret = PollutantsInterface::computeDefault(type->emissionClass, ET, vMax, accel, 0, edge->getTravelTime(veh, time)); // @todo: give correct slope
        }
        return ret;
    }


    static SUMOReal getNoiseEffort(const ROEdge* const edge, const ROVehicle* const veh, SUMOReal time);


    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;
    }

    const RONode* getFromJunction() const {
        return myFromJunction;
    }

    const RONode* getToJunction() const {
        return myToJunction;
    }


    void setJunctions(RONode* from, RONode* to) {
        myFromJunction = from;
        myToJunction = to;
    }

    const std::vector<ROLane*>& getLanes() const {
        return myLanes;
    }
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;

    RONode* myFromJunction;
    RONode* myToJunction;


private:
    ROEdge(const ROEdge& src);

    ROEdge& operator=(const ROEdge& src);

};


#endif

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