Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
ROEdge.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2002-2024 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
24// A basic edge for routing applications
25/****************************************************************************/
26#include <config.h>
27
30#include <algorithm>
31#include <cassert>
32#include <iostream>
36#include "ROLane.h"
37#include "RONet.h"
38#include "ROVehicle.h"
39#include "ROEdge.h"
40
41
42// ===========================================================================
43// static member definitions
44// ===========================================================================
45bool ROEdge::myInterpolate = false;
46bool ROEdge::myHaveTTWarned = false;
47bool ROEdge::myHaveEWarned = false;
50double ROEdge::myMinEdgePriority(std::numeric_limits<double>::max());
52
53
54// ===========================================================================
55// method definitions
56// ===========================================================================
57ROEdge::ROEdge(const std::string& id, RONode* from, RONode* to, int index, const int priority) :
58 Named(id),
59 myFromJunction(from),
60 myToJunction(to),
61 myIndex(index),
62 myPriority(priority),
63 mySpeed(-1),
64 myLength(0),
65 myAmSink(false),
66 myAmSource(false),
67 myUsingTTTimeLine(false),
68 myUsingETimeLine(false),
69 myCombinedPermissions(0),
70 myOtherTazConnector(nullptr),
71 myTimePenalty(0) {
72 while ((int)myEdges.size() <= index) {
73 myEdges.push_back(0);
74 }
75 myEdges[index] = this;
76 if (from == nullptr && to == nullptr) {
77 // TAZ edge, no lanes
79 } else {
80 // TODO we should not calculate the boundary here, the position for the nodes is not valid yet
81 myBoundary.add(from->getPosition());
83 }
84}
85
86
87ROEdge::ROEdge(const std::string& id, const RONode* from, const RONode* to, SVCPermissions p) :
88 Named(id),
89 myFromJunction(const_cast<RONode*>(from)),
90 myToJunction(const_cast<RONode*>(to)),
91 myIndex(-1),
92 myPriority(0),
93 mySpeed(std::numeric_limits<double>::max()),
94 myLength(0),
95 myAmSink(false),
96 myAmSource(false),
97 myUsingTTTimeLine(false),
98 myUsingETimeLine(false),
99 myCombinedPermissions(p),
100 myOtherTazConnector(nullptr),
101 myTimePenalty(0)
102{ }
103
104
106 for (ROLane* const lane : myLanes) {
107 delete lane;
108 }
112}
113
114
115void
117 const double speed = lane->getSpeed();
118 if (speed > mySpeed) {
119 mySpeed = speed;
120 myLength = lane->getLength();
121 }
122 mySpeed = speed > mySpeed ? speed : mySpeed;
123 myLanes.push_back(lane);
124
125 // integrate new allowed classes
127}
128
129
130void
131ROEdge::addSuccessor(ROEdge* s, ROEdge* via, std::string) {
132 if (isInternal()) {
133 // for internal edges after an internal junction,
134 // this is called twice and only the second call counts
135 myFollowingEdges.clear();
136 myFollowingViaEdges.clear();
137 }
138 if (find(myFollowingEdges.begin(), myFollowingEdges.end(), s) == myFollowingEdges.end()) {
139 myFollowingEdges.push_back(s);
140 myFollowingViaEdges.push_back(std::make_pair(s, via));
141 if (isTazConnector() && s->getFromJunction() != nullptr) {
143 }
144 if (!isInternal()) {
145 s->myApproachingEdges.push_back(this);
146 if (s->isTazConnector() && getToJunction() != nullptr) {
147 s->myBoundary.add(getToJunction()->getPosition());
148 }
149 }
150 if (via != nullptr) {
151 if (via->myApproachingEdges.size() == 0) {
152 via->myApproachingEdges.push_back(this);
153 }
154 }
155 }
156}
157
158
159void
160ROEdge::addEffort(double value, double timeBegin, double timeEnd) {
161 myEfforts.add(timeBegin, timeEnd, value);
162 myUsingETimeLine = true;
163}
164
165
166void
167ROEdge::addTravelTime(double value, double timeBegin, double timeEnd) {
168 myTravelTimes.add(timeBegin, timeEnd, value);
169 myUsingTTTimeLine = true;
170}
171
172
173double
174ROEdge::getEffort(const ROVehicle* const veh, double time) const {
175 double ret = 0;
176 if (!getStoredEffort(time, ret)) {
177 return myLength / MIN2(veh->getMaxSpeed(), mySpeed) + myTimePenalty;
178 }
179 return ret;
180}
181
182
183double
184ROEdge::getDistanceTo(const ROEdge* other, const bool doBoundaryEstimate) const {
185 assert(this != other);
186 if (doBoundaryEstimate) {
187 return myBoundary.distanceTo2D(other->myBoundary);
188 }
189 if (isTazConnector()) {
190 if (other->isTazConnector()) {
191 return myBoundary.distanceTo2D(other->myBoundary);
192 }
194 }
195 if (other->isTazConnector()) {
196 return other->myBoundary.distanceTo2D(getToJunction()->getPosition());
197 }
198 return getLanes()[0]->getShape()[-1].distanceTo2D(other->getLanes()[0]->getShape()[0]);
199 //return getToJunction()->getPosition().distanceTo2D(other->getFromJunction()->getPosition());
200}
201
202
203bool
204ROEdge::hasLoadedTravelTime(double time) const {
206}
207
208
209double
210ROEdge::getTravelTime(const ROVehicle* const veh, double time) const {
211 if (myUsingTTTimeLine) {
212 if (myTravelTimes.describesTime(time)) {
213 double lineTT = myTravelTimes.getValue(time);
214 if (myInterpolate) {
215 const double inTT = lineTT;
216 const double split = (double)(myTravelTimes.getSplitTime(time, time + inTT) - time);
217 if (split >= 0) {
218 lineTT = myTravelTimes.getValue(time + inTT) * ((double)1. - split / inTT) + split;
219 }
220 }
221 return MAX2(getMinimumTravelTime(veh), lineTT);
222 } else {
223 if (!myHaveTTWarned) {
224 WRITE_WARNINGF(TL("No interval matches passed time=% in edge '%'.\n Using edge's length / max speed."), time, myID);
225 myHaveTTWarned = true;
226 }
227 }
228 }
229 const double speed = veh != nullptr ? MIN2(veh->getMaxSpeed(), veh->getType()->speedFactor.getParameter()[0] * mySpeed) : mySpeed;
230 return myLength / speed + myTimePenalty;
231}
232
233
234double
235ROEdge::getNoiseEffort(const ROEdge* const edge, const ROVehicle* const veh, double time) {
236 double ret = 0;
237 if (!edge->getStoredEffort(time, ret)) {
238 const double v = MIN2(veh->getMaxSpeed(), edge->mySpeed);
240 }
241 return ret;
242}
243
244
245bool
246ROEdge::getStoredEffort(double time, double& ret) const {
247 if (myUsingETimeLine) {
248 if (!myEfforts.describesTime(time)) {
249 if (!myHaveEWarned) {
250 WRITE_WARNINGF(TL("No interval matches passed time=% in edge '%'.\n Using edge's length / edge's speed."), time, myID);
251 myHaveEWarned = true;
252 }
253 return false;
254 }
255 if (myInterpolate) {
256 const double inTT = myTravelTimes.getValue(time);
257 const double ratio = (myEfforts.getSplitTime(time, time + inTT) - time) / inTT;
258 if (ratio >= 0.) {
259 ret = ratio * myEfforts.getValue(time) + (1. - ratio) * myEfforts.getValue(time + inTT);
260 return true;
261 }
262 }
263 ret = myEfforts.getValue(time);
264 return true;
265 }
266 return false;
267}
268
269
270int
272 if (myAmSink) {
273 return 0;
274 }
275 return (int) myFollowingEdges.size();
276}
277
278
279int
281 if (myAmSource) {
282 return 0;
283 }
284 return (int) myApproachingEdges.size();
285}
286
287
288const ROEdge*
290 const ROEdge* result = this;
291 while (result->isInternal()) {
292 assert(myApproachingEdges.size() == 1);
293 result = result->myApproachingEdges.front();
294 }
295 return result;
296}
297
298
299
300const ROEdge*
302 const ROEdge* result = this;
303 while (result->isInternal()) {
304 assert(myFollowingEdges.size() == 1);
305 result = result->myFollowingEdges.front();
306 }
307 return result;
308}
309
310
311void
312ROEdge::buildTimeLines(const std::string& measure, const bool boundariesOverride) {
313 if (myUsingETimeLine) {
314 double value = myLength / mySpeed;
316 if (measure == "CO") {
317 value = PollutantsInterface::compute(c, PollutantsInterface::CO, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
318 }
319 if (measure == "CO2") {
320 value = PollutantsInterface::compute(c, PollutantsInterface::CO2, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
321 }
322 if (measure == "HC") {
323 value = PollutantsInterface::compute(c, PollutantsInterface::HC, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
324 }
325 if (measure == "PMx") {
326 value = PollutantsInterface::compute(c, PollutantsInterface::PM_X, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
327 }
328 if (measure == "NOx") {
329 value = PollutantsInterface::compute(c, PollutantsInterface::NO_X, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
330 }
331 if (measure == "fuel") {
332 value = PollutantsInterface::compute(c, PollutantsInterface::FUEL, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
333 }
334 if (measure == "electricity") {
335 value = PollutantsInterface::compute(c, PollutantsInterface::ELEC, mySpeed, 0, 0, nullptr) * value; // @todo: give correct slope
336 }
337 myEfforts.fillGaps(value, boundariesOverride);
338 }
339 if (myUsingTTTimeLine) {
340 myTravelTimes.fillGaps(myLength / mySpeed + myTimePenalty, boundariesOverride);
341 }
342}
343
344
345void
346ROEdge::cacheParamRestrictions(const std::vector<std::string>& restrictionKeys) {
347 for (const std::string& key : restrictionKeys) {
348 const std::string value = getParameter(key, "1e40");
350 }
351}
352
353
354double
356 return myLanes.empty() ? 1. : myLanes[0]->getShape().length() / myLanes[0]->getLength();
357}
358
359
360bool
361ROEdge::allFollowersProhibit(const ROVehicle* const vehicle) const {
362 for (ROEdgeVector::const_iterator i = myFollowingEdges.begin(); i != myFollowingEdges.end(); ++i) {
363 if (!(*i)->prohibits(vehicle)) {
364 return false;
365 }
366 }
367 return true;
368}
369
370
371const ROEdgeVector&
373 return myEdges;
374}
375
376
377const Position
379 const double middle = (stop.endPos + stop.startPos) / 2.;
381 return (edge->getFromJunction()->getPosition() + edge->getToJunction()->getPosition()) * (middle / edge->getLength());
382}
383
384
385const ROEdgeVector&
387 if (vClass == SVC_IGNORING || !RONet::getInstance()->hasPermissions() || isTazConnector()) {
388 return myFollowingEdges;
389 }
390#ifdef HAVE_FOX
391 FXMutexLock locker(myLock);
392#endif
393 std::map<SUMOVehicleClass, ROEdgeVector>::const_iterator i = myClassesSuccessorMap.find(vClass);
394 if (i != myClassesSuccessorMap.end()) {
395 // can use cached value
396 return i->second;
397 }
398 // this vClass is requested for the first time. rebuild all successors
399 std::set<ROEdge*> followers;
400 for (const ROLane* const lane : myLanes) {
401 if ((lane->getPermissions() & vClass) != 0) {
402 for (const auto& next : lane->getOutgoingViaLanes()) {
403 if ((next.first->getPermissions() & vClass) != 0 && (next.second == nullptr || (next.second->getPermissions() & vClass) != 0)) {
404 followers.insert(&next.first->getEdge());
405 }
406 }
407 }
408 }
409 // also add district edges (they are not connected at the lane level
410 for (ROEdgeVector::const_iterator it = myFollowingEdges.begin(); it != myFollowingEdges.end(); ++it) {
411 if ((*it)->isTazConnector()) {
412 followers.insert(*it);
413 }
414 }
415 myClassesSuccessorMap[vClass].insert(myClassesSuccessorMap[vClass].begin(),
416 followers.begin(), followers.end());
417 return myClassesSuccessorMap[vClass];
418}
419
420
422ROEdge::getViaSuccessors(SUMOVehicleClass vClass, bool /*ignoreTransientPermissions*/) const {
423 if (vClass == SVC_IGNORING || !RONet::getInstance()->hasPermissions() || isTazConnector()) {
424 return myFollowingViaEdges;
425 }
426#ifdef HAVE_FOX
427 FXMutexLock locker(myLock);
428#endif
429 std::map<SUMOVehicleClass, ROConstEdgePairVector>::const_iterator i = myClassesViaSuccessorMap.find(vClass);
430 if (i != myClassesViaSuccessorMap.end()) {
431 // can use cached value
432 return i->second;
433 }
434 // this vClass is requested for the first time. rebuild all successors
435 std::set<std::pair<const ROEdge*, const ROEdge*> > followers;
436 for (const ROLane* const lane : myLanes) {
437 if ((lane->getPermissions() & vClass) != 0) {
438 for (const auto& next : lane->getOutgoingViaLanes()) {
439 if ((next.first->getPermissions() & vClass) != 0 && (next.second == nullptr || (next.second->getPermissions() & vClass) != 0)) {
440 followers.insert(std::make_pair(&next.first->getEdge(), next.second));
441 }
442 }
443 }
444 }
445 // also add district edges (they are not connected at the lane level
446 for (const ROEdge* e : myFollowingEdges) {
447 if (e->isTazConnector()) {
448 followers.insert(std::make_pair(e, e));
449 }
450 }
451 myClassesViaSuccessorMap[vClass].insert(myClassesViaSuccessorMap[vClass].begin(),
452 followers.begin(), followers.end());
453 return myClassesViaSuccessorMap[vClass];
454}
455
456
457bool
458ROEdge::isConnectedTo(const ROEdge& e, const SUMOVehicleClass vClass) const {
459 const ROEdgeVector& followers = getSuccessors(vClass);
460 return std::find(followers.begin(), followers.end(), &e) != followers.end();
461}
462
463bool
464ROEdge::initPriorityFactor(double priorityFactor) {
465 myPriorityFactor = priorityFactor;
466 double maxEdgePriority = -std::numeric_limits<double>::max();
467 for (ROEdge* edge : myEdges) {
468 maxEdgePriority = MAX2(maxEdgePriority, (double)edge->getPriority());
469 myMinEdgePriority = MIN2(myMinEdgePriority, (double)edge->getPriority());
470 }
471 myEdgePriorityRange = maxEdgePriority - myMinEdgePriority;
472 if (myEdgePriorityRange == 0) {
473 WRITE_WARNING(TL("Option weights.priority-factor does not take effect because all edges have the same priority."));
475 return false;
476 }
477 return true;
478}
479
480
481/****************************************************************************/
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:296
#define WRITE_WARNING(msg)
Definition MsgHandler.h:295
#define TL(string)
Definition MsgHandler.h:315
std::vector< ROEdge * > ROEdgeVector
std::vector< std::pair< const ROEdge *, const ROEdge * > > ROConstEdgePairVector
Definition ROEdge.h:57
std::vector< ROEdge * > ROEdgeVector
Definition ROEdge.h:55
const SVCPermissions SVCAll
all VClasses are allowed
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
int SUMOEmissionClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
T MIN2(T a, T b)
Definition StdDefs.h:76
T MAX2(T a, T b)
Definition StdDefs.h:82
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition Boundary.cpp:78
double distanceTo2D(const Position &p) const
returns the euclidean distance in the x-y-plane
Definition Boundary.cpp:265
std::vector< double > & getParameter()
Returns the parameters of this distribution.
static double computeNoise(SUMOEmissionClass c, double v, double a)
Returns the noise produced by the a vehicle of the given type at the given speed.
Base class for objects which have an id.
Definition Named.h:54
std::string myID
The name of the object.
Definition Named.h:125
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
static double compute(const SUMOEmissionClass c, const EmissionType e, const double v, const double a, const double slope, const EnergyParams *param)
Returns the amount of the emitted pollutant given the vehicle type and state (in mg/s or ml/s for fue...
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
A basic edge for routing applications.
Definition ROEdge.h:72
bool allFollowersProhibit(const ROVehicle *const vehicle) const
Returns whether this edge succeeding edges prohibit the given vehicle to pass them.
Definition ROEdge.cpp:361
static double myPriorityFactor
Coefficient for factoring edge priority into routing weight.
Definition ROEdge.h:660
const ROEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself
Definition ROEdge.cpp:289
double getDistanceTo(const ROEdge *other, const bool doBoundaryEstimate=false) const
optimistic distance heuristic for use in routing
Definition ROEdge.cpp:184
const ROEdge * getNormalAfter() const
if this edge is an internal edge, return its first normal successor, otherwise the edge itself
Definition ROEdge.cpp:301
void addEffort(double value, double timeBegin, double timeEnd)
Adds a weight value.
Definition ROEdge.cpp:160
bool hasLoadedTravelTime(double time) const
Returns whether a travel time for this edge was loaded.
Definition ROEdge.cpp:204
static double getStoredEffort(const ROEdge *const edge, const ROVehicle *const, double time)
Definition ROEdge.h:486
ReversedEdge< ROEdge, ROVehicle > * myReversedRoutingEdge
a reversed version for backward routing
Definition ROEdge.h:673
void buildTimeLines(const std::string &measure, const bool boundariesOverride)
Builds the internal representation of the travel time/effort.
Definition ROEdge.cpp:312
ROEdge(const std::string &id, RONode *from, RONode *to, int index, const int priority)
Constructor.
Definition ROEdge.cpp:57
std::vector< ROLane * > myLanes
This edge's lanes.
Definition ROEdge.h:637
static bool initPriorityFactor(double priorityFactor)
initialize priority factor range
Definition ROEdge.cpp:464
static ROEdgeVector myEdges
Definition ROEdge.h:657
bool myAmSource
Definition ROEdge.h:603
RailEdge< ROEdge, ROVehicle > * myRailwayRoutingEdge
Definition ROEdge.h:676
const RONode * getToJunction() const
Definition ROEdge.h:521
bool myUsingTTTimeLine
Information whether the time line shall be used instead of the length value.
Definition ROEdge.h:607
std::map< SUMOVehicleClass, ROEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
Definition ROEdge.h:667
bool isTazConnector() const
Definition ROEdge.h:173
std::map< SUMOVehicleClass, ROConstEdgePairVector > myClassesViaSuccessorMap
The successors with vias available for a given vClass.
Definition ROEdge.h:670
std::vector< double > myParamRestrictions
cached value of parameters which may restrict access
Definition ROEdge.h:655
bool myUsingETimeLine
Information whether the time line shall be used instead of the length value.
Definition ROEdge.h:612
const RONode * getFromJunction() const
Definition ROEdge.h:517
virtual void addLane(ROLane *lane)
Adds a lane to the edge while loading.
Definition ROEdge.cpp:116
ValueTimeLine< double > myEfforts
Container storing passing time varying over time for the edge.
Definition ROEdge.h:610
bool isInternal() const
return whether this edge is an internal edge
Definition ROEdge.h:159
virtual ~ROEdge()
Destructor.
Definition ROEdge.cpp:105
int getNumSuccessors() const
Returns the number of edges this edge is connected to.
Definition ROEdge.cpp:271
Boundary myBoundary
The bounding rectangle of end nodes incoming or outgoing edges for taz connectors or of my own start ...
Definition ROEdge.h:649
static double getNoiseEffort(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition ROEdge.cpp:235
static bool myInterpolate
Information whether to interpolate at interval boundaries.
Definition ROEdge.h:615
const ROConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING, bool ignoreTransientPermissions=false) const
Returns the following edges including vias, restricted by vClass.
Definition ROEdge.cpp:422
double getTravelTime(const ROVehicle *const veh, double time) const
Returns the travel time for this edge.
Definition ROEdge.cpp:210
double getMinimumTravelTime(const ROVehicle *const veh) const
Returns a lower bound for the travel time on this edge without using any stored timeLine.
Definition ROEdge.h:460
double myLength
The length of the edge.
Definition ROEdge.h:600
bool myAmSink
whether the edge is a source or a sink
Definition ROEdge.h:603
const ROEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition ROEdge.cpp:386
void addTravelTime(double value, double timeBegin, double timeEnd)
Adds a travel time value.
Definition ROEdge.cpp:167
void cacheParamRestrictions(const std::vector< std::string > &restrictionKeys)
Definition ROEdge.cpp:346
int getNumPredecessors() const
Returns the number of edges connected to this edge.
Definition ROEdge.cpp:280
static double myEdgePriorityRange
the difference between maximum and minimum priority for all edges
Definition ROEdge.h:664
double myTimePenalty
flat penalty when computing traveltime
Definition ROEdge.h:652
SVCPermissions myCombinedPermissions
The list of allowed vehicle classes combined across lanes.
Definition ROEdge.h:640
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
Definition ROEdge.cpp:378
static bool myHaveTTWarned
Information whether the edge has reported missing weights.
Definition ROEdge.h:620
double getEffort(const ROVehicle *const veh, double time) const
Returns the effort for this edge.
Definition ROEdge.cpp:174
const std::vector< ROLane * > & getLanes() const
Returns this edge's lanes.
Definition ROEdge.h:529
double getLengthGeometryFactor() const
return a lower bound on shape.length() / myLength that is
Definition ROEdge.cpp:355
double getLength() const
Returns the length of the edge.
Definition ROEdge.h:224
ROEdgeVector myFollowingEdges
List of edges that may be approached from this edge.
Definition ROEdge.h:623
FlippedEdge< ROEdge, RONode, ROVehicle > * myFlippedRoutingEdge
An extended version of the reversed edge for backward routing (used for the arc flag router)
Definition ROEdge.h:675
ROConstEdgePairVector myFollowingViaEdges
Definition ROEdge.h:625
ValueTimeLine< double > myTravelTimes
Container storing passing time varying over time for the edge.
Definition ROEdge.h:605
virtual void addSuccessor(ROEdge *s, ROEdge *via=nullptr, std::string dir="")
Adds information about a connected edge.
Definition ROEdge.cpp:131
static double myMinEdgePriority
Minimum priority for all edges.
Definition ROEdge.h:662
bool isConnectedTo(const ROEdge &e, const SUMOVehicleClass vClass) const
returns the information whether this edge is directly connected to the given
Definition ROEdge.cpp:458
static bool myHaveEWarned
Information whether the edge has reported missing weights.
Definition ROEdge.h:618
static const ROEdgeVector & getAllEdges()
Returns all ROEdges.
Definition ROEdge.cpp:372
ROEdgeVector myApproachingEdges
List of edges that approached this edge.
Definition ROEdge.h:628
double mySpeed
The maximum speed allowed on this edge.
Definition ROEdge.h:597
A single lane the router may use.
Definition ROLane.h:48
double getLength() const
Returns the length of the lane.
Definition ROLane.h:70
SVCPermissions getPermissions() const
Returns the list of allowed vehicle classes.
Definition ROLane.h:86
double getSpeed() const
Returns the maximum speed allowed on this lane.
Definition ROLane.h:78
static RONet * getInstance()
Returns the pointer to the unique instance of RONet (singleton).
Definition RONet.cpp:56
ROEdge * getEdge(const std::string &name) const
Retrieves an edge from the network.
Definition RONet.h:158
Base class for nodes used by the router.
Definition RONode.h:46
const Position & getPosition() const
Returns the position of the node.
Definition RONode.h:67
const SUMOVTypeParameter * getType() const
Returns the type of the routable.
Definition RORoutable.h:82
double getMaxSpeed() const
Returns the vehicle's maximum speed.
Definition RORoutable.h:121
A vehicle as used by router.
Definition ROVehicle.h:50
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition of vehicle stop (position and duration)
std::string lane
The lane to stop at.
double startPos
The stopping position start.
double endPos
The stopping position end.
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
double getSplitTime(double low, double high) const
Returns the time point at which the value changes.
bool describesTime(double time) const
Returns whether a value for the given time is known.
T getValue(double time) const
Returns the value for the given time.
void fillGaps(T value, bool extendOverBoundaries=false)
Sets a default value for all unset intervals.
void add(double begin, double end, T value)
Adds a value for a time interval into the container.
Definition json.hpp:4471