SUMO - Simulation of Urban MObility
NLTriggerBuilder.cpp
Go to the documentation of this file.
1 /****************************************************************************/
12 // Builds trigger objects for microsim
13 /****************************************************************************/
14 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
15 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
16 /****************************************************************************/
17 //
18 // This file is part of SUMO.
19 // SUMO is free software: you can redistribute it and/or modify
20 // it under the terms of the GNU General Public License as published by
21 // the Free Software Foundation, either version 3 of the License, or
22 // (at your option) any later version.
23 //
24 /****************************************************************************/
25 
26 
27 // ===========================================================================
28 // included modules
29 // ===========================================================================
30 #ifdef _MSC_VER
31 #include <windows_config.h>
32 #else
33 #include <config.h>
34 #endif
35 
36 #include <string>
38 #include <microsim/MSLane.h>
39 #include <microsim/MSEdge.h>
40 #include <microsim/MSGlobals.h>
53 #include "NLHandler.h"
54 #include "NLTriggerBuilder.h"
56 #include <utils/xml/XMLSubSys.h>
57 
58 
59 #include <mesosim/MELoop.h>
61 
62 #ifdef CHECK_MEMORY_LEAKS
63 #include <foreign/nvwa/debug_new.h>
64 #endif // CHECK_MEMORY_LEAKS
65 
66 
67 // ===========================================================================
68 // method definitions
69 // ===========================================================================
71  : myHandler(0) {}
72 
73 
75 
76 void
78  myHandler = handler;
79 }
80 
81 
82 void
84  bool ok = true;
85  // get the id, throw if not given or empty...
86  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
87  if (!ok) {
88  return;
89  }
90  MSEdge* e = MSEdge::dictionary(id);
91  if (e == 0) {
92  WRITE_ERROR("Unknown edge ('" + id + "') referenced in a vaporizer.");
93  return;
94  }
95  SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, 0, ok);
96  SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, 0, ok);
97  if (!ok) {
98  return;
99  }
100  if (begin < 0) {
101  WRITE_ERROR("A vaporization begin time is negative (edge id='" + id + "').");
102  return;
103  }
104  if (begin >= end) {
105  WRITE_ERROR("A vaporization ends before it starts (edge id='" + id + "').");
106  return;
107  }
108  if (end >= string2time(OptionsCont::getOptions().getString("begin"))) {
113  }
114 }
115 
116 
117 
118 void
120  const std::string& base) {
121  // get the id, throw if not given or empty...
122  bool ok = true;
123  // get the id, throw if not given or empty...
124  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
125  if (!ok) {
126  return;
127  }
128  // get the file name to read further definitions from
129  std::string file = getFileName(attrs, base, true);
130  std::string objectid = attrs.get<std::string>(SUMO_ATTR_LANES, id.c_str(), ok);
131  if (!ok) {
132  throw InvalidArgument("The lanes to use within MSLaneSpeedTrigger '" + id + "' are not known.");
133  }
134  std::vector<MSLane*> lanes;
135  std::vector<std::string> laneIDs;
136  SUMOSAXAttributes::parseStringVector(objectid, laneIDs);
137  for (std::vector<std::string>::iterator i = laneIDs.begin(); i != laneIDs.end(); ++i) {
138  MSLane* lane = MSLane::dictionary(*i);
139  if (lane == 0) {
140  throw InvalidArgument("The lane to use within MSLaneSpeedTrigger '" + id + "' is not known.");
141  }
142  lanes.push_back(lane);
143  }
144  if (lanes.size() == 0) {
145  throw InvalidArgument("No lane defined for MSLaneSpeedTrigger '" + id + "'.");
146  }
147  try {
148  MSLaneSpeedTrigger* trigger = buildLaneSpeedTrigger(net, id, lanes, file);
149  if (file == "") {
151  }
152  } catch (ProcessError& e) {
153  throw InvalidArgument(e.what());
154  }
155 }
156 
157 void
159  bool ok = true;
160 
161  // get the id, throw if not given or empty...
162  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
163 
164  if (!ok) {
165  throw ProcessError();
166  }
167 
168  // get the lane
169  MSLane* lane = getLane(attrs, "chargingStation", id);
170 
171  // get the positions
172  SUMOReal frompos = attrs.getOpt<SUMOReal>(SUMO_ATTR_STARTPOS, id.c_str(), ok, 0);
173  SUMOReal topos = attrs.getOpt<SUMOReal>(SUMO_ATTR_ENDPOS, id.c_str(), ok, lane->getLength());
174  SUMOReal chrgpower = attrs.getOpt<SUMOReal>(SUMO_ATTR_CHARGINGPOWER, id.c_str(), ok, 0);
175  SUMOReal efficiency = attrs.getOpt<SUMOReal>(SUMO_ATTR_EFFICIENCY, id.c_str(), ok, 0);
176  SUMOReal chargeInTransit = attrs.getOpt<SUMOReal>(SUMO_ATTR_CHARGEINTRANSIT, id.c_str(), ok, 0);
177  SUMOReal ChargeDelay = attrs.getOpt<SUMOReal>(SUMO_ATTR_CHARGEDELAY, id.c_str(), ok, 0);
178 
179  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
180 
181  if (!ok || !myHandler->checkStopPos(frompos, topos, lane->getLength(), POSITION_EPS, friendlyPos)) {
182  throw InvalidArgument("Invalid position for Charging Station '" + id + "'.");
183  }
184 
185  // get the lines
186  std::vector<std::string> lines;
187  SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LINES, id.c_str(), ok, "", false), lines);
188 
189  // build the Charging Station
190  buildChargingStation(net, id, lines, lane, frompos, topos, chrgpower, efficiency, chargeInTransit, ChargeDelay);
191 }
192 
193 
194 void
196  bool ok = true;
197  // get the id, throw if not given or empty...
198  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
199  if (!ok) {
200  throw ProcessError();
201  }
202  // get the lane
203  MSLane* lane = getLane(attrs, toString(element), id);
204  // get the positions
205  SUMOReal frompos = attrs.getOpt<SUMOReal>(SUMO_ATTR_STARTPOS, id.c_str(), ok, 0);
206  SUMOReal topos = attrs.getOpt<SUMOReal>(SUMO_ATTR_ENDPOS, id.c_str(), ok, lane->getLength());
207  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
208  if (!ok || !myHandler->checkStopPos(frompos, topos, lane->getLength(), POSITION_EPS, friendlyPos)) {
209  throw InvalidArgument("Invalid position for " + toString(element) + " '" + id + "'.");
210  }
211  // get the lines
212  std::vector<std::string> lines;
213  SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LINES, id.c_str(), ok, "", false), lines);
214  // build the bus stop
215  buildStoppingPlace(net, id, lines, lane, frompos, topos, element);
216 }
217 
218 
219 void
221  // get the lane
222  MSLane* lane = getLane(attrs, "access" , "");
223  // get the positions
224  bool ok = true;
225  SUMOReal pos = attrs.getOpt<SUMOReal>(SUMO_ATTR_POSITION, "access", ok, 0);
226  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "access", ok, false);
227  if (!ok || !myHandler->checkStopPos(pos, pos, lane->getLength(), 0, friendlyPos)) {
228  throw InvalidArgument("Invalid position for access in stop '" + myCurrentStop->getID() + "'.");
229  }
230  // build the bus stop
231  myCurrentStop->addAccess(lane, pos);
232 }
233 
234 
235 void
237  const std::string& base) {
238  bool ok = true;
239  // get the id, throw if not given or empty...
240  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
241  if (!ok) {
242  throw ProcessError();
243  }
244  // get the file name to read further definitions from
245  MSLane* lane = getLane(attrs, "calibrator", id);
246  const SUMOReal pos = getPosition(attrs, lane, "calibrator", id);
247  const SUMOTime freq = attrs.getOptSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok, DELTA_T); // !!! no error handling
248  std::string file = getFileName(attrs, base, true);
249  std::string outfile = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, id.c_str(), ok, "");
250  std::string routeProbe = attrs.getOpt<std::string>(SUMO_ATTR_ROUTEPROBE, id.c_str(), ok, "");
251  MSRouteProbe* probe = 0;
252  if (routeProbe != "") {
253  probe = dynamic_cast<MSRouteProbe*>(net.getDetectorControl().getTypedDetectors(SUMO_TAG_ROUTEPROBE).get(routeProbe));
254  }
256  METriggeredCalibrator* trigger = buildMECalibrator(net, id, &lane->getEdge(), pos, file, outfile, freq, probe);
257  if (file == "") {
259  }
260  } else {
261  MSCalibrator* trigger = buildCalibrator(net, id, &lane->getEdge(), pos, file, outfile, freq, probe);
262  if (file == "") {
264  }
265  }
266 }
267 
268 
269 void
271  const std::string& base) {
272  bool ok = true;
273  // get the id, throw if not given or empty...
274  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
275  if (!ok) {
276  throw ProcessError();
277  }
278  // get the file name to read further definitions from
279  std::string file = getFileName(attrs, base, true);
280  std::string objectid = attrs.get<std::string>(SUMO_ATTR_EDGES, id.c_str(), ok);
281  if (!ok) {
282  throw InvalidArgument("The edge to use within MSTriggeredRerouter '" + id + "' is not known.");
283  }
284  MSEdgeVector edges;
285  std::vector<std::string> edgeIDs;
286  SUMOSAXAttributes::parseStringVector(objectid, edgeIDs);
287  for (std::vector<std::string>::iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
288  MSEdge* edge = MSEdge::dictionary(*i);
289  if (edge == 0) {
290  throw InvalidArgument("The edge to use within MSTriggeredRerouter '" + id + "' is not known.");
291  }
292  edges.push_back(edge);
293  }
294  if (edges.size() == 0) {
295  throw InvalidArgument("No edges found for MSTriggeredRerouter '" + id + "'.");
296  }
297  SUMOReal prob = attrs.getOpt<SUMOReal>(SUMO_ATTR_PROB, id.c_str(), ok, 1);
298  bool off = attrs.getOpt<bool>(SUMO_ATTR_OFF, id.c_str(), ok, false);
299  if (!ok) {
300  throw InvalidArgument("Could not parse MSTriggeredRerouter '" + id + "'.");
301  }
302  MSTriggeredRerouter* trigger = buildRerouter(net, id, edges, prob, file, off);
303  // read in the trigger description
304  if (file == "") {
306  } else if (!XMLSubSys::runParser(*trigger, file)) {
307  throw ProcessError();
308  }
309 }
310 
311 
312 // -------------------------
313 
314 
316 NLTriggerBuilder::buildLaneSpeedTrigger(MSNet& /*net*/, const std::string& id,
317  const std::vector<MSLane*>& destLanes,
318  const std::string& file) {
319  return new MSLaneSpeedTrigger(id, destLanes, file);
320 }
321 
322 
324 NLTriggerBuilder::buildMECalibrator(MSNet& /*net*/, const std::string& id,
325  const MSEdge* edge, SUMOReal pos,
326  const std::string& file,
327  const std::string& outfile,
328  const SUMOTime freq, MSRouteProbe* probe) {
329  return new METriggeredCalibrator(id, edge, pos, file, outfile, freq, MSGlobals::gMesoNet->getSegmentForEdge(*edge, pos)->getLength(), probe);
330 }
331 
332 
334 NLTriggerBuilder::buildCalibrator(MSNet& /*net*/, const std::string& id,
335  MSEdge* edge, SUMOReal pos,
336  const std::string& file,
337  const std::string& outfile,
338  const SUMOTime freq, const MSRouteProbe* probe) {
339  return new MSCalibrator(id, edge, pos, file, outfile, freq, edge->getLength(), probe);
340 }
341 
342 
344 NLTriggerBuilder::buildRerouter(MSNet&, const std::string& id,
345  MSEdgeVector& edges,
346  SUMOReal prob, const std::string& file, bool off) {
347  return new MSTriggeredRerouter(id, edges, prob, file, off);
348 }
349 
350 
351 void
352 NLTriggerBuilder::buildStoppingPlace(MSNet& net, const std::string& id,
353  const std::vector<std::string>& lines,
354  MSLane* lane, SUMOReal frompos, SUMOReal topos, const SumoXMLTag element) {
355  myCurrentStop = new MSStoppingPlace(id, lines, *lane, frompos, topos);
356  const bool success = element == SUMO_TAG_CONTAINER_STOP ? net.addContainerStop(myCurrentStop) : net.addBusStop(myCurrentStop);
357  if (!success) {
358  delete myCurrentStop;
359  throw InvalidArgument("Could not build " + toString(element) + " '" + id + "'; probably declared twice.");
360  }
361 }
362 
363 
364 void
365 NLTriggerBuilder::buildChargingStation(MSNet& net, const std::string& id,
366  const std::vector<std::string>& lines,
367  MSLane* lane, SUMOReal frompos, SUMOReal topos, SUMOReal chrgpower, SUMOReal efficiency, SUMOReal chargeInTransit, SUMOReal ChargeDelay) {
368 
369  MSChargingStation* chargingStation = new MSChargingStation(id, lines, *lane, frompos, topos, chrgpower, efficiency, chargeInTransit, ChargeDelay);
370 
371  if (!net.addChargingStation(chargingStation)) {
372  delete chargingStation;
373  throw InvalidArgument("Could not build Charging Station '" + id + "'; probably declared twice.");
374  }
375 }
376 
377 std::string
379  const std::string& base,
380  const bool allowEmpty) {
381  // get the file name to read further definitions from
382  bool ok = true;
383  std::string file = attrs.getOpt<std::string>(SUMO_ATTR_FILE, 0, ok, "");
384  if (file == "") {
385  if (allowEmpty) {
386  return file;
387  }
388  throw InvalidArgument("No filename given.");
389  }
390  // check whether absolute or relative filenames are given
391  if (!FileHelpers::isAbsolute(file)) {
392  return FileHelpers::getConfigurationRelative(base, file);
393  }
394  return file;
395 }
396 
397 
398 MSLane*
400  const std::string& tt,
401  const std::string& tid) {
402  bool ok = true;
403  std::string objectid = attrs.get<std::string>(SUMO_ATTR_LANE, tid.c_str(), ok);
404  MSLane* lane = MSLane::dictionary(objectid);
405  if (lane == 0) {
406  throw InvalidArgument("The lane " + objectid + " to use within the " + tt + " '" + tid + "' is not known.");
407  }
408  return lane;
409 }
410 
411 
412 SUMOReal
414  MSLane* lane,
415  const std::string& tt, const std::string& tid) {
416  bool ok = true;
417  SUMOReal pos = attrs.get<SUMOReal>(SUMO_ATTR_POSITION, 0, ok);
418  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, 0, ok, false);
419  if (!ok) {
420  throw InvalidArgument("Error on parsing a position information.");
421  }
422  if (pos < 0) {
423  pos = lane->getLength() + pos;
424  }
425  if (pos > lane->getLength()) {
426  if (friendlyPos) {
427  pos = lane->getLength() - (SUMOReal) 0.1;
428  } else {
429  throw InvalidArgument("The position of " + tt + " '" + tid + "' lies beyond the lane's '" + lane->getID() + "' length.");
430  }
431  }
432  return pos;
433 }
434 
435 
436 
437 /****************************************************************************/
void setHandler(NLHandler *handler)
Sets the parent handler to use for nested parsing.
void parseAndBuildCalibrator(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a mesoscopic or microscopic calibrator.
SumoXMLTag
Numbers representing SUMO-XML - element names.
MSEdge & getEdge() const
Returns the lane&#39;s edge.
Definition: MSLane.h:467
virtual MSCalibrator * buildCalibrator(MSNet &net, const std::string &id, MSEdge *edge, SUMOReal pos, const std::string &file, const std::string &outfile, const SUMOTime freq, const MSRouteProbe *probe)
builds a microscopic calibrator
long long int SUMOTime
Definition: SUMOTime.h:43
static std::string getConfigurationRelative(const std::string &configPath, const std::string &path)
Returns the second path as a relative path to the first file.
Definition: FileHelpers.cpp:86
void addAccess(MSNet &net, const SUMOSAXAttributes &attrs)
Parses the values and adds an access point to the currently parsed stopping place.
A lane area vehicles can halt at.
virtual void buildChargingStation(MSNet &net, const std::string &id, const std::vector< std::string > &lines, MSLane *lane, SUMOReal frompos, SUMOReal topos, SUMOReal chrgpower, SUMOReal efficiency, SUMOReal chargeInTransit, SUMOReal ChargeDelay)
Builds a charging Station.
Writes routes of vehicles passing a certain edge.
Definition: MSRouteProbe.h:68
SUMOReal getLength() const
Returns the lane&#39;s length.
Definition: MSLane.h:375
void parseAndBuildChargingStation(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a charging station.
void parseAndBuildRerouter(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a rerouter.
static bool checkStopPos(SUMOReal &startPos, SUMOReal &endPos, const SUMOReal laneLength, const SUMOReal minLength, const bool friendlyPos)
check start and end position of a stop
bool addBusStop(MSStoppingPlace *busStop)
Adds a bus stop.
Definition: MSNet.cpp:774
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:160
SUMOTime DELTA_T
Definition: SUMOTime.cpp:39
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn&#39;t already in the dictionary...
Definition: MSEdge.cpp:578
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
Definition: MSEdge.cpp:304
NLTriggerBuilder()
Constructor.
Base (microsim) event class.
Definition: Command.h:61
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false)
Runs the given handler on the given file; returns if everything&#39;s ok.
Definition: XMLSubSys.cpp:114
virtual ~NLTriggerBuilder()
Destructor.
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
Definition: MSEdge.cpp:311
The simulated network and simulation perfomer.
Definition: MSNet.h:94
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
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.
Changes the speed allowed on a set of lanes.
T get(const std::string &id) const
Retrieves an item.
virtual void buildStoppingPlace(MSNet &net, const std::string &id, const std::vector< std::string > &lines, MSLane *lane, SUMOReal frompos, SUMOReal topos, const SumoXMLTag element)
Builds a stopping place.
const std::string & getID() const
Returns the id.
Definition: Named.h:65
A road/street connecting two junctions.
Definition: MSEdge.h:80
const NamedObjectCont< MSDetectorFileOutput * > & getTypedDetectors(SumoXMLTag type) const
Returns the list of detectors of the given type.
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
SUMOReal getLength() const
return the length of the edge
Definition: MSEdge.h:562
SUMOReal getPosition(const SUMOSAXAttributes &attrs, MSLane *lane, const std::string &tt, const std::string &tid)
returns the position on the lane checking it
the edges of a route
Encapsulated SAX-Attributes.
Calibrates the flow on a segment to a specified one.
NLHandler * myHandler
The parent handler to set for subhandlers.
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
Definition: MSNet.h:389
A wrapper for a Command function.
void parseAndBuildLaneSpeedTrigger(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a lane speed trigger.
void registerParent(const int tag, GenericSAXHandler *handler)
Assigning a parent handler which is enabled when the specified tag is closed.
MSStoppingPlace * myCurrentStop
The currently parsed stop to add access points to.
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:46
void parseAndBuildStoppingPlace(MSNet &net, const SUMOSAXAttributes &attrs, const SumoXMLTag element)
Parses the values and builds a stopping places for busses, trains or container vehicles.
#define POSITION_EPS
Definition: config.h:187
virtual void addAccess(MSLane *lane, const SUMOReal pos)
adds an access point to this stop
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:54
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
MSDetectorControl & getDetectorControl()
Returns the detector control.
Definition: MSNet.h:359
std::string getFileName(const SUMOSAXAttributes &attrs, const std::string &base, const bool allowEmpty=false)
Helper method to obtain the filename.
virtual SUMOTime addEvent(Command *operation, SUMOTime execTimeStep, AdaptType type)
Adds an Event.
The XML-Handler for network loading.
Definition: NLHandler.h:84
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:206
Reroutes vehicles passing an edge.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition: MSLane.cpp:772
bool addContainerStop(MSStoppingPlace *containerStop)
Adds a container stop.
Definition: MSNet.cpp:799
bool addChargingStation(MSChargingStation *chargingStation)
Adds a chargingg station.
Definition: MSNet.cpp:822
virtual METriggeredCalibrator * buildMECalibrator(MSNet &net, const std::string &id, const MSEdge *edge, SUMOReal pos, const std::string &file, const std::string &outfile, const SUMOTime freq, MSRouteProbe *probe)
builds a mesoscopic calibrator
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:99
Calibrates the flow on a segment to a specified one.
Definition: MSCalibrator.h:57
A variable speed sign.
Patch the time in a way that it is at least as high as the simulation begin time. ...
#define SUMOReal
Definition: config.h:213
virtual MSTriggeredRerouter * buildRerouter(MSNet &net, const std::string &id, MSEdgeVector &edges, SUMOReal prob, const std::string &file, bool off)
builds an rerouter
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual MSLaneSpeedTrigger * buildLaneSpeedTrigger(MSNet &net, const std::string &id, const std::vector< MSLane * > &destLanes, const std::string &file)
Builds a lane speed trigger.
std::vector< MSEdge * > MSEdgeVector
Definition: MSEdge.h:77
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
static bool gUseMesoSim
Definition: MSGlobals.h:87
Representation of a lane in the micro simulation.
Definition: MSLane.h:77
void buildVaporizer(const SUMOSAXAttributes &attrs)
Builds a vaporization.
MSLane * getLane(const SUMOSAXAttributes &attrs, const std::string &tt, const std::string &tid)
Returns the lane defined by attribute "lane".