ROEdge.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2002-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// A basic edge for routing applications
/****************************************************************************/
#ifndef ROEdge_h
#define ROEdge_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#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/geom/Boundary.h>
#ifdef HAVE_FOX
#include <fx.h>
#endif
#include <utils/vehicle/SUMOVTypeParameter.h>
#include "RONode.h"
#include "ROVehicle.h"


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

typedef std::vector<ROEdge*> ROEdgeVector;
typedef std::vector<const ROEdge*> ConstROEdgeVector;
typedef std::vector<std::pair<const ROEdge*, const ROEdge*> > ROConstEdgePairVector;


// ===========================================================================
// class definitions
// ===========================================================================
class ROEdge : public Named {
public:
    ROEdge(const std::string& id, RONode* from, RONode* to, int index, const int priority);


    virtual ~ROEdge();




    virtual void addLane(ROLane* lane);


    virtual void addSuccessor(ROEdge* s, ROEdge* via = nullptr, std::string dir = "");


    inline void setFunction(SumoXMLEdgeFunc func) {
        myFunction = func;
    }


    inline void setSource(const bool isSource = true) {
        myAmSource = isSource;
    }


    inline void setSink(const bool isSink = true) {
        myAmSink = isSink;
    }


    inline void setRestrictions(const std::map<SUMOVehicleClass, double>* restrictions) {
        myRestrictions = restrictions;
    }


    inline bool isInternal() const {
        return myFunction == EDGEFUNC_INTERNAL;
    }

    inline bool isCrossing() const {
        return myFunction == EDGEFUNC_CROSSING;
    }

    inline bool isWalkingArea() const {
        return myFunction == EDGEFUNC_WALKINGAREA;
    }

    inline bool isTazConnector() const {
        return myFunction == EDGEFUNC_CONNECTOR;
    }

    void buildTimeLines(const std::string& measure, const bool boundariesOverride);





    inline SumoXMLEdgeFunc getFunction() const {
        return myFunction;
    }


    inline bool isSink() const {
        return myAmSink;
    }


    double getLength() const {
        return myLength;
    }

    int getNumericalID() const {
        return myIndex;
    }


    double getSpeedLimit() const {
        return mySpeed;
    }

    // sufficient for the astar air-distance heuristic
    double getLengthGeometryFactor() const {
        if (myFromJunction != 0 && myToJunction != 0) {
            return MAX2(1.0, myFromJunction->getPosition().distanceTo(myToJunction->getPosition()) / myLength);
        } else {
            return 1.0;
        }
    }

    inline double getVClassMaxSpeed(SUMOVehicleClass vclass) const {
        if (myRestrictions != 0) {
            std::map<SUMOVehicleClass, double>::const_iterator r = myRestrictions->find(vclass);
            if (r != myRestrictions->end()) {
                return r->second;
            }
        }
        return mySpeed;
    }


    int getNumLanes() const {
        return (int) myLanes.size();
    }


    bool isConnectedTo(const ROEdge* const e, const ROVehicle* const vehicle) const;


    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(double value, double timeBegin, double timeEnd);


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


    int getNumSuccessors() const;


    const ROEdgeVector& getSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) const;

    const ROConstEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) const;


    int getNumPredecessors() const;


    const ROEdgeVector& getPredecessors() const {
        return myApproachingEdges;
    }

    const ROEdge* getNormalBefore() const;

    const ROEdge* getNormalAfter() const;

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


    bool hasLoadedTravelTime(double time) const;


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


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


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


    inline double getMinimumTravelTime(const ROVehicle* const veh) const {
        if (isTazConnector()) {
            return 0;
        } else if (veh != 0) {
            return myLength / MIN2(veh->getType()->maxSpeed, veh->getChosenSpeedFactor() * mySpeed);
        } else {
            return myLength / mySpeed;
        }
    }


    template<PollutantsInterface::EmissionType ET>
    static double getEmissionEffort(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        double ret = 0;
        if (!edge->getStoredEffort(time, ret)) {
            const SUMOVTypeParameter* const type = veh->getType();
            const double vMax = MIN2(type->maxSpeed, edge->mySpeed);
            const double accel = type->getCFParam(SUMO_ATTR_ACCEL, SUMOVTypeParameter::getDefaultAccel(type->vehicleClass)) * type->getCFParam(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 double getNoiseEffort(const ROEdge* const edge, const ROVehicle* const veh, double time);


    double getDistanceTo(const ROEdge* other) const;


    static const ROEdgeVector& getAllEdges();

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

    static void setGlobalOptions(const bool interpolate) {
        myInterpolate = interpolate;
    }

    int getPriority() const {
        return myPriority;
    }

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

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


    const std::vector<ROLane*>& getLanes() const {
        return myLanes;
    }
protected:
    bool getStoredEffort(double time, double& ret) const;



protected:
    RONode* myFromJunction;
    RONode* myToJunction;

    const int myIndex;

    const int myPriority;

    double mySpeed;

    double myLength;

    bool myAmSink, myAmSource;
    mutable ValueTimeLine<double> myTravelTimes;
    bool myUsingTTTimeLine;

    mutable ValueTimeLine<double> myEfforts;
    bool myUsingETimeLine;

    static bool myInterpolate;

    static bool myHaveEWarned;
    static bool myHaveTTWarned;

    ROEdgeVector myFollowingEdges;

    ROConstEdgePairVector myFollowingViaEdges;

    ROEdgeVector myApproachingEdges;

    SumoXMLEdgeFunc myFunction;

    const std::map<SUMOVehicleClass, double>* myRestrictions;

    std::vector<ROLane*> myLanes;

    SVCPermissions myCombinedPermissions;

    Boundary myTazBoundary;

    static ROEdgeVector myEdges;


    mutable std::map<SUMOVehicleClass, ROEdgeVector> myClassesSuccessorMap;

    mutable std::map<SUMOVehicleClass, ROConstEdgePairVector> myClassesViaSuccessorMap;

#ifdef HAVE_FOX
    mutable FXMutex myLock;
#endif

private:
    ROEdge(const ROEdge& src);

    ROEdge& operator=(const ROEdge& src);

};


#endif

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