SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ROEdge.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // A basic edge for routing applications
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
13 // Copyright (C) 2001-2012 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #ifdef _MSC_VER
29 #include <windows_config.h>
30 #else
31 #include <config.h>
32 #endif
33 
35 #include <utils/common/ToString.h>
36 #include <algorithm>
37 #include <cassert>
38 #include <iostream>
39 #include "ROLane.h"
40 #include "ROEdge.h"
41 #include "ROVehicle.h"
45 
46 #ifdef CHECK_MEMORY_LEAKS
47 #include <foreign/nvwa/debug_new.h>
48 #endif // CHECK_MEMORY_LEAKS
49 
50 
51 // ===========================================================================
52 // static member definitions
53 // ===========================================================================
56 bool ROEdge::myInterpolate = false;
57 bool ROEdge::myHaveTTWarned = false;
58 bool ROEdge::myHaveEWarned = false;
59 std::vector<ROEdge*> ROEdge::myEdges;
60 
61 
62 // ===========================================================================
63 // method definitions
64 // ===========================================================================
65 ROEdge::ROEdge(const std::string& id, RONode* from, RONode* to, unsigned int index)
66  : myID(id), mySpeed(-1),
67  myIndex(index), myLength(-1),
68  myUsingTTTimeLine(false),
69  myUsingETimeLine(false),
70  myFromNode(from), myToNode(to) {
71  while (myEdges.size() <= index) {
72  myEdges.push_back(0);
73  }
74  myEdges[index] = this;
75 }
76 
77 
79  for (std::vector<ROLane*>::iterator i = myLanes.begin(); i != myLanes.end(); ++i) {
80  delete(*i);
81  }
82 }
83 
84 
85 void
87  SUMOReal length = lane->getLength();
88  assert(myLength == -1 || length == myLength);
89  myLength = length;
90  SUMOReal speed = lane->getSpeed();
91  mySpeed = speed > mySpeed ? speed : mySpeed;
92  myLanes.push_back(lane);
93 
94  // integrate new allowed classes
96 }
97 
98 
99 void
100 ROEdge::addFollower(ROEdge* s, std::string) {
101  if (find(myFollowingEdges.begin(), myFollowingEdges.end(), s) == myFollowingEdges.end()) {
102  myFollowingEdges.push_back(s);
103 #ifdef HAVE_MESOSIM // catchall for internal stuff
104  s->myApproachingEdges.push_back(this);
105 #endif
106  }
107 }
108 
109 
110 void
111 ROEdge::addEffort(SUMOReal value, SUMOReal timeBegin, SUMOReal timeEnd) {
112  myEfforts.add(timeBegin, timeEnd, value);
113  myUsingETimeLine = true;
114 }
115 
116 
117 void
118 ROEdge::addTravelTime(SUMOReal value, SUMOReal timeBegin, SUMOReal timeEnd) {
119  myTravelTimes.add(timeBegin, timeEnd, value);
120  myUsingTTTimeLine = true;
121 }
122 
123 
124 SUMOReal
125 ROEdge::getEffort(const ROVehicle* const veh, SUMOReal time) const {
126  SUMOReal ret = 0;
127  if (!getStoredEffort(time, ret)) {
128  return (SUMOReal)(myLength / MIN2(veh->getType()->maxSpeed, mySpeed));
129  }
130  return ret;
131 }
132 
133 
134 SUMOReal
135 ROEdge::getDistanceTo(const ROEdge* other) const {
136  return getToNode()->getPosition().distanceTo2D(other->getFromNode()->getPosition());
137 }
138 
139 
140 SUMOReal
141 ROEdge::getTravelTime(const ROVehicle* const veh, SUMOReal time) const {
142  if (myUsingTTTimeLine) {
143  if (!myHaveTTWarned && !myTravelTimes.describesTime(time)) {
144  WRITE_WARNING("No interval matches passed time " + toString(time) + " in edge '" + myID + "'.\n Using edge's length / edge's speed.");
145  myHaveTTWarned = true;
146  }
147  if (myInterpolate) {
148  SUMOReal inTT = myTravelTimes.getValue(time);
149  SUMOReal split = (SUMOReal)(myTravelTimes.getSplitTime(time, time + (SUMOTime)inTT) - time);
150  if (split >= 0) {
151  return myTravelTimes.getValue(time + (SUMOTime)inTT) * ((SUMOReal)1. - split / inTT) + split;
152  }
153  }
154  return myTravelTimes.getValue(time);
155  }
156  // ok, no absolute value was found, use the normal value (without) as default
157  return getMinimumTravelTime(veh);
158 }
159 
160 
161 SUMOReal
162 ROEdge::getMinimumTravelTime(const ROVehicle* const veh) const {
163  return (SUMOReal)(myLength / MIN2(veh->getType()->maxSpeed, mySpeed));
164 }
165 
166 
167 SUMOReal
168 ROEdge::getCOEffort(const ROVehicle* const veh, SUMOReal time) const {
169  SUMOReal ret = 0;
170  if (!getStoredEffort(time, ret)) {
171  const SUMOReal vMax = MIN2(veh->getType()->maxSpeed, mySpeed);
173  ret = HelpersHBEFA::computeDefaultCO(veh->getType()->emissionClass, vMax, accel, getTravelTime(veh, time));
174  }
175  return ret;
176 }
177 
178 
179 SUMOReal
180 ROEdge::getCO2Effort(const ROVehicle* const veh, SUMOReal time) const {
181  SUMOReal ret = 0;
182  if (!getStoredEffort(time, ret)) {
183  const SUMOReal vMax = MIN2(veh->getType()->maxSpeed, mySpeed);
185  ret = HelpersHBEFA::computeDefaultCO2(veh->getType()->emissionClass, vMax, accel, getTravelTime(veh, time));
186  }
187  return ret;
188 }
189 
190 
191 SUMOReal
192 ROEdge::getPMxEffort(const ROVehicle* const veh, SUMOReal time) const {
193  SUMOReal ret = 0;
194  if (!getStoredEffort(time, ret)) {
195  const SUMOReal vMax = MIN2(veh->getType()->maxSpeed, mySpeed);
197  ret = HelpersHBEFA::computeDefaultPMx(veh->getType()->emissionClass, vMax, accel, getTravelTime(veh, time));
198  }
199  return ret;
200 }
201 
202 
203 SUMOReal
204 ROEdge::getHCEffort(const ROVehicle* const veh, SUMOReal time) const {
205  SUMOReal ret = 0;
206  if (!getStoredEffort(time, ret)) {
207  const SUMOReal vMax = MIN2(veh->getType()->maxSpeed, mySpeed);
209  ret = HelpersHBEFA::computeDefaultHC(veh->getType()->emissionClass, vMax, accel, getTravelTime(veh, time));
210  }
211  return ret;
212 }
213 
214 
215 SUMOReal
216 ROEdge::getNOxEffort(const ROVehicle* const veh, SUMOReal time) const {
217  SUMOReal ret = 0;
218  if (!getStoredEffort(time, ret)) {
219  const SUMOReal vMax = MIN2(veh->getType()->maxSpeed, mySpeed);
221  ret = HelpersHBEFA::computeDefaultNOx(veh->getType()->emissionClass, vMax, accel, getTravelTime(veh, time));
222  }
223  return ret;
224 }
225 
226 
227 SUMOReal
228 ROEdge::getFuelEffort(const ROVehicle* const veh, SUMOReal time) const {
229  SUMOReal ret = 0;
230  if (!getStoredEffort(time, ret)) {
231  const SUMOReal vMax = MIN2(veh->getType()->maxSpeed, mySpeed);
233  ret = HelpersHBEFA::computeDefaultFuel(veh->getType()->emissionClass, vMax, accel, getTravelTime(veh, time));
234  }
235  return ret;
236 }
237 
238 
239 SUMOReal
240 ROEdge::getNoiseEffort(const ROVehicle* const veh, SUMOReal time) const {
241  SUMOReal ret = 0;
242  if (!getStoredEffort(time, ret)) {
243  const SUMOReal v = MIN2(veh->getType()->maxSpeed, mySpeed);
245  }
246  return ret;
247 }
248 
249 
250 bool
252  if (myUsingETimeLine) {
253  if (!myEfforts.describesTime(time)) {
254  if (!myHaveEWarned) {
255  WRITE_WARNING("No interval matches passed time " + toString(time) + " in edge '" + myID + "'.\n Using edge's length / edge's speed.");
256  myHaveEWarned = true;
257  }
258  return false;
259  }
260  if (myInterpolate) {
261  SUMOReal inTT = myTravelTimes.getValue(time);
262  SUMOReal ratio = (SUMOReal)(myEfforts.getSplitTime(time, time + (SUMOTime)inTT) - time) / inTT;
263  if (ratio >= 0) {
264  ret = ratio * myEfforts.getValue(time) + (1 - ratio) * myEfforts.getValue(time + (SUMOTime)inTT);
265  return true;
266  }
267  }
268  ret = myEfforts.getValue(time);
269  return true;
270  }
271  return false;
272 }
273 
274 
275 unsigned int
277  if (getType() == ET_SINK) {
278  return 0;
279  }
280  return (unsigned int) myFollowingEdges.size();
281 }
282 
283 
284 #ifdef HAVE_MESOSIM // catchall for internal stuff
285 unsigned int
286 ROEdge::getNumApproaching() const {
287  if (getType() == ET_SOURCE) {
288  return 0;
289  }
290  return (unsigned int) myApproachingEdges.size();
291 }
292 #endif
293 
294 
295 void
297  myType = type;
298 }
299 
300 
301 void
302 ROEdge::buildTimeLines(const std::string& measure) {
303  if (myUsingETimeLine) {
304  SUMOReal value = (SUMOReal)(myLength / mySpeed);
305  if (measure == "CO") {
306  value = HelpersHBEFA::computeCO(SVE_UNKNOWN, mySpeed, 0) * value;
307  }
308  if (measure == "CO2") {
309  value = HelpersHBEFA::computeCO2(SVE_UNKNOWN, mySpeed, 0) * value;
310  }
311  if (measure == "HC") {
312  value = HelpersHBEFA::computeHC(SVE_UNKNOWN, mySpeed, 0) * value;
313  }
314  if (measure == "PMx") {
315  value = HelpersHBEFA::computePMx(SVE_UNKNOWN, mySpeed, 0) * value;
316  }
317  if (measure == "NOx") {
318  value = HelpersHBEFA::computeNOx(SVE_UNKNOWN, mySpeed, 0) * value;
319  }
320  if (measure == "fuel") {
321  value = HelpersHBEFA::computeFuel(SVE_UNKNOWN, mySpeed, 0) * value;
322  }
324  }
325  if (myUsingTTTimeLine) {
326  SUMOReal value = (SUMOReal)(myLength / mySpeed);
328  }
329 }
330 
331 
332 bool
333 ROEdge::allFollowersProhibit(const ROVehicle* const vehicle) const {
334  for (std::vector<ROEdge*>::const_iterator i = myFollowingEdges.begin(); i != myFollowingEdges.end(); ++i) {
335  if (!(*i)->prohibits(vehicle)) {
336  return false;
337  }
338  }
339  return true;
340 }
341 
342 
343 ROEdge*
344 ROEdge::dictionary(size_t id) {
345  assert(myEdges.size() > id);
346  return myEdges[id];
347 }
348 
349 
350 
351 /****************************************************************************/
352