Eclipse SUMO - Simulation of Urban MObility
MSNet.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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/****************************************************************************/
26// The simulated network and simulation perfomer
27/****************************************************************************/
28#include <config.h>
29
30#ifdef HAVE_VERSION_H
31#include <version.h>
32#endif
33
34#include <string>
35#include <iostream>
36#include <sstream>
37#include <typeinfo>
38#include <algorithm>
39#include <cassert>
40#include <vector>
41#include <ctime>
42
43#ifdef HAVE_FOX
45#endif
63#include <utils/xml/XMLSubSys.h>
65#include <libsumo/Helper.h>
66#include <libsumo/Simulation.h>
67#include <mesosim/MELoop.h>
68#include <mesosim/MESegment.h>
103#include <netload/NLBuilder.h>
104
105#include "MSEdgeControl.h"
106#include "MSJunctionControl.h"
107#include "MSInsertionControl.h"
109#include "MSEventControl.h"
110#include "MSEdge.h"
111#include "MSJunction.h"
112#include "MSJunctionLogic.h"
113#include "MSLane.h"
114#include "MSVehicleControl.h"
115#include "MSVehicleTransfer.h"
116#include "MSRoute.h"
117#include "MSGlobals.h"
118#include "MSEdgeWeightsStorage.h"
119#include "MSStateHandler.h"
120#include "MSFrame.h"
121#include "MSParkingArea.h"
122#include "MSStoppingPlace.h"
123#include "MSNet.h"
124
125
126// ===========================================================================
127// debug constants
128// ===========================================================================
129//#define DEBUG_SIMSTEP
130
131
132// ===========================================================================
133// static member definitions
134// ===========================================================================
135MSNet* MSNet::myInstance = nullptr;
136
137const std::string MSNet::STAGE_EVENTS("events");
138const std::string MSNet::STAGE_MOVEMENTS("move");
139const std::string MSNet::STAGE_LANECHANGE("laneChange");
140const std::string MSNet::STAGE_INSERTIONS("insertion");
141const std::string MSNet::STAGE_REMOTECONTROL("remoteControl");
142
144
145// ===========================================================================
146// static member method definitions
147// ===========================================================================
148double
149MSNet::getEffort(const MSEdge* const e, const SUMOVehicle* const v, double t) {
150 double value;
151 const MSVehicle* const veh = dynamic_cast<const MSVehicle* const>(v);
152 if (veh != nullptr && veh->getWeightsStorage().retrieveExistingEffort(e, t, value)) {
153 return value;
154 }
156 return value;
157 }
158 return 0;
159}
160
161
162double
163MSNet::getTravelTime(const MSEdge* const e, const SUMOVehicle* const v, double t) {
164 double value;
165 const MSVehicle* const veh = dynamic_cast<const MSVehicle* const>(v);
166 if (veh != nullptr && veh->getWeightsStorage().retrieveExistingTravelTime(e, t, value)) {
167 return value;
168 }
170 return value;
171 }
172 if (veh != nullptr && veh->getBaseInfluencer() != nullptr && veh->getBaseInfluencer()->getRoutingMode() == libsumo::ROUTING_MODE_AGGREGATED_CUSTOM) {
173 return MSRoutingEngine::getEffortExtra(e, v, t);
174 }
175 return e->getMinimumTravelTime(v);
176}
177
178
179// ---------------------------------------------------------------------------
180// MSNet - methods
181// ---------------------------------------------------------------------------
182MSNet*
184 if (myInstance != nullptr) {
185 return myInstance;
186 }
187 throw ProcessError("A network was not yet constructed.");
188}
189
190void
194 }
195}
196
197void
201 }
202}
203
204
205MSNet::MSNet(MSVehicleControl* vc, MSEventControl* beginOfTimestepEvents,
206 MSEventControl* endOfTimestepEvents,
207 MSEventControl* insertionEvents,
208 ShapeContainer* shapeCont):
209 myAmInterrupted(false),
210 myVehiclesMoved(0),
211 myPersonsMoved(0),
212 myHavePermissions(false),
213 myHasInternalLinks(false),
214 myJunctionHigherSpeeds(false),
215 myHasElevation(false),
216 myHasPedestrianNetwork(false),
217 myHasBidiEdges(false),
218 myEdgeDataEndTime(-1),
219 myDynamicShapeUpdater(nullptr) {
220 if (myInstance != nullptr) {
221 throw ProcessError("A network was already constructed.");
222 }
224 myStep = string2time(oc.getString("begin"));
225 myMaxTeleports = oc.getInt("max-num-teleports");
226 myLogExecutionTime = !oc.getBool("no-duration-log");
227 myLogStepNumber = !oc.getBool("no-step-log");
228 myLogStepPeriod = oc.getInt("step-log.period");
229 myInserter = new MSInsertionControl(*vc, string2time(oc.getString("max-depart-delay")), oc.getBool("eager-insert"), oc.getInt("max-num-vehicles"),
230 string2time(oc.getString("random-depart-offset")));
231 myVehicleControl = vc;
233 myEdges = nullptr;
234 myJunctions = nullptr;
235 myRouteLoaders = nullptr;
236 myLogics = nullptr;
237 myPersonControl = nullptr;
238 myContainerControl = nullptr;
239 myEdgeWeights = nullptr;
240 myShapeContainer = shapeCont == nullptr ? new ShapeContainer() : shapeCont;
241
242 myBeginOfTimestepEvents = beginOfTimestepEvents;
243 myEndOfTimestepEvents = endOfTimestepEvents;
244 myInsertionEvents = insertionEvents;
245 myLanesRTree.first = false;
246
248 MSGlobals::gMesoNet = new MELoop(string2time(oc.getString("meso-recheck")));
249 }
250 myInstance = this;
251 initStatic();
252}
253
254
255void
257 SUMORouteLoaderControl* routeLoaders,
258 MSTLLogicControl* tlc,
259 std::vector<SUMOTime> stateDumpTimes,
260 std::vector<std::string> stateDumpFiles,
261 bool hasInternalLinks,
262 bool junctionHigherSpeeds,
263 double version) {
264 myEdges = edges;
265 myJunctions = junctions;
266 myRouteLoaders = routeLoaders;
267 myLogics = tlc;
268 // save the time the network state shall be saved at
269 myStateDumpTimes = stateDumpTimes;
270 myStateDumpFiles = stateDumpFiles;
271 myStateDumpPeriod = string2time(oc.getString("save-state.period"));
272 myStateDumpPrefix = oc.getString("save-state.prefix");
273 myStateDumpSuffix = oc.getString("save-state.suffix");
274
275 // initialise performance computation
277 myTraCIMillis = 0;
279 myJunctionHigherSpeeds = junctionHigherSpeeds;
283 myVersion = version;
286 throw ProcessError("Option weights.separate-turns is only supported when simulating with internal lanes");
287 }
288}
289
290
293 // delete controls
294 delete myJunctions;
295 delete myDetectorControl;
296 // delete mean data
297 delete myEdges;
298 delete myInserter;
299 delete myLogics;
300 delete myRouteLoaders;
301 if (myPersonControl != nullptr) {
302 delete myPersonControl;
303 }
304 if (myContainerControl != nullptr) {
305 delete myContainerControl;
306 }
307 delete myVehicleControl; // must happen after deleting transportables
308 // delete events late so that vehicles can get rid of references first
310 myBeginOfTimestepEvents = nullptr;
312 myEndOfTimestepEvents = nullptr;
313 delete myInsertionEvents;
314 myInsertionEvents = nullptr;
315 delete myShapeContainer;
316 delete myEdgeWeights;
317 for (auto& router : myRouterTT) {
318 delete router.second;
319 }
320 myRouterTT.clear();
321 for (auto& router : myRouterEffort) {
322 delete router.second;
323 }
324 myRouterEffort.clear();
325 for (auto& router : myPedestrianRouter) {
326 delete router.second;
327 }
328 myPedestrianRouter.clear();
329 for (auto& router : myIntermodalRouter) {
330 delete router.second;
331 }
332 myIntermodalRouter.clear();
333 myLanesRTree.second.RemoveAll();
334 clearAll();
336 delete MSGlobals::gMesoNet;
337 }
338 myInstance = nullptr;
339}
340
341
342void
343MSNet::addRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed) {
344 myRestrictions[id][svc] = speed;
345}
346
347
348const std::map<SUMOVehicleClass, double>*
349MSNet::getRestrictions(const std::string& id) const {
350 std::map<std::string, std::map<SUMOVehicleClass, double> >::const_iterator i = myRestrictions.find(id);
351 if (i == myRestrictions.end()) {
352 return nullptr;
353 }
354 return &i->second;
355}
356
357void
358MSNet::addMesoType(const std::string& typeID, const MESegment::MesoEdgeType& edgeType) {
359 myMesoEdgeTypes[typeID] = edgeType;
360}
361
363MSNet::getMesoType(const std::string& typeID) {
364 if (myMesoEdgeTypes.count(typeID) == 0) {
365 // init defaults
368 edgeType.tauff = string2time(oc.getString("meso-tauff"));
369 edgeType.taufj = string2time(oc.getString("meso-taufj"));
370 edgeType.taujf = string2time(oc.getString("meso-taujf"));
371 edgeType.taujj = string2time(oc.getString("meso-taujj"));
372 edgeType.jamThreshold = oc.getFloat("meso-jam-threshold");
373 edgeType.junctionControl = oc.getBool("meso-junction-control");
374 edgeType.tlsPenalty = oc.getFloat("meso-tls-penalty");
375 edgeType.tlsFlowPenalty = oc.getFloat("meso-tls-flow-penalty");
376 edgeType.minorPenalty = string2time(oc.getString("meso-minor-penalty"));
377 edgeType.overtaking = oc.getBool("meso-overtaking");
378 myMesoEdgeTypes[typeID] = edgeType;
379 }
380 return myMesoEdgeTypes[typeID];
381}
382
385 // report the begin when wished
386 WRITE_MESSAGEF(TL("Simulation version % started with time: %."), VERSION_STRING, time2string(start));
387 // the simulation loop
389 // state loading may have changed the start time so we need to reinit it
390 myStep = start;
391 int numSteps = 0;
392 bool doStepLog = false;
393 while (state == SIMSTATE_RUNNING) {
394 doStepLog = myLogStepNumber && (numSteps % myLogStepPeriod == 0);
395 if (doStepLog) {
397 }
399 if (doStepLog) {
401 }
402 state = adaptToState(simulationState(stop));
403#ifdef DEBUG_SIMSTEP
404 std::cout << SIMTIME << " MSNet::simulate(" << start << ", " << stop << ")"
405 << "\n simulation state: " << getStateMessage(state)
406 << std::endl;
407#endif
408 numSteps++;
409 }
410 if (myLogStepNumber && !doStepLog) {
411 // ensure some output on the last step
414 }
415 // exit simulation loop
416 if (myLogStepNumber) {
417 // start new line for final verbose output
418 std::cout << "\n";
419 }
420 closeSimulation(start, getStateMessage(state));
421 return state;
422}
423
424
425void
428}
429
430
431const std::string
433 std::ostringstream msg;
434 if (myLogExecutionTime) {
436 // print performance notice
437 msg << "Performance: " << "\n" << " Duration: " << elapsedMs2string(duration) << "\n";
438 if (duration != 0) {
439 if (TraCIServer::getInstance() != nullptr) {
440 msg << " TraCI-Duration: " << elapsedMs2string(myTraCIMillis) << "\n";
441 }
442 msg << " Real time factor: " << (STEPS2TIME(myStep - start) * 1000. / (double)duration) << "\n";
443 msg.setf(std::ios::fixed, std::ios::floatfield); // use decimal format
444 msg.setf(std::ios::showpoint); // print decimal point
445 msg << " UPS: " << ((double)myVehiclesMoved / ((double)duration / 1000)) << "\n";
446 if (myPersonsMoved > 0) {
447 msg << " UPS-Persons: " << ((double)myPersonsMoved / ((double)duration / 1000)) << "\n";
448 }
449 }
450 // print vehicle statistics
451 const std::string discardNotice = ((myVehicleControl->getLoadedVehicleNo() != myVehicleControl->getDepartedVehicleNo()) ?
452 " (Loaded: " + toString(myVehicleControl->getLoadedVehicleNo()) + ")" : "");
453 msg << "Vehicles: " << "\n"
454 << " Inserted: " << myVehicleControl->getDepartedVehicleNo() << discardNotice << "\n"
455 << " Running: " << myVehicleControl->getRunningVehicleNo() << "\n"
456 << " Waiting: " << myInserter->getWaitingVehicleNo() << "\n";
457
459 // print optional teleport statistics
460 std::vector<std::string> reasons;
462 reasons.push_back("Collisions: " + toString(myVehicleControl->getCollisionCount()));
463 }
465 reasons.push_back("Jam: " + toString(myVehicleControl->getTeleportsJam()));
466 }
468 reasons.push_back("Yield: " + toString(myVehicleControl->getTeleportsYield()));
469 }
471 reasons.push_back("Wrong Lane: " + toString(myVehicleControl->getTeleportsWrongLane()));
472 }
473 msg << "Teleports: " << myVehicleControl->getTeleportCount() << " (" << joinToString(reasons, ", ") << ")\n";
474 }
476 msg << "Emergency Stops: " << myVehicleControl->getEmergencyStops() << "\n";
477 }
478 if (myPersonControl != nullptr && myPersonControl->getLoadedNumber() > 0) {
479 msg << "Persons: " << "\n"
480 << " Inserted: " << myPersonControl->getLoadedNumber() << "\n"
481 << " Running: " << myPersonControl->getRunningNumber() << "\n";
482 if (myPersonControl->getJammedNumber() > 0) {
483 msg << " Jammed: " << myPersonControl->getJammedNumber() << "\n";
484 }
485 }
486 if (myContainerControl != nullptr && myContainerControl->getLoadedNumber() > 0) {
487 msg << "Containers: " << "\n"
488 << " Inserted: " << myContainerControl->getLoadedNumber() << "\n"
489 << " Running: " << myContainerControl->getRunningNumber() << "\n";
491 msg << " Jammed: " << myContainerControl->getJammedNumber() << "\n";
492 }
493 }
494 }
495 if (OptionsCont::getOptions().getBool("duration-log.statistics")) {
497 }
498 return msg.str();
499}
500
501void
503 OutputDevice& od = OutputDevice::getDeviceByOption("collision-output");
504 for (const auto& item : myCollisions) {
505 for (const auto& c : item.second) {
506 od.openTag("collision");
508 od.writeAttr("type", c.type);
509 od.writeAttr("lane", c.lane->getID());
510 od.writeAttr("pos", c.pos);
511 od.writeAttr("collider", item.first);
512 od.writeAttr("victim", c.victim);
513 od.writeAttr("colliderType", c.colliderType);
514 od.writeAttr("victimType", c.victimType);
515 od.writeAttr("colliderSpeed", c.colliderSpeed);
516 od.writeAttr("victimSpeed", c.victimSpeed);
517 od.closeTag();
518 }
519 }
520
521}
522
523void
525 OutputDevice& od = OutputDevice::getDeviceByOption("statistic-output");
526 od.openTag("vehicles");
530 od.writeAttr("waiting", myInserter->getWaitingVehicleNo());
531 od.closeTag();
532 od.openTag("teleports");
537 od.closeTag();
538 od.openTag("safety");
539 od.writeAttr("collisions", myVehicleControl->getCollisionCount());
540 od.writeAttr("emergencyStops", myVehicleControl->getEmergencyStops());
541 od.closeTag();
542 od.openTag("persons");
543 od.writeAttr("loaded", myPersonControl != nullptr ? myPersonControl->getLoadedNumber() : 0);
544 od.writeAttr("running", myPersonControl != nullptr ? myPersonControl->getRunningNumber() : 0);
545 od.writeAttr("jammed", myPersonControl != nullptr ? myPersonControl->getJammedNumber() : 0);
546 od.closeTag();
547 if (OptionsCont::getOptions().isSet("tripinfo-output") || OptionsCont::getOptions().getBool("duration-log.statistics")) {
549 }
550
551}
552
553
554void
556 // summary output
558 const bool hasOutput = oc.isSet("summary-output");
559 const bool hasPersonOutput = oc.isSet("person-summary-output");
560 if (hasOutput || hasPersonOutput) {
561 const SUMOTime period = string2time(oc.getString("summary-output.period"));
562 const SUMOTime begin = string2time(oc.getString("begin"));
563 if (period > 0 && (myStep - begin) % period != 0) {
564 return;
565 }
566 }
567 if (hasOutput) {
568 OutputDevice& od = OutputDevice::getDeviceByOption("summary-output");
569 int departedVehiclesNumber = myVehicleControl->getDepartedVehicleNo();
570 const double meanWaitingTime = departedVehiclesNumber != 0 ? myVehicleControl->getTotalDepartureDelay() / (double) departedVehiclesNumber : -1.;
571 int endedVehicleNumber = myVehicleControl->getEndedVehicleNo();
572 const double meanTravelTime = endedVehicleNumber != 0 ? myVehicleControl->getTotalTravelTime() / (double) endedVehicleNumber : -1.;
573 od.openTag("step");
574 od.writeAttr("time", time2string(myStep));
578 od.writeAttr("waiting", myInserter->getWaitingVehicleNo());
581 od.writeAttr("collisions", myVehicleControl->getCollisionCount());
582 od.writeAttr("teleports", myVehicleControl->getTeleportCount());
585 od.writeAttr("meanWaitingTime", meanWaitingTime);
586 od.writeAttr("meanTravelTime", meanTravelTime);
587 std::pair<double, double> meanSpeed = myVehicleControl->getVehicleMeanSpeeds();
588 od.writeAttr("meanSpeed", meanSpeed.first);
589 od.writeAttr("meanSpeedRelative", meanSpeed.second);
590 if (myLogExecutionTime) {
591 od.writeAttr("duration", mySimStepDuration);
592 }
593 od.closeTag();
594 }
595 if (hasPersonOutput) {
596 OutputDevice& od = OutputDevice::getDeviceByOption("person-summary-output");
598 od.openTag("step");
599 od.writeAttr("time", time2string(myStep));
600 od.writeAttr("loaded", pc.getLoadedNumber());
601 od.writeAttr("inserted", pc.getDepartedNumber());
602 od.writeAttr("walking", pc.getMovingNumber());
603 od.writeAttr("waitingForRide", pc.getWaitingForVehicleNumber());
604 od.writeAttr("riding", pc.getRidingNumber());
605 od.writeAttr("stopping", pc.getWaitingUntilNumber());
606 od.writeAttr("jammed", pc.getJammedNumber());
607 od.writeAttr("ended", pc.getEndedNumber());
608 od.writeAttr("arrived", pc.getArrivedNumber());
609 if (myLogExecutionTime) {
610 od.writeAttr("duration", mySimStepDuration);
611 }
612 od.closeTag();
613 }
614}
615
616
617void
618MSNet::closeSimulation(SUMOTime start, const std::string& reason) {
619 // report the end when wished
620 WRITE_MESSAGE("Simulation ended at time: " + time2string(getCurrentTimeStep()));
621 if (reason != "") {
622 WRITE_MESSAGE("Reason: " + reason);
623 }
625 if (MSStopOut::active() && OptionsCont::getOptions().getBool("stop-output.write-unfinished")) {
627 }
628 if (OptionsCont::getOptions().getBool("vehroute-output.write-unfinished")) {
630 }
631 if (OptionsCont::getOptions().getBool("tripinfo-output.write-unfinished")) {
633 }
634 if (OptionsCont::getOptions().isSet("chargingstations-output")) {
636 }
637 if (OptionsCont::getOptions().isSet("overheadwiresegments-output")) {
639 }
640 if (OptionsCont::getOptions().isSet("substations-output")) {
642 }
643 if (OptionsCont::getOptions().isSet("railsignal-block-output")) {
645 }
646 if (myLogExecutionTime || OptionsCont::getOptions().getBool("duration-log.statistics")) {
648 }
649 if (OptionsCont::getOptions().isSet("statistic-output")) {
651 }
652}
653
654
655void
657#ifdef DEBUG_SIMSTEP
658 std::cout << SIMTIME << ": MSNet::simulationStep() called"
659 << ", myStep = " << myStep
660 << std::endl;
661#endif
663 if (t != nullptr) {
664 if (myLogExecutionTime) {
666 }
668#ifdef DEBUG_SIMSTEP
669 bool loadRequested = !TraCI::getLoadArgs().empty();
670 assert(t->getTargetTime() >= myStep || loadRequested || TraCIServer::wasClosed());
671#endif
672 if (myLogExecutionTime) {
674 }
675 if (TraCIServer::wasClosed() || !t->getLoadArgs().empty()) {
676 return;
677 }
678 }
679#ifdef DEBUG_SIMSTEP
680 std::cout << SIMTIME << ": TraCI target time: " << t->getTargetTime() << std::endl;
681#endif
682 // execute beginOfTimestepEvents
683 if (myLogExecutionTime) {
685 }
686 // simulation state output
687 std::vector<SUMOTime>::iterator timeIt = std::find(myStateDumpTimes.begin(), myStateDumpTimes.end(), myStep);
688 if (timeIt != myStateDumpTimes.end()) {
689 const int dist = (int)distance(myStateDumpTimes.begin(), timeIt);
691 }
692 if (myStateDumpPeriod > 0 && myStep % myStateDumpPeriod == 0) {
693 std::string timeStamp = time2string(myStep);
694 std::replace(timeStamp.begin(), timeStamp.end(), ':', '-');
695 const std::string filename = myStateDumpPrefix + "_" + timeStamp + myStateDumpSuffix;
697 myPeriodicStateFiles.push_back(filename);
698 int keep = OptionsCont::getOptions().getInt("save-state.period.keep");
699 if (keep > 0 && (int)myPeriodicStateFiles.size() > keep) {
700 std::remove(myPeriodicStateFiles.front().c_str());
702 }
703 }
706#ifdef HAVE_FOX
707 MSRoutingEngine::waitForAll();
708#endif
711 }
712 // check whether the tls programs need to be switched
714
718 } else {
719 // assure all lanes with vehicles are 'active'
721
722 // compute safe velocities for all vehicles for the next few lanes
723 // also register ApproachingVehicleInformation for all links
725
726 // register junction approaches based on planned velocities as basis for right-of-way decision
728
729 // decide right-of-way and execute movements
733 }
734
735 // vehicles may change lanes
737
740 }
741 }
742 loadRoutes();
743
744 // persons
747 }
748 // containers
751 }
752 // insert vehicles
755#ifdef HAVE_FOX
756 MSRoutingEngine::waitForAll();
757#endif
760 //myEdges->patchActiveLanes(); // @note required to detect collisions on lanes that were empty before insertion. wasteful?
762 }
764
765 // execute endOfTimestepEvents
767
768 if (myLogExecutionTime) {
770 }
771 const int numControlled = libsumo::Helper::postProcessRemoteControl();
772 if (numControlled > 0 && MSGlobals::gCheck4Accidents) {
774 }
775 if (myLogExecutionTime) {
778 }
780 // collisions from the previous step were kept to avoid duplicate
781 // warnings. we must remove them now to ensure correct output.
783 }
784 // update and write (if needed) detector values
785 writeOutput();
786
787 if (myLogExecutionTime) {
790 if (myPersonControl != nullptr) {
792 }
793 }
794 myStep += DELTA_T;
795}
796
797
802 }
803 if (TraCIServer::getInstance() != nullptr && !TraCIServer::getInstance()->getLoadArgs().empty()) {
804 return SIMSTATE_LOADING;
805 }
806 if ((stopTime < 0 || myStep > stopTime) && TraCIServer::getInstance() == nullptr && (stopTime > 0 || myStep > myEdgeDataEndTime)) {
809 && (myPersonControl == nullptr || !myPersonControl->hasNonWaiting())
813 }
814 }
815 if (stopTime >= 0 && myStep >= stopTime) {
817 }
820 }
821 if (myAmInterrupted) {
823 }
824 return SIMSTATE_RUNNING;
825}
826
827
829MSNet::adaptToState(MSNet::SimulationState state, const bool isLibsumo) const {
830 if (state == SIMSTATE_LOADING) {
833 } else if (state != SIMSTATE_RUNNING && ((TraCIServer::getInstance() != nullptr && !TraCIServer::wasClosed()) || isLibsumo)) {
834 // overrides SIMSTATE_END_STEP_REACHED, e.g. (TraCI / Libsumo ignore SUMO's --end option)
835 return SIMSTATE_RUNNING;
836 } else if (state == SIMSTATE_NO_FURTHER_VEHICLES) {
837 if (myPersonControl != nullptr) {
839 }
840 if (myContainerControl != nullptr) {
842 }
844 }
845 return state;
846}
847
848
849std::string
851 switch (state) {
853 return "";
855 return "The final simulation step has been reached.";
857 return "All vehicles have left the simulation.";
859 return "TraCI requested termination.";
861 return "An error occurred (see log).";
863 return "Interrupted.";
865 return "Too many teleports.";
867 return "TraCI issued load command.";
868 default:
869 return "Unknown reason.";
870 }
871}
872
873
874void
876 // clear container
883 while (!MSLaneSpeedTrigger::getInstances().empty()) {
884 delete MSLaneSpeedTrigger::getInstances().begin()->second;
885 }
886 while (!MSTriggeredRerouter::getInstances().empty()) {
887 delete MSTriggeredRerouter::getInstances().begin()->second;
888 }
896 if (t != nullptr) {
897 t->cleanup();
898 }
901}
902
903
904void
905MSNet::clearState(const SUMOTime step, bool quickReload) {
909 for (MSEdge* const edge : MSEdge::getAllEdges()) {
910 for (MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge); s != nullptr; s = s->getNextSegment()) {
911 s->clearState();
912 }
913 }
914 } else {
915 for (MSEdge* const edge : MSEdge::getAllEdges()) {
916 for (MSLane* const lane : edge->getLanes()) {
917 lane->getVehiclesSecure();
918 lane->clearState();
919 lane->releaseVehicles();
920 }
921 edge->clearState();
922 }
923 }
925 if (myPersonControl != nullptr) {
927 }
928 if (myContainerControl != nullptr) {
930 }
931 // delete vtypes after transportables have removed their types
938 // delete all routes after vehicles and detector output is done
940 for (auto& item : myStoppingPlaces) {
941 for (auto& item2 : item.second) {
942 item2.second->clearState();
943 }
944 }
950 myStep = step;
952}
953
954
955void
957 // update detector values
960
961 // check state dumps
962 if (oc.isSet("netstate-dump")) {
964 oc.getInt("netstate-dump.precision"));
965 }
966
967 // check fcd dumps
968 if (OptionsCont::getOptions().isSet("fcd-output")) {
970 }
971
972 // check emission dumps
973 if (OptionsCont::getOptions().isSet("emission-output")) {
975 oc.getInt("emission-output.precision"));
976 }
977
978 // battery dumps
979 if (OptionsCont::getOptions().isSet("battery-output")) {
981 oc.getInt("battery-output.precision"));
982 }
983
984 // elecHybrid dumps
985 if (OptionsCont::getOptions().isSet("elechybrid-output")) {
986 std::string output = OptionsCont::getOptions().getString("elechybrid-output");
987
988 if (oc.getBool("elechybrid-output.aggregated")) {
989 // build a xml file with aggregated device.elechybrid output
991 oc.getInt("elechybrid-output.precision"));
992 } else {
993 // build a separate xml file for each vehicle equipped with device.elechybrid
994 // RICE_TODO: Does this have to be placed here in MSNet.cpp ?
996 for (MSVehicleControl::constVehIt it = vc.loadedVehBegin(); it != vc.loadedVehEnd(); ++it) {
997 const SUMOVehicle* veh = it->second;
998 if (!veh->isOnRoad()) {
999 continue;
1000 }
1001 if (static_cast<MSDevice_ElecHybrid*>(veh->getDevice(typeid(MSDevice_ElecHybrid))) != nullptr) {
1002 std::string vehID = veh->getID();
1003 std::string filename2 = output + "_" + vehID + ".xml";
1004 OutputDevice& dev = OutputDevice::getDevice(filename2);
1005 std::map<SumoXMLAttr, std::string> attrs;
1006 attrs[SUMO_ATTR_VEHICLE] = vehID;
1009 dev.writeXMLHeader("elecHybrid-export", "", attrs);
1010 MSElecHybridExport::write(OutputDevice::getDevice(filename2), veh, myStep, oc.getInt("elechybrid-output.precision"));
1011 }
1012 }
1013 }
1014 }
1015
1016
1017 // check full dumps
1018 if (OptionsCont::getOptions().isSet("full-output")) {
1021 }
1022
1023 // check queue dumps
1024 if (OptionsCont::getOptions().isSet("queue-output")) {
1026 }
1027
1028 // check amitran dumps
1029 if (OptionsCont::getOptions().isSet("amitran-output")) {
1031 }
1032
1033 // check vtk dumps
1034 if (OptionsCont::getOptions().isSet("vtk-output")) {
1035
1036 if (MSNet::getInstance()->getVehicleControl().getRunningVehicleNo() > 0) {
1037 std::string timestep = time2string(myStep);
1038 timestep = timestep.substr(0, timestep.length() - 3);
1039 std::string output = OptionsCont::getOptions().getString("vtk-output");
1040 std::string filename = output + "_" + timestep + ".vtp";
1041
1042 OutputDevice_File dev(filename, false);
1043
1044 //build a huge mass of xml files
1046
1047 }
1048
1049 }
1050
1052
1053 // write detector values
1055
1056 // write link states
1057 if (OptionsCont::getOptions().isSet("link-output")) {
1058 OutputDevice& od = OutputDevice::getDeviceByOption("link-output");
1059 od.openTag("timestep");
1061 for (const MSEdge* const edge : myEdges->getEdges()) {
1062 for (const MSLane* const lane : edge->getLanes()) {
1063 for (const MSLink* const link : lane->getLinkCont()) {
1064 link->writeApproaching(od, lane->getID());
1065 }
1066 }
1067 }
1068 od.closeTag();
1069 }
1070
1071 // write SSM output
1073 dev->updateAndWriteOutput();
1074 }
1075
1076 // write ToC output
1078 if (dev->generatesOutput()) {
1079 dev->writeOutput();
1080 }
1081 }
1082
1083 if (OptionsCont::getOptions().isSet("collision-output")) {
1085 }
1086}
1087
1088
1089bool
1091 return myLogExecutionTime;
1092}
1093
1094
1097 if (myPersonControl == nullptr) {
1099 }
1100 return *myPersonControl;
1101}
1102
1103
1106 if (myContainerControl == nullptr) {
1108 }
1109 return *myContainerControl;
1110}
1111
1114 myDynamicShapeUpdater = std::unique_ptr<MSDynamicShapeUpdater> (new MSDynamicShapeUpdater(*myShapeContainer));
1115 return myDynamicShapeUpdater.get();
1116}
1117
1120 if (myEdgeWeights == nullptr) {
1122 }
1123 return *myEdgeWeights;
1124}
1125
1126
1127void
1129 std::cout << "Step #" << time2string(myStep);
1130}
1131
1132
1133void
1135 if (myLogExecutionTime) {
1136 std::ostringstream oss;
1137 oss.setf(std::ios::fixed, std::ios::floatfield); // use decimal format
1138 oss.setf(std::ios::showpoint); // print decimal point
1139 oss << std::setprecision(gPrecision);
1140 if (mySimStepDuration != 0) {
1141 const double durationSec = (double)mySimStepDuration / 1000.;
1142 oss << " (" << mySimStepDuration << "ms ~= "
1143 << (TS / durationSec) << "*RT, ~"
1144 << ((double) myVehicleControl->getRunningVehicleNo() / durationSec);
1145 } else {
1146 oss << " (0ms ?*RT. ?";
1147 }
1148 oss << "UPS, ";
1149 if (TraCIServer::getInstance() != nullptr) {
1150 oss << "TraCI: " << myTraCIStepDuration << "ms, ";
1151 }
1152 oss << "vehicles TOT " << myVehicleControl->getDepartedVehicleNo()
1153 << " ACT " << myVehicleControl->getRunningVehicleNo()
1154 << " BUF " << myInserter->getWaitingVehicleNo()
1155 << ") ";
1156 std::string prev = "Step #" + time2string(myStep - DELTA_T);
1157 std::cout << oss.str().substr(0, 90 - prev.length());
1158 }
1159 std::cout << '\r';
1160}
1161
1162
1163void
1165 if (find(myVehicleStateListeners.begin(), myVehicleStateListeners.end(), listener) == myVehicleStateListeners.end()) {
1166 myVehicleStateListeners.push_back(listener);
1167 }
1168}
1169
1170
1171void
1173 std::vector<VehicleStateListener*>::iterator i = std::find(myVehicleStateListeners.begin(), myVehicleStateListeners.end(), listener);
1174 if (i != myVehicleStateListeners.end()) {
1175 myVehicleStateListeners.erase(i);
1176 }
1177}
1178
1179
1180void
1181MSNet::informVehicleStateListener(const SUMOVehicle* const vehicle, VehicleState to, const std::string& info) {
1182#ifdef HAVE_FOX
1183 ScopedLocker<> lock(myVehicleStateListenerMutex, MSGlobals::gNumThreads > 1);
1184#endif
1185 for (VehicleStateListener* const listener : myVehicleStateListeners) {
1186 listener->vehicleStateChanged(vehicle, to, info);
1187 }
1188}
1189
1190
1191void
1194 myTransportableStateListeners.push_back(listener);
1195 }
1196}
1197
1198
1199void
1201 std::vector<TransportableStateListener*>::iterator i = std::find(myTransportableStateListeners.begin(), myTransportableStateListeners.end(), listener);
1202 if (i != myTransportableStateListeners.end()) {
1204 }
1205}
1206
1207
1208void
1209MSNet::informTransportableStateListener(const MSTransportable* const transportable, TransportableState to, const std::string& info) {
1210#ifdef HAVE_FOX
1211 ScopedLocker<> lock(myTransportableStateListenerMutex, MSGlobals::gNumThreads > 1);
1212#endif
1214 listener->transportableStateChanged(transportable, to, info);
1215 }
1216}
1217
1218
1219bool
1220MSNet::registerCollision(const SUMOTrafficObject* collider, const SUMOTrafficObject* victim, const std::string& collisionType, const MSLane* lane, double pos) {
1221 auto it = myCollisions.find(collider->getID());
1222 if (it != myCollisions.end()) {
1223 for (Collision& old : it->second) {
1224 if (old.victim == victim->getID()) {
1225 // collision from previous step continues
1226 old.colliderSpeed = collider->getSpeed();
1227 old.victimSpeed = victim->getSpeed();
1228 old.type = collisionType;
1229 old.lane = lane;
1230 old.pos = pos;
1231 old.time = myStep;
1232 return false;
1233 }
1234 }
1235 }
1236 Collision c;
1237 c.victim = victim->getID();
1238 c.colliderType = collider->getVehicleType().getID();
1239 c.victimType = victim->getVehicleType().getID();
1240 c.colliderSpeed = collider->getSpeed();
1241 c.victimSpeed = victim->getSpeed();
1242 c.type = collisionType;
1243 c.lane = lane;
1244 c.pos = pos;
1245 c.time = myStep;
1246 myCollisions[collider->getID()].push_back(c);
1247 return true;
1248}
1249
1250
1251void
1253 for (auto it = myCollisions.begin(); it != myCollisions.end();) {
1254 for (auto it2 = it->second.begin(); it2 != it->second.end();) {
1255 if (it2->time != myStep) {
1256 it2 = it->second.erase(it2);
1257 } else {
1258 it2++;
1259 }
1260 }
1261 if (it->second.size() == 0) {
1262 it = myCollisions.erase(it);
1263 } else {
1264 it++;
1265 }
1266 }
1267}
1268
1269
1270bool
1272 return myStoppingPlaces[category == SUMO_TAG_TRAIN_STOP ? SUMO_TAG_BUS_STOP : category].add(stop->getID(), stop);
1273}
1274
1275
1276bool
1278 if (find(myTractionSubstations.begin(), myTractionSubstations.end(), substation) == myTractionSubstations.end()) {
1279 myTractionSubstations.push_back(substation);
1280 return true;
1281 }
1282 return false;
1283}
1284
1285
1287MSNet::getStoppingPlace(const std::string& id, const SumoXMLTag category) const {
1288 if (myStoppingPlaces.count(category) > 0) {
1289 return myStoppingPlaces.find(category)->second.get(id);
1290 }
1291 return nullptr;
1292}
1293
1294
1295std::string
1296MSNet::getStoppingPlaceID(const MSLane* lane, const double pos, const SumoXMLTag category) const {
1297 if (myStoppingPlaces.count(category) > 0) {
1298 for (const auto& it : myStoppingPlaces.find(category)->second) {
1299 MSStoppingPlace* stop = it.second;
1300 if (&stop->getLane() == lane && stop->getBeginLanePosition() - POSITION_EPS <= pos && stop->getEndLanePosition() + POSITION_EPS >= pos) {
1301 return stop->getID();
1302 }
1303 }
1304 }
1305 return "";
1306}
1307
1308
1311 auto it = myStoppingPlaces.find(category);
1312 if (it != myStoppingPlaces.end()) {
1313 return it->second;
1314 } else {
1316 }
1317}
1318
1319
1320void
1323 OutputDevice& output = OutputDevice::getDeviceByOption("chargingstations-output");
1324 for (const auto& it : myStoppingPlaces.find(SUMO_TAG_CHARGING_STATION)->second) {
1325 static_cast<MSChargingStation*>(it.second)->writeChargingStationOutput(output);
1326 }
1327 }
1328}
1329
1330
1331void
1333 OutputDevice& output = OutputDevice::getDeviceByOption("railsignal-block-output");
1334 for (auto tls : myLogics->getAllLogics()) {
1335 MSRailSignal* rs = dynamic_cast<MSRailSignal*>(tls);
1336 if (rs != nullptr) {
1337 rs->writeBlocks(output);
1338 }
1339 }
1340}
1341
1342
1343void
1346 OutputDevice& output = OutputDevice::getDeviceByOption("overheadwiresegments-output");
1347 for (const auto& it : myStoppingPlaces.find(SUMO_TAG_OVERHEAD_WIRE_SEGMENT)->second) {
1348 static_cast<MSOverheadWire*>(it.second)->writeOverheadWireSegmentOutput(output);
1349 }
1350 }
1351}
1352
1353
1354void
1356 if (myTractionSubstations.size() > 0) {
1357 OutputDevice& output = OutputDevice::getDeviceByOption("substations-output");
1358 output.setPrecision(OptionsCont::getOptions().getInt("substations-output.precision"));
1359 for (auto& it : myTractionSubstations) {
1360 it->writeTractionSubstationOutput(output);
1361 }
1362 }
1363}
1364
1365
1367MSNet::findTractionSubstation(const std::string& substationId) {
1368 for (std::vector<MSTractionSubstation*>::iterator it = myTractionSubstations.begin(); it != myTractionSubstations.end(); ++it) {
1369 if ((*it)->getID() == substationId) {
1370 return *it;
1371 }
1372 }
1373 return nullptr;
1374}
1375
1376
1377bool
1378MSNet::existTractionSubstation(const std::string& substationId) {
1379 for (std::vector<MSTractionSubstation*>::iterator it = myTractionSubstations.begin(); it != myTractionSubstations.end(); ++it) {
1380 if ((*it)->getID() == substationId) {
1381 return true;
1382 }
1383 }
1384 return false;
1385}
1386
1387
1389MSNet::getRouterTT(const int rngIndex, const MSEdgeVector& prohibited) const {
1390 if (myRouterTT.count(rngIndex) == 0) {
1391 const std::string routingAlgorithm = OptionsCont::getOptions().getString("routing-algorithm");
1392 if (routingAlgorithm == "dijkstra") {
1393 myRouterTT[rngIndex] = new DijkstraRouter<MSEdge, SUMOVehicle>(MSEdge::getAllEdges(), true, &MSNet::getTravelTime, nullptr, false, nullptr, true);
1394 } else {
1395 if (routingAlgorithm != "astar") {
1396 WRITE_WARNING("TraCI and Triggers cannot use routing algorithm '" + routingAlgorithm + "'. using 'astar' instead.");
1397 }
1399 }
1400 }
1401 myRouterTT[rngIndex]->prohibit(prohibited);
1402 return *myRouterTT[rngIndex];
1403}
1404
1405
1407MSNet::getRouterEffort(const int rngIndex, const MSEdgeVector& prohibited) const {
1408 if (myRouterEffort.count(rngIndex) == 0) {
1410 }
1411 myRouterEffort[rngIndex]->prohibit(prohibited);
1412 return *myRouterEffort[rngIndex];
1413}
1414
1415
1417MSNet::getPedestrianRouter(const int rngIndex, const MSEdgeVector& prohibited) const {
1418 if (myPedestrianRouter.count(rngIndex) == 0) {
1419 myPedestrianRouter[rngIndex] = new MSPedestrianRouter();
1420 }
1421 myPedestrianRouter[rngIndex]->prohibit(prohibited);
1422 return *myPedestrianRouter[rngIndex];
1423}
1424
1425
1427MSNet::getIntermodalRouter(const int rngIndex, const int routingMode, const MSEdgeVector& prohibited) const {
1429 const int key = rngIndex * oc.getInt("thread-rngs") + routingMode;
1430 if (myIntermodalRouter.count(key) == 0) {
1431 int carWalk = 0;
1432 for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
1433 if (opt == "parkingAreas") {
1435 } else if (opt == "ptStops") {
1437 } else if (opt == "allJunctions") {
1439 }
1440 }
1441 // XXX there is currently no reason to combine multiple values, thus getValueString rather than getStringVector
1442 const std::string& taxiDropoff = oc.getValueString("persontrip.transfer.taxi-walk");
1443 const std::string& taxiPickup = oc.getValueString("persontrip.transfer.walk-taxi");
1444 if (taxiDropoff == "") {
1445 if (MSDevice_Taxi::getTaxi() != nullptr) {
1447 }
1448 } else if (taxiDropoff == "ptStops") {
1450 } else if (taxiDropoff == "allJunctions") {
1452 }
1453 if (taxiPickup == "") {
1454 if (MSDevice_Taxi::getTaxi() != nullptr) {
1456 }
1457 } else if (taxiPickup == "ptStops") {
1459 } else if (taxiPickup == "allJunctions") {
1461 }
1462 const std::string routingAlgorithm = OptionsCont::getOptions().getString("routing-algorithm");
1463 double taxiWait = STEPS2TIME(string2time(OptionsCont::getOptions().getString("persontrip.taxi.waiting-time")));
1464 if (routingMode == libsumo::ROUTING_MODE_COMBINED) {
1465 myIntermodalRouter[key] = new MSIntermodalRouter(MSNet::adaptIntermodalRouter, carWalk, taxiWait, routingAlgorithm, routingMode, new FareModul());
1466 } else {
1467 myIntermodalRouter[key] = new MSIntermodalRouter(MSNet::adaptIntermodalRouter, carWalk, taxiWait, routingAlgorithm, routingMode);
1468 }
1469 }
1470 myIntermodalRouter[key]->prohibit(prohibited);
1471 return *myIntermodalRouter[key];
1472}
1473
1474
1475void
1477 double taxiWait = STEPS2TIME(string2time(OptionsCont::getOptions().getString("persontrip.taxi.waiting-time")));
1478 // add access to all parking areas
1479 EffortCalculator* const external = router.getExternalEffort();
1480 for (const auto& stopType : myInstance->myStoppingPlaces) {
1481 // add access to all stopping places
1482 const SumoXMLTag element = stopType.first;
1483 for (const auto& i : stopType.second) {
1484 const MSEdge* const edge = &i.second->getLane().getEdge();
1485 router.getNetwork()->addAccess(i.first, edge, i.second->getBeginLanePosition(), i.second->getEndLanePosition(),
1486 i.second->getAccessDistance(edge), element, false, taxiWait);
1487 if (element == SUMO_TAG_BUS_STOP) {
1488 // add access to all public transport stops
1489 for (const auto& a : i.second->getAllAccessPos()) {
1490 router.getNetwork()->addAccess(i.first, &std::get<0>(a)->getEdge(), std::get<1>(a), std::get<1>(a), std::get<2>(a), element, true, taxiWait);
1491 }
1492 if (external != nullptr) {
1493 external->addStop(router.getNetwork()->getStopEdge(i.first)->getNumericalID(), *i.second);
1494 }
1495 }
1496 }
1497 }
1500 // add access to transfer from walking to taxi-use
1502 for (MSEdge* edge : myInstance->getEdgeControl().getEdges()) {
1503 if ((edge->getPermissions() & SVC_PEDESTRIAN) != 0 && (edge->getPermissions() & SVC_TAXI) != 0) {
1504 router.getNetwork()->addCarAccess(edge, SVC_TAXI, taxiWait);
1505 }
1506 }
1507 }
1508}
1509
1510
1511bool
1513 const MSEdgeVector& edges = myEdges->getEdges();
1514 for (MSEdgeVector::const_iterator e = edges.begin(); e != edges.end(); ++e) {
1515 for (std::vector<MSLane*>::const_iterator i = (*e)->getLanes().begin(); i != (*e)->getLanes().end(); ++i) {
1516 if ((*i)->getShape().hasElevation()) {
1517 return true;
1518 }
1519 }
1520 }
1521 return false;
1522}
1523
1524
1525bool
1527 for (const MSEdge* e : myEdges->getEdges()) {
1528 if (e->getFunction() == SumoXMLEdgeFunc::WALKINGAREA) {
1529 return true;
1530 }
1531 }
1532 return false;
1533}
1534
1535
1536bool
1538 for (const MSEdge* e : myEdges->getEdges()) {
1539 if (e->getBidiEdge() != nullptr) {
1540 return true;
1541 }
1542 }
1543 return false;
1544}
1545
1546bool
1547MSNet::warnOnce(const std::string& typeAndID) {
1548 if (myWarnedOnce.find(typeAndID) == myWarnedOnce.end()) {
1549 myWarnedOnce[typeAndID] = true;
1550 return true;
1551 }
1552 return false;
1553}
1554
1555void
1558 clearState(string2time(oc.getString("begin")), true);
1560 // load traffic from additional files
1561 for (std::string file : oc.getStringVector("additional-files")) {
1562 // ignore failure on parsing calibrator flow
1563 MSRouteHandler rh(file, true);
1564 const long before = PROGRESS_BEGIN_TIME_MESSAGE("Loading traffic from '" + file + "'");
1565 if (!XMLSubSys::runParser(rh, file, false)) {
1566 throw ProcessError("Loading of " + file + " failed.");
1567 }
1568 PROGRESS_TIME_MESSAGE(before);
1569 }
1570 delete myRouteLoaders;
1572 updateGUI();
1573}
1574
1576MSNet::loadState(const std::string& fileName) {
1577 // load time only
1578 const SUMOTime newTime = MSStateHandler::MSStateTimeHandler::getTime(fileName);
1579 // clean up state
1580 clearState(newTime);
1581 // load state
1582 MSStateHandler h(fileName, 0);
1583 XMLSubSys::runParser(h, fileName);
1584 if (MsgHandler::getErrorInstance()->wasInformed()) {
1585 throw ProcessError("Loading state from '" + fileName + "' failed.");
1586 }
1587 // reset route loaders
1588 delete myRouteLoaders;
1590 // prevent loading errors on rewound route file
1592
1593 updateGUI();
1594 return newTime;
1595}
1596
1597/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
std::vector< MSEdge * > MSEdgeVector
Definition: MSEdge.h:73
#define WRITE_MESSAGEF(...)
Definition: MsgHandler.h:268
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:267
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define PROGRESS_BEGIN_TIME_MESSAGE(msg)
Definition: MsgHandler.h:271
#define TL(string)
Definition: MsgHandler.h:282
#define PROGRESS_TIME_MESSAGE(before)
Definition: MsgHandler.h:272
std::string elapsedMs2string(long long int t)
convert ms to string for log output
Definition: SUMOTime.cpp:110
SUMOTime DELTA_T
Definition: SUMOTime.cpp:37
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define TS
Definition: SUMOTime.h:41
#define SIMTIME
Definition: SUMOTime.h:61
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_TAXI
vehicle is a taxi
@ SVC_PEDESTRIAN
pedestrian
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
@ SUMO_TAG_OVERHEAD_WIRE_SEGMENT
An overhead wire segment.
@ SUMO_ATTR_MAXIMUMBATTERYCAPACITY
Maxium battery capacity.
@ SUMO_ATTR_VEHICLE
@ SUMO_ATTR_RECUPERATIONENABLE
@ SUMO_ATTR_ID
int gPrecision
the precision for floating point outputs
Definition: StdDefs.cpp:25
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:282
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
Computes the shortest path through a network using the A* algorithm.
Definition: AStarRouter.h:76
Computes the shortest path through a network using the Dijkstra algorithm.
the effort calculator interface
virtual void addStop(const int stopEdge, const Parameterised &params)=0
int getNumericalID() const
void addCarAccess(const E *edge, SUMOVehicleClass svc, double traveltime)
Adds access edges for transfering from walking to vehicle use.
void addAccess(const std::string &stopId, const E *stopEdge, const double startPos, const double endPos, const double length, const SumoXMLTag category, bool isAccess, double taxiWait)
Adds access edges for stopping places to the intermodal network.
_IntermodalEdge * getStopEdge(const std::string &stopId) const
Returns the associated stop edge.
@ TAXI_PICKUP_ANYWHERE
taxi customer may be picked up anywhere
@ TAXI_DROPOFF_ANYWHERE
taxi customer may exit anywhere
@ PARKING_AREAS
parking areas
@ ALL_JUNCTIONS
junctions with edges allowing the additional mode
@ TAXI_PICKUP_PT
taxi customer may be picked up at public transport stop
@ PT_STOPS
public transport stops and access
@ TAXI_DROPOFF_PT
taxi customer may be picked up at public transport stop
EffortCalculator * getExternalEffort() const
Network * getNetwork() const
int getCarWalkTransfer() const
The main mesocopic simulation loop.
Definition: MELoop.h:47
void simulate(SUMOTime tMax)
Perform simulation up to the given time.
Definition: MELoop.cpp:61
void clearState()
Remove all vehicles before quick-loading state.
Definition: MELoop.cpp:219
A single mesoscopic segment (cell)
Definition: MESegment.h:49
static void write(OutputDevice &of, const SUMOTime timestep)
Writes the complete network state into the given device.
int getRoutingMode() const
return the current routing mode
const MSEdgeWeightsStorage & getWeightsStorage() const
Returns the vehicle's internal edge travel times/efforts container.
static void write(OutputDevice &of, SUMOTime timestep, int precision)
Writes the complete network state of the given edges into the given device.
static void cleanup()
cleanup remaining data structures
Detectors container; responsible for string and output generation.
void writeOutput(SUMOTime step, bool closing)
Writes the output to be generated within the given time step.
void clearState(SUMOTime step)
Remove all vehicles before quick-loading state.
void updateDetectors(const SUMOTime step)
Computes detector values.
void close(SUMOTime step)
Closes the detector outputs.
static void cleanup()
removes remaining vehicleInformation in sVehicles
A device which collects info on the vehicle trip (mainly on departure and arrival)
double getMaximumBatteryCapacity() const
Get the total vehicle's Battery Capacity in kWh.
A device which collects info on the vehicle trip (mainly on departure and arrival)
Definition: MSDevice_SSM.h:55
static const std::set< MSDevice_SSM *, ComparatorNumericalIdLess > & getInstances()
returns all currently existing SSM devices
static void cleanup()
Clean up remaining devices instances.
static bool hasServableReservations()
check whether there are still (servable) reservations in the system
static SUMOVehicle * getTaxi()
returns a taxi if any exist or nullptr
The ToC Device controls transition of control between automated and manual driving.
Definition: MSDevice_ToC.h:52
static void cleanup()
Closes root tags of output files.
static const std::set< MSDevice_ToC *, ComparatorNumericalIdLess > & getInstances()
returns all currently existing ToC devices
Definition: MSDevice_ToC.h:91
static void writeStatistics(OutputDevice &od)
write statistic output to (xml) file
static std::string printStatistics()
get statistics for printing to stdout
static void generateOutputForUnfinished()
generate output for vehicles which are still in the network
static void generateOutputForUnfinished()
generate vehroute output for vehicles which are still in the network
static void cleanupAll()
perform cleanup for all devices
Definition: MSDevice.cpp:136
Stores edges and lanes, performs moving of vehicle.
Definition: MSEdgeControl.h:81
void patchActiveLanes()
Resets information whether a lane is active for all lanes.
void detectCollisions(SUMOTime timestep, const std::string &stage)
Detect collisions.
void setJunctionApproaches(SUMOTime t)
Register junction approaches for all vehicles after velocities have been planned. This is a prerequis...
void executeMovements(SUMOTime t)
Executes planned vehicle movements with regards to right-of-way.
const MSEdgeVector & getEdges() const
Returns loaded edges.
void planMovements(SUMOTime t)
Compute safe velocities for all vehicles based on positions and speeds from the last time step....
void changeLanes(const SUMOTime t)
Moves (precomputes) critical vehicles.
A road/street connecting two junctions.
Definition: MSEdge.h:77
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
Definition: MSEdge.cpp:984
static void clear()
Clears the dictionary.
Definition: MSEdge.cpp:990
double getMinimumTravelTime(const SUMOVehicle *const veh) const
returns the minimum travel time for the given vehicle
Definition: MSEdge.h:473
A storage for edge travel times and efforts.
bool retrieveExistingTravelTime(const MSEdge *const e, const double t, double &value) const
Returns a travel time for an edge and time if stored.
bool retrieveExistingEffort(const MSEdge *const e, const double t, double &value) const
Returns an effort for an edge and time if stored.
static void writeAggregated(OutputDevice &of, SUMOTime timestep, int precision)
static void write(OutputDevice &of, const SUMOVehicle *veh, SUMOTime timestep, int precision)
Writes the complete network state of the given edges into the given device.
static void write(OutputDevice &of, SUMOTime timestep, int precision)
Writes the complete network state of the given edges into the given device.
Stores time-dependant events and executes them at the proper time.
virtual void execute(SUMOTime time)
Executes time-dependant commands.
void clearState(SUMOTime currentTime, SUMOTime newTime)
Remove all events before quick-loading state.
static void write(OutputDevice &of, SUMOTime timestep, bool elevation)
Writes the position and the angle of each vehicle into the given device.
Definition: MSFCDExport.cpp:50
static void write(OutputDevice &of, SUMOTime timestep)
Dumping a hugh List of Parameters available in the Simulation.
static bool gUseMesoSim
Definition: MSGlobals.h:103
static double gWeightsSeparateTurns
Whether turning specific weights are estimated (and how much)
Definition: MSGlobals.h:171
static bool gOverheadWireRecuperation
Definition: MSGlobals.h:121
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:109
static bool gStateLoaded
Information whether a state has been loaded.
Definition: MSGlobals.h:100
static bool gCheck4Accidents
Definition: MSGlobals.h:85
static bool gClearState
whether the simulation is in the process of clearing state (MSNet::clearState)
Definition: MSGlobals.h:139
static bool gHaveEmissions
Whether emission output of some type is needed (files or GUI)
Definition: MSGlobals.h:177
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
Definition: MSGlobals.h:78
static int gNumThreads
how many threads to use
Definition: MSGlobals.h:145
Inserts vehicles into the network when their departure time is reached.
int getWaitingVehicleNo() const
Returns the number of waiting vehicles.
int emitVehicles(SUMOTime time)
Emits vehicles that want to depart at the given time.
void determineCandidates(SUMOTime time)
Checks for all vehicles whether they can be emitted.
int getPendingFlowCount() const
Returns the number of flows that are still active.
void adaptIntermodalRouter(MSNet::MSIntermodalRouter &router) const
void clearState()
Remove all vehicles before quick-loading state.
Container for junctions; performs operations on all stored junctions.
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
static void clear()
Clears the dictionary.
Definition: MSLane.cpp:2222
static const std::map< std::string, MSLaneSpeedTrigger * > & getInstances()
return all MSLaneSpeedTrigger instances
Interface for objects listening to transportable state changes.
Definition: MSNet.h:695
Interface for objects listening to vehicle state changes.
Definition: MSNet.h:636
The simulated network and simulation perfomer.
Definition: MSNet.h:88
std::map< SumoXMLTag, NamedObjectCont< MSStoppingPlace * > > myStoppingPlaces
Dictionary of bus / container stops.
Definition: MSNet.h:973
long myTraCIMillis
The overall time spent waiting for traci operations including.
Definition: MSNet.h:912
static double getEffort(const MSEdge *const e, const SUMOVehicle *const v, double t)
Returns the effort to pass an edge.
Definition: MSNet.cpp:149
bool warnOnce(const std::string &typeAndID)
return whether a warning regarding the given object shall be issued
Definition: MSNet.cpp:1547
std::map< int, SUMOAbstractRouter< MSEdge, SUMOVehicle > * > myRouterEffort
Definition: MSNet.h:1005
MSIntermodalRouter & getIntermodalRouter(const int rngIndex, const int routingMode=0, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition: MSNet.cpp:1427
bool myLogExecutionTime
Information whether the simulation duration shall be logged.
Definition: MSNet.h:898
MSTransportableControl * myPersonControl
Controls person building and deletion;.
Definition: MSNet.h:867
void removeVehicleStateListener(VehicleStateListener *listener)
Removes a vehicle states listener.
Definition: MSNet.cpp:1172
SUMORouteLoaderControl * myRouteLoaders
Route loader for dynamic loading of routes.
Definition: MSNet.h:848
bool addStoppingPlace(const SumoXMLTag category, MSStoppingPlace *stop)
Adds a stopping place.
Definition: MSNet.cpp:1271
void informTransportableStateListener(const MSTransportable *const transportable, TransportableState to, const std::string &info="")
Informs all added listeners about a transportable's state change.
Definition: MSNet.cpp:1209
SUMOTime myStateDumpPeriod
The period for writing state.
Definition: MSNet.h:931
static const NamedObjectCont< MSStoppingPlace * > myEmptyStoppingPlaceCont
Definition: MSNet.h:994
const std::string generateStatistics(SUMOTime start)
Writes performance output and running vehicle stats.
Definition: MSNet.cpp:432
void writeOverheadWireSegmentOutput() const
write the output generated by an overhead wire segment
Definition: MSNet.cpp:1344
void writeChargingStationOutput() const
write charging station output
Definition: MSNet.cpp:1321
std::pair< bool, NamedRTree > myLanesRTree
An RTree structure holding lane IDs.
Definition: MSNet.h:1010
bool checkBidiEdges()
check wether bidirectional edges occur in the network
Definition: MSNet.cpp:1537
VehicleState
Definition of a vehicle state.
Definition: MSNet.h:603
int myLogStepPeriod
Period between successive step-log outputs.
Definition: MSNet.h:903
SUMOTime myStep
Current time step.
Definition: MSNet.h:851
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
bool myHasBidiEdges
Whether the network contains bidirectional rail edges.
Definition: MSNet.h:961
MSEventControl * myBeginOfTimestepEvents
Controls events executed at the begin of a time step;.
Definition: MSNet.h:881
bool addTractionSubstation(MSTractionSubstation *substation)
Adds a traction substation.
Definition: MSNet.cpp:1277
std::map< std::string, bool > myWarnedOnce
container to record warnings that shall only be issued once
Definition: MSNet.h:997
static void initStatic()
Place for static initializations of simulation components (called after successful net build)
Definition: MSNet.cpp:191
void removeOutdatedCollisions()
remove collisions from the previous simulation step
Definition: MSNet.cpp:1252
MSJunctionControl * myJunctions
Controls junctions, realizes right-of-way rules;.
Definition: MSNet.h:873
std::vector< std::string > myPeriodicStateFiles
The names of the last K periodic state files (only only K shall be kept)
Definition: MSNet.h:929
ShapeContainer * myShapeContainer
A container for geometrical shapes;.
Definition: MSNet.h:887
double myVersion
the network version
Definition: MSNet.h:967
std::string myStateDumpSuffix
Definition: MSNet.h:934
bool checkElevation()
check all lanes for elevation data
Definition: MSNet.cpp:1512
bool existTractionSubstation(const std::string &substationId)
return whether given electrical substation exists in the network
Definition: MSNet.cpp:1378
void removeTransportableStateListener(TransportableStateListener *listener)
Removes a transportable states listener.
Definition: MSNet.cpp:1200
SimulationState adaptToState(const SimulationState state, const bool isLibsumo=false) const
Called after a simulation step, this method adapts the current simulation state if necessary.
Definition: MSNet.cpp:829
bool myLogStepNumber
Information whether the number of the simulation step shall be logged.
Definition: MSNet.h:901
MSEventControl * myInsertionEvents
Controls insertion events;.
Definition: MSNet.h:885
virtual MSTransportableControl & getContainerControl()
Returns the container control.
Definition: MSNet.cpp:1105
void closeBuilding(const OptionsCont &oc, MSEdgeControl *edges, MSJunctionControl *junctions, SUMORouteLoaderControl *routeLoaders, MSTLLogicControl *tlc, std::vector< SUMOTime > stateDumpTimes, std::vector< std::string > stateDumpFiles, bool hasInternalLinks, bool junctionHigherSpeeds, double version)
Closes the network's building process.
Definition: MSNet.cpp:256
SimulationState
Possible states of a simulation - running or stopped with different reasons.
Definition: MSNet.h:93
@ SIMSTATE_TOO_MANY_TELEPORTS
The simulation had too many teleports.
Definition: MSNet.h:109
@ SIMSTATE_NO_FURTHER_VEHICLES
The simulation does not contain further vehicles.
Definition: MSNet.h:101
@ SIMSTATE_LOADING
The simulation is loading.
Definition: MSNet.h:95
@ SIMSTATE_ERROR_IN_SIM
An error occurred during the simulation step.
Definition: MSNet.h:105
@ SIMSTATE_CONNECTION_CLOSED
The connection to a client was closed by the client.
Definition: MSNet.h:103
@ SIMSTATE_INTERRUPTED
An external interrupt occured.
Definition: MSNet.h:107
@ SIMSTATE_RUNNING
The simulation is running.
Definition: MSNet.h:97
@ SIMSTATE_END_STEP_REACHED
The final simulation step has been performed.
Definition: MSNet.h:99
SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterTT(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition: MSNet.cpp:1389
std::map< int, MSPedestrianRouter * > myPedestrianRouter
Definition: MSNet.h:1006
static const std::string STAGE_MOVEMENTS
Definition: MSNet.h:825
int myMaxTeleports
Maximum number of teleports.
Definition: MSNet.h:854
long mySimStepDuration
Definition: MSNet.h:906
PedestrianRouter< MSEdge, MSLane, MSJunction, MSVehicle > MSPedestrianRouter
Definition: MSNet.h:112
MSEventControl * myEndOfTimestepEvents
Controls events executed at the end of a time step;.
Definition: MSNet.h:883
static std::string getStateMessage(SimulationState state)
Returns the message to show if a certain state occurs.
Definition: MSNet.cpp:850
std::string getStoppingPlaceID(const MSLane *lane, const double pos, const SumoXMLTag category) const
Returns the stop of the given category close to the given position.
Definition: MSNet.cpp:1296
bool myHasInternalLinks
Whether the network contains internal links/lanes/edges.
Definition: MSNet.h:949
void writeSubstationOutput() const
write electrical substation output
Definition: MSNet.cpp:1355
static const std::string STAGE_INSERTIONS
Definition: MSNet.h:827
SUMOTime loadState(const std::string &fileName)
load state from file and return new time
Definition: MSNet.cpp:1576
long long int myPersonsMoved
Definition: MSNet.h:916
void quickReload()
reset state to the beginning without reloading the network
Definition: MSNet.cpp:1556
MSVehicleControl * myVehicleControl
Controls vehicle building and deletion;.
Definition: MSNet.h:865
static void clearAll()
Clears all dictionaries.
Definition: MSNet.cpp:875
static void cleanupStatic()
Place for static initializations of simulation components (called after successful net build)
Definition: MSNet.cpp:198
IntermodalRouter< MSEdge, MSLane, MSJunction, SUMOVehicle > MSIntermodalRouter
Definition: MSNet.h:113
void writeSummaryOutput()
write summary-output to (xml) file
Definition: MSNet.cpp:555
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:321
MSEdgeControl * myEdges
Controls edges, performs vehicle movement;.
Definition: MSNet.h:871
std::unique_ptr< MSDynamicShapeUpdater > myDynamicShapeUpdater
Updater for dynamic shapes that are tracking traffic objects (ensures removal of shape dynamics when ...
Definition: MSNet.h:1015
const std::map< SUMOVehicleClass, double > * getRestrictions(const std::string &id) const
Returns the restrictions for an edge type If no restrictions are present, 0 is returned.
Definition: MSNet.cpp:349
void closeSimulation(SUMOTime start, const std::string &reason="")
Closes the simulation (all files, connections, etc.)
Definition: MSNet.cpp:618
MSStoppingPlace * getStoppingPlace(const std::string &id, const SumoXMLTag category) const
Returns the named stopping place of the given category.
Definition: MSNet.cpp:1287
void simulationStep()
Performs a single simulation step.
Definition: MSNet.cpp:656
bool myHasElevation
Whether the network contains elevation data.
Definition: MSNet.h:955
static double getTravelTime(const MSEdge *const e, const SUMOVehicle *const v, double t)
Returns the travel time to pass an edge.
Definition: MSNet.cpp:163
MSTransportableControl * myContainerControl
Controls container building and deletion;.
Definition: MSNet.h:869
std::vector< TransportableStateListener * > myTransportableStateListeners
Container for transportable state listener.
Definition: MSNet.h:982
void writeOutput()
Write netstate, summary and detector output.
Definition: MSNet.cpp:956
virtual void updateGUI() const
update view after simulation.loadState
Definition: MSNet.h:591
bool myAmInterrupted
whether an interrupt occured
Definition: MSNet.h:857
void addVehicleStateListener(VehicleStateListener *listener)
Adds a vehicle states listener.
Definition: MSNet.cpp:1164
void clearState(const SUMOTime step, bool quickReload=false)
Resets events when quick-loading state.
Definition: MSNet.cpp:905
void preSimStepOutput() const
Prints the current step number.
Definition: MSNet.cpp:1128
void writeCollisions() const
write collision output to (xml) file
Definition: MSNet.cpp:502
std::vector< SUMOTime > myStateDumpTimes
Times at which a state shall be written.
Definition: MSNet.h:925
void addTransportableStateListener(TransportableStateListener *listener)
Adds a transportable states listener.
Definition: MSNet.cpp:1192
std::vector< MSTractionSubstation * > myTractionSubstations
Dictionary of traction substations.
Definition: MSNet.h:976
SUMOTime myEdgeDataEndTime
end of loaded edgeData
Definition: MSNet.h:970
MSEdgeWeightsStorage & getWeightsStorage()
Returns the net's internal edge travel times/efforts container.
Definition: MSNet.cpp:1119
std::map< std::string, std::map< SUMOVehicleClass, double > > myRestrictions
The vehicle class specific speed restrictions.
Definition: MSNet.h:943
std::vector< std::string > myStateDumpFiles
The names for the state files.
Definition: MSNet.h:927
void addMesoType(const std::string &typeID, const MESegment::MesoEdgeType &edgeType)
Adds edge type specific meso parameters.
Definition: MSNet.cpp:358
void writeRailSignalBlocks() const
write rail signal block output
Definition: MSNet.cpp:1332
MSTLLogicControl * myLogics
Controls tls logics, realizes waiting on tls rules;.
Definition: MSNet.h:875
bool logSimulationDuration() const
Returns whether duration shall be logged.
Definition: MSNet.cpp:1090
long long int myVehiclesMoved
The overall number of vehicle movements.
Definition: MSNet.h:915
static const std::string STAGE_REMOTECONTROL
Definition: MSNet.h:828
void informVehicleStateListener(const SUMOVehicle *const vehicle, VehicleState to, const std::string &info="")
Informs all added listeners about a vehicle's state change.
Definition: MSNet.cpp:1181
std::vector< VehicleStateListener * > myVehicleStateListeners
Container for vehicle state listener.
Definition: MSNet.h:979
SimulationState simulationState(SUMOTime stopTime) const
This method returns the current simulation state. It should not modify status.
Definition: MSNet.cpp:799
long myTraCIStepDuration
The last simulation step duration.
Definition: MSNet.h:906
TransportableState
Definition of a transportable state.
Definition: MSNet.h:680
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition: MSNet.h:432
MSDetectorControl * myDetectorControl
Controls detectors;.
Definition: MSNet.h:879
static const std::string STAGE_LANECHANGE
Definition: MSNet.h:826
MSNet(MSVehicleControl *vc, MSEventControl *beginOfTimestepEvents, MSEventControl *endOfTimestepEvents, MSEventControl *insertionEvents, ShapeContainer *shapeCont=0)
Constructor.
Definition: MSNet.cpp:205
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
Definition: MSNet.cpp:343
std::map< int, SUMOAbstractRouter< MSEdge, SUMOVehicle > * > myRouterTT
Definition: MSNet.h:1004
std::map< std::string, MESegment::MesoEdgeType > myMesoEdgeTypes
The edge type specific meso parameters.
Definition: MSNet.h:946
static void adaptIntermodalRouter(MSIntermodalRouter &router)
Definition: MSNet.cpp:1476
MSEdgeWeightsStorage * myEdgeWeights
The net's knowledge about edge efforts/travel times;.
Definition: MSNet.h:889
MSDynamicShapeUpdater * makeDynamicShapeUpdater()
Creates and returns a dynamic shapes updater.
Definition: MSNet.cpp:1113
std::map< int, MSIntermodalRouter * > myIntermodalRouter
Definition: MSNet.h:1007
virtual ~MSNet()
Destructor.
Definition: MSNet.cpp:291
MSPedestrianRouter & getPedestrianRouter(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition: MSNet.cpp:1417
MSTractionSubstation * findTractionSubstation(const std::string &substationId)
find electrical substation by its id
Definition: MSNet.cpp:1367
static MSNet * myInstance
Unique instance of MSNet.
Definition: MSNet.h:845
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:379
MSInsertionControl * myInserter
Controls vehicle insertion;.
Definition: MSNet.h:877
void postSimStepOutput() const
Prints the statistics of the step at its end.
Definition: MSNet.cpp:1134
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1096
bool registerCollision(const SUMOTrafficObject *collider, const SUMOTrafficObject *victim, const std::string &collisionType, const MSLane *lane, double pos)
register collision and return whether it was the first one involving these vehicles
Definition: MSNet.cpp:1220
static const std::string STAGE_EVENTS
string constants for simstep stages
Definition: MSNet.h:824
void loadRoutes()
loads routes for the next few steps
Definition: MSNet.cpp:426
std::string myStateDumpPrefix
name components for periodic state
Definition: MSNet.h:933
bool myJunctionHigherSpeeds
Whether the network was built with higher speed on junctions.
Definition: MSNet.h:952
MSEdgeControl & getEdgeControl()
Returns the edge control.
Definition: MSNet.h:422
long mySimBeginMillis
The overall simulation duration.
Definition: MSNet.h:909
bool myHasPedestrianNetwork
Whether the network contains pedestrian network elements.
Definition: MSNet.h:958
const MESegment::MesoEdgeType & getMesoType(const std::string &typeID)
Returns edge type specific meso parameters if no type specific parameters have been loaded,...
Definition: MSNet.cpp:363
void writeStatistics() const
write statistic output to (xml) file
Definition: MSNet.cpp:524
bool hasInternalLinks() const
return whether the network contains internal links
Definition: MSNet.h:777
SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterEffort(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition: MSNet.cpp:1407
bool checkWalkingarea()
check all lanes for type walkingArea
Definition: MSNet.cpp:1526
CollisionMap myCollisions
collisions in the current time step
Definition: MSNet.h:985
const NamedObjectCont< MSStoppingPlace * > & getStoppingPlaces(SumoXMLTag category) const
Definition: MSNet.cpp:1310
SimulationState simulate(SUMOTime start, SUMOTime stop)
Simulates from timestep start to stop.
Definition: MSNet.cpp:384
Definition of overhead wire segment.
static void write(OutputDevice &of, SUMOTime timestep)
Export the queueing length in front of a junction (very experimental!)
static void cleanup()
clean up state
static void clearState()
Perform resets events when quick-loading state.
A signal for rails.
Definition: MSRailSignal.h:46
void writeBlocks(OutputDevice &od) const
write rail signal block output for all links and driveways
static void recheckGreen()
final check for driveway compatibility of signals that switched green in this step
Parser and container for routes during their loading.
static void dict_clearState()
Decrement all route references before quick-loading state.
Definition: MSRoute.cpp:303
static void clear()
Clears the dictionary (delete all known routes, too)
Definition: MSRoute.cpp:183
static double getEffortExtra(const MSEdge *const e, const SUMOVehicle *const v, double t)
static SUMOTime getTime(const std::string &fileName)
parse time from state file
Parser and output filter for routes and vehicles state saving and loading.
static void saveState(const std::string &file, SUMOTime step, bool usePrefix=true)
Saves the current state.
static bool active()
Definition: MSStopOut.h:54
static void cleanup()
Definition: MSStopOut.cpp:50
void generateOutputForUnfinished()
generate output for vehicles which are still stopped at simulation end
Definition: MSStopOut.cpp:169
static MSStopOut * getInstance()
Definition: MSStopOut.h:60
A lane area vehicles can halt at.
double getBeginLanePosition() const
Returns the begin position of this stop.
const MSLane & getLane() const
Returns the lane this stop is located at.
A class that stores and controls tls and switching of their programs.
void clearState(SUMOTime time, bool quickReload=false)
Clear all tls states before quick-loading state.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
void check2Switch(SUMOTime step)
Checks whether any WAUT is trying to switch a tls into another program.
Traction substaction powering one or more overhead wire sections.
int getRunningNumber() const
Returns the number of build and inserted, but not yet deleted transportables.
bool hasTransportables() const
checks whether any transportable waits to finish her plan
int getWaitingForVehicleNumber() const
Returns the number of transportables waiting for a ride.
int getEndedNumber() const
Returns the number of transportables that exited the simulation.
void checkWaiting(MSNet *net, const SUMOTime time)
checks whether any transportables waiting time is over
int getArrivedNumber() const
Returns the number of transportables that arrived at their destination.
int getLoadedNumber() const
Returns the number of build transportables.
int getWaitingUntilNumber() const
Returns the number of transportables waiting for a specified amount of time.
void abortAnyWaitingForVehicle()
aborts the plan for any transportable that is still waiting for a ride
bool hasNonWaiting() const
checks whether any transportable is still engaged in walking / stopping
int getMovingNumber() const
Returns the number of transportables moving by themselvs (i.e. walking)
int getJammedNumber() const
Returns the number of times a transportables was jammed.
void clearState()
Resets transportables when quick-loading state.
int getRidingNumber() const
Returns the number of transportables riding a vehicle.
static const std::map< std::string, MSTriggeredRerouter * > & getInstances()
return all rerouter instances
static void write(OutputDevice &of, SUMOTime timestep)
Produce a VTK output to use with Tools like ParaView.
Definition: MSVTKExport.cpp:41
static void init()
Static initalization.
Definition: MSVehicle.cpp:385
static void cleanup()
Static cleanup.
Definition: MSVehicle.cpp:390
The class responsible for building and deletion of vehicles.
int getRunningVehicleNo() const
Returns the number of build and inserted, but not yet deleted vehicles.
void removePending()
Removes a vehicle after it has ended.
double getTotalTravelTime() const
Returns the total travel time.
void adaptIntermodalRouter(MSNet::MSIntermodalRouter &router) const
int getLoadedVehicleNo() const
Returns the number of build vehicles.
int getCollisionCount() const
return the number of collisions
int getTeleportsWrongLane() const
return the number of teleports due to vehicles stuck on the wrong lane
int getStoppedVehiclesCount() const
return the number of vehicles that are currently stopped
int getTeleportsYield() const
return the number of teleports due to vehicles stuck on a minor road
void clearState(const bool reinit)
Remove all vehicles before quick-loading state.
int getEmergencyStops() const
return the number of emergency stops
double getTotalDepartureDelay() const
Returns the total departure delay.
virtual std::pair< double, double > getVehicleMeanSpeeds() const
get current absolute and relative mean vehicle speed in the network
int getDepartedVehicleNo() const
Returns the number of inserted vehicles.
int getArrivedVehicleNo() const
Returns the number of arrived vehicles.
int getActiveVehicleCount() const
Returns the number of build vehicles that have not been removed or need to wait for a passenger or a ...
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
int getTeleportsJam() const
return the number of teleports due to jamming
int getEndedVehicleNo() const
Returns the number of removed vehicles.
virtual int getHaltingVehicleNo() const
Returns the number of halting vehicles.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
int getTeleportCount() const
return the number of teleports (including collisions)
void abortWaiting()
informes about all waiting vehicles (deletion in destructor)
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
BaseInfluencer & getBaseInfluencer()
Returns the velocity/lane influencer.
Definition: MSVehicle.cpp:6781
static MSVehicleTransfer * getInstance()
Returns the instance of this object.
void checkInsertions(SUMOTime time)
Checks "movement" of stored vehicles.
void clearState()
Remove all vehicles before quick-loading state.
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:91
static void write(OutputDevice &of, const MSEdgeControl &ec, SUMOTime timestep, int precision)
Writes the complete network state of the given edges into the given device.
Definition: MSXMLRawOut.cpp:47
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Definition: MsgHandler.cpp:79
static SUMORouteLoaderControl * buildRouteLoaderControl(const OptionsCont &oc)
Builds the route loader control.
Definition: NLBuilder.cpp:424
static void initRandomness()
initializes all RNGs
Definition: NLBuilder.cpp:345
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.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
std::string getValueString(const std::string &name) const
Returns the string-value of the named option (all options)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
static void setArgs(int argc, char **argv)
Stores the command line arguments for later parsing.
Definition: OptionsIO.cpp:58
An output device that encapsulates an ofstream.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:251
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
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.
static void closeAll(bool keepErrorRetrievers=false)
static OutputDevice & getDevice(const std::string &name, bool usePrefix=true)
Returns the described OutputDevice.
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >(), bool includeConfig=true)
Writes an XML header with optional configuration.
void loadNext(SUMOTime step)
loads the next routes up to and including the given time step
Representation of a vehicle, person, or container.
virtual const MSVehicleType & getVehicleType() const =0
Returns the object's "vehicle" type.
virtual double getSpeed() const =0
Returns the object's current speed.
Representation of a vehicle.
Definition: SUMOVehicle.h:60
virtual bool isOnRoad() const =0
Returns the information whether the vehicle is on a road (is simulated)
virtual MSVehicleDevice * getDevice(const std::type_info &type) const =0
Returns a device of the given type if it exists or 0.
A scoped lock which only triggers on condition.
Definition: ScopedLocker.h:40
Storage for geometrical objects.
void clearState()
Remove all dynamics before quick-loading state.
static long getCurrentMillis()
Returns the current time in milliseconds.
Definition: SysUtils.cpp:47
TraCI server used to control sumo by a remote TraCI client.
Definition: TraCIServer.h:59
static bool wasClosed()
check whether close was requested
SUMOTime getTargetTime() const
Definition: TraCIServer.h:64
static TraCIServer * getInstance()
Definition: TraCIServer.h:68
std::vector< std::string > & getLoadArgs()
Definition: TraCIServer.h:258
void cleanup()
clean up subscriptions
void processCommandsUntilSimStep(SUMOTime step)
process all commands until the next SUMO simulation step. It is guaranteed that t->getTargetTime() >=...
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false, const bool isRoute=false)
Runs the given handler on the given file; returns if everything's ok.
Definition: XMLSubSys.cpp:137
static void cleanup()
Definition: Helper.cpp:674
static int postProcessRemoteControl()
return number of remote-controlled entities
Definition: Helper.cpp:1388
TRACI_CONST int ROUTING_MODE_AGGREGATED_CUSTOM
TRACI_CONST int ROUTING_MODE_COMBINED
edge type specific meso parameters
Definition: MESegment.h:55
collision tracking
Definition: MSNet.h:116
double victimSpeed
Definition: MSNet.h:121
const MSLane * lane
Definition: MSNet.h:123
std::string victimType
Definition: MSNet.h:119
double pos
Definition: MSNet.h:124
std::string type
Definition: MSNet.h:122
std::string colliderType
Definition: MSNet.h:118
std::string victim
Definition: MSNet.h:117
double colliderSpeed
Definition: MSNet.h:120
SUMOTime time
Definition: MSNet.h:125