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-2017 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 
63 // ===========================================================================
64 // method definitions
65 // ===========================================================================
67  : myHandler(0), myParkingArea(0) {}
68 
69 
71 
72 void
74  myHandler = handler;
75 }
76 
77 
78 void
80  bool ok = true;
81  // get the id, throw if not given or empty...
82  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
83  if (!ok) {
84  return;
85  }
86  MSEdge* e = MSEdge::dictionary(id);
87  if (e == 0) {
88  WRITE_ERROR("Unknown edge ('" + id + "') referenced in a vaporizer.");
89  return;
90  }
91  SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, 0, ok);
92  SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, 0, ok);
93  if (!ok) {
94  return;
95  }
96  if (begin < 0) {
97  WRITE_ERROR("A vaporization begin time is negative (edge id='" + id + "').");
98  return;
99  }
100  if (begin >= end) {
101  WRITE_ERROR("A vaporization ends before it starts (edge id='" + id + "').");
102  return;
103  }
104  if (end >= string2time(OptionsCont::getOptions().getString("begin"))) {
109  }
110 }
111 
112 
113 
114 void
116  const std::string& base) {
117  // get the id, throw if not given or empty...
118  bool ok = true;
119  // get the id, throw if not given or empty...
120  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
121  if (!ok) {
122  return;
123  }
124  // get the file name to read further definitions from
125  std::string file = getFileName(attrs, base, true);
126  std::string objectid = attrs.get<std::string>(SUMO_ATTR_LANES, id.c_str(), ok);
127  if (!ok) {
128  throw InvalidArgument("The lanes to use within MSLaneSpeedTrigger '" + id + "' are not known.");
129  }
130  std::vector<MSLane*> lanes;
131  std::vector<std::string> laneIDs;
132  SUMOSAXAttributes::parseStringVector(objectid, laneIDs);
133  for (std::vector<std::string>::iterator i = laneIDs.begin(); i != laneIDs.end(); ++i) {
134  MSLane* lane = MSLane::dictionary(*i);
135  if (lane == 0) {
136  throw InvalidArgument("The lane to use within MSLaneSpeedTrigger '" + id + "' is not known.");
137  }
138  lanes.push_back(lane);
139  }
140  if (lanes.size() == 0) {
141  throw InvalidArgument("No lane defined for MSLaneSpeedTrigger '" + id + "'.");
142  }
143  try {
144  MSLaneSpeedTrigger* trigger = buildLaneSpeedTrigger(net, id, lanes, file);
145  if (file == "") {
147  }
148  } catch (ProcessError& e) {
149  throw InvalidArgument(e.what());
150  }
151 }
152 
153 void
155  bool ok = true;
156 
157  // get the id, throw if not given or empty...
158  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
159 
160  if (!ok) {
161  throw ProcessError();
162  }
163 
164  // get the lane
165  MSLane* lane = getLane(attrs, "chargingStation", id);
166 
167  // get the positions
168  double frompos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), ok, 0);
169  double topos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), ok, lane->getLength());
170  double chargingPower = attrs.getOpt<double>(SUMO_ATTR_CHARGINGPOWER, id.c_str(), ok, 0);
171  double efficiency = attrs.getOpt<double>(SUMO_ATTR_EFFICIENCY, id.c_str(), ok, 0);
172  bool chargeInTransit = attrs.getOpt<bool>(SUMO_ATTR_CHARGEINTRANSIT, id.c_str(), ok, 0);
173  int ChargeDelay = attrs.getOpt<int>(SUMO_ATTR_CHARGEDELAY, id.c_str(), ok, 0);
174 
175  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
176 
177  if (!ok || !myHandler->checkStopPos(frompos, topos, lane->getLength(), POSITION_EPS, friendlyPos)) {
178  throw InvalidArgument("Invalid position for Charging Station '" + id + "'.");
179  }
180 
181  // build the Charging Station
182  buildChargingStation(net, id, lane, frompos, topos, chargingPower, efficiency, chargeInTransit, ChargeDelay);
183 }
184 
185 
186 void
188  bool ok = true;
189  // get the id, throw if not given or empty...
190  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
191  if (!ok) {
192  throw ProcessError();
193  }
194 
195  //get the name, leave blank if not given
196  const std::string ptStopName = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
197 
198  // get the lane
199  MSLane* lane = getLane(attrs, toString(element), id);
200  // get the positions
201  double frompos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), ok, 0);
202  double topos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), ok, lane->getLength());
203  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
204  if (!ok || !myHandler->checkStopPos(frompos, topos, lane->getLength(), POSITION_EPS, friendlyPos)) {
205  throw InvalidArgument("Invalid position for " + toString(element) + " '" + id + "'.");
206  }
207  // get the lines
208  std::vector<std::string> lines;
209  SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LINES, id.c_str(), ok, "", false), lines);
210  // build the bus stop
211  buildStoppingPlace(net, id, lines, lane, frompos, topos, element, ptStopName);
212 }
213 
214 
215 void
217  // get the lane
218  MSLane* lane = getLane(attrs, "access" , "");
219  // get the positions
220  bool ok = true;
221  double pos = attrs.getOpt<double>(SUMO_ATTR_POSITION, "access", ok, 0);
222  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "access", ok, false);
223  if (!ok || !myHandler->checkStopPos(pos, pos, lane->getLength(), 0, friendlyPos)) {
224  throw InvalidArgument("Invalid position for access in stop '" + myCurrentStop->getID() + "'.");
225  }
226  // build the bus stop
227  myCurrentStop->addAccess(lane, pos);
228 }
229 
230 
231 void
233  bool ok = true;
234  // get the id, throw if not given or empty...
235  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
236  if (!ok) {
237  throw ProcessError();
238  }
239  // get the lane
240  MSLane* lane = getLane(attrs, "parkingArea", id);
241  // get the positions
242  double frompos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), ok, 0);
243  double topos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), ok, lane->getLength());
244  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
245  unsigned int capacity = attrs.getOpt<int>(SUMO_ATTR_ROADSIDE_CAPACITY, id.c_str(), ok, 0);
246  double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), ok, 0);
247  double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), ok, 0);
248  double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), ok, 0);
249  if (!ok || !myHandler->checkStopPos(frompos, topos, lane->getLength(), POSITION_EPS, friendlyPos)) {
250  throw InvalidArgument("Invalid position for parking area '" + id + "'.");
251  }
252  // get the lines
253  std::vector<std::string> lines;
254  SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LINES, id.c_str(), ok, "", false), lines);
255  // build the parking area
256  beginParkingArea(net, id, lines, lane, frompos, topos, capacity, width, length, angle);
257 }
258 
259 
260 
261 void
263  bool ok = true;
264  // Check for open parking area
265  if (myParkingArea == 0) {
266  throw ProcessError();
267  }
268  // get the positions
269  double x = attrs.get<double>(SUMO_ATTR_X, "", ok);
270  if (!ok) {
271  throw InvalidArgument("Invalid x position for lot entry.");
272  }
273  double y = attrs.get<double>(SUMO_ATTR_Y, "", ok);
274  if (!ok) {
275  throw InvalidArgument("Invalid y position for lot entry.");
276  }
277  double z = attrs.getOpt<double>(SUMO_ATTR_Z, "", ok, 0.);
278  double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, "", ok, myParkingArea->getWidth());
279  double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, "", ok, myParkingArea->getLength());
280  double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, "", ok, myParkingArea->getAngle());
281  // add the lot entry
282  addLotEntry(x, y, z, width, length, angle);
283 }
284 
285 
286 void
288  const std::string& base) {
289  bool ok = true;
290  // get the id, throw if not given or empty...
291  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
292  if (!ok) {
293  throw ProcessError();
294  }
295  // get the file name to read further definitions from
296  MSLane* lane = getLane(attrs, "calibrator", id);
297  const double pos = getPosition(attrs, lane, "calibrator", id);
298  const SUMOTime freq = attrs.getOptSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok, DELTA_T); // !!! no error handling
299  std::string file = getFileName(attrs, base, true);
300  std::string outfile = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, id.c_str(), ok, "");
301  std::string routeProbe = attrs.getOpt<std::string>(SUMO_ATTR_ROUTEPROBE, id.c_str(), ok, "");
302  MSRouteProbe* probe = 0;
303  if (routeProbe != "") {
304  probe = dynamic_cast<MSRouteProbe*>(net.getDetectorControl().getTypedDetectors(SUMO_TAG_ROUTEPROBE).get(routeProbe));
305  }
307  METriggeredCalibrator* trigger = buildMECalibrator(net, id, &lane->getEdge(), pos, file, outfile, freq, probe);
308  if (file == "") {
310  }
311  } else {
312  MSCalibrator* trigger = buildCalibrator(net, id, &lane->getEdge(), pos, file, outfile, freq, probe);
313  if (file == "") {
315  }
316  }
317 }
318 
319 
320 void
322  const std::string& base) {
323  bool ok = true;
324  // get the id, throw if not given or empty...
325  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
326  if (!ok) {
327  throw ProcessError();
328  }
329  // get the file name to read further definitions from
330  std::string file = getFileName(attrs, base, true);
331  std::string objectid = attrs.get<std::string>(SUMO_ATTR_EDGES, id.c_str(), ok);
332  if (!ok) {
333  throw InvalidArgument("The edge to use within MSTriggeredRerouter '" + id + "' is not known.");
334  }
335  MSEdgeVector edges;
336  std::vector<std::string> edgeIDs;
337  SUMOSAXAttributes::parseStringVector(objectid, edgeIDs);
338  for (std::vector<std::string>::iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
339  MSEdge* edge = MSEdge::dictionary(*i);
340  if (edge == 0) {
341  throw InvalidArgument("The edge to use within MSTriggeredRerouter '" + id + "' is not known.");
342  }
343  edges.push_back(edge);
344  }
345  if (edges.size() == 0) {
346  throw InvalidArgument("No edges found for MSTriggeredRerouter '" + id + "'.");
347  }
348  double prob = attrs.getOpt<double>(SUMO_ATTR_PROB, id.c_str(), ok, 1);
349  bool off = attrs.getOpt<bool>(SUMO_ATTR_OFF, id.c_str(), ok, false);
350  if (!ok) {
351  throw InvalidArgument("Could not parse MSTriggeredRerouter '" + id + "'.");
352  }
353  MSTriggeredRerouter* trigger = buildRerouter(net, id, edges, prob, file, off);
354  // read in the trigger description
355  if (file == "") {
357  } else if (!XMLSubSys::runParser(*trigger, file)) {
358  throw ProcessError();
359  }
360 }
361 
362 
363 // -------------------------
364 
365 
367 NLTriggerBuilder::buildLaneSpeedTrigger(MSNet& /*net*/, const std::string& id,
368  const std::vector<MSLane*>& destLanes,
369  const std::string& file) {
370  return new MSLaneSpeedTrigger(id, destLanes, file);
371 }
372 
373 
375 NLTriggerBuilder::buildMECalibrator(MSNet& /*net*/, const std::string& id,
376  const MSEdge* edge, double pos,
377  const std::string& file,
378  const std::string& outfile,
379  const SUMOTime freq, MSRouteProbe* probe) {
380  return new METriggeredCalibrator(id, edge, pos, file, outfile, freq, MSGlobals::gMesoNet->getSegmentForEdge(*edge, pos)->getLength(), probe);
381 }
382 
383 
385 NLTriggerBuilder::buildCalibrator(MSNet& /*net*/, const std::string& id,
386  MSEdge* edge, double pos,
387  const std::string& file,
388  const std::string& outfile,
389  const SUMOTime freq, const MSRouteProbe* probe) {
390  return new MSCalibrator(id, edge, pos, file, outfile, freq, edge->getLength(), probe);
391 }
392 
393 
395 NLTriggerBuilder::buildRerouter(MSNet&, const std::string& id,
396  MSEdgeVector& edges,
397  double prob, const std::string& file, bool off) {
398  return new MSTriggeredRerouter(id, edges, prob, file, off);
399 }
400 
401 
402 void
403 NLTriggerBuilder::buildStoppingPlace(MSNet& net, std::string id, std::vector<std::string> lines, MSLane* lane,
404  double frompos, double topos, const SumoXMLTag element, std::string ptStopName) {
405  myCurrentStop = new MSStoppingPlace(id, lines, *lane, frompos, topos, ptStopName);
406  const bool success = element == SUMO_TAG_CONTAINER_STOP ? net.addContainerStop(myCurrentStop) : net.addBusStop(myCurrentStop);
407  if (!success) {
408  delete myCurrentStop;
409  throw InvalidArgument("Could not build " + toString(element) + " '" + id + "'; probably declared twice.");
410  }
411 }
412 
413 
414 void
415 NLTriggerBuilder::beginParkingArea(MSNet& net, const std::string& id,
416  const std::vector<std::string>& lines,
417  MSLane* lane, double frompos, double topos,
418  unsigned int capacity,
419  double width, double length, double angle) {
420  // Close previous parking area if there are not lots inside
421 
422  MSParkingArea* stop = new MSParkingArea(id, lines, *lane, frompos, topos, capacity, width, length, angle);
423  if (!net.addParkingArea(stop)) {
424  delete stop;
425  throw InvalidArgument("Could not build parking area '" + id + "'; probably declared twice.");
426  } else {
427  myParkingArea = stop;
428  }
429 }
430 
431 
432 void
433 NLTriggerBuilder::addLotEntry(double x, double y, double z,
434  double width, double length, double angle) {
435  if (myParkingArea != 0) {
436  myParkingArea->addLotEntry(x, y, z, width, length, angle);
437  } else {
438  throw InvalidArgument("Could not add lot entry outside a parking area.");
439  }
440 }
441 
442 
443 void
445  if (myParkingArea != 0) {
446  myParkingArea = 0;
447  } else {
448  throw InvalidArgument("Could not end a parking area that is not opened.");
449  }
450 }
451 
452 
453 void
454 NLTriggerBuilder::buildChargingStation(MSNet& net, const std::string& id, MSLane* lane, double frompos, double topos,
455  double chargingPower, double efficiency, bool chargeInTransit, int ChargeDelay) {
456  MSChargingStation* chargingStation = new MSChargingStation(id, *lane, frompos, topos, chargingPower, efficiency, chargeInTransit, ChargeDelay);
457 
458  if (!net.addChargingStation(chargingStation)) {
459  delete chargingStation;
460  throw InvalidArgument("Could not build Charging Station '" + id + "'; probably declared twice.");
461  }
462 }
463 
464 std::string
466  const std::string& base,
467  const bool allowEmpty) {
468  // get the file name to read further definitions from
469  bool ok = true;
470  std::string file = attrs.getOpt<std::string>(SUMO_ATTR_FILE, 0, ok, "");
471  if (file == "") {
472  if (allowEmpty) {
473  return file;
474  }
475  throw InvalidArgument("No filename given.");
476  }
477  // check whether absolute or relative filenames are given
478  if (!FileHelpers::isAbsolute(file)) {
479  return FileHelpers::getConfigurationRelative(base, file);
480  }
481  return file;
482 }
483 
484 
485 MSLane*
487  const std::string& tt,
488  const std::string& tid) {
489  bool ok = true;
490  std::string objectid = attrs.get<std::string>(SUMO_ATTR_LANE, tid.c_str(), ok);
491  MSLane* lane = MSLane::dictionary(objectid);
492  if (lane == 0) {
493  throw InvalidArgument("The lane " + objectid + " to use within the " + tt + " '" + tid + "' is not known.");
494  }
495  return lane;
496 }
497 
498 
499 double
501  MSLane* lane,
502  const std::string& tt, const std::string& tid) {
503  bool ok = true;
504  double pos = attrs.get<double>(SUMO_ATTR_POSITION, 0, ok);
505  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, 0, ok, false);
506  if (!ok) {
507  throw InvalidArgument("Error on parsing a position information.");
508  }
509  if (pos < 0) {
510  pos = lane->getLength() + pos;
511  }
512  if (pos > lane->getLength()) {
513  if (friendlyPos) {
514  pos = lane->getLength() - (double) 0.1;
515  } else {
516  throw InvalidArgument("The position of " + tt + " '" + tid + "' lies beyond the lane's '" + lane->getID() + "' length.");
517  }
518  }
519  return pos;
520 }
521 
522 
523 
524 /****************************************************************************/
void setHandler(NLHandler *handler)
Sets the parent handler to use for nested parsing.
void parseAndAddLotEntry(const SUMOSAXAttributes &attrs)
Parses his values and adds a lot entry to current parking area.
A lane area vehicles can halt at.
Definition: MSParkingArea.h:66
virtual MSTriggeredRerouter * buildRerouter(MSNet &net, const std::string &id, MSEdgeVector &edges, double prob, const std::string &file, bool off)
builds an rerouter
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.
virtual void buildStoppingPlace(MSNet &net, std::string id, std::vector< std::string > lines, MSLane *lane, double frompos, double topos, const SumoXMLTag element, std::string string)
Builds a stopping place.
MSEdge & getEdge() const
Returns the lane&#39;s edge.
Definition: MSLane.h:582
a routeprobe detector
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:82
void addAccess(MSNet &net, const SUMOSAXAttributes &attrs)
Parses the values and adds an access point to the currently parsed stopping place.
virtual void buildChargingStation(MSNet &net, const std::string &id, MSLane *lane, double frompos, double topos, double chargingPower, double efficiency, bool chargeInTransit, int ChargeDelay)
Builds a charging Station.
A lane area vehicles can halt at.
Writes routes of vehicles passing a certain edge.
Definition: MSRouteProbe.h:68
virtual void addAccess(MSLane *lane, const double pos)
adds an access point to this stop
Allow/disallow charge in transit in Charging Stations.
T get(const std::string &id) const
Retrieves an item.
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.
weights: time range begin
bool addBusStop(MSStoppingPlace *busStop)
Adds a bus stop.
Definition: MSNet.cpp:821
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:158
SUMOTime DELTA_T
Definition: SUMOTime.cpp:40
double getLength() const
Returns the lane&#39;s length.
Definition: MSLane.h:484
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:728
bool addParkingArea(MSParkingArea *parkingArea)
Adds a parking area.
Definition: MSNet.cpp:869
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
Definition: MSEdge.cpp:375
const std::string & getID() const
Returns the id.
Definition: Named.h:66
NLTriggerBuilder()
Constructor.
Base (microsim) event class.
Definition: Command.h:61
MSParkingArea * myParkingArea
definition of the currently parsed parking area
double getLength() const
return the length of the edge
Definition: MSEdge.h:586
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:110
virtual ~NLTriggerBuilder()
Destructor.
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
Definition: MSEdge.cpp:382
void parseAndBeginParkingArea(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a parking area.
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
void addLotEntry(double x, double y, double z, double width, double length, double angle)
Add a lot entry to current parking area.
The simulated network and simulation perfomer.
Definition: MSNet.h:94
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:65
Changes the speed allowed on a set of lanes.
virtual MSCalibrator * buildCalibrator(MSNet &net, const std::string &id, MSEdge *edge, double pos, const std::string &file, const std::string &outfile, const SUMOTime freq, const MSRouteProbe *probe)
builds a microscopic calibrator
A road/street connecting two junctions.
Definition: MSEdge.h:80
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
the edges of a route
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:56
Encapsulated SAX-Attributes.
Calibrates the flow on a segment to a specified one.
NLHandler * myHandler
The parent handler to set for subhandlers.
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 isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
Definition: FileHelpers.cpp:97
void endParkingArea()
End a parking area.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
Definition: MSNet.h:403
A wrapper for a Command function.
virtual METriggeredCalibrator * buildMECalibrator(MSNet &net, const std::string &id, const MSEdge *edge, double pos, const std::string &file, const std::string &outfile, const SUMOTime freq, MSRouteProbe *probe)
builds a mesoscopic calibrator
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
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:47
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:175
double getPosition(const SUMOSAXAttributes &attrs, MSLane *lane, const std::string &tt, const std::string &tid)
returns the position on the lane checking it
virtual MSLaneSpeedTrigger * buildLaneSpeedTrigger(MSNet &net, const std::string &id, const std::vector< MSLane *> &destLanes, const std::string &file)
Builds a lane speed trigger.
MSDetectorControl & getDetectorControl()
Returns the detector control.
Definition: MSNet.h:373
std::string getFileName(const SUMOSAXAttributes &attrs, const std::string &base, const bool allowEmpty=false)
Helper method to obtain the filename.
void addLotEntry(double x, double y, double z, double width, double length, double angle)
Add a lot entry to parking area.
double getLength() const
Returns the lot rectangle length.
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:1371
static bool checkStopPos(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check start and end position of a stop
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.
bool addContainerStop(MSStoppingPlace *containerStop)
Adds a container stop.
Definition: MSNet.cpp:846
bool addChargingStation(MSChargingStation *chargingStation)
Adds a chargingg station.
Definition: MSNet.cpp:891
double getWidth() const
Returns the lot rectangle width.
weights: time range end
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 void beginParkingArea(MSNet &net, const std::string &id, const std::vector< std::string > &lines, MSLane *lane, double frompos, double topos, unsigned int capacity, double width, double length, double angle)
Begin a parking area.
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:113
Calibrates the flow on a segment to a specified one.
Definition: MSCalibrator.h:57
A variable speed sign.
Eficiency of the charge in Charging Stations.
long long int SUMOTime
Definition: TraCIDefs.h:52
Delay in the charge of charging stations.
std::vector< MSEdge * > MSEdgeVector
Definition: MSEdge.h:77
const NamedObjectCont< MSDetectorFileOutput * > & getTypedDetectors(SumoXMLTag type) const
Returns the list of detectors of the given type.
static bool gUseMesoSim
Definition: MSGlobals.h:98
Representation of a lane in the micro simulation.
Definition: MSLane.h:79
void buildVaporizer(const SUMOSAXAttributes &attrs)
Builds a vaporization.
double getAngle() const
Returns the lot rectangle angle.
MSLane * getLane(const SUMOSAXAttributes &attrs, const std::string &tt, const std::string &tid)
Returns the lane defined by attribute "lane".