67 myNet(net), myActionBuilder(net),
68 myCurrentIsInternalToSkip(false),
69 myDetectorBuilder(detBuilder), myTriggerBuilder(triggerBuilder),
70 myEdgeControlBuilder(edgeBuilder), myJunctionControlBuilder(junctionBuilder),
71 myAmParsingTLLogicOrJunction(false), myCurrentIsBroken(false),
72 myHaveWarnedAboutInvalidTLType(false),
73 myHaveSeenInternalEdge(false),
74 myHaveJunctionHigherSpeeds(false),
75 myHaveSeenDefaultLength(false),
76 myHaveSeenNeighs(false),
77 myHaveSeenAdditionalSpeedRestrictions(false),
78 myHaveSeenMesoEdgeType(false),
79 myNetworkVersion(0, 0),
80 myNetIsLoaded(false) {
276 const std::string signalID = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
278 throw InvalidArgument(
"Rail signal '" + signalID +
"' in railSignalConstraints is not known");
282 throw InvalidArgument(
"Traffic light '" + signalID +
"' is not a rail signal");
395 if (from ==
nullptr) {
396 WRITE_ERRORF(
TL(
"Unknown from-node '%' for edge '%'."), it->second.first, it->first);
400 WRITE_ERRORF(
TL(
"Unknown to-node '%' for edge '%'."), it->second.second, it->first);
403 if (edge !=
nullptr) {
482 if (!crossingEdges.empty()) {
483 std::vector<std::string> crossingEdgesVector;
486 crossingEdgesVector.push_back(edges.
next());
540 if (shape.size() < 2) {
541 WRITE_ERRORF(
TL(
"Shape of lane '%' is broken.\n Can not build according edge."),
id);
559 MSLane* lane =
myEdgeControlBuilder.
addLane(
id, maxSpeed, friction, length, shape, width, permissions, changeLeft, changeRight, index, isRampAccel, type, outlineShape);
591 if (shape.size() > 2) {
602 std::vector<MSLane*> incomingLanes;
605 std::vector<MSLane*> internalLanes;
615 WRITE_ERROR(e.what() + std::string(
"\n Can not build according junction."));
624 const std::string& def, std::vector<MSLane*>& into,
bool& ok) {
627 std::string laneID = st.
next();
632 if (lane ==
nullptr) {
633 WRITE_ERRORF(
TL(
"An unknown lane ('%') was tried to be set as incoming to junction '%'."), laneID, junctionID);
637 into.push_back(lane);
742 if (request >= 0 && response.length() > 0) {
787 WRITE_ERRORF(
TL(
"Traffic light '%' has unknown type '%'."),
id, typeS);
851 std::string phaseTypeString;
858 if (phaseTypeString.find(
"decisional") != std::string::npos) {
860 }
else if (phaseTypeString.find(
"transient") != std::string::npos) {
863 MsgHandler::getWarningInstance()->
inform(
"SOTL_ATTL_TYPE_DECISIONAL nor SOTL_ATTL_TYPE_TRANSIENT. Assuming phase type as SUMOSOTL_TagAttrDefinitions::SOTL_ATTL_TYPE_TRANSIENT");
866 phase->
myCommit = (phaseTypeString.find(
"commit") != std::string::npos);
868 if (phaseTypeString.find(
"target") != std::string::npos) {
869 std::string delimiter(
" ,;");
894 const std::string
id = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
905 const std::string
id = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
915 const std::string
id = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
930 const std::string
id = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
945 int detectPersons = 0;
950 WRITE_ERRORF(
TL(
"Invalid person mode '%' in E1 detector definition '%'"), mode,
id);
962 friendlyPos, name, vTypes, nextEdges, detectPersons);
1009 WRITE_WARNING(
TL(
"VTypeProbes are deprecated. Use fcd-output devices (assigned to the vType) instead."));
1057 const std::string
id = attrs.
get<std::string>(
SUMO_ATTR_ID,
nullptr, ok);
1059 const std::string toLane = attrs.
getOpt<std::string>(
SUMO_ATTR_TO,
id.c_str(), ok,
"");
1064 const double length = attrs.
getOpt<
double>(
SUMO_ATTR_LENGTH,
id.c_str(), ok, std::numeric_limits<double>::max());
1068 if (contStr !=
"") {
1069 WRITE_WARNINGF(
TL(
"Ignoring deprecated argument 'cont' for E2 detector '%'"),
id);
1072 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1077 double endPosition = attrs.
getOpt<
double>(
SUMO_ATTR_ENDPOS,
id.c_str(), ok, std::numeric_limits<double>::max());
1080 int detectPersons = 0;
1085 WRITE_ERRORF(
TL(
"Invalid person mode '%' in E2 detector definition '%'"), mode,
id);
1095 bool lanesGiven = lanes !=
"";
1096 bool laneGiven = lane !=
"";
1097 if (!(lanesGiven || laneGiven)) {
1099 WRITE_WARNING(
TL(
"Trying to specify detector's lane by the given id since the argument 'lane' is missing."))
1103 bool lengthGiven = length != std::numeric_limits<double>::max();
1104 bool posGiven = position != std::numeric_limits<double>::max();
1105 bool endPosGiven = endPosition != std::numeric_limits<double>::max();
1106 bool lsaGiven = lsaid !=
"";
1107 bool toLaneGiven = toLane !=
"";
1110 std::vector<MSLane*> clanes;
1113 std::string seps =
" ,\t\n";
1117 std::string nextLaneID = st.
next();
1119 if (nextLaneID.find_first_of(seps) != nextLaneID.npos) {
1123 clanes.push_back(clane);
1125 if (clanes.size() == 0) {
1126 throw InvalidArgument(
"Malformed argument 'lanes' for E2Detector '" +
id +
"'.\nSpecify 'lanes' as a sequence of lane-IDs separated by whitespace or comma (',')");
1129 WRITE_WARNING(
"Ignoring argument 'lane' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n"
1130 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
1133 WRITE_WARNING(
"Ignoring argument 'length' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n"
1134 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
1139 WRITE_WARNINGF(
TL(
"Missing argument 'pos' for E2Detector '%'. Assuming detector start == lane start of lane '%'."),
id, clanes[0]->getID());
1143 endPosition = clanes[clanes.size() - 1]->getLength();
1144 WRITE_WARNINGF(
TL(
"Missing argument 'endPos' for E2Detector '%'. Assuming detector end == lane end of lane '%'."),
id, clanes[clanes.size() - 1]->getID());
1149 std::stringstream ss;
1150 ss <<
"Missing argument 'lane' for E2Detector '" <<
id <<
"'."
1151 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1158 if (endPosGiven && lengthGiven) {
1159 std::stringstream ss;
1160 ss <<
"Ignoring argument 'endPos' for E2Detector '" <<
id <<
"' since argument 'pos' was given."
1161 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1163 endPosition = std::numeric_limits<double>::max();
1165 if (!lengthGiven && !endPosGiven) {
1166 std::stringstream ss;
1167 ss <<
"Missing arguments 'length'/'endPos' for E2Detector '" <<
id <<
"'. Assuming detector end == lane end of lane '" << lane <<
"'.";
1171 }
else if (endPosGiven) {
1174 std::stringstream ss;
1175 ss <<
"Missing arguments 'length'/'pos' for E2Detector '" <<
id <<
"'. Assuming detector start == lane start of lane '" << lane <<
"'.";
1179 std::stringstream ss;
1180 if (lengthGiven && fabs(length - clane->
getLength()) > NUMERICAL_EPS) {
1181 ss <<
"Incomplete positional specification for E2Detector '" <<
id <<
"'."
1182 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
1187 ss <<
"Missing arguments 'pos'/'endPos' for E2Detector '" <<
id <<
"'. Assuming that the detector covers the whole lane '" << lane <<
"'.";
1202 period = attrs.
getPeriod(
id.c_str(), ok,
false);
1210 throw InvalidArgument(
"The detector '" +
id +
"' refers to an unknown lsa '" + lsaid +
"'.");
1213 WRITE_WARNINGF(
TL(
"Ignoring argument 'period' for E2Detector '%' since argument 'tl' was given."),
id);
1219 MSLane* cToLane =
nullptr;
1225 std::string filename;
1237 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1238 name, vTypes, nextEdges, detectPersons, friendlyPos, showDetector,
1243 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1244 name, vTypes, nextEdges, detectPersons, friendlyPos, showDetector,
1259 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1266 int detectPersons = 0;
1271 WRITE_ERRORF(
TL(
"Invalid person mode '%' in E3 detector definition '%'"), mode,
id);
1283 period, haltingSpeedThreshold, haltingTimeThreshold, name, vTypes, nextEdges, detectPersons, openEntry, expectArrival);
1332 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1333 const std::string type = attrs.
getOpt<std::string>(
SUMO_ATTR_TYPE,
id.c_str(), ok,
"performance");
1339 std::vector<std::string> edgeIDs = attrs.
getOpt<std::vector<std::string> >(
SUMO_ATTR_EDGES,
id.c_str(), ok);
1345 int detectPersons = 0;
1350 WRITE_ERRORF(
TL(
"Invalid person mode '%' in edgeData definition '%'"), mode,
id);
1354 if (edgesFile !=
"") {
1355 std::ifstream strm(edgesFile.c_str());
1357 throw ProcessError(
"Could not load names of edges for edgeData definition '" +
id +
"' from '" + edgesFile +
"'.");
1359 while (strm.good()) {
1364 edgeIDs.push_back(name.substr(5));
1365 }
else if (name !=
"") {
1366 edgeIDs.push_back(name);
1370 std::vector<MSEdge*> edges;
1371 for (
const std::string& edgeID : edgeIDs) {
1373 if (edge ==
nullptr) {
1374 WRITE_ERRORF(
TL(
"Unknown edge '%' in edgeData definition '%'"), edgeID,
id);
1377 edges.push_back(edge);
1381 WRITE_WARNINGF(
TL(
"LaneData '%' requested for mesoscopic simulation but --meso-lane-queue is not active. Falling back to edgeData."),
id);
1388 excludeEmpty[0] !=
't' && excludeEmpty[0] !=
'T' && excludeEmpty[0] !=
'1' && excludeEmpty[0] !=
'x',
1389 excludeEmpty ==
"defaults", withInternal, trackVehicles, detectPersons,
1390 maxTravelTime, minSamples, haltingSpeedThreshold, vtypes, writeAttributes, edges, aggregate,
1404 const std::string toID = attrs.
get<std::string>(
SUMO_ATTR_TO,
nullptr, ok);
1427 if (from ==
nullptr) {
1428 WRITE_ERRORF(
TL(
"Unknown from-edge '%' in connection."), fromID);
1433 if (to ==
nullptr) {
1437 if (fromLaneIdx < 0 || fromLaneIdx >= (
int)from->getLanes().size() ||
1438 toLaneIdx < 0 || toLaneIdx >= (
int)to->
getLanes().size()) {
1439 WRITE_ERRORF(
TL(
"Invalid lane index in connection from '%' to '%'."), from->getID(), to->
getID());
1442 MSLane* fromLane = from->getLanes()[fromLaneIdx];
1453 if ((tlLinkIdx < 0 || tlLinkIdx >= (
int)logic->getCurrentPhaseDef().getState().size())
1457 "' in connection controlled by '" + tlID +
"'");
1469 if (via ==
nullptr) {
1471 "') should be set as a via-lane for lane '" + toLane->
getID() +
"'.");
1480 myCurrentLink =
new MSLink(fromLane, toLane, via, dir, state, length, foeVisibilityDistance, keepClear, logic, tlLinkIdx, indirect);
1481 if (via !=
nullptr) {
1513 const std::string toID = attrs.
get<std::string>(
SUMO_ATTR_TO,
nullptr, ok);
1519 if (from ==
nullptr) {
1524 if (to ==
nullptr) {
1528 if (fromLaneIdx < 0 || fromLaneIdx >= (
int)from->getLanes().size() ||
1529 toLaneIdx < 0 || toLaneIdx >= (
int)to->
getLanes().size()) {
1530 WRITE_ERRORF(
TL(
"Invalid lane index in conflict with '%' to '%'."), from->getID(), to->
getID());
1533 MSLane* fromLane = from->getLanes()[fromLaneIdx];
1582 WRITE_WARNING(
TL(
"no valid geo projection loaded from network. fcd-output.geo will not work"));
1603 if (sink ==
nullptr) {
1606 sink->
initialize(
new std::vector<MSLane*>());
1614 throw InvalidArgument(
"Another edge with the id '" + sinkID +
"' exists.");
1618 if (source ==
nullptr) {
1621 source->
initialize(
new std::vector<MSLane*>());
1628 throw InvalidArgument(
"Another edge with the id '" + sourceID +
"' exists.");
1634 for (
const std::string& eID : desc) {
1637 if (edge ==
nullptr) {
1653 if (shape.size() != 0) {
1654 if (!
myNet.
getShapeContainer().
addPolygon(
myCurrentDistrictID,
"taz", color, 0, 0,
"",
false, shape,
false, fill, 1.0,
false, name)) {
1678 if (succ !=
nullptr) {
1694 const std::vector<std::string>& edgeIDs = attrs.
get<std::vector<std::string> >(
SUMO_ATTR_EDGES,
nullptr, ok);
1696 for (
const std::string& eID : edgeIDs) {
1698 if (edge ==
nullptr) {
1734 std::vector<std::string> signalIDs = attrs.
get<std::vector<std::string>>(
SUMO_ATTR_SIGNALS,
nullptr, ok);
1735 std::vector<const MSRailSignal*> signals;
1736 for (
const std::string&
id : signalIDs) {
1739 if (rs !=
nullptr) {
1740 signals.push_back(rs);
1776 if (lane ==
nullptr) {
1777 WRITE_ERRORF(
TL(
"Lane '%' to place poi '%' on is not known."), laneID, poiID);
1783 if ((lanePos < 0) && friendlyPos) {
1786 if ((lanePos > lane->
getLength()) && friendlyPos) {
1789 if (lanePos < 0 || lanePos > lane->
getLength()) {
1798 if (rs ==
nullptr) {
1803 const std::string signalID = attrs.
get<std::string>(
SUMO_ATTR_TLID,
nullptr, ok);
1804 const std::string foesString = attrs.
get<std::string>(
SUMO_ATTR_FOES,
nullptr, ok);
1810 throw InvalidArgument(
"Rail signal '" + signalID +
"' in railSignalConstraints is not known");
1813 if (signal ==
nullptr) {
1814 throw InvalidArgument(
"Traffic light '" + signalID +
"' is not a rail signal");
1838 for (
const std::string& foe : foes) {
#define WRITE_WARNINGF(...)
#define WRITE_ERRORF(...)
#define WRITE_WARNING(msg)
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
#define SUMOTime_MAX_PERIOD
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...
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
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_REQUEST
description of a logic request within the junction
@ 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_CONFLICT
conflict between two connections
@ 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_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
connectioon 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_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_DEADLOCK
Saved deadlock information, also for loading as an extra check.
@ 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_EXPECT_ARRIVAL
@ SUMO_ATTR_CONV_BOUNDARY
@ SUMO_ATTR_NARGS
The number of arguments for a condition function.
@ 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_INDIRECT
Whether this connection is an indirect (left) turn.
@ SUMO_ATTR_JAM_DIST_THRESHOLD
@ SUMO_ATTR_MESO_OVERTAKING
@ SUMO_ATTR_TRACK_VEHICLES
@ SUMO_ATTR_YELLOW
yellow duration of a phase
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_VEHICLEEXTENSION
vehicle extension time of a phase
@ SUMO_ATTR_WITH_INTERNAL
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_NEXT
succesor phase index
@ SUMO_ATTR_MAX_TRAVELTIME
@ SUMO_ATTR_MESO_MINOR_PENALTY
@ SUMO_ATTR_FILL
Fill the polygon.
@ 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_END
weights: time range end
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
@ SUMO_ATTR_EARLY_TARGET
The condition expression for an early switch into this phase.
@ SUMO_ATTR_SHOW_DETECTOR
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_MAXDURATION
maximum duration of a phase
@ SUMO_ATTR_OUTLINESHAPE
edge: the outline shape in xml-definition
@ SUMO_ATTR_VISIBILITY_DISTANCE
foe visibility distance of a link
@ SUMO_ATTR_CROSSING_EDGES
the edges crossed by a pedestrian crossing
@ SUMO_ATTR_DIR
The abstract direction of a link.
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
@ SUMO_ATTR_CHECK
The expression for a condition assignment.
@ SUMO_ATTR_MESO_TLS_PENALTY
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
@ SUMO_ATTR_STATE
The state of a link.
@ SUMO_ATTR_TIME
trigger: the time of the step
@ SUMO_ATTR_WRITE_ATTRIBUTES
@ SUMO_ATTR_DETECT_PERSONS
@ SUMO_ATTR_EXCLUDE_EMPTY
@ SUMO_ATTR_EARLIEST_END
The minimum time within the cycle for switching (for coordinated actuation)
const double SUMO_const_laneWidth
std::pair< int, double > MMVersion
(M)ajor/(M)inor version for written networks and default version for loading
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A class that stores a 2D geometrical boundary.
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.
bool isCrossing() const
return whether this edge is a pedestrian crossing
void setOtherTazConnector(const MSEdge *edge)
void setJunctions(MSJunction *from, MSJunction *to)
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
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...
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.
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
void resetTAZ(MSJunction *junction)
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....
static bool gLefthand
Whether lefthand-drive is being simulated.
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
The base class for an intersection.
void addOutgoing(MSEdge *edge)
void addIncoming(MSEdge *edge)
Representation of a lane in the micro simulation.
void addApproachingLane(MSLane *lane, bool warnMultiCon)
void addIncomingLane(MSLane *lane, MSLink *viaLink)
void addLink(MSLink *link)
Delayed initialization.
double getLength() const
Returns the lane's length.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
virtual const PositionVector & getShape(bool) const
MSEdge & getEdge() const
Returns the lane's edge.
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
void addCustomConflict(const MSLane *from, const MSLane *to, double startPos, double endPos)
The simulated network and simulation perfomer.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
MSJunctionControl & getJunctionControl()
Returns the junctions control.
void setPermissionsFound()
Labels the network to contain vehicle class permissions.
void addMesoType(const std::string &typeID, const MESegment::MesoEdgeType &edgeType)
Adds edge type specific meso parameters.
ShapeContainer & getShapeContainer()
Returns the shapes container.
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
const MESegment::MesoEdgeType & getMesoType(const std::string &typeID)
Returns edge type specific meso parameters if no type specific parameters have been loaded,...
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.
void addDeadlockCheck(std::vector< const MSRailSignal * > signals)
static MSRailSignalControl & getInstance()
void addConstraint(const std::string &tripId, MSRailSignalConstraint *constraint)
register constraint for signal switching
Parser and container for routes during their loading.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs) override
Called on the opening of a tag;.
Storage for all programs of a single tls.
void addLink(MSLink *link, MSLane *lane, int pos)
void ignoreLinkIndex(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.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
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.
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
static MsgHandler * getWarningInstance()
Returns the instance to add warnings to.
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.
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...
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, bool expectArrival)
Stores temporary the initial information about an e3 detector to build.
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.
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 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, const PositionVector &outlineShape)
Adds a lane to the current edge.
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
bool myHaveSeenMesoEdgeType
whether edge type specific meso paramters were loaded
std::vector< Parameterised * > myLastParameterised
virtual void addE2Detector(const SUMOSAXAttributes &attrs)
Builds an e2 detector using the given specification.
MSLink * myCurrentLink
the link element for the connection currently being parsed
void addRoundabout(const SUMOSAXAttributes &attrs)
void addWAUTSwitch(const SUMOSAXAttributes &attrs)
virtual void addMesoEdgeType(const SUMOSAXAttributes &attrs)
Loads edge type specific meso parameters.
void addE3Entry(const SUMOSAXAttributes &attrs)
Adds an entry to the currently processed e3 detector.
void beginEdgeParsing(const SUMOSAXAttributes &attrs)
begins the processing of an edge
bool myHaveSeenAdditionalSpeedRestrictions
whether additional files contained type-specific speed limits
std::string myCurrentDistrictID
The id of the current district.
void addPhase(const SUMOSAXAttributes &attrs)
adds a phase to the traffic lights logic currently build
MMVersion myNetworkVersion
the loaded network version
std::string myCurrentTypeID
The id of the currently processed edge type.
void addAssignment(const SUMOSAXAttributes &attrs)
adds a switching condition assignment to the traffic lights logic currently build
static Parameterised * addPredecessorConstraint(int element, const SUMOSAXAttributes &attrs, MSRailSignal *rs)
virtual void addVTypeProbeDetector(const SUMOSAXAttributes &attrs)
Builds a vtype-detector using the given specification.
void addDistrictEdge(const SUMOSAXAttributes &attrs, bool isSource)
std::string myCurrentWAUTID
The id of the currently processed WAUT.
void parseLanes(const std::string &junctionID, const std::string &def, std::vector< MSLane * > &into, bool &ok)
void addFunction(const SUMOSAXAttributes &attrs)
adds a switching condition function to the traffic lights logic currently build
void addLane(const SUMOSAXAttributes &attrs)
adds a lane to the previously opened edge
void initJunctionLogic(const SUMOSAXAttributes &attrs)
begins the reading of a junction row logic
Parameterised myLastEdgeParameters
virtual void myEndElement(int element)
Called when a closing tag occurs.
bool myHaveSeenDefaultLength
whether the loaded network contains edges with default lengths
NLTriggerBuilder & myTriggerBuilder
The trigger builder to use.
virtual void addInstantE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
virtual void openJunction(const SUMOSAXAttributes &attrs)
opens a junction for processing
virtual void endE3Detector()
Builds of an e3 detector using collected values.
bool myAmParsingTLLogicOrJunction
internal information whether a tls-logic is currently read
JunctionGraph myJunctionGraph
void addDistrict(const SUMOSAXAttributes &attrs)
bool myCurrentIsInternalToSkip
Information whether the currently parsed edge is internal and not wished, here.
NLEdgeControlBuilder & myEdgeControlBuilder
The edge builder to use.
void initTrafficLightLogic(const SUMOSAXAttributes &attrs)
begins the reading of a traffic lights logic
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
NLHandler(const std::string &file, MSNet &net, NLDetectorBuilder &detBuilder, NLTriggerBuilder &triggerBuilder, NLEdgeControlBuilder &edgeBuilder, NLJunctionControlBuilder &junctionBuilder)
Constructor.
void addCondition(const SUMOSAXAttributes &attrs)
adds a switching condition to the traffic lights logic currently build
void setLocation(const SUMOSAXAttributes &attrs)
Parses network location description.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
bool myHaveSeenNeighs
whether the loaded network contains explicit neighbor lanes
virtual void openWAUT(const SUMOSAXAttributes &attrs)
LinkState parseLinkState(const std::string &state)
Parses the given character into an enumeration typed link state.
NLDiscreteEventBuilder myActionBuilder
A builder for object actions.
NLDetectorBuilder & myDetectorBuilder
The detector builder to use.
void addConflict(const SUMOSAXAttributes &attrs)
NLJunctionControlBuilder & myJunctionControlBuilder
The junction builder to use.
virtual void addE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
virtual ~NLHandler()
Destructor.
void addE3Exit(const SUMOSAXAttributes &attrs)
Adds an exit to the currently processed e3 detector.
void beginE3Detector(const SUMOSAXAttributes &attrs)
Starts building of an e3 detector using the given specification.
virtual void closeEdge()
Closes the process of building an edge.
void closeFunction()
adds a switching condition function to the traffic lights logic currently build
bool myHaveJunctionHigherSpeeds
Whether the network was built with higher speed on junctions.
MSNet & myNet
The net to fill (preinitialised)
virtual void addDeadlock(const SUMOSAXAttributes &attrs)
Loads deadlock information for preparing additional rail signal checks.
MSRailSignal * myConstrainedSignal
rail signal for which constraints are being loaded
LinkDirection parseLinkDir(const std::string &dir)
Parses the given character into an enumeration typed link direction.
bool myNetIsLoaded
whether the location element was already loadee
void addWAUTJunction(const SUMOSAXAttributes &attrs)
virtual void addRouteProbeDetector(const SUMOSAXAttributes &attrs)
Builds a routeProbe-detector using the given specification.
virtual void addEdgeLaneMeanData(const SUMOSAXAttributes &attrs, int objecttype)
Builds edge or lane base mean data collector using the given specification.
bool myHaveWarnedAboutInvalidTLType
void addParam(const SUMOSAXAttributes &attrs)
void addConnection(const SUMOSAXAttributes &attrs)
adds a connection
Builder of microsim-junctions and tls.
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
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.
const MSSimpleTrafficLightLogic::Phases & getLoadedPhases() const
return the phases loaded so far (for error reporting and cleanup)
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)
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 updateParkingAreaDefaultCapacity()
updates the parkingArea default capacity
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.
T get(const std::string &id) const
Retrieves an item.
static OptionsCont & getOptions()
Retrieves the options.
An upper class for objects with additional parameters.
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.
static const Position INVALID
used to indicate that a position is valid
void closePolygon()
ensures that the last position equals the first
static RGBColor parseColor(std::string coldef)
Parses a color information.
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 getOptOffsetReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a tls offset (SUMOTime or "begin")
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.
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 MMVersion toVersion(const std::string &sData)
parse a (network) version string
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
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
edge type specific meso parameters