Eclipse SUMO - Simulation of Urban MObility
MSDevice_Vehroutes.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2009-2023 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/****************************************************************************/
21// A device which collects info on the vehicle trip
22/****************************************************************************/
23#include <config.h>
24
25#include <microsim/MSGlobals.h>
26#include <microsim/MSNet.h>
27#include <microsim/MSLane.h>
28#include <microsim/MSEdge.h>
29#include <microsim/MSRoute.h>
30#include <microsim/MSStop.h>
31#include <microsim/MSVehicle.h>
38#include "MSDevice_Vehroutes.h"
39
40
41// ===========================================================================
42// static member variables
43// ===========================================================================
57
58
59// ===========================================================================
60// method definitions
61// ===========================================================================
62// ---------------------------------------------------------------------------
63// static initialisation methods
64// ---------------------------------------------------------------------------
65void
68 if (oc.isSet("vehroute-output")) {
69 OutputDevice::createDeviceByOption("vehroute-output", "routes", "routes_file.xsd");
70 mySaveExits = oc.getBool("vehroute-output.exit-times");
71 myLastRouteOnly = oc.getBool("vehroute-output.last-route");
72 myDUAStyle = oc.getBool("vehroute-output.dua");
73 myWriteCosts = oc.getBool("vehroute-output.cost");
74 mySorted = myDUAStyle || oc.getBool("vehroute-output.sorted");
75 myIntendedDepart = oc.getBool("vehroute-output.intended-depart");
76 myRouteLength = oc.getBool("vehroute-output.route-length");
77 mySkipPTLines = oc.getBool("vehroute-output.skip-ptlines");
78 myIncludeIncomplete = oc.getBool("vehroute-output.incomplete");
79 myWriteStopPriorEdges = oc.getBool("vehroute-output.stop-edges");
80 myWriteInternal = oc.getBool("vehroute-output.internal");
83 }
84}
85
86
87void
89 oc.addOptionSubTopic("Vehroutes Device");
90 insertDefaultAssignmentOptions("vehroute", "Vehroutes Device", oc);
91}
92
93
95MSDevice_Vehroutes::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into, int maxRoutes) {
96 if (maxRoutes < std::numeric_limits<int>::max()) {
97 return new MSDevice_Vehroutes(v, "vehroute_" + v.getID(), maxRoutes);
98 }
99 if (mySkipPTLines && v.getParameter().line != "") {
100 return nullptr;
101 }
103 if (equippedByDefaultAssignmentOptions(oc, "vehroute", v, oc.isSet("vehroute-output"))) {
104 if (myLastRouteOnly) {
105 maxRoutes = 0;
106 }
107 myStateListener.myDevices[&v] = new MSDevice_Vehroutes(v, "vehroute_" + v.getID(), maxRoutes);
108 into.push_back(myStateListener.myDevices[&v]);
109 return myStateListener.myDevices[&v];
110 }
111 return nullptr;
112}
113
114
115// ---------------------------------------------------------------------------
116// MSDevice_Vehroutes::StateListener-methods
117// ---------------------------------------------------------------------------
118void
121 const auto& deviceEntry = myDevices.find(vehicle);
122 if (deviceEntry != myDevices.end()) {
123 deviceEntry->second->addRoute(info);
124 }
125 }
126}
127
128
129// ---------------------------------------------------------------------------
130// MSDevice_Vehroutes-methods
131// ---------------------------------------------------------------------------
132MSDevice_Vehroutes::MSDevice_Vehroutes(SUMOVehicle& holder, const std::string& id, int maxRoutes) :
133 MSVehicleDevice(holder, id),
134 myCurrentRoute(holder.getRoutePtr()),
135 myMaxRoutes(maxRoutes),
136 myLastSavedAt(nullptr),
138 myDepartLane(-1),
139 myDepartPos(-1),
140 myDepartSpeed(-1),
142 myStopOut(2) {
143}
144
145
148}
149
150
151bool
154 if (mySorted && myStateListener.myDevices[static_cast<SUMOVehicle*>(&veh)] == this) {
156 myRouteInfos.departureCounts[departure]++;
157 }
159 const MSVehicle& vehicle = static_cast<MSVehicle&>(veh);
160 myDepartLane = vehicle.getLane()->getIndex();
162 }
163 myDepartSpeed = veh.getSpeed();
165 }
168 const MSEdge* e = veh.getEdge();
169 if (myPriorEdges.empty() || myPriorEdges.back() != e) {
170 myPriorEdges.push_back(e);
171 }
172 } else {
173 myPriorEdges.push_back(&enteredLane->getEdge());
174 }
175 }
177 return true;
178}
179
180
181bool
182MSDevice_Vehroutes::notifyLeave(SUMOTrafficObject& veh, double /*lastPos*/, MSMoveReminder::Notification reason, const MSLane* /* enteredLane */) {
183 if (mySaveExits && reason != NOTIFICATION_LANE_CHANGE && reason != NOTIFICATION_PARKING && reason != NOTIFICATION_SEGMENT) {
184 const MSEdge* edge = myWriteInternal ? dynamic_cast<MSBaseVehicle&>(veh).getCurrentEdge() : veh.getEdge();
185 if (myLastSavedAt != edge) {
186 myExits.push_back(MSNet::getInstance()->getCurrentTimeStep());
187 myLastSavedAt = edge;
188 }
189 }
190 return true;
191}
192
193
194void
196 const SUMOVehicleParameter::Stop& stop = myHolder.getStops().front().pars;
197 const bool closeLater = myWriteStopPriorEdges || mySaveExits;
198 stop.write(myStopOut, !closeLater);
200 // calculate length
201 double priorEdgesLength = 0;
202 for (int i = 0; i < (int)myPriorEdges.size(); i++) {
203 if (i == 0) {
204 priorEdgesLength += myPriorEdges.at(i)->getLength();
205 } else if (myPriorEdges.at(i)->getID() != myPriorEdges.at(i - 1)->getID()) {
206 priorEdgesLength += myPriorEdges.at(i)->getLength();
207 }
208 }
209 myStopOut.writeAttr("priorEdges", myPriorEdges);
210 myPriorEdges.clear();
211 myStopOut.writeAttr("priorEdgesLength", priorEdgesLength);
212 }
213 if (mySaveExits) {
215 myStopOut.writeAttr(SUMO_ATTR_ENDED, stop.ended < 0 ? "-1" : time2string(stop.ended));
216 }
217 if (closeLater) {
219 }
220}
221
222
223void
225 if (index == 0 && !myIncludeIncomplete && myReplacedRoutes[index].route->size() == 2 &&
226 myReplacedRoutes[index].route->getEdges().front()->isTazConnector() &&
227 myReplacedRoutes[index].route->getEdges().back()->isTazConnector()) {
228 return;
229 }
230 // check if a previous route shall be written
231 //std::cout << " writeXMLRoute index=" << index << " numReroutes=" << myHolder.getNumberReroutes() << "\n";
232 const int routesToSkip = myHolder.getParameter().wasSet(VEHPARS_FORCE_REROUTE) ? 1 : 0;
234 if (index >= 0) {
235 assert((int)myReplacedRoutes.size() > index);
236 if (myDUAStyle || myWriteCosts) {
237 os.writeAttr(SUMO_ATTR_COST, myReplacedRoutes[index].route->getCosts());
238 }
239 if (myWriteCosts) {
240 os.writeAttr(SUMO_ATTR_SAVINGS, myReplacedRoutes[index].route->getSavings());
241 }
242 // write edge on which the vehicle was when the route was valid
243 os.writeAttr("replacedOnEdge", (myReplacedRoutes[index].edge ?
244 myReplacedRoutes[index].edge->getID() : ""));
245 if (myReplacedRoutes[index].lastRouteIndex > 0) {
246 // do not write the default
247 os.writeAttr(SUMO_ATTR_REPLACED_ON_INDEX, myReplacedRoutes[index].lastRouteIndex);
248 }
249 // write the reason for replacement
250 os.writeAttr("reason", myReplacedRoutes[index].info);
251
252 // write the time at which the route was replaced
254 os.writeAttr(SUMO_ATTR_PROB, "0");
255 OutputDevice_String edgesD;
256 // always write the part that was actually driven and the rest of the current route that wasn't yet driven
257 int start = 0;
258 for (int i = routesToSkip; i < index; i++) {
259 if (myReplacedRoutes[i].edge != nullptr) {
260 int end = myReplacedRoutes[i].lastRouteIndex;
261 myReplacedRoutes[i].route->writeEdgeIDs(edgesD, start, end, myWriteInternal, myHolder.getVClass());
262 }
263 start = myReplacedRoutes[i].newRouteIndex;
264 }
265 myReplacedRoutes[index].route->writeEdgeIDs(edgesD, start, -1, myWriteInternal, myHolder.getVClass());
266 std::string edgesS = edgesD.getString();
267 edgesS.pop_back(); // remove last ' '
268 os.writeAttr(SUMO_ATTR_EDGES, edgesS);
269 if (myRouteLength) {
270 const bool includeInternalLengths = MSGlobals::gUsingInternalLanes && MSNet::getInstance()->hasInternalLinks();
271 ConstMSRoutePtr route = myReplacedRoutes[index].route;
272 const double routeLength = route->getDistanceBetween(myHolder.getDepartPos(), route->getEdges().back()->getLength(),
273 route->begin(), route->end(), includeInternalLengths);
274 os.writeAttr("routeLength", routeLength);
275 }
276 } else {
277 if (myDUAStyle || myWriteCosts) {
279 }
280 if (myWriteCosts) {
282 }
283 OutputDevice_String edgesD;
284 int numWritten = 0;
285 int start = 0;
286 if (myHolder.getNumberReroutes() > 0) {
287 assert((int)myReplacedRoutes.size() <= myHolder.getNumberReroutes());
288 for (int i = routesToSkip; i < (int)myReplacedRoutes.size(); i++) {
289 if (myReplacedRoutes[i].edge != nullptr) {
290 int end = myReplacedRoutes[i].lastRouteIndex;
291 numWritten += myReplacedRoutes[i].route->writeEdgeIDs(edgesD, start, end, myWriteInternal, myHolder.getVClass());
292 }
293 start = myReplacedRoutes[i].newRouteIndex;
294 }
295 }
296 numWritten += myCurrentRoute->writeEdgeIDs(edgesD, start, -1, myWriteInternal, myHolder.getVClass());
297 std::string edgesS = edgesD.getString();
298 edgesS.pop_back(); // remove last ' '
299 os.writeAttr(SUMO_ATTR_EDGES, edgesS);
300
301 if (mySaveExits) {
302 std::vector<std::string> exits;
303 for (SUMOTime t : myExits) {
304 exits.push_back(time2string(t));
305 }
306 assert(numWritten >= (int)myExits.size());
307 std::vector<std::string> missing(numWritten - (int)myExits.size(), "-1");
308 exits.insert(exits.end(), missing.begin(), missing.end());
310 }
311 }
312 os.closeTag();
313}
314
315
316void
318 writeOutput(true);
319}
320
321
322void
323MSDevice_Vehroutes::writeOutput(const bool hasArrived) const {
325 OutputDevice& routeOut = OutputDevice::getDeviceByOption("vehroute-output");
333 }
339 }
340 }
341 if (tmp.wasSet(VEHPARS_DEPARTPOS_SET)) {
347 }
354 }
355 if (oc.getBool("vehroute-output.speedfactor") ||
356 (oc.isDefault("vehroute-output.speedfactor") && tmp.wasSet(VEHPARS_DEPARTSPEED_SET))) {
359 }
360
361 const std::string typeID = myHolder.getVehicleType().getID() != DEFAULT_VTYPE_ID ? myHolder.getVehicleType().getID() : "";
362 tmp.write(od, oc, SUMO_TAG_VEHICLE, typeID);
363 if (hasArrived) {
365 }
366 if (myRouteLength) {
367 const bool includeInternalLengths = MSGlobals::gUsingInternalLanes && MSNet::getInstance()->hasInternalLinks();
368 const double finalPos = hasArrived ? myHolder.getArrivalPos() : myHolder.getPositionOnLane();
369 const double routeLength = myHolder.getRoute().getDistanceBetween(myHolder.getDepartPos(), finalPos,
370 myHolder.getRoute().begin(), myHolder.getCurrentRouteEdge(), includeInternalLengths);
371 od.writeAttr("routeLength", routeLength);
372 }
373 if (myDUAStyle) {
375 if (routeDist != nullptr) {
376 const std::vector<ConstMSRoutePtr>& routes = routeDist->getVals();
377 unsigned index = 0;
378 while (index < routes.size() && routes[index] != myCurrentRoute) {
379 ++index;
380 }
382 const std::vector<double>& probs = routeDist->getProbs();
383 for (int i = 0; i < (int)routes.size(); ++i) {
384 od.setPrecision();
386 od.writeAttr(SUMO_ATTR_COST, routes[i]->getCosts());
387 if (myWriteCosts) {
388 od.writeAttr(SUMO_ATTR_SAVINGS, routes[i]->getSavings());
389 }
390 od.setPrecision(8);
391 od.writeAttr(SUMO_ATTR_PROB, probs[i]);
392 od.setPrecision();
393 OutputDevice_String edgesD;
394 routes[i]->writeEdgeIDs(edgesD, 0, -1, myWriteInternal, myHolder.getVClass());
395 std::string edgesS = edgesD.getString();
396 edgesS.pop_back(); // remove last ' '
397 od.writeAttr(SUMO_ATTR_EDGES, edgesS);
398 od.closeTag();
399 }
400 od.closeTag();
401 } else {
402 writeXMLRoute(od);
403 }
404 } else {
405 std::string dummyMsg;
406 const int routesToSkip = (myHolder.getParameter().wasSet(VEHPARS_FORCE_REROUTE)
408 && myReplacedRoutes.size() > 0
409 && !myHolder.hasValidRoute(dummyMsg, myReplacedRoutes[0].route) ? 1 : 0);
410 if ((int)myReplacedRoutes.size() > routesToSkip) {
412 for (int i = routesToSkip; i < (int)myReplacedRoutes.size(); ++i) {
413 writeXMLRoute(od, i);
414 }
415 writeXMLRoute(od);
416 od.closeTag();
417 } else {
418 writeXMLRoute(od);
419 }
420 }
421 od << myStopOut.getString();
423 od.closeTag();
424 od.lf();
425 if (mySorted) {
426 // numerical id reflects loading order
428 } else {
429 routeOut << od.getString();
430 }
431}
432
433
436 if (index < (int)myReplacedRoutes.size()) {
437 return myReplacedRoutes[index].route;
438 } else {
439 return nullptr;
440 }
441}
442
443
444void
445MSDevice_Vehroutes::addRoute(const std::string& info) {
446 if (myMaxRoutes > 0) {
447 //std::cout << SIMTIME << " " << getID() << " departed=" << myHolder.hasDeparted() << " lastIndex=" << myLastRouteIndex << " start=" << myHolder.getRoutePosition() << "\n";
449 myHolder.hasDeparted() ? myHolder.getEdge() : nullptr,
453 if ((int)myReplacedRoutes.size() > myMaxRoutes) {
454 myReplacedRoutes.erase(myReplacedRoutes.begin());
455 }
456 }
458}
459
460
461void
462MSDevice_Vehroutes::writePendingOutput(const bool includeUnfinished) {
463 MSNet* const net = MSNet::getInstance();
464
465 if (!includeUnfinished) {
466 if (mySorted) {
467 for (const auto& routeInfo : myRouteInfos.routeXML) {
468 for (const auto& rouXML : routeInfo.second) {
469 (*myRouteInfos.routeOut) << rouXML.second;
470 }
471 }
472 if (net->hasPersons()) {
473 const SortedRouteInfo& personRouteInfos = net->getPersonControl().getRouteInfo();
474 if (personRouteInfos.routeOut != myRouteInfos.routeOut) {
475 for (const auto& routeInfo : personRouteInfos.routeXML) {
476 for (const auto& rouXML : routeInfo.second) {
477 (*personRouteInfos.routeOut) << rouXML.second;
478 }
479 }
480 }
481 }
482 }
483 return;
484 }
485 for (const auto& it : myStateListener.myDevices) {
486 if (it.first->hasDeparted()) {
487 if (it.first->isStopped()) {
488 it.second->notifyStopEnded();
489 }
490 it.second->writeOutput(false);
491 }
492 }
493 // unfinished persons
494 if (net->hasPersons()) {
496 while (pc.loadedBegin() != pc.loadedEnd()) {
497 pc.erase(pc.loadedBegin()->second);
498 }
499 }
500}
501
502
503void
506}
507
508
509void
510MSDevice_Vehroutes::writeSortedOutput(MSDevice_Vehroutes::SortedRouteInfo* routeInfo, SUMOTime depart, const std::string& id, const std::string& xmlOutput) {
511 if (routeInfo->routeOut == myRouteInfos.routeOut) {
512 routeInfo = &myRouteInfos;
513 }
514 routeInfo->routeXML[depart][id] = xmlOutput;
515 routeInfo->departureCounts[depart]--;
516 std::map<const SUMOTime, int>::iterator it = routeInfo->departureCounts.begin();
517 while (it != routeInfo->departureCounts.end() && it->second == 0) {
518 for (const auto& rouXML : routeInfo->routeXML[it->first]) {
519 (*routeInfo->routeOut) << rouXML.second;
520 }
521 routeInfo->routeXML.erase(it->first);
522 it = routeInfo->departureCounts.erase(it);
523 }
524}
525
526
527void
531 std::vector<std::string> internals;
533 internals.push_back(toString(myDepartLane));
534 internals.push_back(toString(myDepartPosLat));
535 }
536 internals.push_back(toString(myDepartSpeed));
537 internals.push_back(toString(myDepartPos));
538 internals.push_back(toString(myReplacedRoutes.size()));
539 for (int i = 0; i < (int)myReplacedRoutes.size(); ++i) {
540 const std::string replacedOnEdge = myReplacedRoutes[i].edge == nullptr ? "!NULL" : myReplacedRoutes[i].edge->getID();
541 internals.push_back(replacedOnEdge);
542 internals.push_back(toString(myReplacedRoutes[i].time));
543 internals.push_back(myReplacedRoutes[i].route->getID());
544 internals.push_back(myReplacedRoutes[i].info);
545 internals.push_back(toString(myReplacedRoutes[i].lastRouteIndex));
546 internals.push_back(toString(myReplacedRoutes[i].newRouteIndex));
547 }
548 out.writeAttr(SUMO_ATTR_STATE, toString(internals));
549 if (mySaveExits && myExits.size() > 0) {
552 }
553 out.closeTag();
554}
555
556
557void
559 std::istringstream bis(attrs.getString(SUMO_ATTR_STATE));
561 bis >> myDepartLane;
562 bis >> myDepartPosLat;
563 }
564 bis >> myDepartSpeed;
565 bis >> myDepartPos;
566 int size;
567 bis >> size;
568 for (int i = 0; i < size; ++i) {
569 std::string edgeID;
570 SUMOTime time;
571 std::string routeID;
572 std::string info;
573 int lastIndex;
574 int newIndex;
575 bis >> edgeID;
576 bis >> time;
577 bis >> routeID;
578 bis >> info;
579 bis >> lastIndex;
580 bis >> newIndex;
581
582 ConstMSRoutePtr route = MSRoute::dictionary(routeID);
583 if (route != nullptr) {
584 myReplacedRoutes.push_back(RouteReplaceInfo(MSEdge::dictionary(edgeID), time, route, info, lastIndex, newIndex));
585 }
586 }
588 bool ok = true;
589 for (const std::string& t : attrs.get<std::vector<std::string> >(SUMO_ATTR_EXITTIMES, nullptr, ok)) {
590 myExits.push_back(StringUtils::toLong(t));
591 }
592 if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
594 }
595 }
596}
597
598
599/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition: Route.h:32
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition: SUMOTime.cpp:69
const std::string DEFAULT_VTYPE_ID
@ GIVEN
The lane is given.
@ RANDOM
The lateral position is chosen randomly.
@ GIVEN
The position is given.
@ GIVEN_VEHROUTE
The position is set by the vehroute device.
@ GIVEN
The position is given.
@ GIVEN_VEHROUTE
The position is given.
@ STOP
depart position is endPos of first stop
const int VEHPARS_SPEEDFACTOR_SET
const int VEHPARS_DEPARTPOS_SET
@ GIVEN
The speed is given.
@ GIVEN_VEHROUTE
The speed is set by the vehroute device.
@ LIMIT
The maximum lane speed is used (speedLimit)
const int VEHPARS_DEPARTLANE_SET
const int VEHPARS_FORCE_REROUTE
const int VEHPARS_DEPARTSPEED_SET
const int VEHPARS_DEPARTPOSLAT_SET
@ SUMO_TAG_DEVICE
@ SUMO_TAG_VEHICLE
description of a vehicle
@ SUMO_TAG_ROUTE_DISTRIBUTION
distribution of a route
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_ATTR_LAST
@ SUMO_ATTR_STARTED
@ SUMO_ATTR_REPLACED_AT_TIME
@ SUMO_ATTR_EDGE
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_EXITTIMES
@ SUMO_ATTR_ENDED
@ SUMO_ATTR_COST
@ SUMO_ATTR_REPLACED_ON_INDEX
@ SUMO_ATTR_PROB
@ SUMO_ATTR_SAVINGS
@ SUMO_ATTR_ID
@ SUMO_ATTR_STATE
The state of a link.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
Information about a replaced route.
A class that is notified about reroutings.
std::map< const SUMOVehicle *, MSDevice_Vehroutes *, ComparatorNumericalIdLess > myDevices
A map for internal notification.
void vehicleStateChanged(const SUMOVehicle *const vehicle, MSNet::VehicleState to, const std::string &info="")
Called if a vehicle changes its state.
A device which collects info on the vehicle trip (mainly on departure and arrival)
static bool myWriteCosts
A shortcut for the Option "vehroute-output.costs".
static void writeSortedOutput(SortedRouteInfo *routeInfo, SUMOTime depart, const std::string &id, const std::string &xmlOutput)
static void init()
Static intialization.
std::vector< SUMOTime > myExits
The times at which the vehicle exits an edge.
static bool mySorted
A shortcut for the Option "vehroute-output.sorted".
static bool myIntendedDepart
A shortcut for the Option "vehroute-output.intended-depart".
void addRoute(const std::string &info)
Called on route change.
int myLastRouteIndex
The route index of the last edge that the vehicle left.
static bool myIncludeIncomplete
A shortcut for the Option "vehroute-output.incomplete".
MSDevice_Vehroutes(SUMOVehicle &holder, const std::string &id, int maxRoutes)
Constructor.
static bool myRouteLength
A shortcut for the Option "vehroute-output.route-length".
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_FCD-options.
void writeXMLRoute(OutputDevice &os, int index=-1) const
Called on route output.
ConstMSRoutePtr getRoute(int index) const
Called on route retrieval.
static MSDevice_Vehroutes * buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into, int maxRoutes=std::numeric_limits< int >::max())
Build devices for the given vehicle, if needed.
std::vector< RouteReplaceInfo > myReplacedRoutes
Prior routes.
std::vector< const MSEdge * > myPriorEdges
the edges that were passed before the current stop
const int myMaxRoutes
The maximum number of routes to report.
static bool myWriteStopPriorEdges
A shortcut for the Option "vehroute-output.stop-edges".
double myDepartPosLat
The lateral depart position.
const MSEdge * myLastSavedAt
The last edge the exit time was saved for.
void loadState(const SUMOSAXAttributes &attrs)
Loads the state of the device from the given description.
OutputDevice_String myStopOut
double myDepartPos
The lane the vehicle departed at.
static void writePendingOutput(const bool includeUnfinished)
generate vehroute output for pending vehicles at sim end, either due to sorting or because they are s...
static bool myLastRouteOnly
A shortcut for the Option "vehroute-output.last-route".
ConstMSRoutePtr myCurrentRoute
The currently used route.
double myDepartSpeed
The speed on departure.
int myDepartLane
The lane the vehicle departed at.
static SortedRouteInfo myRouteInfos
Information needed to sort vehicles by departure time.
void writeOutput(const bool hasArrived) const
Called on writing vehroutes output.
~MSDevice_Vehroutes()
Destructor.
bool notifyLeave(SUMOTrafficObject &veh, double lastPos, Notification reason, const MSLane *enteredLane=0)
Saves exit times if needed.
bool notifyEnter(SUMOTrafficObject &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Does nothing, returns true only if exit times should be collected.
static bool myWriteInternal
A shortcut for the Option "vehroute-output.internal".
static bool mySkipPTLines
A shortcut for the Option "vehroute-output.skip-ptlines".
void generateOutput(OutputDevice *tripinfoOut) const
Called on writing vehroutes output.
void notifyStopEnded()
called to update state for stopped vehicles
static bool myDUAStyle
A shortcut for the Option "vehroute-output.dua".
static bool mySaveExits
A shortcut for the Option "vehroute-output.exit-times".
static void registerTransportableDepart(SUMOTime depart)
void saveState(OutputDevice &out) const
Saves the state of the device.
static StateListener myStateListener
A class that is notified about reroutings.
static void insertDefaultAssignmentOptions(const std::string &deviceName, const std::string &optionsTopic, OptionsCont &oc, const bool isPerson=false)
Adds common command options that allow to assign devices to vehicles.
Definition: MSDevice.cpp:148
static bool equippedByDefaultAssignmentOptions(const OptionsCont &oc, const std::string &deviceName, DEVICEHOLDER &v, bool outputOptionSet, const bool isPerson=false)
Determines whether a vehicle should get a certain device.
Definition: MSDevice.h:202
A road/street connecting two junctions.
Definition: MSEdge.h:77
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
Definition: MSEdge.cpp:945
static bool gUseMesoSim
Definition: MSGlobals.h:103
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
Definition: MSGlobals.h:78
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
int getIndex() const
Returns the lane's index.
Definition: MSLane.h:629
MSEdge & getEdge() const
Returns the lane's edge.
Definition: MSLane.h:745
Notification
Definition of a vehicle state.
@ NOTIFICATION_DEPARTED
The vehicle has departed (was inserted into the network)
@ NOTIFICATION_SEGMENT
The vehicle changes the segment (meso only)
@ NOTIFICATION_LANE_CHANGE
The vehicle changes lanes (micro only)
@ NOTIFICATION_PARKING
The vehicle starts or ends parking.
The simulated network and simulation perfomer.
Definition: MSNet.h:88
VehicleState
Definition of a vehicle state.
Definition: MSNet.h:604
@ NEWROUTE
The vehicle got a new route.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:322
void addVehicleStateListener(VehicleStateListener *listener)
Adds a vehicle states listener.
Definition: MSNet.cpp:1240
bool hasPersons() const
Returns whether persons are simulated.
Definition: MSNet.h:397
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1172
bool hasInternalLinks() const
return whether the network contains internal links
Definition: MSNet.h:778
double getSavings() const
Returns the estimated savings due to using this route (compare to the route before rerouting)
Definition: MSRoute.h:176
double getDistanceBetween(double fromPos, double toPos, const MSEdge *fromEdge, const MSEdge *toEdge, bool includeInternal=true, int routePosition=0) const
Compute the distance between 2 given edges on this route, including the length of internal lanes....
Definition: MSRoute.cpp:311
static bool dictionary(const std::string &id, ConstMSRoutePtr route)
Adds a route to the dictionary.
Definition: MSRoute.cpp:109
static RandomDistributor< ConstMSRoutePtr > * distDictionary(const std::string &id)
Returns the named route distribution.
Definition: MSRoute.cpp:161
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
Definition: MSRoute.cpp:73
double getCosts() const
Returns the costs of the route.
Definition: MSRoute.h:168
const MSDevice_Vehroutes::SortedRouteInfo & getRouteInfo()
constVehIt loadedBegin() const
Returns the begin of the internal transportables map.
constVehIt loadedEnd() const
Returns the end of the internal transportables map.
virtual void erase(MSTransportable *transportable)
removes a single transportable
Abstract in-vehicle device.
SUMOVehicle & myHolder
The vehicle that stores the device.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:584
double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
Definition: MSVehicle.h:416
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:91
const std::string & getID() const
Returns the id.
Definition: Named.h:74
A storage for options typed value containers)
Definition: OptionsCont.h:89
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:60
An output device that encapsulates an ofstream.
std::string getString() const
Returns the current content as a string.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
void lf()
writes a line feed if applicable
Definition: OutputDevice.h:242
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:254
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
static bool createDeviceByOption(const std::string &optionName, const std::string &rootElement="", const std::string &schemaFile="")
Creates the device using the output definition stored in the named option.
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
const std::vector< T > & getVals() const
Returns the members of the distribution.
const std::vector< double > & getProbs() const
Returns the probabilities assigned to the members of the distribution.
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
Representation of a vehicle, person, or container.
virtual NumericalID getNumericalID() const =0
return the numerical ID which is only for internal usage
virtual const MSVehicleType & getVehicleType() const =0
Returns the object's "vehicle" type.
virtual double getChosenSpeedFactor() const =0
virtual double getSpeed() const =0
Returns the object's current speed.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
virtual SUMOVehicleClass getVClass() const =0
Returns the object's access class.
virtual int getRoutePosition() const =0
return index of edge within route
virtual const MSEdge * getEdge() const =0
Returns the edge the object is currently at.
virtual double getPositionOnLane() const =0
Get the object's position along the lane.
Representation of a vehicle.
Definition: SUMOVehicle.h:62
virtual const std::list< MSStop > & getStops() const =0
virtual SUMOTime getDeparture() const =0
Returns this vehicle's real departure time.
virtual bool hasDeparted() const =0
Returns whether this vehicle has departed.
virtual int getNumberReroutes() const =0
Returns the number of new routes this vehicle got.
virtual double getArrivalPos() const =0
Returns this vehicle's desired arrivalPos for its current route (may change on reroute)
virtual ConstMSRoutePtr getRoutePtr() const =0
Returns the current route.
virtual bool hasValidRoute(std::string &msg, ConstMSRoutePtr route=0) const =0
Validates the current or given route.
virtual double getDepartPos() const =0
Returns this vehicle's real departure position.
virtual const ConstMSEdgeVector::const_iterator & getCurrentRouteEdge() const =0
Returns an iterator pointing to the current edge in this vehicles route.
virtual const MSRoute & getRoute() const =0
Returns the current route.
Definition of vehicle stop (position and duration)
SUMOTime started
the time at which this stop was reached
void write(OutputDevice &dev, const bool close=true, const bool writeTagAndParents=true) const
Writes the stop as XML.
SUMOTime ended
the time at which this stop was ended
Structure representing possible vehicle parameter.
double departPosLat
(optional) The lateral position the vehicle shall depart from
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
double departSpeed
(optional) The initial speed of the vehicle
double speedFactor
individual speedFactor (overriding distribution from vType)
void write(OutputDevice &dev, const OptionsCont &oc, const SumoXMLTag altTag=SUMO_TAG_VEHICLE, const std::string &typeID="") const
Writes the parameters as a beginning element.
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.
double departPos
(optional) The position the vehicle shall depart from
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
bool wasSet(int what) const
Returns whether the given parameter was set.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
std::string line
The vehicle's line (mainly for public transport)
static long long int toLong(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter,...
Information needed to sort vehicle / transportable output by departure time.
std::map< const SUMOTime, int > departureCounts
Map needed to sort vehicles by departure time.
std::map< const SUMOTime, std::map< const std::string, std::string > > routeXML
pregenerated route output sorted by time
OutputDevice * routeOut
route output device