Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
MSNet.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-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/****************************************************************************/
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(TL("A network was not yet constructed."));
188}
189
190void
196
197void
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(TL("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 const MMVersion& 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(TL("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 myInserter = nullptr;
300 delete myLogics;
301 delete myRouteLoaders;
302 if (myPersonControl != nullptr) {
303 delete myPersonControl;
304 myPersonControl = nullptr; // just to have that clear for later cleanups
305 }
306 if (myContainerControl != nullptr) {
307 delete myContainerControl;
308 myContainerControl = nullptr; // just to have that clear for later cleanups
309 }
310 delete myVehicleControl; // must happen after deleting transportables
311 // delete events late so that vehicles can get rid of references first
313 myBeginOfTimestepEvents = nullptr;
315 myEndOfTimestepEvents = nullptr;
316 delete myInsertionEvents;
317 myInsertionEvents = nullptr;
318 delete myShapeContainer;
319 delete myEdgeWeights;
320 for (auto& router : myRouterTT) {
321 delete router.second;
322 }
323 myRouterTT.clear();
324 for (auto& router : myRouterEffort) {
325 delete router.second;
326 }
327 myRouterEffort.clear();
328 for (auto& router : myPedestrianRouter) {
329 delete router.second;
330 }
331 myPedestrianRouter.clear();
332 for (auto& router : myIntermodalRouter) {
333 delete router.second;
334 }
335 myIntermodalRouter.clear();
336 myLanesRTree.second.RemoveAll();
337 clearAll();
339 delete MSGlobals::gMesoNet;
340 }
341 myInstance = nullptr;
342}
343
344
345void
346MSNet::addRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed) {
347 myRestrictions[id][svc] = speed;
348}
349
350
351const std::map<SUMOVehicleClass, double>*
352MSNet::getRestrictions(const std::string& id) const {
353 std::map<std::string, std::map<SUMOVehicleClass, double> >::const_iterator i = myRestrictions.find(id);
354 if (i == myRestrictions.end()) {
355 return nullptr;
356 }
357 return &i->second;
358}
359
360void
361MSNet::addMesoType(const std::string& typeID, const MESegment::MesoEdgeType& edgeType) {
362 myMesoEdgeTypes[typeID] = edgeType;
363}
364
366MSNet::getMesoType(const std::string& typeID) {
367 if (myMesoEdgeTypes.count(typeID) == 0) {
368 // init defaults
371 edgeType.tauff = string2time(oc.getString("meso-tauff"));
372 edgeType.taufj = string2time(oc.getString("meso-taufj"));
373 edgeType.taujf = string2time(oc.getString("meso-taujf"));
374 edgeType.taujj = string2time(oc.getString("meso-taujj"));
375 edgeType.jamThreshold = oc.getFloat("meso-jam-threshold");
376 edgeType.junctionControl = oc.getBool("meso-junction-control");
377 edgeType.tlsPenalty = oc.getFloat("meso-tls-penalty");
378 edgeType.tlsFlowPenalty = oc.getFloat("meso-tls-flow-penalty");
379 edgeType.minorPenalty = string2time(oc.getString("meso-minor-penalty"));
380 edgeType.overtaking = oc.getBool("meso-overtaking");
381 myMesoEdgeTypes[typeID] = edgeType;
382 }
383 return myMesoEdgeTypes[typeID];
384}
385
386
387bool
388MSNet::hasFlow(const std::string& id) const {
389 // inserter is deleted at the end of the simulation
390 return myInserter != nullptr && myInserter->hasFlow(id);
391}
392
393
396 // report the begin when wished
397 WRITE_MESSAGEF(TL("Simulation version % started with time: %."), VERSION_STRING, time2string(start));
398 // the simulation loop
400 // state loading may have changed the start time so we need to reinit it
401 myStep = start;
402 int numSteps = 0;
403 bool doStepLog = false;
404 while (state == SIMSTATE_RUNNING) {
405 doStepLog = myLogStepNumber && (numSteps % myLogStepPeriod == 0);
406 if (doStepLog) {
408 }
410 if (doStepLog) {
412 }
413 state = adaptToState(simulationState(stop));
414#ifdef DEBUG_SIMSTEP
415 std::cout << SIMTIME << " MSNet::simulate(" << start << ", " << stop << ")"
416 << "\n simulation state: " << getStateMessage(state)
417 << std::endl;
418#endif
419 numSteps++;
420 }
421 if (myLogStepNumber && !doStepLog) {
422 // ensure some output on the last step
425 }
426 // exit simulation loop
427 if (myLogStepNumber) {
428 // start new line for final verbose output
429 std::cout << "\n";
430 }
431 closeSimulation(start, getStateMessage(state));
432 return state;
433}
434
435
436void
440
441
442const std::string
443MSNet::generateStatistics(const SUMOTime start, const long now) {
444 std::ostringstream msg;
445 if (myLogExecutionTime) {
446 const long duration = now - mySimBeginMillis;
447 // print performance notice
448 msg << "Performance: " << "\n" << " Duration: " << elapsedMs2string(duration) << "\n";
449 if (duration != 0) {
450 if (TraCIServer::getInstance() != nullptr) {
451 msg << " TraCI-Duration: " << elapsedMs2string(myTraCIMillis) << "\n";
452 }
453 msg << " Real time factor: " << (STEPS2TIME(myStep - start) * 1000. / (double)duration) << "\n";
454 msg.setf(std::ios::fixed, std::ios::floatfield); // use decimal format
455 msg.setf(std::ios::showpoint); // print decimal point
456 msg << " UPS: " << ((double)myVehiclesMoved / ((double)duration / 1000)) << "\n";
457 if (myPersonsMoved > 0) {
458 msg << " UPS-Persons: " << ((double)myPersonsMoved / ((double)duration / 1000)) << "\n";
459 }
460 }
461 // print vehicle statistics
462 const std::string discardNotice = ((myVehicleControl->getLoadedVehicleNo() != myVehicleControl->getDepartedVehicleNo()) ?
463 " (Loaded: " + toString(myVehicleControl->getLoadedVehicleNo()) + ")" : "");
464 msg << "Vehicles: " << "\n"
465 << " Inserted: " << myVehicleControl->getDepartedVehicleNo() << discardNotice << "\n"
466 << " Running: " << myVehicleControl->getRunningVehicleNo() << "\n"
467 << " Waiting: " << myInserter->getWaitingVehicleNo() << "\n";
468
470 // print optional teleport statistics
471 std::vector<std::string> reasons;
473 reasons.push_back("Collisions: " + toString(myVehicleControl->getCollisionCount()));
474 }
476 reasons.push_back("Jam: " + toString(myVehicleControl->getTeleportsJam()));
477 }
479 reasons.push_back("Yield: " + toString(myVehicleControl->getTeleportsYield()));
480 }
482 reasons.push_back("Wrong Lane: " + toString(myVehicleControl->getTeleportsWrongLane()));
483 }
484 msg << " Teleports: " << myVehicleControl->getTeleportCount() << " (" << joinToString(reasons, ", ") << ")\n";
485 }
487 msg << " Emergency Stops: " << myVehicleControl->getEmergencyStops() << "\n";
488 }
490 msg << " Emergency Braking: " << myVehicleControl->getEmergencyBrakingCount() << "\n";
491 }
492 if (myPersonControl != nullptr && myPersonControl->getLoadedNumber() > 0) {
493 msg << "Persons: " << "\n"
494 << " Inserted: " << myPersonControl->getLoadedNumber() << "\n"
495 << " Running: " << myPersonControl->getRunningNumber() << "\n";
496 if (myPersonControl->getJammedNumber() > 0) {
497 msg << " Jammed: " << myPersonControl->getJammedNumber() << "\n";
498 }
500 std::vector<std::string> reasons;
502 reasons.push_back("Abort Wait: " + toString(myPersonControl->getTeleportsAbortWait()));
503 }
505 reasons.push_back("Wrong Dest: " + toString(myPersonControl->getTeleportsWrongDest()));
506 }
507 msg << " Teleports: " << myPersonControl->getTeleportCount() << " (" << joinToString(reasons, ", ") << ")\n";
508 }
509 }
510 if (myContainerControl != nullptr && myContainerControl->getLoadedNumber() > 0) {
511 msg << "Containers: " << "\n"
512 << " Inserted: " << myContainerControl->getLoadedNumber() << "\n"
513 << " Running: " << myContainerControl->getRunningNumber() << "\n";
515 msg << " Jammed: " << myContainerControl->getJammedNumber() << "\n";
516 }
518 std::vector<std::string> reasons;
520 reasons.push_back("Abort Wait: " + toString(myContainerControl->getTeleportsAbortWait()));
521 }
523 reasons.push_back("Wrong Dest: " + toString(myContainerControl->getTeleportsWrongDest()));
524 }
525 msg << " Teleports: " << myContainerControl->getTeleportCount() << " (" << joinToString(reasons, ", ") << ")\n";
526 }
527 }
528 }
529 if (OptionsCont::getOptions().getBool("duration-log.statistics")) {
531 }
532 return msg.str();
533}
534
535
536void
538 OutputDevice& od = OutputDevice::getDeviceByOption("collision-output");
539 for (const auto& item : myCollisions) {
540 for (const auto& c : item.second) {
541 od.openTag("collision");
543 od.writeAttr("type", c.type);
544 od.writeAttr("lane", c.lane->getID());
545 od.writeAttr("pos", c.pos);
546 od.writeAttr("collider", item.first);
547 od.writeAttr("victim", c.victim);
548 od.writeAttr("colliderType", c.colliderType);
549 od.writeAttr("victimType", c.victimType);
550 od.writeAttr("colliderSpeed", c.colliderSpeed);
551 od.writeAttr("victimSpeed", c.victimSpeed);
552 od.closeTag();
553 }
554 }
555}
556
557
558void
559MSNet::writeStatistics(const SUMOTime start, const long now) const {
560 const long duration = now - mySimBeginMillis;
561 OutputDevice& od = OutputDevice::getDeviceByOption("statistic-output");
562 od.openTag("performance");
563 od.writeAttr("clockBegin", time2string(mySimBeginMillis));
564 od.writeAttr("clockEnd", time2string(now));
565 od.writeAttr("clockDuration", time2string(duration));
566 od.writeAttr("traciDuration", time2string(myTraCIMillis));
567 od.writeAttr("realTimeFactor", duration != 0 ? (double)(myStep - start) / (double)duration : -1);
568 od.writeAttr("vehicleUpdatesPerSecond", duration != 0 ? (double)myVehiclesMoved / ((double)duration / 1000) : -1);
569 od.writeAttr("personUpdatesPerSecond", duration != 0 ? (double)myPersonsMoved / ((double)duration / 1000) : -1);
570 od.writeAttr("begin", time2string(start));
571 od.writeAttr("end", time2string(myStep));
572 od.writeAttr("duration", time2string(myStep - start));
573 od.closeTag();
574 od.openTag("vehicles");
578 od.writeAttr("waiting", myInserter->getWaitingVehicleNo());
579 od.closeTag();
580 od.openTag("teleports");
585 od.closeTag();
586 od.openTag("safety");
587 od.writeAttr("collisions", myVehicleControl->getCollisionCount());
588 od.writeAttr("emergencyStops", myVehicleControl->getEmergencyStops());
589 od.writeAttr("emergencyBraking", myVehicleControl->getEmergencyBrakingCount());
590 od.closeTag();
591 od.openTag("persons");
592 od.writeAttr("loaded", myPersonControl != nullptr ? myPersonControl->getLoadedNumber() : 0);
593 od.writeAttr("running", myPersonControl != nullptr ? myPersonControl->getRunningNumber() : 0);
594 od.writeAttr("jammed", myPersonControl != nullptr ? myPersonControl->getJammedNumber() : 0);
595 od.closeTag();
596 od.openTag("personTeleports");
597 od.writeAttr("total", myPersonControl != nullptr ? myPersonControl->getTeleportCount() : 0);
598 od.writeAttr("abortWait", myPersonControl != nullptr ? myPersonControl->getTeleportsAbortWait() : 0);
599 od.writeAttr("wrongDest", myPersonControl != nullptr ? myPersonControl->getTeleportsWrongDest() : 0);
600 od.closeTag();
601 if (OptionsCont::getOptions().isSet("tripinfo-output") || OptionsCont::getOptions().getBool("duration-log.statistics")) {
603 }
604
605}
606
607
608void
610 // summary output
612 const bool hasOutput = oc.isSet("summary-output");
613 const bool hasPersonOutput = oc.isSet("person-summary-output");
614 if (hasOutput || hasPersonOutput) {
615 const SUMOTime period = string2time(oc.getString("summary-output.period"));
616 const SUMOTime begin = string2time(oc.getString("begin"));
617 if (period > 0 && (myStep - begin) % period != 0) {
618 return;
619 }
620 }
621 if (hasOutput) {
622 OutputDevice& od = OutputDevice::getDeviceByOption("summary-output");
623 int departedVehiclesNumber = myVehicleControl->getDepartedVehicleNo();
624 const double meanWaitingTime = departedVehiclesNumber != 0 ? myVehicleControl->getTotalDepartureDelay() / (double) departedVehiclesNumber : -1.;
625 int endedVehicleNumber = myVehicleControl->getEndedVehicleNo();
626 const double meanTravelTime = endedVehicleNumber != 0 ? myVehicleControl->getTotalTravelTime() / (double) endedVehicleNumber : -1.;
627 od.openTag("step");
628 od.writeAttr("time", time2string(myStep));
632 od.writeAttr("waiting", myInserter->getWaitingVehicleNo());
635 od.writeAttr("collisions", myVehicleControl->getCollisionCount());
636 od.writeAttr("teleports", myVehicleControl->getTeleportCount());
639 od.writeAttr("meanWaitingTime", meanWaitingTime);
640 od.writeAttr("meanTravelTime", meanTravelTime);
641 std::pair<double, double> meanSpeed = myVehicleControl->getVehicleMeanSpeeds();
642 od.writeAttr("meanSpeed", meanSpeed.first);
643 od.writeAttr("meanSpeedRelative", meanSpeed.second);
644 if (myLogExecutionTime) {
645 od.writeAttr("duration", mySimStepDuration);
646 }
647 od.closeTag();
648 }
649 if (hasPersonOutput) {
650 OutputDevice& od = OutputDevice::getDeviceByOption("person-summary-output");
652 od.openTag("step");
653 od.writeAttr("time", time2string(myStep));
654 od.writeAttr("loaded", pc.getLoadedNumber());
655 od.writeAttr("inserted", pc.getDepartedNumber());
656 od.writeAttr("walking", pc.getMovingNumber());
657 od.writeAttr("waitingForRide", pc.getWaitingForVehicleNumber());
658 od.writeAttr("riding", pc.getRidingNumber());
659 od.writeAttr("stopping", pc.getWaitingUntilNumber());
660 od.writeAttr("jammed", pc.getJammedNumber());
661 od.writeAttr("ended", pc.getEndedNumber());
662 od.writeAttr("arrived", pc.getArrivedNumber());
663 od.writeAttr("teleports", pc.getTeleportCount());
664 if (myLogExecutionTime) {
665 od.writeAttr("duration", mySimStepDuration);
666 }
667 od.closeTag();
668 }
669}
670
671
672void
673MSNet::closeSimulation(SUMOTime start, const std::string& reason) {
674 // report the end when wished
675 WRITE_MESSAGE("Simulation ended at time: " + time2string(getCurrentTimeStep()));
676 if (reason != "") {
677 WRITE_MESSAGE("Reason: " + reason);
678 }
680 if (MSStopOut::active() && OptionsCont::getOptions().getBool("stop-output.write-unfinished")) {
682 }
683 MSDevice_Vehroutes::writePendingOutput(OptionsCont::getOptions().getBool("vehroute-output.write-unfinished"));
684 if (OptionsCont::getOptions().getBool("tripinfo-output.write-unfinished")) {
686 }
687 if (OptionsCont::getOptions().isSet("chargingstations-output")) {
689 }
690 if (OptionsCont::getOptions().isSet("overheadwiresegments-output")) {
692 }
693 if (OptionsCont::getOptions().isSet("substations-output")) {
695 }
696 if (OptionsCont::getOptions().isSet("railsignal-block-output")) {
698 }
699 const long now = SysUtils::getCurrentMillis();
700 if (myLogExecutionTime || OptionsCont::getOptions().getBool("duration-log.statistics")) {
702 }
703 if (OptionsCont::getOptions().isSet("statistic-output")) {
704 writeStatistics(start, now);
705 }
706}
707
708
709void
710MSNet::simulationStep(const bool onlyMove) {
712 postMoveStep();
714 return;
715 }
716#ifdef DEBUG_SIMSTEP
717 std::cout << SIMTIME << ": MSNet::simulationStep() called"
718 << ", myStep = " << myStep
719 << std::endl;
720#endif
722 int lastTraCICmd = 0;
723 if (t != nullptr) {
724 if (myLogExecutionTime) {
726 }
727 lastTraCICmd = t->processCommands(myStep);
728#ifdef DEBUG_SIMSTEP
729 bool loadRequested = !TraCI::getLoadArgs().empty();
730 assert(t->getTargetTime() >= myStep || loadRequested || TraCIServer::wasClosed());
731#endif
732 if (myLogExecutionTime) {
734 }
735 if (TraCIServer::wasClosed() || !t->getLoadArgs().empty()) {
736 return;
737 }
738 }
739#ifdef DEBUG_SIMSTEP
740 std::cout << SIMTIME << ": TraCI target time: " << t->getTargetTime() << std::endl;
741#endif
742 // execute beginOfTimestepEvents
743 if (myLogExecutionTime) {
745 }
746 // simulation state output
747 std::vector<SUMOTime>::iterator timeIt = std::find(myStateDumpTimes.begin(), myStateDumpTimes.end(), myStep);
748 if (timeIt != myStateDumpTimes.end()) {
749 const int dist = (int)distance(myStateDumpTimes.begin(), timeIt);
751 }
752 if (myStateDumpPeriod > 0 && myStep % myStateDumpPeriod == 0) {
753 std::string timeStamp = time2string(myStep);
754 std::replace(timeStamp.begin(), timeStamp.end(), ':', '-');
755 const std::string filename = myStateDumpPrefix + "_" + timeStamp + myStateDumpSuffix;
757 myPeriodicStateFiles.push_back(filename);
758 int keep = OptionsCont::getOptions().getInt("save-state.period.keep");
759 if (keep > 0 && (int)myPeriodicStateFiles.size() > keep) {
760 std::remove(myPeriodicStateFiles.front().c_str());
762 }
763 }
766#ifdef HAVE_FOX
767 MSRoutingEngine::waitForAll();
768#endif
771 }
772 // check whether the tls programs need to be switched
774
777 } else {
778 // assure all lanes with vehicles are 'active'
780
781 // compute safe velocities for all vehicles for the next few lanes
782 // also register ApproachingVehicleInformation for all links
784
785 // register junction approaches based on planned velocities as basis for right-of-way decision
787
788 // decide right-of-way and execute movements
792 }
793
794 // vehicles may change lanes
796
799 }
800 }
801 // flush arrived meso vehicles and micro vehicles that were removed due to collision
803 loadRoutes();
804
805 // persons
808 }
809 // containers
812 }
813 // insert vehicles
816#ifdef HAVE_FOX
817 MSRoutingEngine::waitForAll();
818#endif
821 //myEdges->patchActiveLanes(); // @note required to detect collisions on lanes that were empty before insertion. wasteful?
823 }
825
826 // execute endOfTimestepEvents
828
829 if (myLogExecutionTime) {
831 }
832 if (onlyMove) {
834 return;
835 }
836 if (t != nullptr && lastTraCICmd == libsumo::CMD_EXECUTEMOVE) {
837 t->processCommands(myStep, true);
838 }
839 postMoveStep();
840}
841
842
843void
845 const int numControlled = libsumo::Helper::postProcessRemoteControl();
846 if (numControlled > 0 && MSGlobals::gCheck4Accidents) {
848 }
849 if (myLogExecutionTime) {
852 }
854 // collisions from the previous step were kept to avoid duplicate
855 // warnings. we must remove them now to ensure correct output.
857 }
858 // update and write (if needed) detector values
860 writeOutput();
861
862 if (myLogExecutionTime) {
864 if (myPersonControl != nullptr) {
866 }
867 }
868 myStep += DELTA_T;
869}
870
871
876 }
877 if (TraCIServer::getInstance() != nullptr && !TraCIServer::getInstance()->getLoadArgs().empty()) {
878 return SIMSTATE_LOADING;
879 }
880 if ((stopTime < 0 || myStep > stopTime) && TraCIServer::getInstance() == nullptr && (stopTime > 0 || myStep > myEdgeDataEndTime)) {
883 && (myPersonControl == nullptr || !myPersonControl->hasNonWaiting())
887 }
888 }
889 if (stopTime >= 0 && myStep >= stopTime) {
891 }
894 }
895 if (myAmInterrupted) {
897 }
898 return SIMSTATE_RUNNING;
899}
900
901
903MSNet::adaptToState(MSNet::SimulationState state, const bool isLibsumo) const {
904 if (state == SIMSTATE_LOADING) {
907 } else if (state != SIMSTATE_RUNNING && ((TraCIServer::getInstance() != nullptr && !TraCIServer::wasClosed()) || isLibsumo)) {
908 // overrides SIMSTATE_END_STEP_REACHED, e.g. (TraCI / Libsumo ignore SUMO's --end option)
909 return SIMSTATE_RUNNING;
910 } else if (state == SIMSTATE_NO_FURTHER_VEHICLES) {
911 if (myPersonControl != nullptr) {
913 }
914 if (myContainerControl != nullptr) {
916 }
918 }
919 return state;
920}
921
922
923std::string
925 switch (state) {
927 return "";
929 return "The final simulation step has been reached.";
931 return "All vehicles have left the simulation.";
933 return "TraCI requested termination.";
935 return "An error occurred (see log).";
937 return "Interrupted.";
939 return "Too many teleports.";
941 return "TraCI issued load command.";
942 default:
943 return "Unknown reason.";
944 }
945}
946
947
948void
950 // clear container
957 while (!MSLaneSpeedTrigger::getInstances().empty()) {
958 delete MSLaneSpeedTrigger::getInstances().begin()->second;
959 }
960 while (!MSTriggeredRerouter::getInstances().empty()) {
961 delete MSTriggeredRerouter::getInstances().begin()->second;
962 }
970 if (t != nullptr) {
971 t->cleanup();
972 }
975}
976
977
978void
979MSNet::clearState(const SUMOTime step, bool quickReload) {
983 for (MSEdge* const edge : MSEdge::getAllEdges()) {
984 for (MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge); s != nullptr; s = s->getNextSegment()) {
985 s->clearState();
986 }
987 }
988 } else {
989 for (MSEdge* const edge : MSEdge::getAllEdges()) {
990 for (MSLane* const lane : edge->getLanes()) {
991 lane->getVehiclesSecure();
992 lane->clearState();
993 lane->releaseVehicles();
994 }
995 edge->clearState();
996 }
997 }
999 // detectors may still reference persons/vehicles
1003
1004 if (myPersonControl != nullptr) {
1006 }
1007 if (myContainerControl != nullptr) {
1009 }
1010 // delete vtypes after transportables have removed their types
1014 // delete all routes after vehicles and detector output is done
1016 for (auto& item : myStoppingPlaces) {
1017 for (auto& item2 : item.second) {
1018 item2.second->clearState();
1019 }
1020 }
1026 myStep = step;
1027 MSGlobals::gClearState = false;
1028}
1029
1030
1031void
1033 // update detector values
1036
1037 // check state dumps
1038 if (oc.isSet("netstate-dump")) {
1040 oc.getInt("netstate-dump.precision"));
1041 }
1042
1043 // check fcd dumps
1044 if (OptionsCont::getOptions().isSet("fcd-output")) {
1046 }
1047
1048 // check emission dumps
1049 if (OptionsCont::getOptions().isSet("emission-output")) {
1051 oc.getInt("emission-output.precision"));
1052 }
1053
1054 // battery dumps
1055 if (OptionsCont::getOptions().isSet("battery-output")) {
1057 oc.getInt("battery-output.precision"));
1058 }
1059
1060 // elecHybrid dumps
1061 if (OptionsCont::getOptions().isSet("elechybrid-output")) {
1062 std::string output = OptionsCont::getOptions().getString("elechybrid-output");
1063
1064 if (oc.getBool("elechybrid-output.aggregated")) {
1065 // build a xml file with aggregated device.elechybrid output
1067 oc.getInt("elechybrid-output.precision"));
1068 } else {
1069 // build a separate xml file for each vehicle equipped with device.elechybrid
1070 // RICE_TODO: Does this have to be placed here in MSNet.cpp ?
1072 for (MSVehicleControl::constVehIt it = vc.loadedVehBegin(); it != vc.loadedVehEnd(); ++it) {
1073 const SUMOVehicle* veh = it->second;
1074 if (!veh->isOnRoad()) {
1075 continue;
1076 }
1077 if (static_cast<MSDevice_ElecHybrid*>(veh->getDevice(typeid(MSDevice_ElecHybrid))) != nullptr) {
1078 std::string vehID = veh->getID();
1079 std::string filename2 = output + "_" + vehID + ".xml";
1080 OutputDevice& dev = OutputDevice::getDevice(filename2);
1081 std::map<SumoXMLAttr, std::string> attrs;
1082 attrs[SUMO_ATTR_VEHICLE] = vehID;
1085 dev.writeXMLHeader("elecHybrid-export", "", attrs);
1086 MSElecHybridExport::write(OutputDevice::getDevice(filename2), veh, myStep, oc.getInt("elechybrid-output.precision"));
1087 }
1088 }
1089 }
1090 }
1091
1092
1093 // check full dumps
1094 if (OptionsCont::getOptions().isSet("full-output")) {
1097 }
1098
1099 // check queue dumps
1100 if (OptionsCont::getOptions().isSet("queue-output")) {
1102 }
1103
1104 // check amitran dumps
1105 if (OptionsCont::getOptions().isSet("amitran-output")) {
1107 }
1108
1109 // check vtk dumps
1110 if (OptionsCont::getOptions().isSet("vtk-output")) {
1111
1112 if (MSNet::getInstance()->getVehicleControl().getRunningVehicleNo() > 0) {
1113 std::string timestep = time2string(myStep);
1114 timestep = timestep.substr(0, timestep.length() - 3);
1115 std::string output = OptionsCont::getOptions().getString("vtk-output");
1116 std::string filename = output + "_" + timestep + ".vtp";
1117
1118 OutputDevice_File dev(filename, false);
1119
1120 //build a huge mass of xml files
1122
1123 }
1124
1125 }
1126
1128
1129 // write detector values
1131
1132 // write link states
1133 if (OptionsCont::getOptions().isSet("link-output")) {
1134 OutputDevice& od = OutputDevice::getDeviceByOption("link-output");
1135 od.openTag("timestep");
1137 for (const MSEdge* const edge : myEdges->getEdges()) {
1138 for (const MSLane* const lane : edge->getLanes()) {
1139 for (const MSLink* const link : lane->getLinkCont()) {
1140 link->writeApproaching(od, lane->getID());
1141 }
1142 }
1143 }
1144 od.closeTag();
1145 }
1146
1147 // write SSM output
1149 dev->updateAndWriteOutput();
1150 }
1151
1152 // write ToC output
1154 if (dev->generatesOutput()) {
1155 dev->writeOutput();
1156 }
1157 }
1158
1159 if (OptionsCont::getOptions().isSet("collision-output")) {
1161 }
1162}
1163
1164
1165bool
1169
1170
1173 if (myPersonControl == nullptr) {
1175 }
1176 return *myPersonControl;
1177}
1178
1179
1182 if (myContainerControl == nullptr) {
1184 }
1185 return *myContainerControl;
1186}
1187
1190 myDynamicShapeUpdater = std::unique_ptr<MSDynamicShapeUpdater> (new MSDynamicShapeUpdater(*myShapeContainer));
1191 return myDynamicShapeUpdater.get();
1192}
1193
1196 if (myEdgeWeights == nullptr) {
1198 }
1199 return *myEdgeWeights;
1200}
1201
1202
1203void
1205 std::cout << "Step #" << time2string(myStep);
1206}
1207
1208
1209void
1211 if (myLogExecutionTime) {
1212 std::ostringstream oss;
1213 oss.setf(std::ios::fixed, std::ios::floatfield); // use decimal format
1214 oss.setf(std::ios::showpoint); // print decimal point
1215 oss << std::setprecision(gPrecision);
1216 if (mySimStepDuration != 0) {
1217 const double durationSec = (double)mySimStepDuration / 1000.;
1218 oss << " (" << mySimStepDuration << "ms ~= "
1219 << (TS / durationSec) << "*RT, ~"
1220 << ((double) myVehicleControl->getRunningVehicleNo() / durationSec);
1221 } else {
1222 oss << " (0ms ?*RT. ?";
1223 }
1224 oss << "UPS, ";
1225 if (TraCIServer::getInstance() != nullptr) {
1226 oss << "TraCI: " << myTraCIStepDuration << "ms, ";
1227 }
1228 oss << "vehicles TOT " << myVehicleControl->getDepartedVehicleNo()
1229 << " ACT " << myVehicleControl->getRunningVehicleNo()
1230 << " BUF " << myInserter->getWaitingVehicleNo()
1231 << ") ";
1232 std::string prev = "Step #" + time2string(myStep - DELTA_T);
1233 std::cout << oss.str().substr(0, 90 - prev.length());
1234 }
1235 std::cout << '\r';
1236}
1237
1238
1239void
1241 if (find(myVehicleStateListeners.begin(), myVehicleStateListeners.end(), listener) == myVehicleStateListeners.end()) {
1242 myVehicleStateListeners.push_back(listener);
1243 }
1244}
1245
1246
1247void
1249 std::vector<VehicleStateListener*>::iterator i = std::find(myVehicleStateListeners.begin(), myVehicleStateListeners.end(), listener);
1250 if (i != myVehicleStateListeners.end()) {
1251 myVehicleStateListeners.erase(i);
1252 }
1253}
1254
1255
1256void
1257MSNet::informVehicleStateListener(const SUMOVehicle* const vehicle, VehicleState to, const std::string& info) {
1258#ifdef HAVE_FOX
1259 ScopedLocker<> lock(myVehicleStateListenerMutex, MSGlobals::gNumThreads > 1);
1260#endif
1261 for (VehicleStateListener* const listener : myVehicleStateListeners) {
1262 listener->vehicleStateChanged(vehicle, to, info);
1263 }
1264}
1265
1266
1267void
1273
1274
1275void
1277 std::vector<TransportableStateListener*>::iterator i = std::find(myTransportableStateListeners.begin(), myTransportableStateListeners.end(), listener);
1278 if (i != myTransportableStateListeners.end()) {
1280 }
1281}
1282
1283
1284void
1285MSNet::informTransportableStateListener(const MSTransportable* const transportable, TransportableState to, const std::string& info) {
1286#ifdef HAVE_FOX
1287 ScopedLocker<> lock(myTransportableStateListenerMutex, MSGlobals::gNumThreads > 1);
1288#endif
1290 listener->transportableStateChanged(transportable, to, info);
1291 }
1292}
1293
1294
1295bool
1296MSNet::registerCollision(const SUMOTrafficObject* collider, const SUMOTrafficObject* victim, const std::string& collisionType, const MSLane* lane, double pos) {
1297 auto it = myCollisions.find(collider->getID());
1298 if (it != myCollisions.end()) {
1299 for (Collision& old : it->second) {
1300 if (old.victim == victim->getID()) {
1301 // collision from previous step continues
1302 old.colliderSpeed = collider->getSpeed();
1303 old.victimSpeed = victim->getSpeed();
1304 old.type = collisionType;
1305 old.lane = lane;
1306 old.pos = pos;
1307 old.time = myStep;
1308 return false;
1309 }
1310 }
1311 }
1312 Collision c;
1313 c.victim = victim->getID();
1314 c.colliderType = collider->getVehicleType().getID();
1315 c.victimType = victim->getVehicleType().getID();
1316 c.colliderSpeed = collider->getSpeed();
1317 c.victimSpeed = victim->getSpeed();
1318 c.type = collisionType;
1319 c.lane = lane;
1320 c.pos = pos;
1321 c.time = myStep;
1322 myCollisions[collider->getID()].push_back(c);
1323 return true;
1324}
1325
1326
1327void
1329 for (auto it = myCollisions.begin(); it != myCollisions.end();) {
1330 for (auto it2 = it->second.begin(); it2 != it->second.end();) {
1331 if (it2->time != myStep) {
1332 it2 = it->second.erase(it2);
1333 } else {
1334 it2++;
1335 }
1336 }
1337 if (it->second.size() == 0) {
1338 it = myCollisions.erase(it);
1339 } else {
1340 it++;
1341 }
1342 }
1343}
1344
1345
1346bool
1348 return myStoppingPlaces[category == SUMO_TAG_TRAIN_STOP ? SUMO_TAG_BUS_STOP : category].add(stop->getID(), stop);
1349}
1350
1351
1352bool
1354 if (find(myTractionSubstations.begin(), myTractionSubstations.end(), substation) == myTractionSubstations.end()) {
1355 myTractionSubstations.push_back(substation);
1356 return true;
1357 }
1358 return false;
1359}
1360
1361
1363MSNet::getStoppingPlace(const std::string& id, const SumoXMLTag category) const {
1364 if (myStoppingPlaces.count(category) > 0) {
1365 return myStoppingPlaces.find(category)->second.get(id);
1366 }
1367 return nullptr;
1368}
1369
1370
1371std::string
1372MSNet::getStoppingPlaceID(const MSLane* lane, const double pos, const SumoXMLTag category) const {
1373 if (myStoppingPlaces.count(category) > 0) {
1374 for (const auto& it : myStoppingPlaces.find(category)->second) {
1375 MSStoppingPlace* stop = it.second;
1376 if (&stop->getLane() == lane && stop->getBeginLanePosition() - POSITION_EPS <= pos && stop->getEndLanePosition() + POSITION_EPS >= pos) {
1377 return stop->getID();
1378 }
1379 }
1380 }
1381 return "";
1382}
1383
1384
1387 auto it = myStoppingPlaces.find(category);
1388 if (it != myStoppingPlaces.end()) {
1389 return it->second;
1390 } else {
1392 }
1393}
1394
1395
1396void
1399 OutputDevice& output = OutputDevice::getDeviceByOption("chargingstations-output");
1400 for (const auto& it : myStoppingPlaces.find(SUMO_TAG_CHARGING_STATION)->second) {
1401 static_cast<MSChargingStation*>(it.second)->writeChargingStationOutput(output);
1402 }
1403 }
1404}
1405
1406
1407void
1409 OutputDevice& output = OutputDevice::getDeviceByOption("railsignal-block-output");
1410 for (auto tls : myLogics->getAllLogics()) {
1411 MSRailSignal* rs = dynamic_cast<MSRailSignal*>(tls);
1412 if (rs != nullptr) {
1413 rs->writeBlocks(output);
1414 }
1415 }
1416}
1417
1418
1419void
1422 OutputDevice& output = OutputDevice::getDeviceByOption("overheadwiresegments-output");
1423 for (const auto& it : myStoppingPlaces.find(SUMO_TAG_OVERHEAD_WIRE_SEGMENT)->second) {
1424 static_cast<MSOverheadWire*>(it.second)->writeOverheadWireSegmentOutput(output);
1425 }
1426 }
1427}
1428
1429
1430void
1432 if (myTractionSubstations.size() > 0) {
1433 OutputDevice& output = OutputDevice::getDeviceByOption("substations-output");
1434 output.setPrecision(OptionsCont::getOptions().getInt("substations-output.precision"));
1435 for (auto& it : myTractionSubstations) {
1436 it->writeTractionSubstationOutput(output);
1437 }
1438 }
1439}
1440
1441
1443MSNet::findTractionSubstation(const std::string& substationId) {
1444 for (std::vector<MSTractionSubstation*>::iterator it = myTractionSubstations.begin(); it != myTractionSubstations.end(); ++it) {
1445 if ((*it)->getID() == substationId) {
1446 return *it;
1447 }
1448 }
1449 return nullptr;
1450}
1451
1452
1453bool
1454MSNet::existTractionSubstation(const std::string& substationId) {
1455 for (std::vector<MSTractionSubstation*>::iterator it = myTractionSubstations.begin(); it != myTractionSubstations.end(); ++it) {
1456 if ((*it)->getID() == substationId) {
1457 return true;
1458 }
1459 }
1460 return false;
1461}
1462
1463
1465MSNet::getRouterTT(const int rngIndex, const MSEdgeVector& prohibited) const {
1466 if (myRouterTT.count(rngIndex) == 0) {
1467 const std::string routingAlgorithm = OptionsCont::getOptions().getString("routing-algorithm");
1468 if (routingAlgorithm == "dijkstra") {
1469 myRouterTT[rngIndex] = new DijkstraRouter<MSEdge, SUMOVehicle>(MSEdge::getAllEdges(), true, &MSNet::getTravelTime, nullptr, false, nullptr, true);
1470 } else {
1471 if (routingAlgorithm != "astar") {
1472 WRITE_WARNINGF(TL("TraCI and Triggers cannot use routing algorithm '%'. using 'astar' instead."), routingAlgorithm);
1473 }
1475 }
1476 }
1477 myRouterTT[rngIndex]->prohibit(prohibited);
1478 return *myRouterTT[rngIndex];
1479}
1480
1481
1483MSNet::getRouterEffort(const int rngIndex, const MSEdgeVector& prohibited) const {
1484 if (myRouterEffort.count(rngIndex) == 0) {
1486 }
1487 myRouterEffort[rngIndex]->prohibit(prohibited);
1488 return *myRouterEffort[rngIndex];
1489}
1490
1491
1493MSNet::getPedestrianRouter(const int rngIndex, const MSEdgeVector& prohibited) const {
1494 if (myPedestrianRouter.count(rngIndex) == 0) {
1495 myPedestrianRouter[rngIndex] = new MSPedestrianRouter();
1496 }
1497 myPedestrianRouter[rngIndex]->prohibit(prohibited);
1498 return *myPedestrianRouter[rngIndex];
1499}
1500
1501
1503MSNet::getIntermodalRouter(const int rngIndex, const int routingMode, const MSEdgeVector& prohibited) const {
1505 const int key = rngIndex * oc.getInt("thread-rngs") + routingMode;
1506 if (myIntermodalRouter.count(key) == 0) {
1507 int carWalk = 0;
1508 for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
1509 if (opt == "parkingAreas") {
1510 carWalk |= MSIntermodalRouter::Network::PARKING_AREAS;
1511 } else if (opt == "ptStops") {
1512 carWalk |= MSIntermodalRouter::Network::PT_STOPS;
1513 } else if (opt == "allJunctions") {
1514 carWalk |= MSIntermodalRouter::Network::ALL_JUNCTIONS;
1515 }
1516 }
1517 // XXX there is currently no reason to combine multiple values, thus getValueString rather than getStringVector
1518 const std::string& taxiDropoff = oc.getValueString("persontrip.transfer.taxi-walk");
1519 const std::string& taxiPickup = oc.getValueString("persontrip.transfer.walk-taxi");
1520 if (taxiDropoff == "") {
1521 if (MSDevice_Taxi::getTaxi() != nullptr) {
1522 carWalk |= MSIntermodalRouter::Network::TAXI_DROPOFF_ANYWHERE;
1523 }
1524 } else if (taxiDropoff == "ptStops") {
1525 carWalk |= MSIntermodalRouter::Network::TAXI_DROPOFF_PT;
1526 } else if (taxiDropoff == "allJunctions") {
1527 carWalk |= MSIntermodalRouter::Network::TAXI_DROPOFF_ANYWHERE;
1528 }
1529 if (taxiPickup == "") {
1530 if (MSDevice_Taxi::getTaxi() != nullptr) {
1531 carWalk |= MSIntermodalRouter::Network::TAXI_PICKUP_ANYWHERE;
1532 }
1533 } else if (taxiPickup == "ptStops") {
1534 carWalk |= MSIntermodalRouter::Network::TAXI_PICKUP_PT;
1535 } else if (taxiPickup == "allJunctions") {
1536 carWalk |= MSIntermodalRouter::Network::TAXI_PICKUP_ANYWHERE;
1537 }
1538 const std::string routingAlgorithm = OptionsCont::getOptions().getString("routing-algorithm");
1539 double taxiWait = STEPS2TIME(string2time(OptionsCont::getOptions().getString("persontrip.taxi.waiting-time")));
1540 if (routingMode == libsumo::ROUTING_MODE_COMBINED) {
1541 myIntermodalRouter[key] = new MSIntermodalRouter(MSNet::adaptIntermodalRouter, carWalk, taxiWait, routingAlgorithm, routingMode, new FareModul());
1542 } else {
1543 myIntermodalRouter[key] = new MSIntermodalRouter(MSNet::adaptIntermodalRouter, carWalk, taxiWait, routingAlgorithm, routingMode);
1544 }
1545 }
1546 myIntermodalRouter[key]->prohibit(prohibited);
1547 return *myIntermodalRouter[key];
1548}
1549
1550
1551void
1553 double taxiWait = STEPS2TIME(string2time(OptionsCont::getOptions().getString("persontrip.taxi.waiting-time")));
1554 // add access to all parking areas
1555 EffortCalculator* const external = router.getExternalEffort();
1556 for (const auto& stopType : myInstance->myStoppingPlaces) {
1557 // add access to all stopping places
1558 const SumoXMLTag element = stopType.first;
1559 for (const auto& i : stopType.second) {
1560 const MSEdge* const edge = &i.second->getLane().getEdge();
1561 router.getNetwork()->addAccess(i.first, edge, i.second->getBeginLanePosition(), i.second->getEndLanePosition(),
1562 i.second->getAccessDistance(edge), element, false, taxiWait);
1563 if (element == SUMO_TAG_BUS_STOP) {
1564 // add access to all public transport stops
1565 for (const auto& a : i.second->getAllAccessPos()) {
1566 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);
1567 }
1568 if (external != nullptr) {
1569 external->addStop(router.getNetwork()->getStopEdge(i.first)->getNumericalID(), *i.second);
1570 }
1571 }
1572 }
1573 }
1576 // add access to transfer from walking to taxi-use
1577 if ((router.getCarWalkTransfer() & MSIntermodalRouter::Network::TAXI_PICKUP_ANYWHERE) != 0) {
1578 for (MSEdge* edge : myInstance->getEdgeControl().getEdges()) {
1579 if ((edge->getPermissions() & SVC_PEDESTRIAN) != 0 && (edge->getPermissions() & SVC_TAXI) != 0) {
1580 router.getNetwork()->addCarAccess(edge, SVC_TAXI, taxiWait);
1581 }
1582 }
1583 }
1584}
1585
1586
1587bool
1589 const MSEdgeVector& edges = myEdges->getEdges();
1590 for (MSEdgeVector::const_iterator e = edges.begin(); e != edges.end(); ++e) {
1591 for (std::vector<MSLane*>::const_iterator i = (*e)->getLanes().begin(); i != (*e)->getLanes().end(); ++i) {
1592 if ((*i)->getShape().hasElevation()) {
1593 return true;
1594 }
1595 }
1596 }
1597 return false;
1598}
1599
1600
1601bool
1603 for (const MSEdge* e : myEdges->getEdges()) {
1604 if (e->getFunction() == SumoXMLEdgeFunc::WALKINGAREA) {
1605 return true;
1606 }
1607 }
1608 return false;
1609}
1610
1611
1612bool
1614 for (const MSEdge* e : myEdges->getEdges()) {
1615 if (e->getBidiEdge() != nullptr) {
1616 return true;
1617 }
1618 }
1619 return false;
1620}
1621
1622bool
1623MSNet::warnOnce(const std::string& typeAndID) {
1624 if (myWarnedOnce.find(typeAndID) == myWarnedOnce.end()) {
1625 myWarnedOnce[typeAndID] = true;
1626 return true;
1627 }
1628 return false;
1629}
1630
1631void
1634 clearState(string2time(oc.getString("begin")), true);
1636 // load traffic from additional files
1637 for (std::string file : oc.getStringVector("additional-files")) {
1638 // ignore failure on parsing calibrator flow
1639 MSRouteHandler rh(file, true);
1640 const long before = PROGRESS_BEGIN_TIME_MESSAGE("Loading traffic from '" + file + "'");
1641 if (!XMLSubSys::runParser(rh, file, false)) {
1642 throw ProcessError(TLF("Loading of % failed.", file));
1643 }
1644 PROGRESS_TIME_MESSAGE(before);
1645 }
1646 delete myRouteLoaders;
1648 updateGUI();
1649}
1650
1651
1653MSNet::loadState(const std::string& fileName, const bool catchExceptions) {
1654 // load time only
1655 const SUMOTime newTime = MSStateHandler::MSStateTimeHandler::getTime(fileName);
1656 // clean up state
1657 clearState(newTime);
1658 // load state
1659 MSStateHandler h(fileName, 0);
1660 XMLSubSys::runParser(h, fileName, false, false, false, catchExceptions);
1661 if (MsgHandler::getErrorInstance()->wasInformed()) {
1662 throw ProcessError(TLF("Loading state from '%' failed.", fileName));
1663 }
1664 // reset route loaders
1665 delete myRouteLoaders;
1667 // prevent loading errors on rewound route file
1669
1670 updateGUI();
1671 return newTime;
1672}
1673
1674
1675/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
std::vector< MSEdge * > MSEdgeVector
Definition MSEdge.h:73
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_MESSAGEF(...)
Definition MsgHandler.h:273
#define WRITE_MESSAGE(msg)
Definition MsgHandler.h:272
#define PROGRESS_BEGIN_TIME_MESSAGE(msg)
Definition MsgHandler.h:276
#define TL(string)
Definition MsgHandler.h:287
#define PROGRESS_TIME_MESSAGE(before)
Definition MsgHandler.h:277
#define TLF(string,...)
Definition MsgHandler.h:288
std::string elapsedMs2string(long long int t)
convert ms to string for log output
Definition SUMOTime.cpp:118
SUMOTime DELTA_T
Definition SUMOTime.cpp:38
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
#define STEPS2TIME(x)
Definition SUMOTime.h:55
#define TS
Definition SUMOTime.h:42
#define SIMTIME
Definition SUMOTime.h:62
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:26
std::pair< int, double > MMVersion
(M)ajor/(M)inor version for written networks and default version for loading
Definition StdDefs.h:67
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition ToString.h:283
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.
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:230
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)
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.
static void cleanup()
Closes root tags of output files.
static const std::set< MSDevice_ToC *, ComparatorNumericalIdLess > & getInstances()
returns all currently existing ToC devices
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 writePendingOutput(const bool includeUnfinished)
generate vehroute output for pending vehicles at sim end, either due to sorting or because they are s...
static void cleanupAll()
perform cleanup for all devices
Definition MSDevice.cpp:140
Stores edges and lanes, performs moving of vehicle.
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.
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:172
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:140
static bool gHaveEmissions
Whether emission output of some type is needed (files or GUI)
Definition MSGlobals.h:178
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:146
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.
bool hasFlow(const std::string &id) const
checks whether the given flow still exists
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:2348
static const std::map< std::string, MSLaneSpeedTrigger * > & getInstances()
return all MSLaneSpeedTrigger instances
Interface for objects listening to transportable state changes.
Definition MSNet.h:696
Interface for objects listening to vehicle state changes.
Definition MSNet.h:637
The simulated network and simulation perfomer.
Definition MSNet.h:88
std::map< SumoXMLTag, NamedObjectCont< MSStoppingPlace * > > myStoppingPlaces
Dictionary of bus / container stops.
Definition MSNet.h:986
long myTraCIMillis
The overall time spent waiting for traci operations including.
Definition MSNet.h:925
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:1623
SUMOTime loadState(const std::string &fileName, const bool catchExceptions)
load state from file and return new time
Definition MSNet.cpp:1653
std::map< int, SUMOAbstractRouter< MSEdge, SUMOVehicle > * > myRouterEffort
Definition MSNet.h:1018
MSIntermodalRouter & getIntermodalRouter(const int rngIndex, const int routingMode=0, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition MSNet.cpp:1503
bool myLogExecutionTime
Information whether the simulation duration shall be logged.
Definition MSNet.h:911
MSTransportableControl * myPersonControl
Controls person building and deletion;.
Definition MSNet.h:880
void removeVehicleStateListener(VehicleStateListener *listener)
Removes a vehicle states listener.
Definition MSNet.cpp:1248
SUMORouteLoaderControl * myRouteLoaders
Route loader for dynamic loading of routes.
Definition MSNet.h:858
bool addStoppingPlace(const SumoXMLTag category, MSStoppingPlace *stop)
Adds a stopping place.
Definition MSNet.cpp:1347
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:1285
SUMOTime myStateDumpPeriod
The period for writing state.
Definition MSNet.h:944
static const NamedObjectCont< MSStoppingPlace * > myEmptyStoppingPlaceCont
Definition MSNet.h:1007
void writeOverheadWireSegmentOutput() const
write the output generated by an overhead wire segment
Definition MSNet.cpp:1420
void writeChargingStationOutput() const
write charging station output
Definition MSNet.cpp:1397
std::pair< bool, NamedRTree > myLanesRTree
An RTree structure holding lane IDs.
Definition MSNet.h:1023
bool checkBidiEdges()
check wether bidirectional edges occur in the network
Definition MSNet.cpp:1613
VehicleState
Definition of a vehicle state.
Definition MSNet.h:604
int myLogStepPeriod
Period between successive step-log outputs.
Definition MSNet.h:916
SUMOTime myStep
Current time step.
Definition MSNet.h:861
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:974
MSEventControl * myBeginOfTimestepEvents
Controls events executed at the begin of a time step;.
Definition MSNet.h:894
bool addTractionSubstation(MSTractionSubstation *substation)
Adds a traction substation.
Definition MSNet.cpp:1353
std::map< std::string, bool > myWarnedOnce
container to record warnings that shall only be issued once
Definition MSNet.h:1010
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:1328
MSJunctionControl * myJunctions
Controls junctions, realizes right-of-way rules;.
Definition MSNet.h:886
std::vector< std::string > myPeriodicStateFiles
The names of the last K periodic state files (only only K shall be kept)
Definition MSNet.h:942
ShapeContainer * myShapeContainer
A container for geometrical shapes;.
Definition MSNet.h:900
std::string myStateDumpSuffix
Definition MSNet.h:947
bool checkElevation()
check all lanes for elevation data
Definition MSNet.cpp:1588
bool existTractionSubstation(const std::string &substationId)
return whether given electrical substation exists in the network
Definition MSNet.cpp:1454
void removeTransportableStateListener(TransportableStateListener *listener)
Removes a transportable states listener.
Definition MSNet.cpp:1276
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:903
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, const MMVersion &version)
Closes the network's building process.
Definition MSNet.cpp:256
bool myLogStepNumber
Information whether the number of the simulation step shall be logged.
Definition MSNet.h:914
MMVersion myVersion
the network version
Definition MSNet.h:980
MSEventControl * myInsertionEvents
Controls insertion events;.
Definition MSNet.h:898
virtual MSTransportableControl & getContainerControl()
Returns the container control.
Definition MSNet.cpp:1181
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:1465
std::map< int, MSPedestrianRouter * > myPedestrianRouter
Definition MSNet.h:1019
static const std::string STAGE_MOVEMENTS
Definition MSNet.h:831
bool hasFlow(const std::string &id) const
return whether the given flow is known
Definition MSNet.cpp:388
int myMaxTeleports
Maximum number of teleports.
Definition MSNet.h:867
long mySimStepDuration
Definition MSNet.h:919
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:896
static std::string getStateMessage(SimulationState state)
Returns the message to show if a certain state occurs.
Definition MSNet.cpp:924
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:1372
bool myHasInternalLinks
Whether the network contains internal links/lanes/edges.
Definition MSNet.h:962
void writeSubstationOutput() const
write electrical substation output
Definition MSNet.cpp:1431
static const std::string STAGE_INSERTIONS
Definition MSNet.h:833
long long int myPersonsMoved
Definition MSNet.h:929
void quickReload()
reset state to the beginning without reloading the network
Definition MSNet.cpp:1632
MSVehicleControl * myVehicleControl
Controls vehicle building and deletion;.
Definition MSNet.h:878
static void clearAll()
Clears all dictionaries.
Definition MSNet.cpp:949
static void cleanupStatic()
Place for static initializations of simulation components (called after successful net build)
Definition MSNet.cpp:198
void writeStatistics(const SUMOTime start, const long now) const
write statistic output to (xml) file
Definition MSNet.cpp:559
IntermodalRouter< MSEdge, MSLane, MSJunction, SUMOVehicle > MSIntermodalRouter
Definition MSNet.h:113
void writeSummaryOutput()
write summary-output to (xml) file
Definition MSNet.cpp:609
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition MSNet.h:322
MSEdgeControl * myEdges
Controls edges, performs vehicle movement;.
Definition MSNet.h:884
std::unique_ptr< MSDynamicShapeUpdater > myDynamicShapeUpdater
Updater for dynamic shapes that are tracking traffic objects (ensures removal of shape dynamics when ...
Definition MSNet.h:1028
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:352
void closeSimulation(SUMOTime start, const std::string &reason="")
Closes the simulation (all files, connections, etc.)
Definition MSNet.cpp:673
MSStoppingPlace * getStoppingPlace(const std::string &id, const SumoXMLTag category) const
Returns the named stopping place of the given category.
Definition MSNet.cpp:1363
bool myHasElevation
Whether the network contains elevation data.
Definition MSNet.h:968
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:882
std::vector< TransportableStateListener * > myTransportableStateListeners
Container for transportable state listener.
Definition MSNet.h:995
void writeOutput()
Write netstate, summary and detector output.
Definition MSNet.cpp:1032
virtual void updateGUI() const
update view after simulation.loadState
Definition MSNet.h:592
bool myAmInterrupted
whether an interrupt occured
Definition MSNet.h:870
void simulationStep(const bool onlyMove=false)
Performs a single simulation step.
Definition MSNet.cpp:710
void addVehicleStateListener(VehicleStateListener *listener)
Adds a vehicle states listener.
Definition MSNet.cpp:1240
void clearState(const SUMOTime step, bool quickReload=false)
Resets events when quick-loading state.
Definition MSNet.cpp:979
void preSimStepOutput() const
Prints the current step number.
Definition MSNet.cpp:1204
void writeCollisions() const
write collision output to (xml) file
Definition MSNet.cpp:537
std::vector< SUMOTime > myStateDumpTimes
Times at which a state shall be written.
Definition MSNet.h:938
void addTransportableStateListener(TransportableStateListener *listener)
Adds a transportable states listener.
Definition MSNet.cpp:1268
std::vector< MSTractionSubstation * > myTractionSubstations
Dictionary of traction substations.
Definition MSNet.h:989
SUMOTime myEdgeDataEndTime
end of loaded edgeData
Definition MSNet.h:983
MSEdgeWeightsStorage & getWeightsStorage()
Returns the net's internal edge travel times/efforts container.
Definition MSNet.cpp:1195
std::map< std::string, std::map< SUMOVehicleClass, double > > myRestrictions
The vehicle class specific speed restrictions.
Definition MSNet.h:956
std::vector< std::string > myStateDumpFiles
The names for the state files.
Definition MSNet.h:940
void addMesoType(const std::string &typeID, const MESegment::MesoEdgeType &edgeType)
Adds edge type specific meso parameters.
Definition MSNet.cpp:361
void writeRailSignalBlocks() const
write rail signal block output
Definition MSNet.cpp:1408
MSTLLogicControl * myLogics
Controls tls logics, realizes waiting on tls rules;.
Definition MSNet.h:888
bool logSimulationDuration() const
Returns whether duration shall be logged.
Definition MSNet.cpp:1166
long long int myVehiclesMoved
The overall number of vehicle movements.
Definition MSNet.h:928
static const std::string STAGE_REMOTECONTROL
Definition MSNet.h:834
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:1257
std::vector< VehicleStateListener * > myVehicleStateListeners
Container for vehicle state listener.
Definition MSNet.h:992
SimulationState simulationState(SUMOTime stopTime) const
This method returns the current simulation state. It should not modify status.
Definition MSNet.cpp:873
long myTraCIStepDuration
The last simulation step duration.
Definition MSNet.h:919
TransportableState
Definition of a transportable state.
Definition MSNet.h:681
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition MSNet.h:433
MSDetectorControl * myDetectorControl
Controls detectors;.
Definition MSNet.h:892
bool myStepCompletionMissing
whether libsumo triggered a partial step (executeMove)
Definition MSNet.h:864
static const std::string STAGE_LANECHANGE
Definition MSNet.h:832
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:346
std::map< int, SUMOAbstractRouter< MSEdge, SUMOVehicle > * > myRouterTT
Definition MSNet.h:1017
std::map< std::string, MESegment::MesoEdgeType > myMesoEdgeTypes
The edge type specific meso parameters.
Definition MSNet.h:959
static void adaptIntermodalRouter(MSIntermodalRouter &router)
Definition MSNet.cpp:1552
MSEdgeWeightsStorage * myEdgeWeights
The net's knowledge about edge efforts/travel times;.
Definition MSNet.h:902
MSDynamicShapeUpdater * makeDynamicShapeUpdater()
Creates and returns a dynamic shapes updater.
Definition MSNet.cpp:1189
std::map< int, MSIntermodalRouter * > myIntermodalRouter
Definition MSNet.h:1020
virtual ~MSNet()
Destructor.
Definition MSNet.cpp:291
MSPedestrianRouter & getPedestrianRouter(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition MSNet.cpp:1493
MSTractionSubstation * findTractionSubstation(const std::string &substationId)
find electrical substation by its id
Definition MSNet.cpp:1443
static MSNet * myInstance
Unique instance of MSNet.
Definition MSNet.h:855
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition MSNet.h:380
MSInsertionControl * myInserter
Controls vehicle insertion;.
Definition MSNet.h:890
void postSimStepOutput() const
Prints the statistics of the step at its end.
Definition MSNet.cpp:1210
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition MSNet.cpp:1172
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:1296
static const std::string STAGE_EVENTS
string constants for simstep stages
Definition MSNet.h:830
void loadRoutes()
loads routes for the next few steps
Definition MSNet.cpp:437
std::string myStateDumpPrefix
name components for periodic state
Definition MSNet.h:946
bool myJunctionHigherSpeeds
Whether the network was built with higher speed on junctions.
Definition MSNet.h:965
MSEdgeControl & getEdgeControl()
Returns the edge control.
Definition MSNet.h:423
long mySimBeginMillis
The overall simulation duration.
Definition MSNet.h:922
bool myHasPedestrianNetwork
Whether the network contains pedestrian network elements.
Definition MSNet.h:971
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:366
void postMoveStep()
Performs the parts of the simulation step which happen after the move.
Definition MSNet.cpp:844
bool hasInternalLinks() const
return whether the network contains internal links
Definition MSNet.h:778
const std::string generateStatistics(const SUMOTime start, const long now)
Writes performance output and running vehicle stats.
Definition MSNet.cpp:443
SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterEffort(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition MSNet.cpp:1483
bool checkWalkingarea()
check all lanes for type walkingArea
Definition MSNet.cpp:1602
CollisionMap myCollisions
collisions in the current time step
Definition MSNet.h:998
const NamedObjectCont< MSStoppingPlace * > & getStoppingPlaces(SumoXMLTag category) const
Definition MSNet.cpp:1386
SimulationState simulate(SUMOTime start, SUMOTime stop)
Simulates from timestep start to stop.
Definition MSNet.cpp:395
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.
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:301
static void clear()
Clears the dictionary (delete all known routes, too)
Definition MSRoute.cpp:174
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
static MSStopOut * getInstance()
Definition MSStopOut.h:60
A lane area vehicles can halt at.
double getBeginLanePosition() const
Returns the begin position of this stop.
double getEndLanePosition() const
Returns the end 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 getTeleportCount() const
Returns the number of teleports transportables did.
int getLoadedNumber() const
Returns the number of build transportables.
int getWaitingUntilNumber() const
Returns the number of transportables waiting for a specified amount of time.
int getTeleportsWrongDest() const
return the number of teleports of transportables riding to the wrong destination
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 getTeleportsAbortWait() const
return the number of teleports due to excessive waiting for a ride
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.
static void init()
Static initalization.
static void cleanup()
Static cleanup.
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 getEmergencyBrakingCount() const
return the number of emergency stops
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.
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.
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.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
static SUMORouteLoaderControl * buildRouteLoaderControl(const OptionsCont &oc)
Builds the route loader control.
static void initRandomness()
initializes all RNGs
const std::string & getID() const
Returns the id.
Definition Named.h:74
A map of named object pointers.
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.
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.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
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:62
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.
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:43
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()
void cleanup()
clean up subscriptions
int processCommands(const SUMOTime step, const bool afterMove=false)
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, const bool isExternal=false, const bool catchExceptions=true)
Runs the given handler on the given file; returns if everything's ok.
static void cleanup()
Definition Helper.cpp:677
static int postProcessRemoteControl()
return number of remote-controlled entities
Definition Helper.cpp:1392
TRACI_CONST int CMD_EXECUTEMOVE
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
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