Eclipse SUMO - Simulation of Urban MObility
SUMOXMLDefinitions.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2002-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
20 // Definitions of elements and attributes known by SUMO
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <config.h>
28 
29 #include <cassert>
32 
33 #include "SUMOXMLDefinitions.h"
34 
35 // ===========================================================================
36 // definitions
37 // ===========================================================================
38 
40  // Simulation elements
41  { "net", SUMO_TAG_NET },
42  { "edge", SUMO_TAG_EDGE },
43  { "lane", SUMO_TAG_LANE },
44  { "neigh", SUMO_TAG_NEIGH },
45  { "poi", SUMO_TAG_POI },
46  { "poiLane", SUMO_TAG_POILANE },
47  { "poly", SUMO_TAG_POLY },
48  { "junction", SUMO_TAG_JUNCTION },
49  { "restriction", SUMO_TAG_RESTRICTION },
50  { "e1Detector", SUMO_TAG_E1DETECTOR },
51  { "inductionLoop", SUMO_TAG_INDUCTION_LOOP },
52  { "e2Detector", SUMO_TAG_E2DETECTOR },
53  { "e2MultilaneDetector", SUMO_TAG_E2DETECTOR_MULTILANE },
54  { "laneAreaDetector", SUMO_TAG_LANE_AREA_DETECTOR },
55  { "e3Detector", SUMO_TAG_E3DETECTOR },
56  { "entryExitDetector", SUMO_TAG_ENTRY_EXIT_DETECTOR },
57  { "edgeData", SUMO_TAG_MEANDATA_EDGE },
58  { "laneData", SUMO_TAG_MEANDATA_LANE },
59  { "detEntry", SUMO_TAG_DET_ENTRY },
60  { "detExit", SUMO_TAG_DET_EXIT },
61  { "edgeFollowDetector", SUMO_TAG_EDGEFOLLOWDETECTOR },
62  { "instantInductionLoop", SUMO_TAG_INSTANT_INDUCTION_LOOP },
63  { "variableSpeedSign", SUMO_TAG_VSS },
64  { "calibrator", SUMO_TAG_CALIBRATOR },
65  { "laneCalibrator", SUMO_TAG_LANECALIBRATOR },
66  { "rerouter", SUMO_TAG_REROUTER },
67  { "busStop", SUMO_TAG_BUS_STOP },
68  { "trainStop", SUMO_TAG_TRAIN_STOP },
69  { "ptLine", SUMO_TAG_PT_LINE },
70  { "access", SUMO_TAG_ACCESS },
71  { "containerStop", SUMO_TAG_CONTAINER_STOP },
72  { "parkingArea", SUMO_TAG_PARKING_AREA },
73  { "space", SUMO_TAG_PARKING_SPACE },
74  { "chargingStation", SUMO_TAG_CHARGING_STATION },
75  { "vTypeProbe", SUMO_TAG_VTYPEPROBE },
76  { "routeProbe", SUMO_TAG_ROUTEPROBE },
77  { "routes", SUMO_TAG_ROUTES },
78  { "vehicle", SUMO_TAG_VEHICLE },
79  { "vType", SUMO_TAG_VTYPE },
80  { "pType", SUMO_TAG_PTYPE },
81  { "route", SUMO_TAG_ROUTE },
82  { "embeddedRoute", SUMO_TAG_EMBEDDEDROUTE },
83  { "request", SUMO_TAG_REQUEST },
84  { "source", SUMO_TAG_SOURCE },
85  { "taz", SUMO_TAG_TAZ },
86  { "tazSource", SUMO_TAG_TAZSOURCE },
87  { "tazSink", SUMO_TAG_TAZSINK },
88  { "trafficLight", SUMO_TAG_TRAFFIC_LIGHT },
89  { "tlLogic", SUMO_TAG_TLLOGIC },
90  { "phase", SUMO_TAG_PHASE },
91  { "trip", SUMO_TAG_TRIP },
92  { "tripTAZ", SUMO_TAG_TRIP_TAZ },
93  { "flow", SUMO_TAG_FLOW },
94  { "routeFlow", SUMO_TAG_ROUTEFLOW },
95  { "flowCalibrator", SUMO_TAG_FLOW_CALIBRATOR },
96  { "flowState", SUMO_TAG_FLOWSTATE },
97  { "step", SUMO_TAG_STEP },
98  { "interval", SUMO_TAG_INTERVAL },
99  { "timedEvent", SUMO_TAG_TIMEDEVENT },
100  { "fromEdge", SUMO_TAG_FROMEDGE },
101  { "toEdge", SUMO_TAG_TOEDGE },
102  { "sink", SUMO_TAG_SINK },
103  { "param", SUMO_TAG_PARAM },
104  { "WAUT", SUMO_TAG_WAUT },
105  { "wautSwitch", SUMO_TAG_WAUT_SWITCH },
106  { "wautJunction", SUMO_TAG_WAUT_JUNCTION },
107  { "segment", SUMO_TAG_SEGMENT },
108  { "delete", SUMO_TAG_DELETE },
109  { "stop", SUMO_TAG_STOP },
110  { "stopBusStop", SUMO_TAG_STOP_BUSSTOP },
111  { "stopContainerStop", SUMO_TAG_STOP_CONTAINERSTOP },
112  { "stopChargingStation", SUMO_TAG_STOP_CHARGINGSTATION },
113  { "stopParkingArea", SUMO_TAG_STOP_PARKINGAREA },
114  { "stopLane", SUMO_TAG_STOP_LANE },
115  { "destProbReroute", SUMO_TAG_DEST_PROB_REROUTE },
116  { "closingReroute", SUMO_TAG_CLOSING_REROUTE },
117  { "closingLaneReroute", SUMO_TAG_CLOSING_LANE_REROUTE },
118  { "routeProbReroute", SUMO_TAG_ROUTE_PROB_REROUTE },
119  { "parkingAreaReroute", SUMO_TAG_PARKING_ZONE_REROUTE },
120  { "polygonType", SUMO_TAG_POLYTYPE },
121  { "connection", SUMO_TAG_CONNECTION },
122  { "prohibition", SUMO_TAG_PROHIBITION },
123  { "split", SUMO_TAG_SPLIT },
124  { "node", SUMO_TAG_NODE },
125  { "type", SUMO_TAG_TYPE },
126  { "detectorDefinition", SUMO_TAG_DETECTOR_DEFINITION },
127  { "routeDistribution", SUMO_TAG_ROUTE_DISTRIBUTION },
128  { "vTypeDistribution", SUMO_TAG_VTYPE_DISTRIBUTION },
129  { "vaporizer", SUMO_TAG_VAPORIZER },
130  { "roundabout", SUMO_TAG_ROUNDABOUT },
131  { "join", SUMO_TAG_JOIN },
132  { "joinExclude", SUMO_TAG_JOINEXCLUDE },
133  { "crossing", SUMO_TAG_CROSSING },
134  { "walkingArea", SUMO_TAG_WALKINGAREA },
135  { "stopOffset", SUMO_TAG_STOPOFFSET },
136  // OSM
137  { "way", SUMO_TAG_WAY },
138  { "nd", SUMO_TAG_ND },
139  { "tag", SUMO_TAG_TAG },
140  { "relation", SUMO_TAG_RELATION },
141  { "member", SUMO_TAG_MEMBER },
142  // View
143  { "viewsettings", SUMO_TAG_VIEWSETTINGS },
144  { "decal", SUMO_TAG_VIEWSETTINGS_DECAL },
145  { "light", SUMO_TAG_VIEWSETTINGS_LIGHT },
146  { "scheme", SUMO_TAG_VIEWSETTINGS_SCHEME },
147  { "opengl", SUMO_TAG_VIEWSETTINGS_OPENGL },
148  { "background", SUMO_TAG_VIEWSETTINGS_BACKGROUND },
149  { "edges", SUMO_TAG_VIEWSETTINGS_EDGES },
150  { "vehicles", SUMO_TAG_VIEWSETTINGS_VEHICLES },
151  { "persons", SUMO_TAG_VIEWSETTINGS_PERSONS },
152  { "containers", SUMO_TAG_VIEWSETTINGS_CONTAINERS },
153  { "junctions", SUMO_TAG_VIEWSETTINGS_JUNCTIONS },
154  { "additionals", SUMO_TAG_VIEWSETTINGS_ADDITIONALS },
155  { "pois", SUMO_TAG_VIEWSETTINGS_POIS },
156  { "polys", SUMO_TAG_VIEWSETTINGS_POLYS },
157  { "legend", SUMO_TAG_VIEWSETTINGS_LEGEND },
158  { "event", SUMO_TAG_VIEWSETTINGS_EVENT },
160  { "include", SUMO_TAG_INCLUDE },
161  { "delay", SUMO_TAG_DELAY },
162  { "viewport", SUMO_TAG_VIEWPORT },
163  { "snapshot", SUMO_TAG_SNAPSHOT },
164  { "breakpoints-file", SUMO_TAG_BREAKPOINTS_FILE },
165  { "breakpoint", SUMO_TAG_BREAKPOINT },
166  { "location", SUMO_TAG_LOCATION },
167  { "colorScheme", SUMO_TAG_COLORSCHEME },
168  { "scalingScheme", SUMO_TAG_SCALINGSCHEME },
169  { "entry", SUMO_TAG_ENTRY },
170  { "rngState", SUMO_TAG_RNGSTATE },
171  { "vehicleTransfer", SUMO_TAG_VEHICLETRANSFER },
172  { "device", SUMO_TAG_DEVICE },
173  // Cars
174  { "carFollowing-IDM", SUMO_TAG_CF_IDM },
175  { "carFollowing-IDMM", SUMO_TAG_CF_IDMM },
176  { "carFollowing-Krauss", SUMO_TAG_CF_KRAUSS },
177  { "carFollowing-KraussPS", SUMO_TAG_CF_KRAUSS_PLUS_SLOPE },
178  { "carFollowing-KraussOrig1", SUMO_TAG_CF_KRAUSS_ORIG1 },
179  { "carFollowing-KraussX", SUMO_TAG_CF_KRAUSSX },
180  { "carFollowing-SmartSK", SUMO_TAG_CF_SMART_SK },
181  { "carFollowing-Daniel1", SUMO_TAG_CF_DANIEL1 },
182  { "carFollowing-PWagner2009", SUMO_TAG_CF_PWAGNER2009 },
183  { "carFollowing-BKerner", SUMO_TAG_CF_BKERNER },
184  { "carFollowing-Wiedemann", SUMO_TAG_CF_WIEDEMANN },
185  { "carFollowing-W99", SUMO_TAG_CF_W99 },
186  { "carFollowing-Rail", SUMO_TAG_CF_RAIL },
187  { "carFollowing-ACC", SUMO_TAG_CF_ACC },
188  { "carFollowing-CACC", SUMO_TAG_CF_CACC },
189  { "carFollowing-CC", SUMO_TAG_CF_CC },
190  // Person
191  { "person", SUMO_TAG_PERSON },
192  { "personTrip", SUMO_TAG_PERSONTRIP },
193  { "ride", SUMO_TAG_RIDE },
194  { "walk", SUMO_TAG_WALK },
195  { "personFlow", SUMO_TAG_PERSONFLOW },
196  // Person (Netedit)
197  { "personTripFromTo", SUMO_TAG_PERSONTRIP_FROMTO },
198  { "personTripBusStop", SUMO_TAG_PERSONTRIP_BUSSTOP },
199  { "walkEdges", SUMO_TAG_WALK_EDGES },
200  { "walkFromTo", SUMO_TAG_WALK_FROMTO },
201  { "walkBusStop", SUMO_TAG_WALK_BUSSTOP },
202  { "walkRoute", SUMO_TAG_WALK_ROUTE },
203  { "rideFromTo", SUMO_TAG_RIDE_FROMTO },
204  { "rideBusStop", SUMO_TAG_RIDE_BUSSTOP },
205  { "personStopBusStop", SUMO_TAG_PERSONSTOP_BUSSTOP },
206  { "personStopLane", SUMO_TAG_PERSONSTOP_LANE },
207  // Transport
208  { "container", SUMO_TAG_CONTAINER },
209  { "transport", SUMO_TAG_TRANSPORT },
210  { "tranship", SUMO_TAG_TRANSHIP },
211  //Trajectories
212  { "trajectories", SUMO_TAG_TRAJECTORIES },
213  { "timestep", SUMO_TAG_TIMESTEP },
214  { "timeSlice", SUMO_TAG_TIMESLICE },
215  { "actorConfig", SUMO_TAG_ACTORCONFIG },
216  { "motionState", SUMO_TAG_MOTIONSTATE },
217  { "odPair", SUMO_TAG_OD_PAIR },
218  // ActivityGen statistics file
219  { "general", AGEN_TAG_GENERAL },
220  { "street", AGEN_TAG_STREET },
221  { "workHours", AGEN_TAG_WORKHOURS },
222  { "opening", AGEN_TAG_OPENING },
223  { "closing", AGEN_TAG_CLOSING },
224  { "schools", AGEN_TAG_SCHOOLS },
225  { "school", AGEN_TAG_SCHOOL },
226  { "busStation", AGEN_TAG_BUSSTATION },
227  { "busLine", AGEN_TAG_BUSLINE },
228  { "stations", AGEN_TAG_STATIONS },
229  { "revStations", AGEN_TAG_REV_STATIONS },
230  { "station", AGEN_TAG_STATION },
231  { "frequency", AGEN_TAG_FREQUENCY },
232  { "population", AGEN_TAG_POPULATION },
233  { "bracket", AGEN_TAG_BRACKET },
234  { "cityGates", AGEN_TAG_CITYGATES },
235  { "entrance", AGEN_TAG_ENTRANCE },
236  { "parameters", AGEN_TAG_PARAM },
237  // Other
238  { "", SUMO_TAG_NOTHING } //< must be the last one
239 };
240 
241 
243  // Edge
244  { "id", SUMO_ATTR_ID },
245  { "refId", SUMO_ATTR_REFID },
246  { "name", SUMO_ATTR_NAME },
247  { "type", SUMO_ATTR_TYPE },
248  { "priority", SUMO_ATTR_PRIORITY },
249  { "numLanes", SUMO_ATTR_NUMLANES },
250  { "speed", SUMO_ATTR_SPEED },
251  { "oneway", SUMO_ATTR_ONEWAY },
252  { "width", SUMO_ATTR_WIDTH },
253  { "widthResolution", SUMO_ATTR_WIDTHRESOLUTION },
254  { "maxWidth", SUMO_ATTR_MAXWIDTH },
255  { "minWidth", SUMO_ATTR_MINWIDTH },
256  { "sidewalkWidth", SUMO_ATTR_SIDEWALKWIDTH },
257  { "bikeLaneWidth", SUMO_ATTR_BIKELANEWIDTH },
258  { "remove", SUMO_ATTR_REMOVE },
259  { "length", SUMO_ATTR_LENGTH },
260  { "bidi", SUMO_ATTR_BIDI },
261  { "distance", SUMO_ATTR_DISTANCE },
262  // Split
263  { "idBefore", SUMO_ATTR_ID_BEFORE },
264  { "idAfter", SUMO_ATTR_ID_AFTER },
265  // Positions
266  { "x", SUMO_ATTR_X },
267  { "y", SUMO_ATTR_Y },
268  { "z", SUMO_ATTR_Z },
269  { "centerX", SUMO_ATTR_CENTER_X },
270  { "centerY", SUMO_ATTR_CENTER_Y },
271  { "centerZ", SUMO_ATTR_CENTER_Z },
272 
273  { "key", SUMO_ATTR_KEY },
274  { "requestSize", SUMO_ATTR_REQUESTSIZE },
275  { "request", SUMO_ATTR_REQUEST },
276  { "response", SUMO_ATTR_RESPONSE },
277  { "programID", SUMO_ATTR_PROGRAMID },
278  { "offset", SUMO_ATTR_OFFSET },
279  { "endOffset", SUMO_ATTR_ENDOFFSET },
280  { "incLanes", SUMO_ATTR_INCLANES },
281  { "intLanes", SUMO_ATTR_INTLANES },
282 
283  { "weight", SUMO_ATTR_WEIGHT },
284  { "node", SUMO_ATTR_NODE },
285  { "edge", SUMO_ATTR_EDGE },
286  { "edges", SUMO_ATTR_EDGES },
287  // Vehicle
288  { "depart", SUMO_ATTR_DEPART },
289  { "departLane", SUMO_ATTR_DEPARTLANE },
290  { "departPos", SUMO_ATTR_DEPARTPOS },
291  { "departPosLat", SUMO_ATTR_DEPARTPOS_LAT },
292  { "departSpeed", SUMO_ATTR_DEPARTSPEED },
293  { "arrivalLane", SUMO_ATTR_ARRIVALLANE },
294  { "arrivalPos", SUMO_ATTR_ARRIVALPOS },
295  { "arrivalPosLat", SUMO_ATTR_ARRIVALPOS_LAT },
296  { "arrivalSpeed", SUMO_ATTR_ARRIVALSPEED },
297  { "route", SUMO_ATTR_ROUTE },
298  { "maxSpeed", SUMO_ATTR_MAXSPEED },
299  { "maxSpeedLat", SUMO_ATTR_MAXSPEED_LAT },
300  { "latAlignment", SUMO_ATTR_LATALIGNMENT },
301  { "minGapLat", SUMO_ATTR_MINGAP_LAT },
302  { "accel", SUMO_ATTR_ACCEL },
303  { "decel", SUMO_ATTR_DECEL },
304  { "emergencyDecel", SUMO_ATTR_EMERGENCYDECEL },
305  { "apparentDecel", SUMO_ATTR_APPARENTDECEL },
306  { "actionStepLength", SUMO_ATTR_ACTIONSTEPLENGTH },
307  { "hasDriverState", SUMO_ATTR_HASDRIVERSTATE },
308  { "vClass", SUMO_ATTR_VCLASS },
309  { "vClasses", SUMO_ATTR_VCLASSES },
310  { "exceptions", SUMO_ATTR_EXCEPTIONS },
311  { "repno", SUMO_ATTR_REPNUMBER },
312  { "speedFactor", SUMO_ATTR_SPEEDFACTOR },
313  { "speedDev", SUMO_ATTR_SPEEDDEV },
314  { "laneChangeModel", SUMO_ATTR_LANE_CHANGE_MODEL },
315  { "carFollowModel", SUMO_ATTR_CAR_FOLLOW_MODEL },
316  { "minGap", SUMO_ATTR_MINGAP },
317  { "collisionMinGapFactor", SUMO_ATTR_COLLISION_MINGAP_FACTOR },
318  { "boardingDuration", SUMO_ATTR_BOARDING_DURATION },
319  { "loadingDuration", SUMO_ATTR_LOADING_DURATION },
320  // Charging Station
321  { "power", SUMO_ATTR_CHARGINGPOWER },
322  { "efficiency", SUMO_ATTR_EFFICIENCY },
323  { "chargeInTransit", SUMO_ATTR_CHARGEINTRANSIT },
324  { "chargeDelay", SUMO_ATTR_CHARGEDELAY},
325  // MSDevice_Battery
326  { "actualBatteryCapacity", SUMO_ATTR_ACTUALBATTERYCAPACITY },
327  { "maximumBatteryCapacity", SUMO_ATTR_MAXIMUMBATTERYCAPACITY },
328  { "maximumPower", SUMO_ATTR_MAXIMUMPOWER },
329  { "vehicleMass", SUMO_ATTR_VEHICLEMASS },
330  { "frontSurfaceArea", SUMO_ATTR_FRONTSURFACEAREA },
331  { "airDragCoefficient", SUMO_ATTR_AIRDRAGCOEFFICIENT },
332  { "internalMomentOfInertia", SUMO_ATTR_INTERNALMOMENTOFINERTIA },
333  { "radialDragCoefficient", SUMO_ATTR_RADIALDRAGCOEFFICIENT },
334  { "rollDragCoefficient", SUMO_ATTR_ROLLDRAGCOEFFICIENT },
335  { "constantPowerIntake", SUMO_ATTR_CONSTANTPOWERINTAKE },
336  { "propulsionEfficiency", SUMO_ATTR_PROPULSIONEFFICIENCY },
337  { "recuperationEfficiency", SUMO_ATTR_RECUPERATIONEFFICIENCY },
338  { "recuperationEfficiencyByDecel", SUMO_ATTR_RECUPERATIONEFFICIENCY_BY_DECELERATION },
339  { "stoppingTreshold", SUMO_ATTR_STOPPINGTRESHOLD },
340  // MSBatteryExport
341  { "energyConsumed", SUMO_ATTR_ENERGYCONSUMED },
342  { "chargingStationId", SUMO_ATTR_CHARGINGSTATIONID },
343  { "energyCharged", SUMO_ATTR_ENERGYCHARGED },
344  { "energyChargedInTransit", SUMO_ATTR_ENERGYCHARGEDINTRANSIT },
345  { "energyChargedStopped", SUMO_ATTR_ENERGYCHARGEDSTOPPED },
346  { "posOnLane", SUMO_ATTR_POSONLANE },
347  { "timeStopped", SUMO_ATTR_TIMESTOPPED },
348  // ChargingStation output
349  { "chargingStatus", SUMO_ATTR_CHARGING_STATUS },
350  { "totalEnergyCharged", SUMO_ATTR_TOTALENERGYCHARGED },
351  { "chargingSteps", SUMO_ATTR_CHARGINGSTEPS },
352  { "totalEnergyChargedIntoVehicle", SUMO_ATTR_TOTALENERGYCHARGED_VEHICLE },
353  { "chargingBegin", SUMO_ATTR_CHARGINGBEGIN },
354  { "chargingEnd", SUMO_ATTR_CHARGINGEND },
355  { "partialCharge", SUMO_ATTR_PARTIALCHARGE },
356 
357  { "sigma", SUMO_ATTR_SIGMA },
358  { "tau", SUMO_ATTR_TAU },
359  { "tmp1", SUMO_ATTR_TMP1 },
360  { "tmp2", SUMO_ATTR_TMP2 },
361  { "tmp3", SUMO_ATTR_TMP3 },
362  { "tmp4", SUMO_ATTR_TMP4 },
363  { "tmp5", SUMO_ATTR_TMP5 },
364 
365  { "speedControlGain", SUMO_ATTR_SC_GAIN },
366  { "gapClosingControlGainSpeed", SUMO_ATTR_GCC_GAIN_SPEED },
367  { "gapClosingControlGainSpace", SUMO_ATTR_GCC_GAIN_SPACE },
368  { "gapControlGainSpeed", SUMO_ATTR_GC_GAIN_SPEED },
369  { "gapControlGainSpace", SUMO_ATTR_GC_GAIN_SPACE },
370  { "collisionAvoidanceGainSpeed", SUMO_ATTR_CA_GAIN_SPEED },
371  { "collisionAvoidanceGainSpace", SUMO_ATTR_CA_GAIN_SPACE },
372 
373  { "speedControlGainCACC", SUMO_ATTR_SC_GAIN_CACC },
374  { "gapClosingControlGainGap", SUMO_ATTR_GCC_GAIN_GAP_CACC },
375  { "gapClosingControlGainGapDot", SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC },
376  { "gapControlGainGap", SUMO_ATTR_GC_GAIN_GAP_CACC },
377  { "gapControlGainGapDot", SUMO_ATTR_GC_GAIN_GAP_DOT_CACC },
378  { "tauCACCToACC", SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC },
379  { "collisionAvoidanceGainGap", SUMO_ATTR_CA_GAIN_GAP_CACC },
380  { "collisionAvoidanceGainGapDot", SUMO_ATTR_CA_GAIN_GAP_DOT_CACC },
381 
382  { "trainType", SUMO_ATTR_TRAIN_TYPE },
383 
384  { "lcStrategic", SUMO_ATTR_LCA_STRATEGIC_PARAM },
385  { "lcCooperative", SUMO_ATTR_LCA_COOPERATIVE_PARAM },
386  { "lcSpeedGain", SUMO_ATTR_LCA_SPEEDGAIN_PARAM },
387  { "lcKeepRight", SUMO_ATTR_LCA_KEEPRIGHT_PARAM },
388  { "lcSublane", SUMO_ATTR_LCA_SUBLANE_PARAM },
389  { "lcOpposite", SUMO_ATTR_LCA_OPPOSITE_PARAM },
390  { "lcPushy", SUMO_ATTR_LCA_PUSHY },
391  { "lcPushyGap", SUMO_ATTR_LCA_PUSHYGAP },
392  { "lcAssertive", SUMO_ATTR_LCA_ASSERTIVE },
393  { "lcImpatience", SUMO_ATTR_LCA_IMPATIENCE },
394  { "lcTimeToImpatience", SUMO_ATTR_LCA_TIME_TO_IMPATIENCE },
395  { "lcAccelLat", SUMO_ATTR_LCA_ACCEL_LAT },
396  { "lcTurnAlignmentDistance", SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE },
397  { "lcOvertakeRight", SUMO_ATTR_LCA_OVERTAKE_RIGHT },
398  { "lcLookaheadLeft", SUMO_ATTR_LCA_LOOKAHEADLEFT },
399  { "lcSpeedGainRight", SUMO_ATTR_LCA_SPEEDGAINRIGHT },
400  { "lcMaxSpeedLatStanding", SUMO_ATTR_LCA_MAXSPEEDLATSTANDING },
401  { "lcMaxSpeedLatFactor", SUMO_ATTR_LCA_MAXSPEEDLATFACTOR },
402  { "lcExperimental1", SUMO_ATTR_LCA_EXPERIMENTAL1 },
403 
404  { "jmCrossingGap", SUMO_ATTR_JM_CROSSING_GAP },
405  { "jmDriveAfterYellowTime", SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME },
406  { "jmDriveAfterRedTime", SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME },
407  { "jmDriveRedSpeed", SUMO_ATTR_JM_DRIVE_RED_SPEED },
408  { "jmIgnoreKeepClearTime", SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME },
409  { "jmIgnoreFoeSpeed", SUMO_ATTR_JM_IGNORE_FOE_SPEED },
410  { "jmIgnoreFoeProb", SUMO_ATTR_JM_IGNORE_FOE_PROB },
411  { "jmSigmaMinor", SUMO_ATTR_JM_SIGMA_MINOR },
412  { "jmTimegapMinor", SUMO_ATTR_JM_TIMEGAP_MINOR },
413 
414  { "last", SUMO_ATTR_LAST },
415  { "cost", SUMO_ATTR_COST },
416  { "savings", SUMO_ATTR_SAVINGS },
417  { "probability", SUMO_ATTR_PROB },
418  { "probabilities", SUMO_ATTR_PROBS },
419  { "routes", SUMO_ATTR_ROUTES },
420  { "vTypes", SUMO_ATTR_VTYPES },
421 
422  { "lane", SUMO_ATTR_LANE },
423  { "lanes", SUMO_ATTR_LANES },
424  { "from", SUMO_ATTR_FROM },
425  { "to", SUMO_ATTR_TO },
426  { "fromLonLat", SUMO_ATTR_FROMLONLAT },
427  { "toLonLat", SUMO_ATTR_TOLONLAT },
428  { "fromXY", SUMO_ATTR_FROMXY },
429  { "toXY", SUMO_ATTR_TOXY },
430  { "period", SUMO_ATTR_PERIOD },
431  { "fromTaz", SUMO_ATTR_FROM_TAZ },
432  { "toTaz", SUMO_ATTR_TO_TAZ },
433  { "reroute", SUMO_ATTR_REROUTE },
434  { "personCapacity", SUMO_ATTR_PERSON_CAPACITY },
435  { "containerCapacity", SUMO_ATTR_CONTAINER_CAPACITY },
436  { "personNumber", SUMO_ATTR_PERSON_NUMBER },
437  { "containerNumber", SUMO_ATTR_CONTAINER_NUMBER },
438  { "modes", SUMO_ATTR_MODES },
439  { "walkFactor", SUMO_ATTR_WALKFACTOR },
440 
441  { "function", SUMO_ATTR_FUNCTION },
442  { "pos", SUMO_ATTR_POSITION },
443  { "posLat", SUMO_ATTR_POSITION_LAT },
444  { "freq", SUMO_ATTR_FREQUENCY },
445  { "style", SUMO_ATTR_STYLE },
446  { "file", SUMO_ATTR_FILE },
447  { "junction", SUMO_ATTR_JUNCTION },
448  { "number", SUMO_ATTR_NUMBER },
449  { "duration", SUMO_ATTR_DURATION },
450  { "until", SUMO_ATTR_UNTIL },
451  { "routeProbe", SUMO_ATTR_ROUTEPROBE },
452  { "crossingEdges", SUMO_ATTR_CROSSING_EDGES },
453  // Traffic light & Nodes
454  { "time", SUMO_ATTR_TIME },
455  { "begin", SUMO_ATTR_BEGIN },
456  { "end", SUMO_ATTR_END },
457  { "tl", SUMO_ATTR_TLID },
458  { "tlType", SUMO_ATTR_TLTYPE },
459  { "linkIndex", SUMO_ATTR_TLLINKINDEX },
460  { "linkIndex2", SUMO_ATTR_TLLINKINDEX2 },
461  { "shape", SUMO_ATTR_SHAPE },
462  { "spreadType", SUMO_ATTR_SPREADTYPE },
463  { "radius", SUMO_ATTR_RADIUS },
464  { "customShape", SUMO_ATTR_CUSTOMSHAPE },
465  { "keepClear", SUMO_ATTR_KEEP_CLEAR },
466  { "rightOfWay", SUMO_ATTR_RIGHT_OF_WAY },
467  { "fringe", SUMO_ATTR_FRINGE },
468  { "color", SUMO_ATTR_COLOR },
469  { "dir", SUMO_ATTR_DIR },
470  { "state", SUMO_ATTR_STATE },
471  { "layer", SUMO_ATTR_LAYER },
472  { "fill", SUMO_ATTR_FILL },
473  { "lineWidth", SUMO_ATTR_LINEWIDTH },
474  { "prefix", SUMO_ATTR_PREFIX },
475  { "discard", SUMO_ATTR_DISCARD },
476 
477  { "fromLane", SUMO_ATTR_FROM_LANE },
478  { "toLane", SUMO_ATTR_TO_LANE },
479  { "dest", SUMO_ATTR_DEST },
480  { "source", SUMO_ATTR_SOURCE },
481  { "via", SUMO_ATTR_VIA },
482  { "viaLonLat", SUMO_ATTR_VIALONLAT },
483  { "viaXY", SUMO_ATTR_VIAXY },
484  { "nodes", SUMO_ATTR_NODES },
485  { "visibility", SUMO_ATTR_VISIBILITY_DISTANCE },
486 
487  { "minDur", SUMO_ATTR_MINDURATION },
488  { "maxDur", SUMO_ATTR_MAXDURATION },
489  { "next", SUMO_ATTR_NEXT },
490  { "foes", SUMO_ATTR_FOES },
491  // E2 detector
492  { "cont", SUMO_ATTR_CONT },
493  { "contPos", SUMO_ATTR_CONTPOS },
494  { "timeThreshold", SUMO_ATTR_HALTING_TIME_THRESHOLD },
495  { "speedThreshold", SUMO_ATTR_HALTING_SPEED_THRESHOLD },
496  { "jamThreshold", SUMO_ATTR_JAM_DIST_THRESHOLD },
497  { "show", SUMO_ATTR_SHOW_DETECTOR },
498  // E3 detector
499  { "openEntry", SUMO_ATTR_OPEN_ENTRY },
500 
501  { "wautID", SUMO_ATTR_WAUT_ID },
502  { "junctionID", SUMO_ATTR_JUNCTION_ID },
503  { "procedure", SUMO_ATTR_PROCEDURE },
504  { "synchron", SUMO_ATTR_SYNCHRON },
505  { "refTime", SUMO_ATTR_REF_TIME },
506  { "startProg", SUMO_ATTR_START_PROG },
507  { "off", SUMO_ATTR_OFF },
508  { "friendlyPos", SUMO_ATTR_FRIENDLY_POS },
509  { "splitByType", SUMO_ATTR_SPLIT_VTYPE },
510  { "uncontrolled", SUMO_ATTR_UNCONTROLLED },
511  { "pass", SUMO_ATTR_PASS },
512  { "busStop", SUMO_ATTR_BUS_STOP },
513  { "containerStop", SUMO_ATTR_CONTAINER_STOP },
514  { "parkingArea", SUMO_ATTR_PARKING_AREA },
515  { "roadsideCapacity", SUMO_ATTR_ROADSIDE_CAPACITY },
516  { "onRoad", SUMO_ATTR_ONROAD },
517  { "chargingStation", SUMO_ATTR_CHARGING_STATION},
518  { "line", SUMO_ATTR_LINE },
519  { "lines", SUMO_ATTR_LINES },
520  { "tripId", SUMO_ATTR_TRIP_ID },
521  { "intended", SUMO_ATTR_INTENDED },
522  { "value", SUMO_ATTR_VALUE },
523  { "prohibitor", SUMO_ATTR_PROHIBITOR },
524  { "prohibited", SUMO_ATTR_PROHIBITED },
525  { "allow", SUMO_ATTR_ALLOW },
526  { "disallow", SUMO_ATTR_DISALLOW },
527  { "prefer", SUMO_ATTR_PREFER },
528  { "controlledInner", SUMO_ATTR_CONTROLLED_INNER },
529  { "vehsPerHour", SUMO_ATTR_VEHSPERHOUR },
530  { "personsPerHour", SUMO_ATTR_PERSONSPERHOUR },
531  { "output", SUMO_ATTR_OUTPUT },
532  { "height", SUMO_ATTR_HEIGHT },
533  { "guiShape", SUMO_ATTR_GUISHAPE },
534  { "osgFile", SUMO_ATTR_OSGFILE },
535  { "imgFile", SUMO_ATTR_IMGFILE },
536  { "relativePath", SUMO_ATTR_RELATIVEPATH },
537  { "angle", SUMO_ATTR_ANGLE },
538  { "emissionClass", SUMO_ATTR_EMISSIONCLASS },
539  { "impatience", SUMO_ATTR_IMPATIENCE },
540  { "startPos", SUMO_ATTR_STARTPOS },
541  { "endPos", SUMO_ATTR_ENDPOS },
542  { "triggered", SUMO_ATTR_TRIGGERED },
543  { "containerTriggered", SUMO_ATTR_CONTAINER_TRIGGERED },
544  { "parking", SUMO_ATTR_PARKING },
545  { "expected", SUMO_ATTR_EXPECTED },
546  { "expectedContainers", SUMO_ATTR_EXPECTED_CONTAINERS },
547  { "index", SUMO_ATTR_INDEX },
548 
549  { "entering", SUMO_ATTR_ENTERING },
550  { "excludeEmpty", SUMO_ATTR_EXCLUDE_EMPTY },
551  { "withInternal", SUMO_ATTR_WITH_INTERNAL },
552  { "trackVehicles", SUMO_ATTR_TRACK_VEHICLES },
553  { "detectPersons", SUMO_ATTR_DETECT_PERSONS },
554  { "maxTraveltime", SUMO_ATTR_MAX_TRAVELTIME },
555  { "minSamples", SUMO_ATTR_MIN_SAMPLES },
556 
557  { "lon", SUMO_ATTR_LON },
558  { "lat", SUMO_ATTR_LAT },
559  { "geo", SUMO_ATTR_GEO },
560  { "geoShape", SUMO_ATTR_GEOSHAPE },
561  { "lon/lat", SUMO_ATTR_GEOPOSITION },
562  { "k", SUMO_ATTR_K },
563  { "v", SUMO_ATTR_V },
564  { "ref", SUMO_ATTR_REF },
565  { "href", SUMO_ATTR_HREF },
566  { "zoom", SUMO_ATTR_ZOOM },
567  { "interpolated", SUMO_ATTR_INTERPOLATED },
568  { "threshold", SUMO_ATTR_THRESHOLD },
569 
570  { "netOffset", SUMO_ATTR_NET_OFFSET },
571  { "convBoundary", SUMO_ATTR_CONV_BOUNDARY },
572  { "origBoundary", SUMO_ATTR_ORIG_BOUNDARY },
573  { "projParameter", SUMO_ATTR_ORIG_PROJ },
574 
575  { "tauLast", SUMO_ATTR_CF_PWAGNER2009_TAULAST },
576  { "apProb", SUMO_ATTR_CF_PWAGNER2009_APPROB },
577  { "delta", SUMO_ATTR_CF_IDM_DELTA },
578  { "stepping", SUMO_ATTR_CF_IDM_STEPPING },
579  { "adaptFactor", SUMO_ATTR_CF_IDMM_ADAPT_FACTOR },
580  { "adaptTime", SUMO_ATTR_CF_IDMM_ADAPT_TIME },
581  { "phi", SUMO_ATTR_CF_KERNER_PHI },
582 
583  { "security", SUMO_ATTR_CF_WIEDEMANN_SECURITY },
584  { "estimation", SUMO_ATTR_CF_WIEDEMANN_ESTIMATION },
585  { "cc1", SUMO_ATTR_CF_W99_CC1 },
586  { "cc2", SUMO_ATTR_CF_W99_CC2 },
587  { "cc3", SUMO_ATTR_CF_W99_CC3 },
588  { "cc4", SUMO_ATTR_CF_W99_CC4 },
589  { "cc5", SUMO_ATTR_CF_W99_CC5 },
590  { "cc6", SUMO_ATTR_CF_W99_CC6 },
591  { "cc7", SUMO_ATTR_CF_W99_CC7 },
592  { "cc8", SUMO_ATTR_CF_W99_CC8 },
593  { "cc9", SUMO_ATTR_CF_W99_CC9 },
594 
595  { "ccDecel", SUMO_ATTR_CF_CC_CCDECEL },
596  { "constSpacing", SUMO_ATTR_CF_CC_CONSTSPACING },
597  { "kp", SUMO_ATTR_CF_CC_KP },
598  { "lambda", SUMO_ATTR_CF_CC_LAMBDA },
599  { "c1", SUMO_ATTR_CF_CC_C1 },
600  { "xi", SUMO_ATTR_CF_CC_XI },
601  { "omegaN", SUMO_ATTR_CF_CC_OMEGAN },
602  { "tauEngine", SUMO_ATTR_CF_CC_TAU },
603  { "lanesCount", SUMO_ATTR_CF_CC_LANES_COUNT },
604  { "ccAccel", SUMO_ATTR_CF_CC_CCACCEL },
605  { "ploegKp", SUMO_ATTR_CF_CC_PLOEG_KP },
606  { "ploegKd", SUMO_ATTR_CF_CC_PLOEG_KD },
607  { "ploegH", SUMO_ATTR_CF_CC_PLOEG_H },
608  { "flatbedKa", SUMO_ATTR_CF_CC_FLATBED_KA },
609  { "flatbedKv", SUMO_ATTR_CF_CC_FLATBED_KV },
610  { "flatbedKp", SUMO_ATTR_CF_CC_FLATBED_KP },
611  { "flatbedD", SUMO_ATTR_CF_CC_FLATBED_D },
612  { "flatbedH", SUMO_ATTR_CF_CC_FLATBED_H },
613 
614  { "generateWalks", SUMO_ATTR_GENERATE_WALKS },
615  { "actType", SUMO_ATTR_ACTTYPE },
616  { "slope", SUMO_ATTR_SLOPE },
617  { "version", SUMO_ATTR_VERSION },
618  { "junctionCornerDetail", SUMO_ATTR_CORNERDETAIL },
619  { "junctionLinkDetail", SUMO_ATTR_LINKDETAIL },
620  { "rectangularLaneCut", SUMO_ATTR_RECTANGULAR_LANE_CUT },
621  { "walkingareas", SUMO_ATTR_WALKINGAREAS },
622  { "lefthand", SUMO_ATTR_LEFTHAND },
623  { "limitTurnSpeed", SUMO_ATTR_LIMIT_TURN_SPEED },
624  { "checkLaneFoesAll", SUMO_ATTR_CHECKLANEFOES_ALL },
625  { "checkLaneFoesRoundabout", SUMO_ATTR_CHECKLANEFOES_ROUNDABOUT },
626 
627  { "actorConfig", SUMO_ATTR_ACTORCONFIG },
628  { "vehicle", SUMO_ATTR_VEHICLE },
629  { "startTime", SUMO_ATTR_STARTTIME },
630  { "vehicleClass", SUMO_ATTR_VEHICLECLASS },
631  { "fuel", SUMO_ATTR_FUEL },
632  { "acceleration", SUMO_ATTR_ACCELERATION },
633  { "amount", SUMO_ATTR_AMOUNT },
634  { "origin", SUMO_ATTR_ORIGIN },
635  { "destination", SUMO_ATTR_DESTINATION },
636  { "visible", SUMO_ATTR_VISIBLE },
637 
638 #ifndef WIN32
639  { "commandPosix", SUMO_ATTR_COMMAND },
640 #else
641  { "commandWindows", SUMO_ATTR_COMMAND },
642 #endif
643 
644  // ActivityGen statistics file
645  { "inhabitants", AGEN_ATTR_INHABITANTS },
646  { "households", AGEN_ATTR_HOUSEHOLDS },
647  { "childrenAgeLimit", AGEN_ATTR_CHILDREN },
648  { "retirementAgeLimit", AGEN_ATTR_RETIREMENT },
649  { "carRate", AGEN_ATTR_CARS },
650  { "unemploymentRate", AGEN_ATTR_UNEMPLOYEMENT },
651  { "laborDemand", AGEN_ATTR_LABORDEMAND },
652  { "footDistanceLimit", AGEN_ATTR_MAX_FOOT_DIST },
653  { "incomingTraffic", AGEN_ATTR_IN_TRAFFIC },
654  { "incoming", AGEN_ATTR_INCOMING },
655  { "outgoingTraffic", AGEN_ATTR_OUT_TRAFFIC },
656  { "outgoing", AGEN_ATTR_OUTGOING },
657  { "population", AGEN_ATTR_POPULATION },
658  { "workPosition", AGEN_ATTR_OUT_WORKPOSITION },
659  { "hour", AGEN_ATTR_HOUR },
660  { "proportion", AGEN_ATTR_PROP },
661  { "capacity", AGEN_ATTR_CAPACITY },
662  { "opening", AGEN_ATTR_OPENING },
663  { "closing", AGEN_ATTR_CLOSING },
664  { "maxTripDuration", AGEN_ATTR_MAX_TRIP_DURATION },
665  { "rate", AGEN_ATTR_RATE },
666  { "beginAge", AGEN_ATTR_BEGINAGE },
667  { "endAge", AGEN_ATTR_ENDAGE },
668  { "peopleNbr", AGEN_ATTR_PEOPLENBR },
669  { "carPreference", AGEN_ATTR_CARPREF },
670  { "meanTimePerKmInCity", AGEN_ATTR_CITYSPEED },
671  { "freeTimeActivityRate", AGEN_ATTR_FREETIMERATE },
672  { "uniformRandomTraffic", AGEN_ATTR_UNI_RAND_TRAFFIC },
673  { "departureVariation", AGEN_ATTR_DEP_VARIATION },
674 
675  // netEdit
676  { "selected", GNE_ATTR_SELECTED },
677  { "modificationStatusNotForPrinting", GNE_ATTR_MODIFICATION_STATUS },
678  { "shapeStart", GNE_ATTR_SHAPE_START },
679  { "shapeEnd", GNE_ATTR_SHAPE_END },
680  { "bidiRail", GNE_ATTR_BIDIR },
681  { "blockMovement", GNE_ATTR_BLOCK_MOVEMENT },
682  { "blockShape", GNE_ATTR_BLOCK_SHAPE },
683  { "closedShape", GNE_ATTR_CLOSE_SHAPE },
684  { "parentItem", GNE_ATTR_PARENT },
685  { "genericParameter", GNE_ATTR_GENERIC },
686  { "defaultVTypeModified", GNE_ATTR_DEFAULT_VTYPE_MODIFIED },
687 
688  { "carriageLength", SUMO_ATTR_CARRIAGE_LENGTH },
689  { "locomotiveLength", SUMO_ATTR_LOCOMOTIVE_LENGTH },
690  { "carriageGap", SUMO_ATTR_CARRIAGE_GAP },
691 
692  { "targetLanes", SUMO_ATTR_TARGETLANE },
693  { "crossing", SUMO_ATTR_CROSSING },
694 
695  { "xmlns:xsi", SUMO_ATTR_XMLNS },
696  { "xsi:noNamespaceSchemaLocation", SUMO_ATTR_SCHEMA_LOCATION },
697 
698  //@name RNG state saving attributes
699  // @{
700  { "default", SUMO_ATTR_RNG_DEFAULT },
701  { "routeHandler", SUMO_ATTR_RNG_ROUTEHANDLER },
702  { "insertionControl", SUMO_ATTR_RNG_INSERTIONCONTROL },
703  { "device", SUMO_ATTR_RNG_DEVICE },
704  { "device.btreceiver", SUMO_ATTR_RNG_DEVICE_BT },
705  { "driverState", SUMO_ATTR_RNG_DRIVERSTATE },
706  // @}
707 
708  // Other
709  { "", SUMO_ATTR_NOTHING } //< must be the last one
710 };
711 
712 
713 const std::string SUMO_PARAM_ORIGID("origId");
714 
715 
717  {"traffic_light", NODETYPE_TRAFFIC_LIGHT},
718  {"traffic_light_unregulated", NODETYPE_TRAFFIC_LIGHT_NOJUNCTION},
719  {"traffic_light_right_on_red", NODETYPE_TRAFFIC_LIGHT_RIGHT_ON_RED},
720  {"rail_signal", NODETYPE_RAIL_SIGNAL},
721  {"rail_crossing", NODETYPE_RAIL_CROSSING},
722  {"priority", NODETYPE_PRIORITY},
723  {"priority_stop", NODETYPE_PRIORITY_STOP},
724  {"right_before_left", NODETYPE_RIGHT_BEFORE_LEFT},
725  {"allway_stop", NODETYPE_ALLWAY_STOP},
726  {"zipper", NODETYPE_ZIPPER},
727  {"district", NODETYPE_DISTRICT},
728  {"unregulated", NODETYPE_NOJUNCTION},
729  {"internal", NODETYPE_INTERNAL},
730  {"dead_end", NODETYPE_DEAD_END},
731  {"DEAD_END", NODETYPE_DEAD_END_DEPRECATED},
732  {"unknown", NODETYPE_UNKNOWN} //< must be the last one
733 };
734 
735 
737  {"unknown", EDGEFUNC_UNKNOWN},
738  {"normal", EDGEFUNC_NORMAL},
739  {"connector", EDGEFUNC_CONNECTOR},
740  {"crossing", EDGEFUNC_CROSSING},
741  {"walkingarea", EDGEFUNC_WALKINGAREA},
742  {"internal", EDGEFUNC_INTERNAL} //< must be the last one
743 };
744 
745 
747  {"right", LANESPREAD_RIGHT }, // default
748  {"center", LANESPREAD_CENTER } //< must be the last one
749 };
750 
752  {"edgePriority", RIGHT_OF_WAY_EDGEPRIORITY },
753  {"default", RIGHT_OF_WAY_DEFAULT } // default (must be the last one)
754 };
755 
757  {"outer", FRINGE_TYPE_OUTER },
758  {"inner", FRINGE_TYPE_INNER },
759  {"default", FRINGE_TYPE_DEFAULT } // default (must be the last one)
760 };
761 
763  {"none", PERSONMODE_NONE},
764  {"walk", PERSONMODE_WALK},
765  {"bicycle", PERSONMODE_BICYCLE },
766  {"car", PERSONMODE_CAR },
767  {"public", PERSONMODE_PUBLIC} // (must be the last one)
768 };
769 
771  { "G", LINKSTATE_TL_GREEN_MAJOR },
772  { "g", LINKSTATE_TL_GREEN_MINOR },
773  { "r", LINKSTATE_TL_RED },
774  { "u", LINKSTATE_TL_REDYELLOW },
775  { "Y", LINKSTATE_TL_YELLOW_MAJOR },
776  { "y", LINKSTATE_TL_YELLOW_MINOR },
777  { "o", LINKSTATE_TL_OFF_BLINKING },
778  { "O", LINKSTATE_TL_OFF_NOSIGNAL },
779  { "M", LINKSTATE_MAJOR },
780  { "m", LINKSTATE_MINOR },
781  { "=", LINKSTATE_EQUAL },
782  { "s", LINKSTATE_STOP },
783  { "w", LINKSTATE_ALLWAY_STOP },
784  { "Z", LINKSTATE_ZIPPER },
785  { "-", LINKSTATE_DEADEND } //< must be the last one
786 };
787 
791  LINKSTATE_STOP, // used for NODETYPE_TRAFFIC_LIGHT_RIGHT_ON_RED
798 };
799 const std::string SUMOXMLDefinitions::ALLOWED_TLS_LINKSTATES(AllowedTLS_linkStatesInitializer, 9);
800 
802  { "s", LINKDIR_STRAIGHT },
803  { "t", LINKDIR_TURN },
804  { "T", LINKDIR_TURN_LEFTHAND },
805  { "l", LINKDIR_LEFT },
806  { "r", LINKDIR_RIGHT },
807  { "L", LINKDIR_PARTLEFT },
808  { "R", LINKDIR_PARTRIGHT },
809  { "invalid", LINKDIR_NODIR } //< must be the last one
810 };
811 
812 
814  { "static", TLTYPE_STATIC },
815  { "railSignal", TLTYPE_RAIL_SIGNAL },
816  { "railCrossing", TLTYPE_RAIL_CROSSING },
817  { "actuated", TLTYPE_ACTUATED },
818  { "delay_based", TLTYPE_DELAYBASED },
819  { "sotl_phase", TLTYPE_SOTL_PHASE },
820  { "sotl_platoon", TLTYPE_SOTL_PLATOON },
821  { "sotl_request", TLTYPE_SOTL_REQUEST },
822  { "sotl_wave", TLTYPE_SOTL_WAVE },
823  { "sotl_marching", TLTYPE_SOTL_MARCHING },
824  { "swarm", TLTYPE_SWARM_BASED },
825  { "deterministic", TLTYPE_HILVL_DETERMINISTIC },
826  { "off", TLTYPE_OFF },
827  { "<invalid>", TLTYPE_INVALID } //< must be the last one
828 };
829 
830 
832  { "DK2008", LCM_DK2008 },
833  { "LC2013", LCM_LC2013 },
834  { "SL2015", LCM_SL2015 },
835  { "default", LCM_DEFAULT } //< must be the last one
836 };
837 
839  { "IDM", SUMO_TAG_CF_IDM },
840  { "IDMM", SUMO_TAG_CF_IDMM },
841  { "Krauss", SUMO_TAG_CF_KRAUSS },
842  { "KraussPS", SUMO_TAG_CF_KRAUSS_PLUS_SLOPE },
843  { "KraussOrig1", SUMO_TAG_CF_KRAUSS_ORIG1 },
844  { "KraussX", SUMO_TAG_CF_KRAUSSX }, // experimental extensions to the Krauss model
845  { "SmartSK", SUMO_TAG_CF_SMART_SK },
846  { "Daniel1", SUMO_TAG_CF_DANIEL1 },
847  { "PWagner2009", SUMO_TAG_CF_PWAGNER2009 },
848  { "BKerner", SUMO_TAG_CF_BKERNER },
849  { "Rail", SUMO_TAG_CF_RAIL },
850  { "CC", SUMO_TAG_CF_CC },
851  { "ACC", SUMO_TAG_CF_ACC },
852  { "CACC", SUMO_TAG_CF_CACC },
853  { "W99", SUMO_TAG_CF_W99 },
854  { "Wiedemann", SUMO_TAG_CF_WIEDEMANN } //< must be the last one
855 };
856 
858  { "right", LATALIGN_RIGHT },
859  { "center", LATALIGN_CENTER },
860  { "arbitrary", LATALIGN_ARBITRARY },
861  { "nice", LATALIGN_NICE },
862  { "compact", LATALIGN_COMPACT },
863  { "left", LATALIGN_LEFT } //< must be the last one
864 };
865 
867  { "stay", LCA_STAY },
868  { "left", LCA_LEFT },
869  { "right", LCA_RIGHT },
870  { "strategic", LCA_STRATEGIC },
871  { "cooperative", LCA_COOPERATIVE },
872  { "speedGain", LCA_SPEEDGAIN },
873  { "keepRight", LCA_KEEPRIGHT },
874  { "sublane", LCA_SUBLANE },
875  { "traci", LCA_TRACI },
876  { "urgent", LCA_URGENT },
877  { "overlapping", LCA_OVERLAPPING },
878  { "blocked", LCA_BLOCKED },
879  { "amBL", LCA_AMBLOCKINGLEADER },
880  { "amBF", LCA_AMBLOCKINGFOLLOWER },
881  { "amBB", LCA_AMBACKBLOCKER },
882  { "amBBS", LCA_AMBACKBLOCKER_STANDING },
883  { "MR", LCA_MRIGHT },
884  { "ML", LCA_MLEFT },
885 
886  { "unknown", LCA_UNKNOWN } //< must be the last one
887 };
888 
890  { "NGT400", TRAINTYPE_NGT400 },
891  { "NGT400_16", TRAINTYPE_NGT400_16 },
892  { "RB425", TRAINTYPE_RB425 },
893  { "RB628", TRAINTYPE_RB628 },
894  { "ICE1", TRAINTYPE_ICE1 },
895  { "REDosto7", TRAINTYPE_REDOSTO7 },
896  { "Freight", TRAINTYPE_FREIGHT },
897  { "ICE3", TRAINTYPE_ICE3 }
898 };
899 
900 
902  SUMOXMLDefinitions::tags, SUMO_TAG_NOTHING);
903 
905  SUMOXMLDefinitions::attrs, SUMO_ATTR_NOTHING);
906 
908  SUMOXMLDefinitions::sumoNodeTypeValues, NODETYPE_UNKNOWN);
909 
911  SUMOXMLDefinitions::sumoEdgeFuncValues, EDGEFUNC_INTERNAL);
912 
914  SUMOXMLDefinitions::laneSpreadFunctionValues, LANESPREAD_CENTER);
915 
917  SUMOXMLDefinitions::rightOfWayValuesInitializer, RIGHT_OF_WAY_DEFAULT);
918 
920  SUMOXMLDefinitions::fringeTypeValuesInitializer, FRINGE_TYPE_DEFAULT);
921 
923  SUMOXMLDefinitions::personModeValuesInitializer, PERSONMODE_PUBLIC);
924 
926  SUMOXMLDefinitions::linkStateValues, LINKSTATE_DEADEND);
927 
929  SUMOXMLDefinitions::linkDirectionValues, LINKDIR_NODIR);
930 
932  SUMOXMLDefinitions::trafficLightTypesValues, TLTYPE_INVALID);
933 
935  SUMOXMLDefinitions::laneChangeModelValues, LCM_DEFAULT);
936 
938  SUMOXMLDefinitions::carFollowModelValues, SUMO_TAG_CF_WIEDEMANN);
939 
941  SUMOXMLDefinitions::lateralAlignmentValues, LATALIGN_LEFT);
942 
944  SUMOXMLDefinitions::laneChangeActionValues, LCA_UNKNOWN);
945 
947  SUMOXMLDefinitions::trainTypeValues, TRAINTYPE_ICE3);
948 
949 
950 std::string
951 SUMOXMLDefinitions::getJunctionIDFromInternalEdge(const std::string internalEdge) {
952  assert(internalEdge[0] == ':');
953  return internalEdge.substr(1, internalEdge.rfind('_') - 1);
954 }
955 
956 
957 std::string
958 SUMOXMLDefinitions::getEdgeIDFromLane(const std::string laneID) {
959  return laneID.substr(0, laneID.rfind('_'));
960 }
961 
962 
963 bool
964 SUMOXMLDefinitions::isValidNetID(const std::string& value) {
965  return (value.size() > 0) && value.find_first_of(" \t\n\r|\\'\";,:!<>&*?") == std::string::npos;
966 }
967 
968 
969 bool
970 SUMOXMLDefinitions::isValidVehicleID(const std::string& value) {
971  return (value.size() > 0) && value.find_first_of(" \t\n\r|\\'\";,!<>&*?") == std::string::npos;
972 }
973 
974 
975 bool
976 SUMOXMLDefinitions::isValidTypeID(const std::string& value) {
977  return (value.size() > 0) && value.find_first_of(" \t\n\r|\\'\";,<>&*?") == std::string::npos;
978 }
979 
980 
981 bool
982 SUMOXMLDefinitions::isValidDetectorID(const std::string& value) {
983  return (value.size() > 0) && value.find_first_of("\t\n\r|\\'\";,:!<>&*?") == std::string::npos;
984 }
985 
986 
987 bool
988 SUMOXMLDefinitions::isValidAttribute(const std::string& value) {
989  return value.find_first_of("\t\n\r@$%^&/|\\{}*'\";:<>") == std::string::npos;
990 }
991 
992 
993 bool
994 SUMOXMLDefinitions::isValidFilename(const std::string& value) {
995  return (value.find_first_of("\t\n\r@$%^&|{}*'\";<>") == std::string::npos);
996 }
997 
998 
999 bool
1000 SUMOXMLDefinitions::isValidListOfNetIDs(const std::string& value) {
1001  const std::vector<std::string>& typeIDs = StringTokenizer(value).getVector();
1002  if (typeIDs.empty()) {
1003  return false;
1004  } else {
1005  // check that gives IDs are valid
1006  for (auto i : typeIDs) {
1008  return false;
1009  }
1010  }
1011  return true;
1012  }
1013 }
1014 
1015 
1016 bool
1017 SUMOXMLDefinitions::isValidListOfTypeID(const std::string& value) {
1018  const std::vector<std::string>& typeIDs = StringTokenizer(value).getVector();
1019  if (typeIDs.empty()) {
1020  return false;
1021  } else {
1022  // check that gives IDs are valid
1023  for (auto i : typeIDs) {
1025  return false;
1026  }
1027  }
1028  return true;
1029  }
1030 }
1031 
1032 
1033 bool
1035  // Generic parameters keys cannot be empty
1036  return (value.size() > 0);
1037 }
1038 
1039 
1040 bool
1042  // Generic parameters should not be restricted (characters such as <>'" only
1043  // reach this function if they are properly escaped in the xml inputs (and
1044  // they are also escaped when writing)
1045  return true;
1046 }
1047 
1048 /****************************************************************************/
1049 
stop placed over a parking area (used in netedit)
number of steps that a vehicle is charging
The information about how to spread the lanes from the given position.
static StringBijection< LaneChangeModel >::Entry laneChangeModelValues[]
lane change model values
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
The link is a partial left direction.
The link has green light, may pass.
Internal moment of inertia.
segment of a lane
static StringBijection< SumoXMLTag > CarFollowModels
car following models
static StringBijection< SumoXMLNodeType > NodeTypes
node types
a routeprobe detector
static StringBijection< LinkDirection >::Entry linkDirectionValues[]
link direction values
a list of node ids, used for controlling joining
static StringBijection< PersonMode >::Entry personModeValuesInitializer[]
person mode values
alternative tag for e1 detector
description of a vehicle type
Whether vehicles must keep the junction clear.
split something
whether a given shape is user-defined
a source within a district (connection road)
The action is due to the default of keeping right "Rechtsfahrgebot".
ActivityGen Tags.
The action is done to help someone else.
static StringBijection< int >::Entry attrs[]
The names of SUMO-XML attributes (for passing to GenericSAXHandler)
static bool isValidAttribute(const std::string &value)
whether the given string is a valid attribute for a certain key (for example, a name) ...
static StringBijection< LinkState >::Entry linkStateValues[]
link state values
static bool isValidListOfTypeID(const std::string &value)
whether the given string is a valid list of ids for an edge or vehicle type (empty aren&#39;t allowed) ...
root element of a network file
begin/end of the description of a junction
begin/end of the description of a single lane
a flow definitio nusing a from-to edges instead of a route (used by router)
block shape of a graphic element (Used mainly in GNEShapes)
Outgoing edge specification (jtrrouter)
static StringBijection< LaneSpreadFunction >::Entry laneSpreadFunctionValues[]
lane spread function values
A calibrator placed over edge.
an e2 detector over multiple lanes (used by Netedit)
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
a traffic assignment zone
static const std::string ALLOWED_TLS_LINKSTATES
all allowed characters for phase state
distribution of a route
lane of a reroute of type closing
a flow definition nusing a route instead of a from-to edges route (used in NETEDIT) ...
A layer number.
The link has green light, has to brake.
connectio between two lanes
This is an uncontrolled, minor link, has to stop.
Allow/disallow charge in transit in Charging Stations.
static StringBijection< LateralAlignment >::Entry lateralAlignmentValues[]
lanteral alignment values
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea ...
workingHours object
closing for workingHours object
foe visibility distance of a link
population and children accompaniment brackets
The link is a 180 degree turn.
Wants go to the right.
Close shape of a polygon (Used by GNEPolys)
a flow state definition (used when saving and loading simulatino state)
stop placed over a lane (used in netedit)
weights: time range begin
link,node: the traffic light id responsible for this link
This is a dead end link.
tgotal of Energy charged
begin/end of the description of a Point of interest
This is an uncontrolled, right-before-left link.
maximum duration of a phase
align with the closest sublane border
static StringBijection< LinkState > LinkStates
link states
static StringBijection< SumoXMLNodeType >::Entry sumoNodeTypeValues[]
containers for the different SUMOXMLDefinitions
drive on the right side
begin/end of the description of an edge restriction
The link is controlled by a tls which is off, not blinking, may pass.
A parking space for a single vehicle within a parking area.
Wants go to the left.
first coordinate of edge shape
static bool isValidGenericParameterKey(const std::string &value)
whether the given string is a valid key for a generic parameter
This is an uncontrolled, all-way stop link.
The action is due to the wish to be faster (tactical lc)
generic attribute
used by the sublane model
prohibition of circulation between two edges
The link is a (hard) left direction.
This is an uncontrolled, zipper-merge link.
begin/end of the description of a route
Position on lane.
an e3 entry point
Sink(s) specification.
link: the index of the opposite direction link of a pedestrian crossing
whether a feature has been loaded,guessed,modified or approved
Radial drag coefficient.
an edge based mean data detector
The link is a straight direction.
Needs to stay on the current lane.
The state of a link.
drive on the left side
static StringBijection< LinkDirection > LinkDirections
link directions
alternative definition for Population
The action has not been determined.
The definition of a periodic event.
How to compute right of way.
root element of a route file
The turning radius at an intersection in m.
whether an edge is part of a bidirectional railway
static StringBijection< LaneChangeAction > LaneChangeActions
lane change actions
stop placed over a charging station (used in netedit)
static bool isValidGenericParameterValue(const std::string &value)
whether the given string is a valid value for a generic parameter
blocked in all directions
the edges of a route
station for a certain vehicle
rev stations for certain vehicles
The action is urgent (to be defined by lc-model)
frequency of a object
An instantenous induction loop.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
This is an uncontrolled, minor link, has to brake.
walking area for pedestrians
parameter associated to a certain key
an e3 exit point
timesteps in which charging ends
schools object
static bool isValidDetectorID(const std::string &value)
whether the given string is a valid id for an detector
An edge-following detector.
Recuperation efficiency (constant)
A calibrator placed over lane (used in netedit)
busStation and bus objects
block movement of a graphic element
stop placed over a containerStop (used in netedit)
stop placed over a busStop (used in netedit)
invalid attribute
definition of a detector
roundabout defined in junction
Incoming edge specification (jtrrouter)
energy provied by charging station at certain timestep
The link is a (hard) right direction.
Energy charged in transit.
The action is needed to follow the route (navigational lc)
node: the type of traffic light
edge: the shape in xml-definition
probability of route of a reroute
probability of destiny of a reroute
begin/end of the description of a neighboring lane
maintain the current alignment
The link is a partial right direction.
description of a logic request within the junction
streets object
begin/end of the description of an edge
timestep in which charging begins
static StringBijection< TrainType > TrainTypes
train types
static bool isValidNetID(const std::string &value)
whether the given string is a valid id for a network element
std::vector< std::string > getVector()
return vector of strings
reroute of type closing
succesor phase index
drive in the middle
entry for an alternative parking zone
static StringBijection< int >::Entry tags[]
The names of SUMO-XML elements (for passing to GenericSAXHandler)
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
stop for vehicles
a lane based mean data detector
trigger: the time of the step
A train stop (alias for bus stop)
alternative definition for city entrances
a sink within a district (connection road)
the edges crossed by a pedestrian crossing
static StringBijection< LaneChangeAction >::Entry laneChangeActionValues[]
lane change action values
The link has yellow light, may pass.
static StringBijection< FringeType > FringeTypeValues
fringe types
static StringBijection< RightOfWay >::Entry rightOfWayValuesInitializer[]
lane spread function values
The vehicle is blocked being overlapping.
The link is controlled by a tls which is off and blinks, has to brake.
static StringBijection< int > Attrs
The names of SUMO-XML attributes for use in netbuild.
weights: time range end
Join operation.
a vtypeprobe detector
element is selected
alternative definition for junction
static bool isValidListOfNetIDs(const std::string &value)
whether the given string is a valid list of id for a network (empty aren&#39;t allowed) ...
The link has red light (must brake)
Energy charged stopped.
This is an uncontrolled, major link, may pass.
total energy charged into a single vehicle
crossing between edges for pedestrians
vaporizer of vehicles
Recuperation efficiency (by deceleration)
The abstract direction of a link.
align with the rightmost sublane that allows keeping the current speed
begin/end of the description of a embedded route (used in NETEDIT)
description of a vehicle
an aggreagated-output interval
The action is due to a TraCI request.
The link is a 180 degree turn (left-hand network)
static StringBijection< PersonMode > PersonModeValues
person modes
static StringBijection< SumoXMLTag >::Entry carFollowModelValues[]
car follwing model values
A variable speed sign.
Eficiency of the charge in Charging Stations.
a single trip definition that uses TAZs (used in NETEDIT)
link: the index of the link within the traffic light
last coordinate of edge shape
description of a person type (used in NETEDIT)
a single trip definition (used by router)
type of polygon
parent of an additional element
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
a traffic light logic
static const char AllowedTLS_linkStatesInitializer[]
all allowed characters for phase state
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
static StringBijection< FringeType >::Entry fringeTypeValuesInitializer[]
lane spread function values
Delay in the charge of charging stations.
static StringBijection< SumoXMLEdgeFunc >::Entry sumoEdgeFuncValues[]
edge function values
The link has yellow light, has to brake anyway.
opening for workingHours object
delete certain element
begin/end of the description of a Point of interest over Lane (used by Netedit)
a flow definition within in Calibrator (used in NETEDIT)
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static StringBijection< SumoXMLEdgeFunc > EdgeFunctions
edge functions
An access point for a train stop.
distribution of a vehicle type
Flag to check if a default VType was modified.
Fringe type of node.
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name) ...
A color information.
The link has red light (must brake) but indicates upcoming green.
a single phase description
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
alternative tag for e3 detector
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Fill the polygon.
alternative tag for e2 detector
const std::string SUMO_PARAM_ORIGID("origId")
static StringBijection< TrainType >::Entry trainTypeValues[]
train type values values
stations for certain vehicles
join exlude operation
static StringBijection< TrafficLightType >::Entry trafficLightTypesValues[]
traffic light types values
begin/end of the description of a polygon
trigger: a step description
The link has no direction (is a dead end link)
Information on vClass specific stop offsets at lane end.