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.org/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 const int routesToSkip = myHolder.getParameter().wasSet(VEHPARS_FORCE_REROUTE) && !myIncludeIncomplete ? 1 : 0;
406 if ((int)myReplacedRoutes.size() > routesToSkip) {
408 for (int i = routesToSkip; i < (int)myReplacedRoutes.size(); ++i) {
409 writeXMLRoute(od, i);
410 }
411 writeXMLRoute(od);
412 od.closeTag();
413 } else {
414 writeXMLRoute(od);
415 }
416 }
417 od << myStopOut.getString();
419 od.closeTag();
420 od.lf();
421 if (mySorted) {
422 // numerical id reflects loading order
424 } else {
425 routeOut << od.getString();
426 }
427}
428
429
432 if (index < (int)myReplacedRoutes.size()) {
433 return myReplacedRoutes[index].route;
434 } else {
435 return nullptr;
436 }
437}
438
439
440void
441MSDevice_Vehroutes::addRoute(const std::string& info) {
442 if (myMaxRoutes > 0) {
443 //std::cout << SIMTIME << " " << getID() << " departed=" << myHolder.hasDeparted() << " lastIndex=" << myLastRouteIndex << " start=" << myHolder.getRoutePosition() << "\n";
445 myHolder.hasDeparted() ? myHolder.getEdge() : nullptr,
449 if ((int)myReplacedRoutes.size() > myMaxRoutes) {
450 myReplacedRoutes.erase(myReplacedRoutes.begin());
451 }
452 }
454}
455
456
457void
458MSDevice_Vehroutes::writePendingOutput(const bool includeUnfinished) {
459 MSNet* const net = MSNet::getInstance();
460
461 if (!includeUnfinished) {
462 if (mySorted) {
463 for (const auto& routeInfo : myRouteInfos.routeXML) {
464 for (const auto& rouXML : routeInfo.second) {
465 (*myRouteInfos.routeOut) << rouXML.second;
466 }
467 }
468 if (net->hasPersons()) {
469 const SortedRouteInfo& personRouteInfos = net->getPersonControl().getRouteInfo();
470 if (personRouteInfos.routeOut != myRouteInfos.routeOut) {
471 for (const auto& routeInfo : personRouteInfos.routeXML) {
472 for (const auto& rouXML : routeInfo.second) {
473 (*personRouteInfos.routeOut) << rouXML.second;
474 }
475 }
476 }
477 }
478 }
479 return;
480 }
481 for (const auto& it : myStateListener.myDevices) {
482 if (it.first->hasDeparted()) {
483 if (it.first->isStopped()) {
484 it.second->notifyStopEnded();
485 }
486 it.second->writeOutput(false);
487 }
488 }
489 // unfinished persons
490 if (net->hasPersons()) {
492 while (pc.loadedBegin() != pc.loadedEnd()) {
493 pc.erase(pc.loadedBegin()->second);
494 }
495 }
496}
497
498
499void
502}
503
504
505void
506MSDevice_Vehroutes::writeSortedOutput(MSDevice_Vehroutes::SortedRouteInfo* routeInfo, SUMOTime depart, const std::string& id, const std::string& xmlOutput) {
507 if (routeInfo->routeOut == myRouteInfos.routeOut) {
508 routeInfo = &myRouteInfos;
509 }
510 routeInfo->routeXML[depart][id] = xmlOutput;
511 routeInfo->departureCounts[depart]--;
512 std::map<const SUMOTime, int>::iterator it = routeInfo->departureCounts.begin();
513 while (it != routeInfo->departureCounts.end() && it->second == 0) {
514 for (const auto& rouXML : routeInfo->routeXML[it->first]) {
515 (*routeInfo->routeOut) << rouXML.second;
516 }
517 routeInfo->routeXML.erase(it->first);
518 it = routeInfo->departureCounts.erase(it);
519 }
520}
521
522
523void
527 std::vector<std::string> internals;
529 internals.push_back(toString(myDepartLane));
530 internals.push_back(toString(myDepartPosLat));
531 }
532 internals.push_back(toString(myDepartSpeed));
533 internals.push_back(toString(myDepartPos));
534 internals.push_back(toString(myReplacedRoutes.size()));
535 for (int i = 0; i < (int)myReplacedRoutes.size(); ++i) {
536 const std::string replacedOnEdge = myReplacedRoutes[i].edge == nullptr ? "!NULL" : myReplacedRoutes[i].edge->getID();
537 internals.push_back(replacedOnEdge);
538 internals.push_back(toString(myReplacedRoutes[i].time));
539 internals.push_back(myReplacedRoutes[i].route->getID());
540 internals.push_back(myReplacedRoutes[i].info);
541 internals.push_back(toString(myReplacedRoutes[i].lastRouteIndex));
542 internals.push_back(toString(myReplacedRoutes[i].newRouteIndex));
543 }
544 out.writeAttr(SUMO_ATTR_STATE, toString(internals));
545 if (mySaveExits && myExits.size() > 0) {
548 }
549 out.closeTag();
550}
551
552
553void
555 std::istringstream bis(attrs.getString(SUMO_ATTR_STATE));
557 bis >> myDepartLane;
558 bis >> myDepartPosLat;
559 }
560 bis >> myDepartSpeed;
561 bis >> myDepartPos;
562 int size;
563 bis >> size;
564 for (int i = 0; i < size; ++i) {
565 std::string edgeID;
566 SUMOTime time;
567 std::string routeID;
568 std::string info;
569 int lastIndex;
570 int newIndex;
571 bis >> edgeID;
572 bis >> time;
573 bis >> routeID;
574 bis >> info;
575 bis >> lastIndex;
576 bis >> newIndex;
577
578 ConstMSRoutePtr route = MSRoute::dictionary(routeID);
579 if (route != nullptr) {
580 myReplacedRoutes.push_back(RouteReplaceInfo(MSEdge::dictionary(edgeID), time, route, info, lastIndex, newIndex));
581 }
582 }
584 bool ok = true;
585 for (const std::string& t : attrs.get<std::vector<std::string> >(SUMO_ATTR_EXITTIMES, nullptr, ok)) {
586 myExits.push_back(StringUtils::toLong(t));
587 }
588 if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
590 }
591 }
592}
593
594
595/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition: Route.h:32
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
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:144
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:602
@ 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:320
void addVehicleStateListener(VehicleStateListener *listener)
Adds a vehicle states listener.
Definition: MSNet.cpp:1227
bool hasPersons() const
Returns whether persons are simulated.
Definition: MSNet.h:395
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1159
bool hasInternalLinks() const
return whether the network contains internal links
Definition: MSNet.h:776
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:307
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:59
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 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