Eclipse SUMO - Simulation of Urban MObility
NLHandler.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/****************************************************************************/
23// The XML-Handler for network loading
24/****************************************************************************/
25#include <config.h>
26
27#include <string>
28#include "NLHandler.h"
31#include "NLDetectorBuilder.h"
32#include "NLTriggerBuilder.h"
41#include <microsim/MSGlobals.h>
42#include <microsim/MSLane.h>
43#include <microsim/MSJunction.h>
49#include <mesosim/MESegment.h>
54#include <utils/shapes/Shape.h>
55
56
57// ===========================================================================
58// method definitions
59// ===========================================================================
60NLHandler::NLHandler(const std::string& file, MSNet& net,
61 NLDetectorBuilder& detBuilder,
62 NLTriggerBuilder& triggerBuilder,
63 NLEdgeControlBuilder& edgeBuilder,
64 NLJunctionControlBuilder& junctionBuilder) :
65 MSRouteHandler(file, true),
66 myNet(net), myActionBuilder(net),
67 myCurrentIsInternalToSkip(false),
68 myDetectorBuilder(detBuilder), myTriggerBuilder(triggerBuilder),
69 myEdgeControlBuilder(edgeBuilder), myJunctionControlBuilder(junctionBuilder),
70 myAmParsingTLLogicOrJunction(false), myCurrentIsBroken(false),
71 myHaveWarnedAboutInvalidTLType(false),
72 myHaveSeenInternalEdge(false),
73 myHaveJunctionHigherSpeeds(false),
74 myHaveSeenDefaultLength(false),
75 myHaveSeenNeighs(false),
76 myHaveSeenAdditionalSpeedRestrictions(false),
77 myHaveSeenMesoEdgeType(false),
78 myNetworkVersion(0),
79 myNetIsLoaded(false) {
80}
81
82
84
85
86void
88 const SUMOSAXAttributes& attrs) {
89 try {
90 switch (element) {
91 case SUMO_TAG_NET: {
92 bool ok;
93 MSGlobals::gLefthand = attrs.getOpt<bool>(SUMO_ATTR_LEFTHAND, nullptr, ok, false);
94 myHaveJunctionHigherSpeeds = attrs.getOpt<bool>(SUMO_ATTR_HIGHER_SPEED, nullptr, ok, false);
95 myNetworkVersion = attrs.get<double>(SUMO_ATTR_VERSION, nullptr, ok, false);
96 break;
97 }
98 case SUMO_TAG_EDGE:
99 beginEdgeParsing(attrs);
100 break;
101 case SUMO_TAG_LANE:
102 addLane(attrs);
103 break;
104 case SUMO_TAG_NEIGH:
107 }
108 myHaveSeenNeighs = true;
109 break;
111 openJunction(attrs);
112 initJunctionLogic(attrs);
113 break;
114 case SUMO_TAG_PHASE:
115 addPhase(attrs);
116 break;
118 addCondition(attrs);
119 break;
121 addAssignment(attrs);
122 break;
124 addFunction(attrs);
125 break;
127 addConnection(attrs);
128 break;
129 case SUMO_TAG_TLLOGIC:
131 break;
132 case SUMO_TAG_REQUEST:
133 addRequest(attrs);
134 break;
135 case SUMO_TAG_WAUT:
136 openWAUT(attrs);
137 break;
139 addWAUTSwitch(attrs);
140 break;
142 addWAUTJunction(attrs);
143 break;
146 addE1Detector(attrs);
147 break;
150 addE2Detector(attrs);
151 break;
154 beginE3Detector(attrs);
155 break;
157 addE3Entry(attrs);
158 break;
160 addE3Exit(attrs);
161 break;
164 break;
165 case SUMO_TAG_VSS:
167 break;
170 break;
173 break;
179 break;
182 break;
186 break;
187 case SUMO_TAG_ACCESS:
189 break;
193 break;
196 break;
199 break;
202 break;
205 break;
208 break;
211 break;
214 break;
217 break;
220 break;
223 break;
225 setLocation(attrs);
226 break;
227 case SUMO_TAG_TAZ:
228 addDistrict(attrs);
229 break;
231 addDistrictEdge(attrs, true);
232 break;
233 case SUMO_TAG_TAZSINK:
234 addDistrictEdge(attrs, false);
235 break;
237 addRoundabout(attrs);
238 break;
239 case SUMO_TAG_TYPE: {
240 bool ok = true;
241 myCurrentTypeID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
242 break;
243 }
245 bool ok = true;
246 const SUMOVehicleClass svc = getVehicleClassID(attrs.get<std::string>(SUMO_ATTR_VCLASS, myCurrentTypeID.c_str(), ok));
247 const double speed = attrs.get<double>(SUMO_ATTR_SPEED, myCurrentTypeID.c_str(), ok);
248 if (ok) {
250 }
251 if (myNetIsLoaded) {
253 }
254 break;
255 }
256 case SUMO_TAG_MESO: {
257 addMesoEdgeType(attrs);
258 break;
259 }
260 case SUMO_TAG_STOPOFFSET: {
261 bool ok = true;
262 const StopOffset stopOffset(attrs, ok);
263 if (!ok) {
265 } else {
267 }
268 break;
269 }
271 bool ok = true;
272 const std::string signalID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
273 if (!MSNet::getInstance()->getTLSControl().knows(signalID)) {
274 throw InvalidArgument("Rail signal '" + signalID + "' in railSignalConstraints is not known");
275 }
277 if (myConstrainedSignal == nullptr) {
278 throw InvalidArgument("Traffic light '" + signalID + "' is not a rail signal");
279 }
280 break;
281 }
282 case SUMO_TAG_PREDECESSOR: // intended fall-through
283 case SUMO_TAG_FOE_INSERTION: // intended fall-through
284 case SUMO_TAG_INSERTION_PREDECESSOR: // intended fall-through
285 case SUMO_TAG_INSERTION_ORDER: // intended fall-through
288 break;
289 default:
290 break;
291 }
292 } catch (InvalidArgument& e) {
293 myCurrentIsBroken = true;
294 WRITE_ERROR(e.what());
295 }
296 MSRouteHandler::myStartElement(element, attrs);
297 if (element == SUMO_TAG_PARAM && !myCurrentIsBroken) {
298 addParam(attrs);
299 }
300}
301
302
303void
305 switch (element) {
306 case SUMO_TAG_EDGE:
307 closeEdge();
308 break;
309 case SUMO_TAG_LANE:
312 myLastParameterised.pop_back();
313 }
314 break;
316 if (!myCurrentIsBroken) {
317 try {
320 } catch (InvalidArgument& e) {
321 WRITE_ERROR(e.what());
322 }
323 }
325 break;
326 case SUMO_TAG_TLLOGIC:
327 if (!myCurrentIsBroken) {
328 try {
330 } catch (InvalidArgument& e) {
331 WRITE_ERROR(e.what());
332 }
333 }
335 break;
338 break;
339 case SUMO_TAG_WAUT:
340 closeWAUT();
341 break;
343 myConstrainedSignal = nullptr;
344 break;
350 if (!myCurrentIsBroken) {
351 myLastParameterised.pop_back();
352 }
353 break;
357 if (!myCurrentIsBroken) {
358 myLastParameterised.pop_back();
359 }
360 break;
363 myLastParameterised.pop_back();
364 break;
370 myLastParameterised.pop_back();
371 break;
372 case SUMO_TAG_PREDECESSOR: // intended fall-through
373 case SUMO_TAG_FOE_INSERTION: // intended fall-through
374 case SUMO_TAG_INSERTION_PREDECESSOR: // intended fall-through
375 case SUMO_TAG_INSERTION_ORDER: // intended fall-through
377 myLastParameterised.pop_back();
378 break;
379 case SUMO_TAG_NET:
380 // build junction graph
381 for (JunctionGraph::iterator it = myJunctionGraph.begin(); it != myJunctionGraph.end(); ++it) {
382 MSEdge* edge = MSEdge::dictionary(it->first);
383 MSJunction* from = myJunctionControlBuilder.retrieve(it->second.first);
384 MSJunction* to = myJunctionControlBuilder.retrieve(it->second.second);
385 if (from == nullptr) {
386 WRITE_ERROR("Unknown from-node '" + it->second.first + "' for edge '" + it->first + "'.");
387 return;
388 }
389 if (to == nullptr) {
390 WRITE_ERROR("Unknown to-node '" + it->second.second + "' for edge '" + it->first + "'.");
391 return;
392 }
393 if (edge != nullptr) {
394 edge->setJunctions(from, to);
395 from->addOutgoing(edge);
396 to->addIncoming(edge);
397 }
398 }
399 myNetIsLoaded = true;
400 break;
401 default:
402 break;
403 }
405}
406
407
408
409// ---- the root/edge - element
410void
412 bool ok = true;
413 myCurrentIsBroken = false;
414 // get the id, report an error if not given or empty...
415 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
416 if (!ok) {
417 myCurrentIsBroken = true;
418 return;
419 }
420 // parse the function
422 if (!ok) {
423 myCurrentIsBroken = true;
424 return;
425 }
426 // omit internal edges if not wished
427 if (id[0] == ':') {
431 return;
432 }
433 std::string junctionID = SUMOXMLDefinitions::getJunctionIDFromInternalEdge(id);
434 myJunctionGraph[id] = std::make_pair(junctionID, junctionID);
435 } else {
437 myJunctionGraph[id] = std::make_pair(
438 attrs.get<std::string>(SUMO_ATTR_FROM, id.c_str(), ok),
439 attrs.get<std::string>(SUMO_ATTR_TO, id.c_str(), ok));
440 }
441 if (!ok) {
442 myCurrentIsBroken = true;
443 return;
444 }
446 // get the street name
447 const std::string streetName = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
448 // get the edge type
449 const std::string edgeType = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
450 // get the edge priority (only for visualization)
451 const int priority = attrs.getOpt<int>(SUMO_ATTR_PRIORITY, id.c_str(), ok, -1); // default taken from netbuild/NBFrame option 'default.priority'
452 // get the bidi-edge
453 const std::string bidi = attrs.getOpt<std::string>(SUMO_ATTR_BIDI, id.c_str(), ok, "");
454 // get the kilometrage/mileage (for visualization and output)
455 const double distance = attrs.getOpt<double>(SUMO_ATTR_DISTANCE, id.c_str(), ok, 0);
456
457 if (!ok) {
458 myCurrentIsBroken = true;
459 return;
460 }
461 //
462 try {
463 myEdgeControlBuilder.beginEdgeParsing(id, func, streetName, edgeType, priority, bidi, distance);
464 } catch (InvalidArgument& e) {
465 WRITE_ERROR(e.what());
466 myCurrentIsBroken = true;
467 }
468
469 if (func == SumoXMLEdgeFunc::CROSSING) {
470 //get the crossingEdges attribute (to implement the other side of the road pushbutton)
471 const std::string crossingEdges = attrs.getOpt<std::string>(SUMO_ATTR_CROSSING_EDGES, id.c_str(), ok, "");
472 if (!crossingEdges.empty()) {
473 std::vector<std::string> crossingEdgesVector;
474 StringTokenizer edges(crossingEdges);
475 while (edges.hasNext()) {
476 crossingEdgesVector.push_back(edges.next());
477 }
478 myEdgeControlBuilder.addCrossingEdges(crossingEdgesVector);
479 }
480 }
483}
484
485
486void
488 myLastParameterised.clear();
489 // omit internal edges if not wished and broken edges
491 return;
492 }
493 try {
495 MSEdge::dictionary(e->getID(), e);
497 } catch (InvalidArgument& e) {
498 WRITE_ERROR(e.what());
499 }
500}
501
502
503// ---- the root/edge/lanes/lane - element
504void
506 // omit internal edges if not wished and broken edges
508 return;
509 }
510 bool ok = true;
511 // get the id, report an error if not given or empty...
512 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
513 if (!ok) {
514 myCurrentIsBroken = true;
515 return;
516 }
517 const double maxSpeed = attrs.get<double>(SUMO_ATTR_SPEED, id.c_str(), ok);
518 const double friction = attrs.getOpt<double>(SUMO_ATTR_FRICTION, id.c_str(), ok, (double)(1.), false);
519 const double length = attrs.get<double>(SUMO_ATTR_LENGTH, id.c_str(), ok);
520 const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, id.c_str(), ok, "", false);
521 const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, id.c_str(), ok, "");
522 const std::string changeLeftS = attrs.getOpt<std::string>(SUMO_ATTR_CHANGE_LEFT, id.c_str(), ok, "");
523 const std::string changeRightS = attrs.getOpt<std::string>(SUMO_ATTR_CHANGE_RIGHT, id.c_str(), ok, "");
524 const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), ok, SUMO_const_laneWidth);
525 const PositionVector shape = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok);
526 const int index = attrs.get<int>(SUMO_ATTR_INDEX, id.c_str(), ok);
527 const bool isRampAccel = attrs.getOpt<bool>(SUMO_ATTR_ACCELERATION, id.c_str(), ok, false);
528 const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
529 if (shape.size() < 2) {
530 WRITE_ERROR("Shape of lane '" + id + "' is broken.\n Can not build according edge.");
531 myCurrentIsBroken = true;
532 return;
533 }
534 const SVCPermissions permissions = parseVehicleClasses(allow, disallow, myNetworkVersion);
535 SVCPermissions changeLeft = parseVehicleClasses(changeLeftS, "", myNetworkVersion);
536 SVCPermissions changeRight = parseVehicleClasses(changeRightS, "", myNetworkVersion);
538 // internally, changeLeft always checks for the higher lane index
539 // even though the higher lane index is to the right in a left-hand network
540 std::swap(changeLeft, changeRight);
541 }
542 if (permissions != SVCAll || changeLeft != SVCAll || changeRight != SVCAll) {
544 }
545 myCurrentIsBroken |= !ok;
546 if (!myCurrentIsBroken) {
547 try {
548 MSLane* lane = myEdgeControlBuilder.addLane(id, maxSpeed, friction, length, shape, width, permissions, changeLeft, changeRight, index, isRampAccel, type);
549 // insert the lane into the lane-dictionary, checking
550 if (!MSLane::dictionary(id, lane)) {
551 delete lane;
552 WRITE_ERROR("Another lane with the id '" + id + "' exists.");
553 myCurrentIsBroken = true;
554 myLastParameterised.push_back(nullptr);
555 } else {
556 myLastParameterised.push_back(lane);
557 }
558 } catch (InvalidArgument& e) {
559 WRITE_ERROR(e.what());
560 }
561 }
562}
563
564
565// ---- the root/junction - element
566void
568 myCurrentIsBroken = false;
569 bool ok = true;
570 // get the id, report an error if not given or empty...
571 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
572 if (!ok) {
573 myCurrentIsBroken = true;
574 return;
575 }
576 PositionVector shape;
577 if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
578 // inner junctions have no shape
579 shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok, PositionVector());
580 if (shape.size() > 2) {
581 shape.closePolygon();
582 }
583 }
584 double x = attrs.get<double>(SUMO_ATTR_X, id.c_str(), ok);
585 double y = attrs.get<double>(SUMO_ATTR_Y, id.c_str(), ok);
586 double z = attrs.getOpt<double>(SUMO_ATTR_Z, id.c_str(), ok, 0);
587 const SumoXMLNodeType type = attrs.get<SumoXMLNodeType>(SUMO_ATTR_TYPE, id.c_str(), ok);
588 std::string key = attrs.getOpt<std::string>(SUMO_ATTR_KEY, id.c_str(), ok, "");
589 std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
590 // incoming lanes
591 std::vector<MSLane*> incomingLanes;
592 parseLanes(id, attrs.getStringSecure(SUMO_ATTR_INCLANES, ""), incomingLanes, ok);
593 // internal lanes
594 std::vector<MSLane*> internalLanes;
596 parseLanes(id, attrs.getStringSecure(SUMO_ATTR_INTLANES, ""), internalLanes, ok);
597 }
598 if (!ok) {
599 myCurrentIsBroken = true;
600 } else {
601 try {
602 myJunctionControlBuilder.openJunction(id, key, type, Position(x, y, z), shape, incomingLanes, internalLanes, name);
603 } catch (InvalidArgument& e) {
604 WRITE_ERROR(e.what() + std::string("\n Can not build according junction."));
605 myCurrentIsBroken = true;
606 }
607 }
608}
609
610
611void
612NLHandler::parseLanes(const std::string& junctionID,
613 const std::string& def, std::vector<MSLane*>& into, bool& ok) {
614 StringTokenizer st(def, " ");
615 while (ok && st.hasNext()) {
616 std::string laneID = st.next();
617 MSLane* lane = MSLane::dictionary(laneID);
618 if (!MSGlobals::gUsingInternalLanes && laneID[0] == ':') {
619 continue;
620 }
621 if (lane == nullptr) {
622 WRITE_ERROR("An unknown lane ('" + laneID + "') was tried to be set as incoming to junction '" + junctionID + "'.");
623 ok = false;
624 continue;
625 }
626 into.push_back(lane);
627 }
628}
629// ----
630
631void
633 bool ok = true;
634 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
635 // circumventing empty string test
636 const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
637 if (myLastParameterised.size() > 0 && myLastParameterised.back() != nullptr) {
638 myLastParameterised.back()->setParameter(key, val);
639 }
640 // set
642 assert(key != "");
644 }
645}
646
647
648void
650 myCurrentIsBroken = false;
651 bool ok = true;
652 // get the id, report an error if not given or empty...
653 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
654 if (!ok) {
655 myCurrentIsBroken = true;
656 return;
657 }
658 SUMOTime refTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_REF_TIME, id.c_str(), ok, 0);
659 SUMOTime period = attrs.getOptSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), ok, 0);
660 std::string startProg = attrs.get<std::string>(SUMO_ATTR_START_PROG, id.c_str(), ok);
661 if (!ok) {
662 myCurrentIsBroken = true;
663 }
664 if (!myCurrentIsBroken) {
665 myCurrentWAUTID = id;
666 try {
667 myJunctionControlBuilder.getTLLogicControlToUse().addWAUT(refTime, id, startProg, period);
668 } catch (InvalidArgument& e) {
669 WRITE_ERROR(e.what());
670 myCurrentIsBroken = true;
671 }
672 }
673}
674
675
676void
678 bool ok = true;
680 std::string to = attrs.get<std::string>(SUMO_ATTR_TO, myCurrentWAUTID.c_str(), ok);
681 if (!ok) {
682 myCurrentIsBroken = true;
683 }
684 if (!myCurrentIsBroken) {
685 try {
687 } catch (InvalidArgument& e) {
688 WRITE_ERROR(e.what());
689 myCurrentIsBroken = true;
690 }
691 }
692}
693
694
695void
697 bool ok = true;
698 std::string wautID = attrs.get<std::string>(SUMO_ATTR_WAUT_ID, nullptr, ok);
699 std::string junctionID = attrs.get<std::string>(SUMO_ATTR_JUNCTION_ID, nullptr, ok);
700 std::string procedure = attrs.getOpt<std::string>(SUMO_ATTR_PROCEDURE, nullptr, ok, "");
701 bool synchron = attrs.getOpt<bool>(SUMO_ATTR_SYNCHRON, nullptr, ok, false);
702 if (!ok) {
703 myCurrentIsBroken = true;
704 }
705 try {
706 if (!myCurrentIsBroken) {
707 myJunctionControlBuilder.getTLLogicControlToUse().addWAUTJunction(wautID, junctionID, procedure, synchron);
708 }
709 } catch (InvalidArgument& e) {
710 WRITE_ERROR(e.what());
711 myCurrentIsBroken = true;
712 }
713}
714
715
716void
718 if (myCurrentIsBroken) {
719 return;
720 }
721 bool ok = true;
722 int request = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
723 bool cont = false;
724 cont = attrs.getOpt<bool>(SUMO_ATTR_CONT, nullptr, ok, false);
725 std::string response = attrs.get<std::string>(SUMO_ATTR_RESPONSE, nullptr, ok);
726 std::string foes = attrs.get<std::string>(SUMO_ATTR_FOES, nullptr, ok);
727 if (!ok) {
728 return;
729 }
730 // store received information
731 if (request >= 0 && response.length() > 0) {
732 try {
733 myJunctionControlBuilder.addLogicItem(request, response, foes, cont);
734 } catch (InvalidArgument& e) {
735 WRITE_ERROR(e.what());
736 }
737 }
738}
739
740
741void
743 if (myCurrentIsBroken) {
744 return;
745 }
747 bool ok = true;
748 // we either a have a junction or a legacy network with ROWLogic
749 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
750 if (ok) {
752 }
753}
754
755
756void
758 myCurrentIsBroken = false;
760 bool ok = true;
761 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
762 std::string programID = attrs.getOpt<std::string>(SUMO_ATTR_PROGRAMID, id.c_str(), ok, "<unknown>");
764 std::string typeS;
765 if (myJunctionControlBuilder.getTLLogicControlToUse().get(id, programID) == nullptr) {
766 // SUMO_ATTR_TYPE is not needed when only modifying the offset of an
767 // existing program
768 typeS = attrs.get<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok);
769 if (!ok) {
770 myCurrentIsBroken = true;
771 return;
772 }
773 if (SUMOXMLDefinitions::TrafficLightTypes.hasString(typeS)) {
775 } else {
776 WRITE_ERROR("Traffic light '" + id + "' has unknown type '" + typeS + "'.");
777 }
780 WRITE_WARNING("Traffic light type '" + toString(type) + "' cannot be used in mesoscopic simulation. Using '" + toString(TrafficLightType::STATIC) + "' as fallback.");
782 }
784 }
785 }
786 //
787 const SUMOTime offset = attrs.getOptSUMOTimeReporting(SUMO_ATTR_OFFSET, id.c_str(), ok, 0);
788 if (!ok) {
789 myCurrentIsBroken = true;
790 return;
791 }
792 myJunctionControlBuilder.initTrafficLightLogic(id, programID, type, offset);
793}
794
795
796void
798 // try to get the phase definition
799 bool ok = true;
800 const std::string& id = myJunctionControlBuilder.getActiveKey();
802
804 const std::string state = attrs.get<std::string>(SUMO_ATTR_STATE, nullptr, ok);
805 if (duration == 0) {
807 + " for tlLogic '" + myJunctionControlBuilder.getActiveKey()
808 + "' program '" + myJunctionControlBuilder.getActiveSubKey() + "' is zero.");
809 return;
810 }
811 if (!ok) {
812 return;
813 }
814 MSPhaseDefinition* phase = new MSPhaseDefinition(duration, state);
815
816 // if the traffic light is an actuated traffic light, try to get
817 // the minimum and maximum durations
818 phase->minDuration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MINDURATION, id.c_str(), ok, duration);
819 // if minDur is set but not maxDur, assume high maxDur (avoid using the absolute max in case we do some arithmetic later)
820 SUMOTime defaultMaxDur = attrs.hasAttribute(SUMO_ATTR_MINDURATION) ? std::numeric_limits<int>::max() : duration;
821 phase->maxDuration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MAXDURATION, id.c_str(), ok, defaultMaxDur);
822 phase->earliestEnd = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EARLIEST_END, id.c_str(), ok, tDefault);
823 phase->latestEnd = attrs.getOptSUMOTimeReporting(SUMO_ATTR_LATEST_END, id.c_str(), ok, tDefault);
824 phase->nextPhases = attrs.getOpt<std::vector<int> >(SUMO_ATTR_NEXT, id.c_str(), ok);
825 phase->earlyTarget = attrs.getOpt<std::string>(SUMO_ATTR_EARLY_TARGET, id.c_str(), ok);
826 phase->finalTarget = attrs.getOpt<std::string>(SUMO_ATTR_FINAL_TARGET, id.c_str(), ok);
827 phase->name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok);
828
829 phase->vehext = attrs.getOptSUMOTimeReporting(SUMO_ATTR_VEHICLEEXTENSION, id.c_str(), ok, tDefault);
830 phase->yellow = attrs.getOptSUMOTimeReporting(SUMO_ATTR_YELLOW, id.c_str(), ok, tDefault);
831 phase->red = attrs.getOptSUMOTimeReporting(SUMO_ATTR_RED, id.c_str(), ok, tDefault);
832
833 if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
834 //SOTL attributes
835 //If the type attribute is not present, the parsed phase is of type "undefined" (MSPhaseDefinition constructor),
836 //in this way SOTL traffic light logic can recognize the phase as unsuitable or decides other
837 //behaviors. See SOTL traffic light logic implementations.
838 std::string phaseTypeString;
839 try {
840 phaseTypeString = attrs.get<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, false);
841 } catch (EmptyData&) {
842 MsgHandler::getWarningInstance()->inform("Empty type definition. Assuming phase type as SUMOSOTL_TagAttrDefinitions::SOTL_ATTL_TYPE_TRANSIENT");
843 phase->myTransientNotDecisional = false;
844 }
845 if (phaseTypeString.find("decisional") != std::string::npos) {
846 phase->myTransientNotDecisional = false;
847 } else if (phaseTypeString.find("transient") != std::string::npos) {
848 phase->myTransientNotDecisional = true;
849 } else {
850 MsgHandler::getWarningInstance()->inform("SOTL_ATTL_TYPE_DECISIONAL nor SOTL_ATTL_TYPE_TRANSIENT. Assuming phase type as SUMOSOTL_TagAttrDefinitions::SOTL_ATTL_TYPE_TRANSIENT");
851 phase->myTransientNotDecisional = false;
852 }
853 phase->myCommit = (phaseTypeString.find("commit") != std::string::npos);
854
855 if (phaseTypeString.find("target") != std::string::npos) {
856 std::string delimiter(" ,;");
857 //Phase declared as target, getting targetLanes attribute
858 try {
860 } catch (EmptyData&) {
861 MsgHandler::getErrorInstance()->inform("Missing targetLane definition for the target phase.");
862 delete phase;
863 return;
864 }
865 }
866 }
867
868 if (phase->maxDuration < phase->minDuration) {
869 WRITE_WARNINGF(TL("maxDur % should not be smaller than minDir % in phase of tlLogic %"), phase->maxDuration, phase->minDuration, id);
870 phase->maxDuration = phase->duration;
871 }
872
873 phase->myLastSwitch = string2time(OptionsCont::getOptions().getString("begin")) - 1; // SUMOTime-option
875}
876
877
878void
880 bool ok = true;
881 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
882 const std::string value = attrs.get<std::string>(SUMO_ATTR_VALUE, id.c_str(), ok);
883 if (!myJunctionControlBuilder.addCondition(id, value)) {
884 WRITE_ERROR("Duplicate condition '" + id + "' in tlLogic '" + myJunctionControlBuilder.getActiveKey() + "'");
885 }
886}
887
888
889void
891 bool ok = true;
892 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
893 const std::string check = attrs.get<std::string>(SUMO_ATTR_CHECK, nullptr, ok);
894 const std::string value = attrs.get<std::string>(SUMO_ATTR_VALUE, id.c_str(), ok);
895 myJunctionControlBuilder.addAssignment(id, check, value);
896}
897
898
899void
901 bool ok = true;
902 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
903 const int nArgs = attrs.get<int>(SUMO_ATTR_NARGS, nullptr, ok);
905}
906
907void
910}
911
912void
914 myCurrentIsBroken = false;
915 bool ok = true;
916 // get the id, report an error if not given or empty...
917 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
918 if (!ok) {
919 myCurrentIsBroken = true;
920 return;
921 }
922 const SUMOTime period = attrs.getOptPeriod(id.c_str(), ok, SUMOTime_MAX_PERIOD);
923 const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), ok);
924 const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), ok, 0);
925 const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
926 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
927 const std::string vTypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
928 const std::string nextEdges = attrs.getOpt<std::string>(SUMO_ATTR_NEXT_EDGES, id.c_str(), ok, "");
929 const std::string lane = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), ok);
930 const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
931 const std::string detectPersonsString = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, id.c_str(), ok, "");
932 int detectPersons = 0;
933 for (std::string mode : StringTokenizer(detectPersonsString).getVector()) {
934 if (SUMOXMLDefinitions::PersonModeValues.hasString(mode)) {
935 detectPersons |= (int)SUMOXMLDefinitions::PersonModeValues.get(mode);
936 } else {
937 WRITE_ERROR("Invalid person mode '" + mode + "' in E1 detector definition '" + id + "'");
938 myCurrentIsBroken = true;
939 return;
940 }
941 }
942 if (!ok) {
943 myCurrentIsBroken = true;
944 return;
945 }
946 try {
947 Parameterised* det = myDetectorBuilder.buildInductLoop(id, lane, position, length, period,
949 friendlyPos, name, vTypes, nextEdges, detectPersons);
950 myLastParameterised.push_back(det);
951 } catch (InvalidArgument& e) {
952 myCurrentIsBroken = true;
953 WRITE_ERROR(e.what());
954 } catch (IOError& e) {
955 myCurrentIsBroken = true;
956 WRITE_ERROR(e.what());
957 }
958}
959
960
961void
963 myCurrentIsBroken = false;
964 bool ok = true;
965 // get the id, report an error if not given or empty...
966 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
967 if (!ok) {
968 myCurrentIsBroken = true;
969 return;
970 }
971 const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), ok);
972 const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
973 const std::string lane = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), ok);
974 const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
975 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
976 const std::string vTypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
977 const std::string nextEdges = attrs.getOpt<std::string>(SUMO_ATTR_NEXT_EDGES, id.c_str(), ok, "");
978 if (!ok) {
979 myCurrentIsBroken = true;
980 return;
981 }
982 try {
983 Parameterised* det = myDetectorBuilder.buildInstantInductLoop(id, lane, position, FileHelpers::checkForRelativity(file, getFileName()), friendlyPos, name, vTypes, nextEdges);
984 myLastParameterised.push_back(det);
985 } catch (InvalidArgument& e) {
986 WRITE_ERROR(e.what());
987 } catch (IOError& e) {
988 WRITE_ERROR(e.what());
989 }
990 myCurrentIsBroken = true;
991}
992
993
994void
996 WRITE_WARNING(TL("VTypeProbes are deprecated. Use fcd-output devices (assigned to the vType) instead."));
997 bool ok = true;
998 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
999 SUMOTime period = attrs.getOptPeriod(id.c_str(), ok, SUMOTime_MAX_PERIOD);
1000 std::string type = attrs.getStringSecure(SUMO_ATTR_TYPE, "");
1001 std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
1002 if (!ok) {
1003 return;
1004 }
1005 try {
1007 } catch (InvalidArgument& e) {
1008 WRITE_ERROR(e.what());
1009 } catch (IOError& e) {
1010 WRITE_ERROR(e.what());
1011 }
1012}
1013
1014
1015void
1017 bool ok = true;
1018 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
1019 SUMOTime period = attrs.getOptPeriod(id.c_str(), ok, SUMOTime_MAX_PERIOD);
1020 SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), ok, -1);
1021 std::string edge = attrs.get<std::string>(SUMO_ATTR_EDGE, id.c_str(), ok);
1022 std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
1023 const std::string vTypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
1024 if (!ok) {
1025 return;
1026 }
1027 try {
1028 myDetectorBuilder.buildRouteProbe(id, edge, period, begin,
1030 } catch (InvalidArgument& e) {
1031 WRITE_ERROR(e.what());
1032 } catch (IOError& e) {
1033 WRITE_ERROR(e.what());
1034 }
1035}
1036
1037
1038
1039void
1041 myCurrentIsBroken = false;
1042 // check whether this is a detector connected to a tls and optionally to a link
1043 bool ok = true;
1044 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
1045 const std::string lsaid = attrs.getOpt<std::string>(SUMO_ATTR_TLID, id.c_str(), ok, "");
1046 const std::string toLane = attrs.getOpt<std::string>(SUMO_ATTR_TO, id.c_str(), ok, "");
1047 const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), ok, TIME2STEPS(1));
1048 const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), ok, 5.0f / 3.6f);
1049 const double jamDistThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), ok, 10.0f);
1050 double position = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), ok, std::numeric_limits<double>::max());
1051 const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), ok, std::numeric_limits<double>::max());
1052 const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
1053 const bool showDetector = attrs.getOpt<bool>(SUMO_ATTR_SHOW_DETECTOR, id.c_str(), ok, true);
1054 const std::string contStr = attrs.getOpt<std::string>(SUMO_ATTR_CONT, id.c_str(), ok, "");
1055 if (contStr != "") {
1056 WRITE_WARNING("Ignoring deprecated argument 'cont' for E2 detector '" + id + "'");
1057 }
1058 std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), ok, "");
1059 const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
1060 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
1061 const std::string vTypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
1062 const std::string nextEdges = attrs.getOpt<std::string>(SUMO_ATTR_NEXT_EDGES, id.c_str(), ok, "");
1063
1064 double endPosition = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), ok, std::numeric_limits<double>::max());
1065 const std::string lanes = attrs.getOpt<std::string>(SUMO_ATTR_LANES, id.c_str(), ok, ""); // lanes has priority to lane
1066 const std::string detectPersonsString = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, id.c_str(), ok, "");
1067 int detectPersons = 0;
1068 for (std::string mode : StringTokenizer(detectPersonsString).getVector()) {
1069 if (SUMOXMLDefinitions::PersonModeValues.hasString(mode)) {
1070 detectPersons |= (int)SUMOXMLDefinitions::PersonModeValues.get(mode);
1071 } else {
1072 WRITE_ERROR("Invalid person mode '" + mode + "' in E2 detector definition '" + id + "'");
1073 myCurrentIsBroken = true;
1074 return;
1075 }
1076 }
1077 if (!ok) {
1078 myCurrentIsBroken = true;
1079 return;
1080 }
1081
1082 bool lanesGiven = lanes != "";
1083 bool laneGiven = lane != "";
1084 if (!(lanesGiven || laneGiven)) {
1085 // in absence of any lane-specification assume specification by id
1086 WRITE_WARNING(TL("Trying to specify detector's lane by the given id since the argument 'lane' is missing."))
1087 lane = id;
1088 laneGiven = true;
1089 }
1090 bool lengthGiven = length != std::numeric_limits<double>::max();
1091 bool posGiven = position != std::numeric_limits<double>::max();
1092 bool endPosGiven = endPosition != std::numeric_limits<double>::max();
1093 bool lsaGiven = lsaid != "";
1094 bool toLaneGiven = toLane != "";
1095
1096 MSLane* clane = nullptr;
1097 std::vector<MSLane*> clanes;
1098 if (lanesGiven) {
1099 // If lanes is given, endPos and startPos are required. lane, and length are ignored
1100 std::string seps = " ,\t\n";
1101 StringTokenizer st = StringTokenizer(lanes, seps, true);
1102// std::cout << "Parsing lanes..." << std::endl;
1103 while (st.hasNext()) {
1104 std::string nextLaneID = st.next();
1105// std::cout << "Next: " << nextLaneID << std::endl;
1106 if (nextLaneID.find_first_of(seps) != nextLaneID.npos) {
1107 continue;
1108 }
1109 clane = myDetectorBuilder.getLaneChecking(nextLaneID, SUMO_TAG_E2DETECTOR, id);
1110 clanes.push_back(clane);
1111 }
1112 if (clanes.size() == 0) {
1113 throw InvalidArgument("Malformed argument 'lanes' for E2Detector '" + id + "'.\nSpecify 'lanes' as a sequence of lane-IDs seperated by whitespace or comma (',')");
1114 }
1115 if (laneGiven) {
1116 WRITE_WARNING("Ignoring argument 'lane' for E2Detector '" + id + "' since argument 'lanes' was given.\n"
1117 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
1118 }
1119 if (lengthGiven) {
1120 WRITE_WARNING("Ignoring argument 'length' for E2Detector '" + id + "' since argument 'lanes' was given.\n"
1121 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
1122 }
1123 if (!posGiven) {
1124 // assuming start pos == lane start
1125 position = 0;
1126 WRITE_WARNING("Missing argument 'pos' for E2Detector '" + id + "'. Assuming detector start == lane start of lane '" + clanes[0]->getID() + "'.");
1127 }
1128 if (!endPosGiven) {
1129 // assuming end pos == lane end
1130 endPosition = clanes[clanes.size() - 1]->getLength();
1131 WRITE_WARNING("Missing argument 'endPos' for E2Detector '" + id + "'. Assuming detector end == lane end of lane '" + clanes[clanes.size() - 1]->getID() + "'.");
1132 }
1133
1134 } else {
1135 if (!laneGiven) {
1136 std::stringstream ss;
1137 ss << "Missing argument 'lane' for E2Detector '" << id << "'."
1138 << "\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1139 throw InvalidArgument(ss.str());
1140 }
1142
1143 if (posGiven) {
1144 // start pos is given
1145 if (endPosGiven && lengthGiven) {
1146 std::stringstream ss;
1147 ss << "Ignoring argument 'endPos' for E2Detector '" << id << "' since argument 'pos' was given."
1148 << "\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1149 WRITE_WARNING(ss.str());
1150 endPosition = std::numeric_limits<double>::max();
1151 }
1152 if (!lengthGiven && !endPosGiven) {
1153 std::stringstream ss;
1154 ss << "Missing arguments 'length'/'endPos' for E2Detector '" << id << "'. Assuming detector end == lane end of lane '" << lane << "'.";
1155 WRITE_WARNING(ss.str());
1156 endPosition = clane->getLength();
1157 }
1158 } else if (endPosGiven) {
1159 // endPos is given, pos is not given
1160 if (!lengthGiven) {
1161 std::stringstream ss;
1162 ss << "Missing arguments 'length'/'pos' for E2Detector '" << id << "'. Assuming detector start == lane start of lane '" << lane << "'.";
1163 WRITE_WARNING(ss.str());
1164 }
1165 } else {
1166 std::stringstream ss;
1167 if (lengthGiven && fabs(length - clane->getLength()) > NUMERICAL_EPS) {
1168 ss << "Incomplete positional specification for E2Detector '" << id << "'."
1169 << "\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1170 throw InvalidArgument(ss.str());
1171 }
1172 endPosition = clane->getLength();
1173 position = 0;
1174 ss << "Missing arguments 'pos'/'endPos' for E2Detector '" << id << "'. Assuming that the detector covers the whole lane '" << lane << "'.";
1175 WRITE_WARNING(ss.str());
1176 }
1177 }
1178
1179 // Period
1180
1181 SUMOTime period;
1182 if (!lsaGiven) {
1183 period = attrs.getOptPeriod(id.c_str(), ok, SUMOTime_MAX_PERIOD);
1184 if (!ok) {
1185 myCurrentIsBroken = true;
1186 return;
1187 }
1188 } else {
1189 period = attrs.getPeriod(id.c_str(), ok, false);
1190 }
1191
1192 // TLS
1193 MSTLLogicControl::TLSLogicVariants* tlls = nullptr;
1194 if (lsaGiven) {
1195 tlls = &myJunctionControlBuilder.getTLLogic(lsaid);
1196 if (tlls->getActive() == nullptr) {
1197 throw InvalidArgument("The detector '" + id + "' refers to an unknown lsa '" + lsaid + "'.");
1198 }
1199 if (period != -1) {
1200 WRITE_WARNING("Ignoring argument 'period' for E2Detector '" + id + "' since argument 'tl' was given.");
1201 period = -1;
1202 }
1203 }
1204
1205 // Link
1206 MSLane* cToLane = nullptr;
1207 if (toLaneGiven) {
1209 }
1210
1211 // File
1212 std::string filename;
1213 try {
1214 filename = FileHelpers::checkForRelativity(file, getFileName());
1215 } catch (IOError& e) {
1216 WRITE_ERROR(e.what());
1217 }
1218
1219 Parameterised* det;
1220 // Build detector
1221 if (lanesGiven) {
1222 // specification by a lane sequence
1223 det = myDetectorBuilder.buildE2Detector(id, clanes, position, endPosition, filename, period,
1224 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1225 name, vTypes, nextEdges, detectPersons, friendlyPos, showDetector,
1226 tlls, cToLane);
1227 } else {
1228 // specification by start or end lane
1229 det = myDetectorBuilder.buildE2Detector(id, clane, position, endPosition, length, filename, period,
1230 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1231 name, vTypes, nextEdges, detectPersons, friendlyPos, showDetector,
1232 tlls, cToLane);
1233 }
1234 myLastParameterised.push_back(det);
1235}
1236
1237
1238void
1240 myCurrentIsBroken = false;
1241 bool ok = true;
1242 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
1243 const SUMOTime period = attrs.getOptPeriod(id.c_str(), ok, SUMOTime_MAX_PERIOD);
1244 const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), ok, TIME2STEPS(1));
1245 const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), ok, 5.0f / 3.6f);
1246 const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
1247 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
1248 const std::string vTypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
1249 const std::string nextEdges = attrs.getOpt<std::string>(SUMO_ATTR_NEXT_EDGES, id.c_str(), ok, "");
1250 const bool openEntry = attrs.getOpt<bool>(SUMO_ATTR_OPEN_ENTRY, id.c_str(), ok, false);
1251 const std::string detectPersonsString = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, id.c_str(), ok, "");
1252 int detectPersons = 0;
1253 for (std::string mode : StringTokenizer(detectPersonsString).getVector()) {
1254 if (SUMOXMLDefinitions::PersonModeValues.hasString(mode)) {
1255 detectPersons |= (int)SUMOXMLDefinitions::PersonModeValues.get(mode);
1256 } else {
1257 WRITE_ERROR("Invalid person mode '" + mode + "' in E3 detector definition '" + id + "'");
1258 myCurrentIsBroken = true;
1259 return;
1260 }
1261 }
1262 if (!ok) {
1263 myCurrentIsBroken = true;
1264 return;
1265 }
1266 try {
1269 period, haltingSpeedThreshold, haltingTimeThreshold, name, vTypes, nextEdges, detectPersons, openEntry);
1270 myLastParameterised.push_back(det);
1271 } catch (InvalidArgument& e) {
1272 myCurrentIsBroken = true;
1273 WRITE_ERROR(e.what());
1274 } catch (IOError& e) {
1275 myCurrentIsBroken = true;
1276 WRITE_ERROR(e.what());
1277 }
1278}
1279
1280
1281void
1283 bool ok = true;
1284 const double position = attrs.get<double>(SUMO_ATTR_POSITION, myDetectorBuilder.getCurrentE3ID().c_str(), ok);
1285 const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, myDetectorBuilder.getCurrentE3ID().c_str(), ok, false);
1286 const std::string lane = attrs.get<std::string>(SUMO_ATTR_LANE, myDetectorBuilder.getCurrentE3ID().c_str(), ok);
1287 if (!ok) {
1288 return;
1289 }
1290 myDetectorBuilder.addE3Entry(lane, position, friendlyPos);
1291}
1292
1293
1294void
1296 bool ok = true;
1297 const double position = attrs.get<double>(SUMO_ATTR_POSITION, myDetectorBuilder.getCurrentE3ID().c_str(), ok);
1298 const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, myDetectorBuilder.getCurrentE3ID().c_str(), ok, false);
1299 const std::string lane = attrs.get<std::string>(SUMO_ATTR_LANE, myDetectorBuilder.getCurrentE3ID().c_str(), ok);
1300 if (!ok) {
1301 return;
1302 }
1303 myDetectorBuilder.addE3Exit(lane, position, friendlyPos);
1304}
1305
1306
1307void
1309 bool ok = true;
1310 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
1311 const double maxTravelTime = attrs.getOpt<double>(SUMO_ATTR_MAX_TRAVELTIME, id.c_str(), ok, 100000);
1312 const double minSamples = attrs.getOpt<double>(SUMO_ATTR_MIN_SAMPLES, id.c_str(), ok, 0);
1313 const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), ok, POSITION_EPS);
1314 const std::string excludeEmpty = attrs.getOpt<std::string>(SUMO_ATTR_EXCLUDE_EMPTY, id.c_str(), ok, "false");
1315 const bool withInternal = attrs.getOpt<bool>(SUMO_ATTR_WITH_INTERNAL, id.c_str(), ok, false);
1316 const bool trackVehicles = attrs.getOpt<bool>(SUMO_ATTR_TRACK_VEHICLES, id.c_str(), ok, false);
1317 const std::string detectPersonsString = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, id.c_str(), ok, "");
1318 const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
1319 const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "performance");
1320 std::string vtypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
1321 const std::string writeAttributes = attrs.getOpt<std::string>(SUMO_ATTR_WRITE_ATTRIBUTES, id.c_str(), ok, "");
1322 const SUMOTime period = attrs.getOptPeriod(id.c_str(), ok, -1);
1323 const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), ok, string2time(OptionsCont::getOptions().getString("begin")));
1324 const SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), ok, string2time(OptionsCont::getOptions().getString("end")));
1325 std::vector<std::string> edgeIDs = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), ok);
1326 const std::string edgesFile = attrs.getOpt<std::string>(SUMO_ATTR_EDGESFILE, id.c_str(), ok, "");
1327 const bool aggregate = attrs.getOpt<bool>(SUMO_ATTR_AGGREGATE, id.c_str(), ok, false);
1328 if (!ok) {
1329 return;
1330 }
1331 int detectPersons = 0;
1332 for (std::string mode : StringTokenizer(detectPersonsString).getVector()) {
1333 if (SUMOXMLDefinitions::PersonModeValues.hasString(mode)) {
1334 detectPersons |= (int)SUMOXMLDefinitions::PersonModeValues.get(mode);
1335 } else {
1336 WRITE_ERROR("Invalid person mode '" + mode + "' in edgeData definition '" + id + "'");
1337 return;
1338 }
1339 }
1340 if (edgesFile != "") {
1341 std::ifstream strm(edgesFile.c_str());
1342 if (!strm.good()) {
1343 throw ProcessError("Could not load names of edges for edgeData defintion '" + id + "' from '" + edgesFile + "'.");
1344 }
1345 while (strm.good()) {
1346 std::string name;
1347 strm >> name;
1348 // maybe we're loading an edge-selection
1349 if (StringUtils::startsWith(name, "edge:")) {
1350 edgeIDs.push_back(name.substr(5));
1351 } else if (name != "") {
1352 edgeIDs.push_back(name);
1353 }
1354 }
1355 }
1356 std::vector<MSEdge*> edges;
1357 for (const std::string& edgeID : edgeIDs) {
1358 MSEdge* edge = MSEdge::dictionary(edgeID);
1359 if (edge == nullptr) {
1360 WRITE_ERROR("Unknown edge '" + edgeID + "' in edgeData definition '" + id + "'");
1361 return;
1362 }
1363 edges.push_back(edge);
1364 }
1365 try {
1366 myDetectorBuilder.createEdgeLaneMeanData(id, period, begin, end,
1367 type, objecttype == SUMO_TAG_MEANDATA_LANE,
1368 // equivalent to TplConvert::_2bool used in SUMOSAXAttributes::getBool
1369 excludeEmpty[0] != 't' && excludeEmpty[0] != 'T' && excludeEmpty[0] != '1' && excludeEmpty[0] != 'x',
1370 excludeEmpty == "defaults", withInternal, trackVehicles, detectPersons,
1371 maxTravelTime, minSamples, haltingSpeedThreshold, vtypes, writeAttributes, edges, aggregate,
1373 } catch (InvalidArgument& e) {
1374 WRITE_ERROR(e.what());
1375 } catch (IOError& e) {
1376 WRITE_ERROR(e.what());
1377 }
1378}
1379
1380
1381void
1383 bool ok = true;
1384 const std::string fromID = attrs.get<std::string>(SUMO_ATTR_FROM, nullptr, ok);
1385 const std::string toID = attrs.get<std::string>(SUMO_ATTR_TO, nullptr, ok);
1386 if (!MSGlobals::gUsingInternalLanes && (fromID[0] == ':' || toID[0] == ':')) {
1387 std::string tlID = attrs.getOpt<std::string>(SUMO_ATTR_TLID, nullptr, ok, "");
1388 if (tlID != "") {
1389 int tlLinkIdx = attrs.get<int>(SUMO_ATTR_TLLINKINDEX, nullptr, ok);
1391 }
1392 return;
1393 }
1394
1395 MSLink* link = nullptr;
1396 try {
1397 const int fromLaneIdx = attrs.get<int>(SUMO_ATTR_FROM_LANE, nullptr, ok);
1398 const int toLaneIdx = attrs.get<int>(SUMO_ATTR_TO_LANE, nullptr, ok);
1399 LinkDirection dir = parseLinkDir(attrs.get<std::string>(SUMO_ATTR_DIR, nullptr, ok));
1400 LinkState state = parseLinkState(attrs.get<std::string>(SUMO_ATTR_STATE, nullptr, ok));
1401 const double foeVisibilityDistance = attrs.getOpt<double>(SUMO_ATTR_VISIBILITY_DISTANCE, nullptr, ok, state == LINKSTATE_ZIPPER ? 100 : 4.5);
1402 const bool keepClear = attrs.getOpt<bool>(SUMO_ATTR_KEEP_CLEAR, nullptr, ok, true);
1403 const bool indirect = attrs.getOpt<bool>(SUMO_ATTR_INDIRECT, nullptr, ok, false);
1404 std::string tlID = attrs.getOpt<std::string>(SUMO_ATTR_TLID, nullptr, ok, "");
1405 std::string viaID = attrs.getOpt<std::string>(SUMO_ATTR_VIA, nullptr, ok, "");
1406
1408 if (from == nullptr) {
1409 WRITE_ERROR("Unknown from-edge '" + fromID + "' in connection.");
1410 return;
1411 }
1412 myPreviousEdgeIdx = from->getNumericalID();
1413 MSEdge* to = MSEdge::dictionary(toID);
1414 if (to == nullptr) {
1415 WRITE_ERROR("Unknown to-edge '" + toID + "' in connection.");
1416 return;
1417 }
1418 if (fromLaneIdx < 0 || fromLaneIdx >= (int)from->getLanes().size() ||
1419 toLaneIdx < 0 || toLaneIdx >= (int)to->getLanes().size()) {
1420 WRITE_ERROR("Invalid lane index in connection from '" + from->getID() + "' to '" + to->getID() + "'.");
1421 return;
1422 }
1423 MSLane* fromLane = from->getLanes()[fromLaneIdx];
1424 MSLane* toLane = to->getLanes()[toLaneIdx];
1425 assert(fromLane);
1426 assert(toLane);
1427
1428 MSTrafficLightLogic* logic = nullptr;
1429 int tlLinkIdx = -1;
1430 if (tlID != "") {
1431 tlLinkIdx = attrs.get<int>(SUMO_ATTR_TLLINKINDEX, nullptr, ok);
1432 // make sure that the index is in range
1434 if ((tlLinkIdx < 0 || tlLinkIdx >= (int)logic->getCurrentPhaseDef().getState().size())
1435 && logic->getLogicType() != TrafficLightType::RAIL_SIGNAL
1436 && logic->getLogicType() != TrafficLightType::RAIL_CROSSING) {
1437 WRITE_ERROR("Invalid " + toString(SUMO_ATTR_TLLINKINDEX) + " '" + toString(tlLinkIdx) +
1438 "' in connection controlled by '" + tlID + "'");
1439 return;
1440 }
1441 if (!ok) {
1442 return;
1443 }
1444 }
1445 double length;
1446 // build the link
1447 MSLane* via = nullptr;
1448 if (viaID != "" && MSGlobals::gUsingInternalLanes) {
1449 via = MSLane::dictionary(viaID);
1450 if (via == nullptr) {
1451 WRITE_ERROR("An unknown lane ('" + viaID +
1452 "') should be set as a via-lane for lane '" + toLane->getID() + "'.");
1453 return;
1454 }
1455 length = via->getLength();
1456 } else if (toLane->getEdge().isCrossing()) {
1457 length = toLane->getLength();
1458 } else {
1459 length = fromLane->getShape()[-1].distanceTo(toLane->getShape()[0]);
1460 }
1461 link = new MSLink(fromLane, toLane, via, dir, state, length, foeVisibilityDistance, keepClear, logic, tlLinkIdx, indirect);
1462 if (via != nullptr) {
1463 via->addIncomingLane(fromLane, link);
1464 } else {
1465 toLane->addIncomingLane(fromLane, link);
1466 }
1467 toLane->addApproachingLane(fromLane, myNetworkVersion < 0.25);
1468
1469 // if a traffic light is responsible for it, inform the traffic light
1470 // check whether this link is controlled by a traffic light
1471 // we can not reuse logic here because it might be an inactive one
1472 if (tlID != "") {
1473 myJunctionControlBuilder.getTLLogic(tlID).addLink(link, fromLane, tlLinkIdx);
1474 }
1475 // add the link
1476 fromLane->addLink(link);
1477
1478 } catch (InvalidArgument& e) {
1479 WRITE_ERROR(e.what());
1480 }
1481}
1482
1483
1485NLHandler::parseLinkDir(const std::string& dir) {
1486 if (SUMOXMLDefinitions::LinkDirections.hasString(dir)) {
1488 } else {
1489 throw InvalidArgument("Unrecognised link direction '" + dir + "'.");
1490 }
1491}
1492
1493
1495NLHandler::parseLinkState(const std::string& state) {
1496 if (SUMOXMLDefinitions::LinkStates.hasString(state)) {
1497 return SUMOXMLDefinitions::LinkStates.get(state);
1498 } else {
1499 if (state == "t") { // legacy networks
1500 // WRITE_WARNING(TL("Obsolete link state 't'. Use 'o' instead"));
1502 } else {
1503 throw InvalidArgument("Unrecognised link state '" + state + "'.");
1504 }
1505 }
1506}
1507
1508
1509// ----------------------------------
1510void
1512 if (myNetIsLoaded) {
1513 //WRITE_WARNING(TL("POIs and Polygons should be loaded using option --po-files"))
1514 return;
1515 }
1516 bool ok = true;
1517 PositionVector s = attrs.get<PositionVector>(SUMO_ATTR_NET_OFFSET, nullptr, ok);
1518 Boundary convBoundary = attrs.get<Boundary>(SUMO_ATTR_CONV_BOUNDARY, nullptr, ok);
1519 Boundary origBoundary = attrs.get<Boundary>(SUMO_ATTR_ORIG_BOUNDARY, nullptr, ok);
1520 std::string proj = attrs.get<std::string>(SUMO_ATTR_ORIG_PROJ, nullptr, ok);
1521 if (ok) {
1522 Position networkOffset = s[0];
1523 GeoConvHelper::init(proj, networkOffset, origBoundary, convBoundary);
1524 if (OptionsCont::getOptions().getBool("fcd-output.geo") && !GeoConvHelper::getFinal().usingGeoProjection()) {
1525 WRITE_WARNING(TL("no valid geo projection loaded from network. fcd-output.geo will not work"));
1526 }
1527 }
1528}
1529
1530
1531void
1533 bool ok = true;
1534 myCurrentIsBroken = false;
1535 // get the id, report an error if not given or empty...
1536 myCurrentDistrictID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
1537 if (!ok) {
1538 myCurrentIsBroken = true;
1539 return;
1540 }
1541 try {
1542 const std::string sinkID = myCurrentDistrictID + "-sink";
1543 const std::string sourceID = myCurrentDistrictID + "-source";
1544
1545 MSEdge* sink = myEdgeControlBuilder.buildEdge(sinkID, SumoXMLEdgeFunc::CONNECTOR, "", "", -1, 0);
1546 if (!MSEdge::dictionary(sinkID, sink)) {
1547 delete sink;
1548 if (OptionsCont::getOptions().getBool("junction-taz")
1550 // overwrite junction taz
1551 sink = MSEdge::dictionary(sinkID);
1553 WRITE_WARNINGF(TL("Replacing junction-taz '%' with loaded TAZ."), myCurrentDistrictID);
1554 } else {
1555 throw InvalidArgument("Another edge with the id '" + sinkID + "' exists.");
1556 }
1557 } else {
1558 sink->initialize(new std::vector<MSLane*>());
1559 }
1560 MSEdge* source = myEdgeControlBuilder.buildEdge(sourceID, SumoXMLEdgeFunc::CONNECTOR, "", "", -1, 0);
1561 if (!MSEdge::dictionary(sourceID, source)) {
1562 delete source;
1563 if (OptionsCont::getOptions().getBool("junction-taz")
1565 // overwrite junction taz
1566 source = MSEdge::dictionary(sourceID);
1568 } else {
1569 throw InvalidArgument("Another edge with the id '" + sourceID + "' exists.");
1570 }
1571 } else {
1572 source->initialize(new std::vector<MSLane*>());
1573 }
1574 sink->setOtherTazConnector(source);
1575 source->setOtherTazConnector(sink);
1576 const std::vector<std::string>& desc = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, myCurrentDistrictID.c_str(), ok);
1577 for (const std::string& eID : desc) {
1578 MSEdge* edge = MSEdge::dictionary(eID);
1579 // check whether the edge exists
1580 if (edge == nullptr) {
1581 throw InvalidArgument("The edge '" + eID + "' within district '" + myCurrentDistrictID + "' is not known.");
1582 }
1583 source->addSuccessor(edge);
1584 edge->addSuccessor(sink);
1585 }
1586 RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, myCurrentDistrictID.c_str(), ok, RGBColor::parseColor("1.0,.33,.33"));
1587 const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, myCurrentDistrictID.c_str(), ok, "");
1588 source->setParameter("tazColor", toString(color));
1589 sink->setParameter("tazColor", toString(color));
1590
1591 if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
1593 const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, myCurrentDistrictID.c_str(), ok, false);
1594 if (shape.size() != 0) {
1595 if (!myNet.getShapeContainer().addPolygon(myCurrentDistrictID, "taz", color, 0, 0, "", false, shape, false, fill, 1.0, false, name)) {
1596 WRITE_WARNING("Skipping visualization of taz '" + myCurrentDistrictID + "', polygon already exists.");
1597 } else {
1599 myCurrentIsBroken = false;
1600 }
1601 }
1602 }
1603 } catch (InvalidArgument& e) {
1604 WRITE_ERROR(e.what());
1605 myCurrentIsBroken = true;
1606 }
1607}
1608
1609
1610void
1611NLHandler::addDistrictEdge(const SUMOSAXAttributes& attrs, bool isSource) {
1612 if (myCurrentIsBroken) {
1613 // earlier error
1614 return;
1615 }
1616 bool ok = true;
1617 std::string id = attrs.get<std::string>(SUMO_ATTR_ID, myCurrentDistrictID.c_str(), ok);
1618 MSEdge* succ = MSEdge::dictionary(id);
1619 if (succ != nullptr) {
1620 // connect edge
1621 if (isSource) {
1622 MSEdge::dictionary(myCurrentDistrictID + "-source")->addSuccessor(succ);
1623 } else {
1624 succ->addSuccessor(MSEdge::dictionary(myCurrentDistrictID + "-sink"));
1625 }
1626 } else {
1627 WRITE_ERROR("At district '" + myCurrentDistrictID + "': succeeding edge '" + id + "' does not exist.");
1628 }
1629}
1630
1631
1632void
1634 bool ok = true;
1635 const std::vector<std::string>& edgeIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, nullptr, ok);
1636 if (ok) {
1637 for (const std::string& eID : edgeIDs) {
1638 MSEdge* edge = MSEdge::dictionary(eID);
1639 if (edge == nullptr) {
1640 WRITE_ERROR("Unknown edge '" + eID + "' in roundabout");
1641 } else {
1642 edge->markAsRoundabout();
1643 }
1644 }
1645 }
1646}
1647
1648
1649void
1651 bool ok = true;
1652 MESegment::MesoEdgeType edgeType = myNet.getMesoType(""); // init defaults
1653 edgeType.tauff = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MESO_TAUFF, myCurrentTypeID.c_str(), ok, edgeType.tauff);
1654 edgeType.taufj = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MESO_TAUFJ, myCurrentTypeID.c_str(), ok, edgeType.taufj);
1655 edgeType.taujf = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MESO_TAUJF, myCurrentTypeID.c_str(), ok, edgeType.taujf);
1656 edgeType.taujj = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MESO_TAUJJ, myCurrentTypeID.c_str(), ok, edgeType.taujj);
1657 edgeType.jamThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, myCurrentTypeID.c_str(), ok, edgeType.jamThreshold);
1658 edgeType.junctionControl = attrs.getOpt<bool>(SUMO_ATTR_MESO_JUNCTION_CONTROL, myCurrentTypeID.c_str(), ok, edgeType.junctionControl);
1659 edgeType.tlsPenalty = attrs.getOpt<double>(SUMO_ATTR_MESO_TLS_PENALTY, myCurrentTypeID.c_str(), ok, edgeType.tlsPenalty);
1660 edgeType.tlsFlowPenalty = attrs.getOpt<double>(SUMO_ATTR_MESO_TLS_FLOW_PENALTY, myCurrentTypeID.c_str(), ok, edgeType.tlsFlowPenalty);
1662 edgeType.overtaking = attrs.getOpt<bool>(SUMO_ATTR_MESO_OVERTAKING, myCurrentTypeID.c_str(), ok, edgeType.overtaking);
1663
1664 if (ok) {
1666 }
1667 if (myNetIsLoaded) {
1669 }
1670}
1671
1672// ----------------------------------
1673void
1675 try {
1677 } catch (InvalidArgument& e) {
1678 WRITE_ERROR(e.what());
1679 }
1680}
1681
1682
1683void
1685 if (!myCurrentIsBroken) {
1686 try {
1688 } catch (InvalidArgument& e) {
1689 WRITE_ERROR(e.what());
1690 myCurrentIsBroken = true;
1691 }
1692 }
1693 myCurrentWAUTID = "";
1694}
1695
1696
1698NLShapeHandler::getLanePos(const std::string& poiID, const std::string& laneID, double lanePos, bool friendlyPos, double lanePosLat) {
1699 MSLane* lane = MSLane::dictionary(laneID);
1700 if (lane == nullptr) {
1701 WRITE_ERROR("Lane '" + laneID + "' to place poi '" + poiID + "' on is not known.");
1702 return Position::INVALID;
1703 }
1704 if (lanePos < 0) {
1705 lanePos = lane->getLength() + lanePos;
1706 }
1707 if ((lanePos < 0) && friendlyPos) {
1708 lanePos = 0;
1709 }
1710 if ((lanePos > lane->getLength()) && friendlyPos) {
1711 lanePos = lane->getLength();
1712 }
1713 if (lanePos < 0 || lanePos > lane->getLength()) {
1714 WRITE_WARNING("lane position " + toString(lanePos) + " for poi '" + poiID + "' is not valid.");
1715 }
1716 return lane->geometryPositionAtOffset(lanePos, -lanePosLat);
1717}
1718
1719
1722 if (rs == nullptr) {
1723 throw InvalidArgument("Rail signal '" + toString((SumoXMLTag)element) + "' constraint must occur within a railSignalConstraints element");
1724 }
1725 bool ok = true;
1726 const std::string tripId = attrs.get<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok);
1727 const std::string signalID = attrs.get<std::string>(SUMO_ATTR_TLID, nullptr, ok);
1728 const std::string foesString = attrs.get<std::string>(SUMO_ATTR_FOES, nullptr, ok);
1729 const std::vector<std::string> foes = StringTokenizer(foesString).getVector();
1730 const int limit = attrs.getOpt<int>(SUMO_ATTR_LIMIT, nullptr, ok, (int)foes.size());
1731 const bool active = attrs.getOpt<bool>(SUMO_ATTR_ACTIVE, nullptr, ok, true);
1732
1733 if (!MSNet::getInstance()->getTLSControl().knows(signalID)) {
1734 throw InvalidArgument("Rail signal '" + signalID + "' in railSignalConstraints is not known");
1735 }
1736 MSRailSignal* signal = dynamic_cast<MSRailSignal*>(MSNet::getInstance()->getTLSControl().get(signalID).getDefault());
1737 if (signal == nullptr) {
1738 throw InvalidArgument("Traffic light '" + signalID + "' is not a rail signal");
1739 }
1741 switch (element) {
1743 type = MSRailSignalConstraint::ConstraintType::PREDECESSOR;
1744 break;
1746 type = MSRailSignalConstraint::ConstraintType::INSERTION_PREDECESSOR;
1747 break;
1749 type = MSRailSignalConstraint::ConstraintType::FOE_INSERTION;
1750 break;
1752 type = MSRailSignalConstraint::ConstraintType::INSERTION_ORDER;
1753 break;
1755 type = MSRailSignalConstraint::ConstraintType::BIDI_PREDECESSOR;
1756 break;
1757 default:
1758 throw InvalidArgument("Unsupported rail signal constraint '" + toString((SumoXMLTag)element) + "'");
1759 }
1760 Parameterised* result = nullptr;
1761 if (ok) {
1762 for (const std::string& foe : foes) {
1763 MSRailSignalConstraint* c = new MSRailSignalConstraint_Predecessor(type, signal, foe, limit, active);
1764 rs->addConstraint(tripId, c);
1765 // XXX if there are multiple foes, only one constraint will receive the parameters
1766 result = c;
1767 }
1768 }
1769 return result;
1770}
1771
1772
1773/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:266
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
#define SUMOTime_MAX_PERIOD
Definition: SUMOTime.h:35
#define TIME2STEPS(x)
Definition: SUMOTime.h:56
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
const SVCPermissions SVCAll
all VClasses are allowed
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
TrafficLightType
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_TRACTION_SUBSTATION
A traction substation.
@ SUMO_TAG_PHASE
a single phase description
@ SUMO_TAG_RAILSIGNAL_CONSTRAINTS
Constraints on switching a rail signal.
@ SUMO_TAG_BIDI_PREDECESSOR
Predecessor constraint for rail signal before bidirectional section.
@ SUMO_TAG_NET
root element of a network file
@ SUMO_TAG_REROUTER
A rerouter.
@ SUMO_TAG_INSERTION_PREDECESSOR
Predecessor constraint on insertion before rail signal.
@ SUMO_TAG_STOPOFFSET
Information on vClass specific stop offsets at lane end.
@ SUMO_TAG_WAUT_JUNCTION
@ SUMO_TAG_REQUEST
description of a logic request within the junction
@ SUMO_TAG_WAUT_SWITCH
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
@ SUMO_TAG_TAZ
a traffic assignment zone
@ SUMO_TAG_TIMEDEVENT
The definition of a periodic event.
@ SUMO_TAG_E2DETECTOR
an e2 detector
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
@ SUMO_TAG_ACCESS
An access point for a train stop.
@ SUMO_TAG_CONDITION
a condition for phase switching
@ SUMO_TAG_CONTAINER_STOP
A container stop.
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_TAG_MESO
edge-specific meso settings
@ SUMO_TAG_FUNCTION
a sequence of assignments evaluated in the context of passed arguments
@ SUMO_TAG_MEANDATA_LANE
a lane based mean data detector
@ SUMO_TAG_LOCATION
@ SUMO_TAG_RESTRICTION
begin/end of the description of an edge restriction
@ SUMO_TAG_OVERHEAD_WIRE_CLAMP
An overhead wire clamp (connection of wires in opposite directions)
@ SUMO_TAG_CONNECTION
connectio between two lanes
@ SUMO_TAG_PARKING_AREA
A parking area.
@ SUMO_TAG_ROUNDABOUT
roundabout defined in junction
@ SUMO_TAG_DET_ENTRY
an e3 entry point
@ SUMO_TAG_TLLOGIC
a traffic light logic
@ SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
@ SUMO_TAG_FOE_INSERTION
Predecessor constraint on switching a rail signal.
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
@ SUMO_TAG_MEANDATA_EDGE
an edge based mean data detector
@ SUMO_TAG_OVERHEAD_WIRE_SECTION
An overhead wire section.
@ SUMO_TAG_VTYPEPROBE
a vtypeprobe detector
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
@ SUMO_TAG_OVERHEAD_WIRE_SEGMENT
An overhead wire segment.
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
@ SUMO_TAG_PARAM
parameter associated to a certain key
@ SUMO_TAG_E1DETECTOR
an e1 detector
@ SUMO_TAG_INSERTION_ORDER
Predecessor constraint on insertion before rail signal.
@ SUMO_TAG_DET_EXIT
an e3 exit point
@ SUMO_TAG_TYPE
type (edge)
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
@ SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
@ SUMO_TAG_WAUT
@ SUMO_TAG_ASSIGNMENT
a conditional variable assignment for phase switching
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
@ SUMO_TAG_NEIGH
begin/end of the description of a neighboring lane
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
@ SUMO_TAG_ENTRY_EXIT_DETECTOR
alternative tag for e3 detector
@ SUMO_TAG_E3DETECTOR
an e3 detector
@ SUMO_TAG_VSS
A variable speed sign.
@ SUMO_TAG_PREDECESSOR
Predecessor constraint on switching a rail signal.
@ SUMO_TAG_EDGE
begin/end of the description of an edge
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
@ LINKSTATE_ZIPPER
This is an uncontrolled, zipper-merge link.
@ LINKSTATE_TL_OFF_BLINKING
The link is controlled by a tls which is off and blinks, has to brake.
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
@ SUMO_ATTR_DISALLOW
@ SUMO_ATTR_CONV_BOUNDARY
@ SUMO_ATTR_ALLOW
@ SUMO_ATTR_LANE
@ SUMO_ATTR_NET_OFFSET
@ SUMO_ATTR_NARGS
The number of arguments for a condition function.
@ SUMO_ATTR_CONT
@ SUMO_ATTR_ORIG_BOUNDARY
@ SUMO_ATTR_MESO_TLS_FLOW_PENALTY
@ SUMO_ATTR_LATEST_END
The maximum time within the cycle for switching (for coordinated actuation)
@ SUMO_ATTR_MESO_JUNCTION_CONTROL
@ SUMO_ATTR_RED
red duration of a phase
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_VIA
@ SUMO_ATTR_NEXT_EDGES
@ SUMO_ATTR_FILE
@ SUMO_ATTR_PROCEDURE
@ SUMO_ATTR_INDIRECT
Whether this connection is an indirect (left) turn.
@ SUMO_ATTR_Y
@ SUMO_ATTR_FROM_LANE
@ SUMO_ATTR_Z
@ SUMO_ATTR_EDGE
@ SUMO_ATTR_JAM_DIST_THRESHOLD
@ SUMO_ATTR_MESO_OVERTAKING
@ SUMO_ATTR_TRACK_VEHICLES
@ SUMO_ATTR_RESPONSE
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_TARGETLANE
@ SUMO_ATTR_OFFSET
@ SUMO_ATTR_X
@ SUMO_ATTR_WAUT_ID
@ SUMO_ATTR_YELLOW
yellow duration of a phase
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_INTLANES
@ SUMO_ATTR_VEHICLEEXTENSION
vehicle extension time of a phase
@ SUMO_ATTR_WITH_INTERNAL
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_START_PROG
@ SUMO_ATTR_BIDI
@ SUMO_ATTR_AGGREGATE
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_LIMIT
@ SUMO_ATTR_PRIORITY
@ SUMO_ATTR_MESO_TAUFF
@ SUMO_ATTR_LANES
@ SUMO_ATTR_VTYPES
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_LEFTHAND
@ SUMO_ATTR_NEXT
succesor phase index
@ SUMO_ATTR_MAX_TRAVELTIME
@ SUMO_ATTR_MESO_MINOR_PENALTY
@ SUMO_ATTR_INCLANES
@ SUMO_ATTR_CHANGE_LEFT
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_FILL
Fill the polygon.
@ SUMO_ATTR_NAME
@ SUMO_ATTR_ORIG_PROJ
@ SUMO_ATTR_PERIOD
@ SUMO_ATTR_FINAL_TARGET
The condition expression for switching into this phase when the active phase must end.
@ SUMO_ATTR_HALTING_SPEED_THRESHOLD
@ SUMO_ATTR_HIGHER_SPEED
@ SUMO_ATTR_TRIP_ID
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_ACCELERATION
@ SUMO_ATTR_CHANGE_RIGHT
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
@ SUMO_ATTR_VCLASS
@ SUMO_ATTR_DISTANCE
@ SUMO_ATTR_EARLY_TARGET
The condition expression for an early switch into this phase.
@ SUMO_ATTR_MESO_TAUJF
@ SUMO_ATTR_SHOW_DETECTOR
@ SUMO_ATTR_FOES
@ SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_TO_LANE
@ SUMO_ATTR_MIN_SAMPLES
@ SUMO_ATTR_JUNCTION_ID
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_VERSION
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_ID
@ SUMO_ATTR_MAXDURATION
maximum duration of a phase
@ SUMO_ATTR_PROGRAMID
@ SUMO_ATTR_FUNCTION
@ SUMO_ATTR_MESO_TAUFJ
@ SUMO_ATTR_VISIBILITY_DISTANCE
foe visibility distance of a link
@ SUMO_ATTR_OPEN_ENTRY
@ SUMO_ATTR_MESO_TAUJJ
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_CROSSING_EDGES
the edges crossed by a pedestrian crossing
@ SUMO_ATTR_SYNCHRON
@ SUMO_ATTR_DIR
The abstract direction of a link.
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
@ SUMO_ATTR_MINDURATION
@ SUMO_ATTR_CHECK
The expression for a condition assignment.
@ SUMO_ATTR_MESO_TLS_PENALTY
@ SUMO_ATTR_KEY
@ SUMO_ATTR_REF_TIME
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
@ SUMO_ATTR_POSITION
@ SUMO_ATTR_STATE
The state of a link.
@ SUMO_ATTR_FRICTION
@ SUMO_ATTR_TIME
trigger: the time of the step
@ SUMO_ATTR_WRITE_ATTRIBUTES
@ SUMO_ATTR_ACTIVE
@ SUMO_ATTR_DETECT_PERSONS
@ SUMO_ATTR_EXCLUDE_EMPTY
@ SUMO_ATTR_EDGESFILE
@ SUMO_ATTR_EARLIEST_END
The minimum time within the cycle for switching (for coordinated actuation)
const double SUMO_const_laneWidth
Definition: StdDefs.h:48
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
static std::string checkForRelativity(const std::string &filename, const std::string &basePath)
Returns the path from a configuration so that it is accessable from the current working directory.
const std::string & getFileName() const
returns the current file name
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
static bool init(OptionsCont &oc)
Initialises the processing and the final instance using the given options.
A road/street connecting two junctions.
Definition: MSEdge.h:77
bool isCrossing() const
return whether this edge is a pedestrian crossing
Definition: MSEdge.h:270
void setOtherTazConnector(const MSEdge *edge)
Definition: MSEdge.h:292
void setJunctions(MSJunction *from, MSJunction *to)
Definition: MSEdge.cpp:1215
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:168
void addSuccessor(MSEdge *edge, const MSEdge *via=nullptr)
Adds an edge to the list of edges which may be reached from this edge and to the incoming of the othe...
Definition: MSEdge.cpp:1140
static MSEdge * dictionaryHint(const std::string &id, const int startIdx)
Returns the MSEdge associated to the key id giving a hint with a numerical id.
Definition: MSEdge.cpp:971
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
Definition: MSEdge.cpp:101
void resetTAZ(MSJunction *junction)
Definition: MSEdge.cpp:162
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
Definition: MSEdge.cpp:945
void markAsRoundabout()
Definition: MSEdge.h:698
static bool gUseMesoSim
Definition: MSGlobals.h:103
static bool gLefthand
Whether lefthand-drive is being simulated.
Definition: MSGlobals.h:168
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
Definition: MSGlobals.h:78
The base class for an intersection.
Definition: MSJunction.h:58
void addOutgoing(MSEdge *edge)
Definition: MSJunction.h:125
void addIncoming(MSEdge *edge)
Definition: MSJunction.h:121
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
void addApproachingLane(MSLane *lane, bool warnMultiCon)
Definition: MSLane.cpp:2537
void addIncomingLane(MSLane *lane, MSLink *viaLink)
Definition: MSLane.cpp:2527
void addLink(MSLink *link)
Delayed initialization.
Definition: MSLane.cpp:310
double getLength() const
Returns the lane's length.
Definition: MSLane.h:575
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:506
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition: MSLane.cpp:2199
MSEdge & getEdge() const
Returns the lane's edge.
Definition: MSLane.h:713
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:533
The simulated network and simulation perfomer.
Definition: MSNet.h:88
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
Definition: MSNet.h:452
MSJunctionControl & getJunctionControl()
Returns the junctions control.
Definition: MSNet.h:462
void setPermissionsFound()
Labels the network to contain vehicle class permissions.
Definition: MSNet.h:215
void addMesoType(const std::string &typeID, const MESegment::MesoEdgeType &edgeType)
Adds edge type specific meso parameters.
Definition: MSNet.cpp:358
ShapeContainer & getShapeContainer()
Returns the shapes container.
Definition: MSNet.h:502
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
Definition: MSNet.cpp:343
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
The definition of a single phase of a tls logic.
std::string name
Optional name or description for the current phase.
std::vector< std::string > myTargetLaneSet
SUMOTime maxDuration
The maximum duration of the phase.
bool myCommit
the phase is a commit, compulsory directive for SOTL policies
static const SUMOTime UNSPECIFIED_DURATION
SUMOTime vehext
for NEMA phase
SUMOTime latestEnd
The maximum time within the cycle for switching (for coordinated actuation)
bool myTransientNotDecisional
the phase is a transient one or a decisional one, compulsory directive for SOTL policies
SUMOTime minDuration
The minimum duration of the phase.
SUMOTime yellow
for NEMA phase
SUMOTime red
for NEMA phase
SUMOTime myLastSwitch
Stores the timestep of the last on-switched of the phase.
SUMOTime duration
The duration of the phase.
std::vector< int > nextPhases
The index of the phase that suceeds this one (or -1)
std::string finalTarget
The condition expression for switching into this phase when the active phase must end.
std::string earlyTarget
The condition expression for an early switch into this phase.
SUMOTime earliestEnd
The minimum time within the cycle for switching (for coordinated actuation)
A base class for constraints.
A signal for rails.
Definition: MSRailSignal.h:46
void addConstraint(const std::string &tripId, MSRailSignalConstraint *constraint)
register contraint for signal switching
Parser and container for routes during their loading.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Storage for all programs of a single tls.
void addLink(MSLink *link, MSLane *lane, int pos)
MSTrafficLightLogic * getActive() const
MSTrafficLightLogic * getDefault() const
return the default program (that last used program except TRACI_PROGRAM)
void addWAUTJunction(const std::string &wautid, const std::string &tls, const std::string &proc, bool synchron)
Adds a tls to the list of tls to be switched by the named WAUT.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg, SUMOTime period)
Adds a WAUT definition.
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
The parent class for traffic light logics.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Definition: MsgHandler.cpp:79
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:116
static MsgHandler * getWarningInstance()
Returns the instance to add warnings to.
Definition: MsgHandler.cpp:66
Builds detectors for microsim.
void endE3Detector()
Builds of an e3 detector using collected values.
void createEdgeLaneMeanData(const std::string &id, SUMOTime frequency, SUMOTime begin, SUMOTime end, const std::string &type, const bool useLanes, const bool withEmpty, const bool printDefaults, const bool withInternal, const bool trackVehicles, const int detectPersons, const double maxTravelTime, const double minSamples, const double haltSpeed, const std::string &vTypes, const std::string &writeAttributes, std::vector< MSEdge * > edges, bool aggregate, const std::string &device)
Creates edge based mean data collector using the given specification.
MSLane * getLaneChecking(const std::string &laneID, SumoXMLTag type, const std::string &detid)
Returns the named lane.
void buildVTypeProbe(const std::string &id, const std::string &vtype, SUMOTime frequency, const std::string &device)
Builds a vTypeProbe and adds it to the net.
void addE3Exit(const std::string &lane, double pos, bool friendlyPos)
Builds an exit point of an e3 detector.
void buildRouteProbe(const std::string &id, const std::string &edge, SUMOTime frequency, SUMOTime begin, const std::string &device, const std::string &vTypes)
Builds a routeProbe and adds it to the net.
Parameterised * beginE3Detector(const std::string &id, const std::string &device, SUMOTime splInterval, double haltingSpeedThreshold, SUMOTime haltingTimeThreshold, const std::string name, const std::string &vTypes, const std::string &nextEdges, int detectPersons, bool openEntry)
Stores temporary the initial information about an e3 detector to build.
void addE3Entry(const std::string &lane, double pos, bool friendlyPos)
Builds an entry point of an e3 detector.
Parameterised * buildInductLoop(const std::string &id, const std::string &lane, double pos, double length, SUMOTime splInterval, const std::string &device, bool friendlyPos, const std::string name, const std::string &vTypes, const std::string &nextEdges, int detectPersons)
Builds an e1 detector and adds it to the net.
Parameterised * buildInstantInductLoop(const std::string &id, const std::string &lane, double pos, const std::string &device, bool friendlyPos, const std::string name, const std::string &vTypes, const std::string &nextEdges)
Builds an instantenous induction and adds it to the net.
Parameterised * buildE2Detector(const std::string &id, MSLane *lane, double pos, double endPos, double length, const std::string &device, SUMOTime frequency, SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold, const std::string name, const std::string &vTypes, const std::string &nextEdges, int detectPersons, bool friendlyPos, bool showDetector, MSTLLogicControl::TLSLogicVariants *tlls=0, MSLane *toLane=0)
Builds a new E2 detector and adds it to the net's detector control. Also performs some consistency ch...
std::string getCurrentE3ID() const
Returns the id of the currently built e3 detector.
void addAction(const SUMOSAXAttributes &attrs, const std::string &basePath)
Builds an action and saves it for further use.
Interface for building edges.
virtual MSEdge * closeEdge()
Closes the building of an edge; The edge is completely described by now and may not be opened again.
virtual void addNeigh(const std::string id)
Adds a neighbor to the current lane.
void closeLane()
Closes the building of a lane; The edge is completely described by now and may not be opened again.
virtual MSLane * addLane(const std::string &id, double maxSpeed, double friction, double length, const PositionVector &shape, double width, SVCPermissions permissions, SVCPermissions changeLeft, SVCPermissions changeRight, int index, bool isRampAccel, const std::string &type)
Adds a lane to the current edge.
std::string reportCurrentEdgeOrLane() const
Return info about currently processed edge or lane.
void beginEdgeParsing(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority, const std::string &bidi, double distance)
Begins building of an MSEdge.
virtual void addCrossingEdges(const std::vector< std::string > &)
add the crossingEdges in a crossing edge if present
void addStopOffsets(const StopOffset &stopOffsets)
process a stopOffset element (originates either from the active edge or lane).
virtual MSEdge * buildEdge(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, const int priority, const double distance)
Builds an edge instance (MSEdge in this case)
void addRequest(const SUMOSAXAttributes &attrs)
adds a request item to the current junction logic
Definition: NLHandler.cpp:717
bool myHaveSeenMesoEdgeType
whether edge type specific meso paramters were loaded
Definition: NLHandler.h:368
std::vector< Parameterised * > myLastParameterised
Definition: NLHandler.h:350
virtual void addE2Detector(const SUMOSAXAttributes &attrs)
Builds an e2 detector using the given specification.
Definition: NLHandler.cpp:1040
void addRoundabout(const SUMOSAXAttributes &attrs)
Definition: NLHandler.cpp:1633
void addWAUTSwitch(const SUMOSAXAttributes &attrs)
Definition: NLHandler.cpp:677
virtual void addMesoEdgeType(const SUMOSAXAttributes &attrs)
Loads edge type specific meso parameters.
Definition: NLHandler.cpp:1650
bool myCurrentIsBroken
Definition: NLHandler.h:345
void addE3Entry(const SUMOSAXAttributes &attrs)
Adds an entry to the currently processed e3 detector.
Definition: NLHandler.cpp:1282
void beginEdgeParsing(const SUMOSAXAttributes &attrs)
begins the processing of an edge
Definition: NLHandler.cpp:411
bool myHaveSeenAdditionalSpeedRestrictions
whether additional files contained type-specific speed limits
Definition: NLHandler.h:365
std::string myCurrentDistrictID
The id of the current district.
Definition: NLHandler.h:328
void addPhase(const SUMOSAXAttributes &attrs)
adds a phase to the traffic lights logic currently build
Definition: NLHandler.cpp:797
std::string myCurrentTypeID
The id of the currently processed edge type.
Definition: NLHandler.h:337
void addAssignment(const SUMOSAXAttributes &attrs)
adds a switching condition assignment to the traffic lights logic currently build
Definition: NLHandler.cpp:890
static Parameterised * addPredecessorConstraint(int element, const SUMOSAXAttributes &attrs, MSRailSignal *rs)
Definition: NLHandler.cpp:1721
virtual void addVTypeProbeDetector(const SUMOSAXAttributes &attrs)
Builds a vtype-detector using the given specification.
Definition: NLHandler.cpp:995
void addDistrictEdge(const SUMOSAXAttributes &attrs, bool isSource)
Definition: NLHandler.cpp:1611
std::string myCurrentWAUTID
The id of the currently processed WAUT.
Definition: NLHandler.h:334
void parseLanes(const std::string &junctionID, const std::string &def, std::vector< MSLane * > &into, bool &ok)
Definition: NLHandler.cpp:612
void addFunction(const SUMOSAXAttributes &attrs)
adds a switching condition function to the traffic lights logic currently build
Definition: NLHandler.cpp:900
int myPreviousEdgeIdx
Definition: NLHandler.h:383
void addLane(const SUMOSAXAttributes &attrs)
adds a lane to the previously opened edge
Definition: NLHandler.cpp:505
void initJunctionLogic(const SUMOSAXAttributes &attrs)
begins the reading of a junction row logic
Definition: NLHandler.cpp:742
Parameterised myLastEdgeParameters
Definition: NLHandler.h:349
virtual void myEndElement(int element)
Called when a closing tag occurs.
Definition: NLHandler.cpp:304
bool myHaveSeenDefaultLength
whether the loaded network contains edges with default lengths
Definition: NLHandler.h:359
NLTriggerBuilder & myTriggerBuilder
The trigger builder to use.
Definition: NLHandler.h:319
virtual void addInstantE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
Definition: NLHandler.cpp:962
virtual void openJunction(const SUMOSAXAttributes &attrs)
opens a junction for processing
Definition: NLHandler.cpp:567
virtual void endE3Detector()
Builds of an e3 detector using collected values.
Definition: NLHandler.cpp:1674
bool myAmParsingTLLogicOrJunction
internal information whether a tls-logic is currently read
Definition: NLHandler.h:331
JunctionGraph myJunctionGraph
Definition: NLHandler.h:381
double myNetworkVersion
the loaded network version
Definition: NLHandler.h:371
void addDistrict(const SUMOSAXAttributes &attrs)
Definition: NLHandler.cpp:1532
bool myCurrentIsInternalToSkip
Information whether the currently parsed edge is internal and not wished, here.
Definition: NLHandler.h:312
NLEdgeControlBuilder & myEdgeControlBuilder
The edge builder to use.
Definition: NLHandler.h:322
void initTrafficLightLogic(const SUMOSAXAttributes &attrs)
begins the reading of a traffic lights logic
Definition: NLHandler.cpp:757
void closeWAUT()
Definition: NLHandler.cpp:1684
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
Definition: NLHandler.h:353
NLHandler(const std::string &file, MSNet &net, NLDetectorBuilder &detBuilder, NLTriggerBuilder &triggerBuilder, NLEdgeControlBuilder &edgeBuilder, NLJunctionControlBuilder &junctionBuilder)
Constructor.
Definition: NLHandler.cpp:60
void addCondition(const SUMOSAXAttributes &attrs)
adds a switching condition to the traffic lights logic currently build
Definition: NLHandler.cpp:879
void setLocation(const SUMOSAXAttributes &attrs)
Parses network location description.
Definition: NLHandler.cpp:1511
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: NLHandler.cpp:87
bool myHaveSeenNeighs
whether the loaded network contains explicit neighbor lanes
Definition: NLHandler.h:362
virtual void openWAUT(const SUMOSAXAttributes &attrs)
Definition: NLHandler.cpp:649
LinkState parseLinkState(const std::string &state)
Parses the given character into an enumeration typed link state.
Definition: NLHandler.cpp:1495
NLDiscreteEventBuilder myActionBuilder
A builder for object actions.
Definition: NLHandler.h:309
NLDetectorBuilder & myDetectorBuilder
The detector builder to use.
Definition: NLHandler.h:316
NLJunctionControlBuilder & myJunctionControlBuilder
The junction builder to use.
Definition: NLHandler.h:325
virtual void addE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
Definition: NLHandler.cpp:913
virtual ~NLHandler()
Destructor.
Definition: NLHandler.cpp:83
void addE3Exit(const SUMOSAXAttributes &attrs)
Adds an exit to the currently processed e3 detector.
Definition: NLHandler.cpp:1295
void beginE3Detector(const SUMOSAXAttributes &attrs)
Starts building of an e3 detector using the given specification.
Definition: NLHandler.cpp:1239
virtual void closeEdge()
Closes the process of building an edge.
Definition: NLHandler.cpp:487
void closeFunction()
adds a switching condition function to the traffic lights logic currently build
Definition: NLHandler.cpp:908
bool myHaveJunctionHigherSpeeds
Whether the network was built with higher speed on junctions.
Definition: NLHandler.h:356
MSNet & myNet
The net to fill (preinitialised)
Definition: NLHandler.h:306
MSRailSignal * myConstrainedSignal
rail signal for which constraints are being loaded
Definition: NLHandler.h:377
LinkDirection parseLinkDir(const std::string &dir)
Parses the given character into an enumeration typed link direction.
Definition: NLHandler.cpp:1485
bool myNetIsLoaded
whether the location element was already loadee
Definition: NLHandler.h:374
void addWAUTJunction(const SUMOSAXAttributes &attrs)
Definition: NLHandler.cpp:696
virtual void addRouteProbeDetector(const SUMOSAXAttributes &attrs)
Builds a routeProbe-detector using the given specification.
Definition: NLHandler.cpp:1016
virtual void addEdgeLaneMeanData(const SUMOSAXAttributes &attrs, int objecttype)
Builds edge or lane base mean data collector using the given specification.
Definition: NLHandler.cpp:1308
bool myHaveWarnedAboutInvalidTLType
Definition: NLHandler.h:347
void addParam(const SUMOSAXAttributes &attrs)
Definition: NLHandler.cpp:632
void addConnection(const SUMOSAXAttributes &attrs)
adds a connection
Definition: NLHandler.cpp:1382
Builder of microsim-junctions and tls.
void closeJunctionLogic()
Ends the building of a junction logic (row-logic)
MSTLLogicControl::TLSLogicVariants & getTLLogic(const std::string &id) const
Returns a previously build tls logic.
void closeFunction()
closes a switching condition function to the traffic lights logic currently build
MSJunction * retrieve(const std::string id)
try to retrieve junction by id
int getNumberOfLoadedPhases() const
return the number of phases loaded so far (for error reporting)
void addPhase(MSPhaseDefinition *phase)
Adds a phase to the currently built traffic lights logic.
MSTLLogicControl & getTLLogicControlToUse() const
Returns the used tls control.
void addFunction(const std::string &id, int nArgs)
adds a switching condition function to the traffic lights logic currently build
const std::string & getActiveSubKey() const
Returns the active sub key.
bool addCondition(const std::string &id, const std::string &value)
Adds a condition to the currently built traffic lights logic.
void openJunction(const std::string &id, const std::string &key, const SumoXMLNodeType type, const Position pos, const PositionVector &shape, const std::vector< MSLane * > &incomingLanes, const std::vector< MSLane * > &internalLanes, const std::string &name)
Begins the processing of the named junction.
void addParam(const std::string &key, const std::string &value)
Adds a parameter.
void initJunctionLogic(const std::string &id)
Initialises a junction logic.
void initTrafficLightLogic(const std::string &id, const std::string &programID, TrafficLightType type, SUMOTime offset)
Begins the reading of a traffic lights logic.
const std::string & getActiveKey() const
Returns the active key.
void addAssignment(const std::string &id, const std::string &check, const std::string &value)
Adds an assignment to the currently built traffic lights logic.
void addLogicItem(int request, const std::string &response, const std::string &foes, bool cont)
Adds a logic item.
void closeJunction(const std::string &basePath)
Closes (ends) the processing of the current junction.
virtual void closeTrafficLightLogic(const std::string &basePath)
Ends the building of a traffic lights logic.
Position getLanePos(const std::string &poiID, const std::string &laneID, double lanePos, bool friendlyPos, double lanePosLat)
get position for a given laneID (Has to be implemented in all child)
Definition: NLHandler.cpp:1698
Builds trigger objects for microsim.
void parseAndBuildTractionSubstation(MSNet &net, const SUMOSAXAttributes &attrs)
Parses its values and builds a traction substation.
void addAccess(MSNet &net, const SUMOSAXAttributes &attrs)
Parses the values and adds an access point to the currently parsed stopping place.
void parseAndBuildOverheadWireSegment(MSNet &net, const SUMOSAXAttributes &attrs)
Parses its values and builds an overhead wire segment.
void parseAndBuildCalibrator(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a mesoscopic or microscopic calibrator.
virtual void endParkingArea()
End a parking area.
void parseAndBuildLaneSpeedTrigger(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a lane speed trigger.
void parseAndAddLotEntry(const SUMOSAXAttributes &attrs)
Parses his values and adds a lot entry to current parking area.
void buildVaporizer(const SUMOSAXAttributes &attrs)
Builds a vaporization.
void parseAndBuildRerouter(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a rerouter.
void parseAndBuildOverheadWireSection(MSNet &net, const SUMOSAXAttributes &attrs)
Parses its values and builds an overhead wire section.
void parseAndBuildChargingStation(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a charging station.
void parseAndBuildOverheadWireClamp(MSNet &net, const SUMOSAXAttributes &attrs)
Parses its values and builds an overhead wire clamp.
virtual void endStoppingPlace()
End a stopping place.
MSStoppingPlace * getCurrentStop()
void parseAndBuildStoppingPlace(MSNet &net, const SUMOSAXAttributes &attrs, const SumoXMLTag element)
Parses the values and builds a stopping places for busses, trains or container vehicles.
void parseAndBeginParkingArea(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a parking area.
const std::string & getID() const
Returns the id.
Definition: Named.h:74
T get(const std::string &id) const
Retrieves an item.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
void clearParameter()
Clears the parameter map.
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
void updateParameters(const Parameterised::Map &mapArg)
Adds or updates all given parameters from the map.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:298
A list of positions.
void closePolygon()
ensures that the last position equals the first
static RGBColor parseColor(std::string coldef)
Parses a color information.
Definition: RGBColor.cpp:239
virtual void myEndElement(int element)
Called when a closing tag occurs.
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOTime getOptPeriod(const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read the SUMOTime 'period' attribute.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMOTime getPeriod(const char *objectid, bool &ok, bool report=true) const
Tries to read the SUMOTime 'period' attribute.
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
static StringBijection< PersonMode > PersonModeValues
person modes
static StringBijection< LinkState > LinkStates
link states
static StringBijection< LinkDirection > LinkDirections
link directions
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea
const Polygons & getPolygons() const
Returns all polygons.
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, bool relativePath, const PositionVector &shape, bool geo, bool fill, double lineWidth, bool ignorePruning=false, const std::string &name=Shape::DEFAULT_NAME)
Builds a polygon using the given values and adds it to the container.
stop offset
T get(const std::string &str) const
std::vector< std::string > getVector()
return vector of strings
bool hasNext()
returns the information whether further substrings exist
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
auto get(const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())
Definition: json.hpp:4451
NLOHMANN_BASIC_JSON_TPL_DECLARATION void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL &j1, nlohmann::NLOHMANN_BASIC_JSON_TPL &j2) noexcept(//NOLINT(readability-inconsistent-declaration-parameter-name) is_nothrow_move_constructible< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value &&//NOLINT(misc-redundant-expression) is_nothrow_move_assignable< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value)
exchanges the values of two JSON objects
Definition: json.hpp:21884
edge type specific meso parameters
Definition: MESegment.h:55