Eclipse SUMO - Simulation of Urban MObility
AGActivityGenHandler.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // activitygen module
5 // Copyright 2010 TUM (Technische Universitaet Muenchen, http://www.tum.de/)
6 // This program and the accompanying materials
7 // are made available under the terms of the Eclipse Public License v2.0
8 // which accompanies this distribution, and is available at
9 // http://www.eclipse.org/legal/epl-v20.html
10 // SPDX-License-Identifier: EPL-2.0
11 /****************************************************************************/
20 // The handler for parsing the statistics file.
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <config.h>
28 
29 #include "AGActivityGenHandler.h"
30 #include <iostream>
31 #include <utility>
32 #include <map>
33 #include <string>
40 #include <router/RONet.h>
41 #include "city/AGCity.h"
42 #include "city/AGSchool.h"
43 #include "city/AGPosition.h"
44 #include "city/AGBusLine.h"
45 
46 
47 // ===========================================================================
48 // method definitions
49 // ===========================================================================
51  : SUMOSAXHandler("sumo-stat"),
52  myCity(city), net(net) {}
53 
54 
56 
57 
58 void
60  try {
61  switch (element) {
62  case AGEN_TAG_GENERAL:
63  parseGeneralCityInfo(attrs);
64  break;
65  case AGEN_TAG_STREET:
66  parseStreets(attrs);
67  break;
68  case AGEN_TAG_WORKHOURS:
70  break;
71  case AGEN_TAG_OPENING:
72  parseOpeningHour(attrs);
73  break;
74  case AGEN_TAG_CLOSING:
75  parseClosingHour(attrs);
76  break;
77  case AGEN_TAG_SCHOOLS:
78  parseSchools();
79  break;
80  case AGEN_TAG_SCHOOL:
81  parseSchool(attrs);
82  break;
84  parseBusStation(attrs);
85  break;
86  case AGEN_TAG_BUSLINE:
87  parseBusLine(attrs);
88  break;
89  case AGEN_TAG_STATIONS:
90  parseStations();
91  break;
94  break;
95  case AGEN_TAG_STATION:
96  parseStation(attrs);
97  break;
98  case AGEN_TAG_FREQUENCY:
99  parseFrequency(attrs);
100  break;
101  case AGEN_TAG_POPULATION:
102  parsePopulation();
103  break;
104  /*case AGEN_TAG_CHILD_ACOMP:
105  parseChildrenAccompaniment();
106  break;*/
107  case AGEN_TAG_BRACKET:
108  parseBracket(attrs);
109  break;
110  case AGEN_TAG_PARAM:
111  parseParameters(attrs);
112  break;
113  case AGEN_TAG_ENTRANCE:
114  parseCityGates(attrs);
115  break;
116  default:
117  break;
118  }
119  } catch (const std::exception& e) {
120  throw ProcessError(e.what());
121  }
122 }
123 
124 
125 void
127  try {
128  bool ok;
131  myCity.statData.limitAgeChildren = attrs.getOpt<int>(AGEN_ATTR_CHILDREN, nullptr, ok, 18);
132  myCity.statData.limitAgeRetirement = attrs.getOpt<int>(AGEN_ATTR_RETIREMENT, nullptr, ok, 63);
133  myCity.statData.carRate = attrs.getOpt<double>(AGEN_ATTR_CARS, nullptr, ok, 0.58);
134  myCity.statData.unemployement = attrs.getOpt<double>(AGEN_ATTR_UNEMPLOYEMENT, nullptr, ok, 0.06);
135  myCity.statData.laborDemand = attrs.getOpt<double>(AGEN_ATTR_LABORDEMAND, nullptr, ok, 1.05);
136  myCity.statData.maxFootDistance = attrs.getOpt<double>(AGEN_ATTR_MAX_FOOT_DIST, nullptr, ok, 300.0);
137  myCity.statData.incomingTraffic = attrs.getOpt<int>(AGEN_ATTR_IN_TRAFFIC, nullptr, ok, 0);
138  myCity.statData.outgoingTraffic = attrs.getOpt<int>(AGEN_ATTR_OUT_TRAFFIC, nullptr, ok, 0);
139  } catch (const std::exception& e) {
140  WRITE_ERROR("Error while parsing the element " +
141  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_GENERAL) + ": " +
142  e.what());
143  throw ProcessError();
144  }
145 }
146 
147 void
149  try {
150  bool ok;
151  myCity.statData.carPreference = attrs.getOpt<double>(AGEN_ATTR_CARPREF, nullptr, ok, 0.0);
152  myCity.statData.speedTimePerKm = attrs.getOpt<double>(AGEN_ATTR_CITYSPEED, nullptr, ok, 360.0);
153  myCity.statData.freeTimeActivityRate = attrs.getOpt<double>(AGEN_ATTR_FREETIMERATE, nullptr, ok, 0.15);
154  myCity.statData.uniformRandomTrafficRate = attrs.getOpt<double>(AGEN_ATTR_UNI_RAND_TRAFFIC, nullptr, ok, 0.0);
155  myCity.statData.departureVariation = attrs.getOpt<double>(AGEN_ATTR_DEP_VARIATION, nullptr, ok, 0.0);
156  } catch (const std::exception& e) {
157  WRITE_ERROR("Error while parsing the element " +
158  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_PARAM) + ": " +
159  e.what());
160  throw ProcessError();
161  }
162 }
163 
164 void
166  try {
167  double pop = 0;
168  double work = 0;
169 
170  if (attrs.hasAttribute(AGEN_ATTR_POPULATION)) {
171  pop = attrs.getFloat(AGEN_ATTR_POPULATION);
172  }
174  work = attrs.getFloat(AGEN_ATTR_OUT_WORKPOSITION);
175  }
176  std::string eid = attrs.getString(SUMO_ATTR_EDGE);
177  AGStreet* street = dynamic_cast<AGStreet*>(net->getEdge(eid));
178  if (street == nullptr) {
179  WRITE_ERROR("Edge '" + eid + "' is not known.");
180  return;
181  }
182  street->setPopulation(pop * street->getLength());
183  street->setWorkplaceNumber(work * street->getLength());
184  myCity.streets.push_back(street);
185  } catch (const std::exception& e) {
186  WRITE_ERROR("Error while parsing the element " +
187  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_STREET) + ": " +
188  e.what());
189  throw ProcessError();
190  }
191 }
192 
193 void
195  try {
196  std::string edge = attrs.getString(SUMO_ATTR_EDGE);
197  double positionOnEdge = attrs.getFloat(SUMO_ATTR_POSITION);
198  AGPosition posi(myCity.getStreet(edge), positionOnEdge);
201  myCity.cityGates.push_back(posi);
202 
203  } catch (const std::exception& e) {
204  WRITE_ERROR("Error while parsing the element " +
205  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_CITYGATES) + ": " +
206  e.what());
207  throw ProcessError();
208  }
209 }
210 
211 void
213  myCurrentObject = "workHours";
214 }
215 
216 void
218  if (myCurrentObject == "workHours") {
219  try {
221 
222  } catch (const std::exception& e) {
223  WRITE_ERROR("Error while parsing the element " +
225  + e.what());
226  throw ProcessError();
227  }
228  }
229 }
230 
231 void
233  if (myCurrentObject == "workHours") {
234  try {
236 
237  } catch (const std::exception& e) {
238  WRITE_ERROR("Error while parsing the element " +
240  + e.what());
241  throw ProcessError();
242  }
243  }
244 }
245 
246 void
248  myCurrentObject = "schools";
249 }
250 
251 void
253  try {
254  std::string edge = attrs.getString(SUMO_ATTR_EDGE);
255  double positionOnEdge = attrs.getFloat(SUMO_ATTR_POSITION);
256  AGPosition posi(myCity.getStreet(edge), positionOnEdge);
257  int beginAge = attrs.getInt(AGEN_ATTR_BEGINAGE);
258  int endAge = attrs.getInt(AGEN_ATTR_ENDAGE);
259  int capacity = attrs.getInt(AGEN_ATTR_CAPACITY);
260  int openingHour = attrs.getInt(AGEN_ATTR_OPENING);
261  int closingHour = attrs.getInt(AGEN_ATTR_CLOSING);
262  AGSchool sch(capacity, posi, beginAge, endAge, openingHour, closingHour);
263  myCity.schools.push_back(sch);
264 
265  } catch (const std::exception& e) {
266  WRITE_ERROR("Error while parsing the element " +
267  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_SCHOOL) + ": " +
268  e.what());
269  throw ProcessError();
270  }
271 }
272 
273 void
275  try {
276  std::string edge = attrs.getString(SUMO_ATTR_EDGE);
277  double positionOnEdge = attrs.getFloat(SUMO_ATTR_POSITION);
278  int id = attrs.getInt(SUMO_ATTR_ID);
279  AGPosition posi(myCity.getStreet(edge), positionOnEdge);
280  myCity.statData.busStations.insert(std::pair<int, AGPosition>(id, posi));
281 
282  } catch (const std::exception& e) {
283  WRITE_ERROR("Error while parsing the element " +
285  e.what());
286  throw ProcessError();
287  }
288 }
289 
290 void
292  try {
293  myCurrentObject = "busLine";
294  AGBusLine busL(attrs.getString(SUMO_ATTR_ID));
296  myCity.busLines.push_front(busL);
297  currentBusLine = &*myCity.busLines.begin();
298 
299  } catch (const std::exception& e) {
300  WRITE_ERROR("Error while parsing the element " +
301  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_BUSLINE) + ": " +
302  e.what());
303  throw ProcessError();
304  }
305 }
306 
307 void
309  isRevStation = false;
310 }
311 
312 void
314  isRevStation = true;
315 }
316 
317 void
319  if (myCurrentObject != "busLine") {
320  return;
321  }
322 
323  try {
324  bool ok = true;
325  int refID = attrs.get<int>(SUMO_ATTR_REFID, myCurrentObject.c_str(), ok);
326  if (!ok) {
327  throw ProcessError();
328  }
329  if (myCity.statData.busStations.count(refID) == 0) {
330  throw ProcessError("Unknown bus station " + toString(refID));
331  }
332  if (!isRevStation) {
334  } else {
336  }
337 
338  } catch (const std::exception& e) {
339  WRITE_ERROR("Error while parsing the element " +
340  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_STATION) + ": " +
341  e.what());
342  throw ProcessError();
343  }
344 }
345 
346 void
348  if (myCurrentObject != "busLine") {
349  return;
350  }
351 
352  try {
353  int beginB = attrs.getInt(SUMO_ATTR_BEGIN);
354  int endB = attrs.getInt(SUMO_ATTR_END);
355  int rateB = attrs.getInt(AGEN_ATTR_RATE);
356  currentBusLine->generateBuses(beginB, endB, rateB);
357 
358  } catch (const std::exception& e) {
359  WRITE_ERROR("Error while parsing the element " +
360  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_FREQUENCY) + ": " +
361  e.what());
362  throw ProcessError();
363  }
364 }
365 
366 void
368  myCurrentObject = "population";
369 }
370 
371 void
373  try {
374 //TODO beginAge needs to be evaluated
375 // int beginAge = attrs.getInt(AGEN_ATTR_BEGINAGE); //included in the bracket
376  int endAge = attrs.getInt(AGEN_ATTR_ENDAGE); //NOT included in the bracket
377  if (myCurrentObject == "population") {
379  }
380 
381  } catch (const std::exception& e) {
382  WRITE_ERROR("Error while parsing the element " +
383  SUMOXMLDefinitions::Tags.getString(AGEN_TAG_BRACKET) + ": " +
384  e.what());
385  throw ProcessError();
386  }
387 }
388 
389 /****************************************************************************/
390 
AGEN_TAG_SCHOOL
schools object
Definition: SUMOXMLDefinitions.h:339
AGActivityGenHandler::parseParameters
void parseParameters(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:148
AGActivityGenHandler::myCurrentObject
std::string myCurrentObject
The name of the object that is currently processed.
Definition: AGActivityGenHandler.h:146
AGActivityGenHandler::parsePopulation
void parsePopulation()
Definition: AGActivityGenHandler.cpp:367
AGEN_TAG_OPENING
opening for workingHours object
Definition: SUMOXMLDefinitions.h:333
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
AGEN_TAG_POPULATION
population and children accompaniment brackets
Definition: SUMOXMLDefinitions.h:353
SUMOSAXAttributes::getString
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOSAXHandler
SAX-handler base for SUMO-files.
Definition: SUMOSAXHandler.h:41
AGCity::busLines
std::list< AGBusLine > busLines
Definition: AGCity.h:84
AGActivityGenHandler.h
AGEN_ATTR_CARS
Definition: SUMOXMLDefinitions.h:908
AGEN_ATTR_POPULATION
Definition: SUMOXMLDefinitions.h:919
AGDataAndStatistics::outgoingTraffic
int outgoingTraffic
Definition: AGDataAndStatistics.h:61
AGEN_TAG_STREET
streets object
Definition: SUMOXMLDefinitions.h:329
AGEN_TAG_GENERAL
ActivityGen Tags.
Definition: SUMOXMLDefinitions.h:327
OptionsCont.h
RONet::getEdge
ROEdge * getEdge(const std::string &name) const
Retrieves an edge from the network.
Definition: RONet.h:152
AGEN_ATTR_LABORDEMAND
Definition: SUMOXMLDefinitions.h:910
SUMOSAXAttributes::getInt
virtual int getInt(int id) const =0
Returns the int-value of the named (by its enum-value) attribute.
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
AGActivityGenHandler::parseStations
void parseStations()
Definition: AGActivityGenHandler.cpp:308
MsgHandler.h
AGEN_ATTR_INHABITANTS
Definition: SUMOXMLDefinitions.h:904
AGStreet::setWorkplaceNumber
void setWorkplaceNumber(const double work)
Modifies the number of work places in this street.
Definition: AGStreet.cpp:66
AGEN_TAG_BUSLINE
bus line
Definition: SUMOXMLDefinitions.h:343
SUMOSAXHandler.h
AGDataAndStatistics::uniformRandomTrafficRate
double uniformRandomTrafficRate
Definition: AGDataAndStatistics.h:63
AGSchool
Definition: AGSchool.h:36
SUMO_ATTR_EDGE
Definition: SUMOXMLDefinitions.h:423
AGDataAndStatistics::limitAgeRetirement
int limitAgeRetirement
Definition: AGDataAndStatistics.h:54
AGDataAndStatistics::departureVariation
double departureVariation
Definition: AGDataAndStatistics.h:64
AGDataAndStatistics::speedTimePerKm
double speedTimePerKm
Definition: AGDataAndStatistics.h:45
AGCity::getStreet
const AGStreet & getStreet(const std::string &edge)
Definition: AGCity.cpp:394
AGEN_ATTR_CARPREF
Definition: SUMOXMLDefinitions.h:954
RONet
The router's network representation.
Definition: RONet.h:63
AGActivityGenHandler::parseCityGates
void parseCityGates(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:194
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
AGEN_ATTR_ENDAGE
Definition: SUMOXMLDefinitions.h:948
AGEN_ATTR_PROP
Definition: SUMOXMLDefinitions.h:926
AGDataAndStatistics::population
std::map< int, double > population
Definition: AGDataAndStatistics.h:70
SUMOSAXAttributes::getFloat
virtual double getFloat(int id) const =0
Returns the double-value of the named (by its enum-value) attribute.
AGSchool.h
AGEN_TAG_BRACKET
alternative definition for Population
Definition: SUMOXMLDefinitions.h:355
AGEN_TAG_FREQUENCY
frequency of a object
Definition: SUMOXMLDefinitions.h:351
AGBusLine.h
AGDataAndStatistics::carPreference
double carPreference
Definition: AGDataAndStatistics.h:46
AGActivityGenHandler::parseGeneralCityInfo
void parseGeneralCityInfo(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:126
AGDataAndStatistics::busStations
std::map< int, AGPosition > busStations
Definition: AGDataAndStatistics.h:68
SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:678
AGCity::streets
std::vector< AGStreet * > streets
Definition: AGCity.h:81
AGEN_TAG_STATION
station for a certain vehicle
Definition: SUMOXMLDefinitions.h:349
AGActivityGenHandler::parseStreets
void parseStreets(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:165
AGEN_TAG_REV_STATIONS
rev stations for certain vehicles
Definition: SUMOXMLDefinitions.h:347
AGDataAndStatistics::beginWorkHours
std::map< int, double > beginWorkHours
Definition: AGDataAndStatistics.h:66
AGDataAndStatistics::outgoing
std::map< int, double > outgoing
Definition: AGDataAndStatistics.h:77
AGEN_ATTR_CLOSING
Definition: SUMOXMLDefinitions.h:934
AGEN_ATTR_RETIREMENT
Definition: SUMOXMLDefinitions.h:907
AGEN_ATTR_MAX_FOOT_DIST
Definition: SUMOXMLDefinitions.h:911
RONet.h
SUMO_ATTR_REFID
Definition: SUMOXMLDefinitions.h:379
AGBusLine::locateRevStation
void locateRevStation(AGPosition pos)
Definition: AGBusLine.cpp:137
AGActivityGenHandler::parseSchools
void parseSchools()
Definition: AGActivityGenHandler.cpp:247
AGCity
Definition: AGCity.h:52
AGEN_ATTR_OUT_TRAFFIC
Definition: SUMOXMLDefinitions.h:913
AGEN_TAG_WORKHOURS
workingHours object
Definition: SUMOXMLDefinitions.h:331
AGEN_ATTR_RATE
Definition: SUMOXMLDefinitions.h:942
ProcessError
Definition: UtilExceptions.h:39
AGEN_ATTR_OPENING
Definition: SUMOXMLDefinitions.h:933
AGEN_ATTR_HOUSEHOLDS
Definition: SUMOXMLDefinitions.h:905
AGActivityGenHandler::myCity
AGCity & myCity
The city to store the information into.
Definition: AGActivityGenHandler.h:143
AGActivityGenHandler::parseBusLine
void parseBusLine(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:291
AGStreet
A model of the street in the city.
Definition: AGStreet.h:52
UtilExceptions.h
AGDataAndStatistics::incomingTraffic
int incomingTraffic
Definition: AGDataAndStatistics.h:60
AGActivityGenHandler::parseClosingHour
void parseClosingHour(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:232
SUMOSAXAttributes::getOpt
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.
Definition: SUMOSAXAttributes.h:518
AGActivityGenHandler::parseFrequency
void parseFrequency(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:347
SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:660
AGEN_ATTR_DEP_VARIATION
Definition: SUMOXMLDefinitions.h:958
AGActivityGenHandler::net
RONet * net
The loaded network.
Definition: AGActivityGenHandler.h:153
AGActivityGenHandler::currentBusLine
AGBusLine * currentBusLine
Definition: AGActivityGenHandler.h:147
AGDataAndStatistics::unemployement
double unemployement
Definition: AGDataAndStatistics.h:57
AGActivityGenHandler::parseOpeningHour
void parseOpeningHour(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:217
AGEN_TAG_CLOSING
closing for workingHours object
Definition: SUMOXMLDefinitions.h:335
AGEN_ATTR_CAPACITY
Definition: SUMOXMLDefinitions.h:932
AGEN_TAG_STATIONS
stations for certain vehicles
Definition: SUMOXMLDefinitions.h:345
AGStreet::setPopulation
void setPopulation(const double pop)
Modifies the number of persons living in this street.
Definition: AGStreet.cpp:54
AGActivityGenHandler::isRevStation
bool isRevStation
indicator whether the current station (in bus line context) is a reverse station or not.
Definition: AGActivityGenHandler.h:150
AGDataAndStatistics::maxFootDistance
double maxFootDistance
Definition: AGDataAndStatistics.h:59
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
AGEN_ATTR_CITYSPEED
Definition: SUMOXMLDefinitions.h:955
AGPosition.h
AGEN_ATTR_FREETIMERATE
Definition: SUMOXMLDefinitions.h:956
AGBusLine::setMaxTripTime
void setMaxTripTime(int time)
Definition: AGBusLine.cpp:47
AGDataAndStatistics::endWorkHours
std::map< int, double > endWorkHours
Definition: AGDataAndStatistics.h:67
AGActivityGenHandler::parseBusStation
void parseBusStation(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:274
SUMOXMLDefinitions::Tags
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
Definition: SUMOXMLDefinitions.h:1359
AGActivityGenHandler::parseRevStations
void parseRevStations()
Definition: AGActivityGenHandler.cpp:313
AGEN_TAG_SCHOOLS
school object
Definition: SUMOXMLDefinitions.h:337
AGDataAndStatistics::incoming
std::map< int, double > incoming
Definition: AGDataAndStatistics.h:76
AGPosition
A location in the 2D plane freely positioned on a street.
Definition: AGPosition.h:55
AGEN_ATTR_UNI_RAND_TRAFFIC
Definition: SUMOXMLDefinitions.h:957
ROEdge::getLength
double getLength() const
Returns the length of the edge.
Definition: ROEdge.h:204
AGDataAndStatistics::inhabitants
int inhabitants
Definition: AGDataAndStatistics.h:51
AGBusLine::locateStation
void locateStation(AGPosition pos)
Definition: AGBusLine.cpp:132
AGEN_ATTR_INCOMING
Definition: SUMOXMLDefinitions.h:963
AGActivityGenHandler::parseBracket
void parseBracket(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:372
AGEN_TAG_PARAM
parameters
Definition: SUMOXMLDefinitions.h:362
AGActivityGenHandler::parseWorkHours
void parseWorkHours()
Definition: AGActivityGenHandler.cpp:212
AGDataAndStatistics::laborDemand
double laborDemand
Definition: AGDataAndStatistics.h:58
AGEN_ATTR_HOUR
Definition: SUMOXMLDefinitions.h:925
AGActivityGenHandler::myStartElement
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: AGActivityGenHandler.cpp:59
AGCity::cityGates
std::vector< AGPosition > cityGates
Definition: AGCity.h:86
AGDataAndStatistics::freeTimeActivityRate
double freeTimeActivityRate
Definition: AGDataAndStatistics.h:62
AGEN_TAG_ENTRANCE
alternative definition for city entrances
Definition: SUMOXMLDefinitions.h:360
config.h
AGEN_ATTR_OUT_WORKPOSITION
Definition: SUMOXMLDefinitions.h:920
AGEN_TAG_CITYGATES
city entrances
Definition: SUMOXMLDefinitions.h:358
StringTokenizer.h
SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
AGEN_ATTR_IN_TRAFFIC
Definition: SUMOXMLDefinitions.h:912
AGActivityGenHandler::parseSchool
void parseSchool(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:252
AGEN_TAG_BUSSTATION
busStation and bus objects
Definition: SUMOXMLDefinitions.h:341
AGEN_ATTR_MAX_TRIP_DURATION
Definition: SUMOXMLDefinitions.h:940
AGBusLine::generateBuses
void generateBuses(int start, int stop, int rate)
Definition: AGBusLine.cpp:142
AGCity.h
AGDataAndStatistics::carRate
double carRate
Definition: AGDataAndStatistics.h:56
AGEN_ATTR_UNEMPLOYEMENT
Definition: SUMOXMLDefinitions.h:909
AGEN_ATTR_CHILDREN
Definition: SUMOXMLDefinitions.h:906
AGActivityGenHandler::parseStation
void parseStation(const SUMOSAXAttributes &attrs)
Definition: AGActivityGenHandler.cpp:318
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
AGActivityGenHandler::AGActivityGenHandler
AGActivityGenHandler(AGCity &city, RONet *net)
Constructor.
Definition: AGActivityGenHandler.cpp:50
AGDataAndStatistics::limitAgeChildren
int limitAgeChildren
Definition: AGDataAndStatistics.h:53
AGEN_ATTR_PEOPLENBR
Definition: SUMOXMLDefinitions.h:949
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
AGBusLine
Definition: AGBusLine.h:40
SUMOXMLDefinitions.h
AGDataAndStatistics::households
int households
Definition: AGDataAndStatistics.h:52
AGCity::statData
AGDataAndStatistics & statData
Definition: AGCity.h:80
AGCity::schools
std::list< AGSchool > schools
Definition: AGCity.h:83
AGEN_ATTR_BEGINAGE
Definition: SUMOXMLDefinitions.h:947
AGEN_ATTR_OUTGOING
Definition: SUMOXMLDefinitions.h:964
AGActivityGenHandler::~AGActivityGenHandler
virtual ~AGActivityGenHandler()
Destructor.
Definition: AGActivityGenHandler.cpp:55