SUMO - Simulation of Urban MObility
AGActivities.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // Main class that manages activities taken in account and generates the
11 // inhabitants' trip list.
12 /****************************************************************************/
13 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
14 // Copyright (C) 2010-2015 DLR (http://www.dlr.de/) and contributors
15 // activitygen module
16 // Copyright 2010 TUM (Technische Universitaet Muenchen, http://www.tum.de/)
17 /****************************************************************************/
18 //
19 // This file is part of SUMO.
20 // SUMO is free software: you can redistribute it and/or modify
21 // it under the terms of the GNU General Public License as published by
22 // the Free Software Foundation, either version 3 of the License, or
23 // (at your option) any later version.
24 //
25 /****************************************************************************/
26 
27 
28 // ===========================================================================
29 // included modules
30 // ===========================================================================
31 #ifdef _MSC_VER
32 #include <windows_config.h>
33 #else
34 #include <config.h>
35 #endif
36 
37 #include "AGActivities.h"
38 #include "AGWorkAndSchool.h"
39 #include "AGFreeTime.h"
40 #include "../city/AGTime.h"
41 #include <sstream>
43 
44 #define REBUILD_ITERATION_LIMIT 2
45 
46 
47 // ===========================================================================
48 // method definitions
49 // ===========================================================================
50 void
51 AGActivities::addTrip(AGTrip t, std::list<AGTrip>* tripSet) {
52  tripSet->push_back(t);
53 }
54 
55 void
56 AGActivities::addTrips(std::list<AGTrip> t, std::list<AGTrip>* tripSet) {
57  std::list<AGTrip>::iterator it;
58  for (it = t.begin(); it != t.end(); ++it) {
59  tripSet->push_back(*it);
60  }
61 }
62 
63 void
65  int numbErr;
69  numbErr = 0;
70  std::list<AGBusLine>::iterator itBL;
71  for (itBL = myCity->busLines.begin(); itBL != myCity->busLines.end(); ++itBL) {
72  if (! generateBusTraffic(*itBL)) {
73  ++numbErr;
74  }
75  }
76  if (numbErr != 0) {
77  std::cerr << "ERROR: " << numbErr << " bus lines couldn't been completely generated ( " << (float)numbErr * 100.0 / (float)myCity->busLines.size() << "% )..." << std::endl;
78  } else {
79  std::cout << "no problem during bus line trip generation..." << std::endl;
80  }
81 
82  std::cout << "after public transportation: " << trips.size() << std::endl;
87  numbErr = 0;
88  std::list<AGHousehold>::iterator itHH;
89  for (itHH = myCity->households.begin(); itHH != myCity->households.end(); ++itHH) {
90  if (! generateTrips(*itHH)) {
91  ++numbErr;
92  }
93  }
94  if (numbErr != 0) {
95  std::cout << "WARNING: " << numbErr << " ( " << (float)numbErr * 100.0 / (float)myCity->households.size() << "% ) households' trips haven't been generated: would probably need more iterations for rebuilding..." << std::endl;
96  } else {
97  std::cout << "no problem during households' trips generation..." << std::endl;
98  }
99 
100  std::cout << "after household activities: " << trips.size() << std::endl;
105  if (! generateInOutTraffic()) {
106  std::cerr << "ERROR while generating in/Out traffic..." << std::endl;
107  } else {
108  std::cout << "no problem during in/out traffic generation..." << std::endl;
109  }
110 
111  std::cout << "after incoming/outgoing traffic: " << trips.size() << std::endl;
116  if (! generateRandomTraffic()) {
117  std::cerr << "ERROR while generating random traffic..." << std::endl;
118  } else {
119  std::cout << "no problem during random traffic generation..." << std::endl;
120  }
121 
122  std::cout << "after random traffic: " << trips.size() << std::endl;
123 }
124 
125 bool
127  int iteration = 0;
128  bool generated = false;
129  std::list<AGTrip> temporaTrips;
130  while (!generated && iteration < REBUILD_ITERATION_LIMIT) {
131  if (!temporaTrips.empty()) {
132  temporaTrips.clear();
133  }
134  // Work and school activities
135  AGWorkAndSchool ws(&hh, &(myCity->statData), &temporaTrips);
136  generated = ws.generateTrips();
137  if (!generated) {
138  hh.regenerate();
139  ++iteration;
140  continue;
141  }
142  addTrips(ws.getPartialActivityTrips(), &temporaTrips);
143 
144  // free time activities
145  AGFreeTime ft(&hh, &(myCity->statData), &temporaTrips, nbrDays);
146  generated = ft.generateTrips();
147  if (!generated) {
148  hh.regenerate();
149  ++iteration;
150  continue;
151  }
152  addTrips(ft.getPartialActivityTrips(), &temporaTrips);
153  //cout << "after this hh: " << temporaTrips.size() << " we have: " << trips.size() << endl;
154  //trips of all activities generated:
155  addTrips(temporaTrips, &trips);
156  }
157  return generated;
158 }
159 
160 bool
162  std::list<AGBus>::iterator itB;
163  std::list<AGPosition>::iterator itS;
167  for (itB = bl.buses.begin(); itB != bl.buses.end(); ++itB) {
168  if (bl.stations.size() < 1) {
169  return false;
170  }
171  AGTrip t(bl.stations.front(), bl.stations.back(), *itB, itB->getDeparture());
172  for (itS = bl.stations.begin(); itS != bl.stations.end(); ++itS) {
173  if (*itS == t.getDep() || *itS == t.getArr()) {
174  continue;
175  }
176  t.addLayOver(*itS);
177  }
178  trips.push_back(t);
179  }
183  //verify that buses return back to the beginning
184  if (bl.revStations.empty()) {
185  return true; //in this case, no return way: everything is ok.
186  }
187  for (itB = bl.revBuses.begin(); itB != bl.revBuses.end(); ++itB) {
188  if (bl.revStations.size() < 1) {
189  return false;
190  }
191  AGTrip t(bl.revStations.front(), bl.revStations.back(), *itB, itB->getDeparture());
192  for (itS = bl.revStations.begin(); itS != bl.revStations.end(); ++itS) {
193  if (*itS == t.getDep() || *itS == t.getArr()) {
194  continue;
195  }
196  t.addLayOver(*itS);
197  }
198  trips.push_back(t);
199  }
200  return true;
201 }
202 
203 bool
210  if (myCity->peopleIncoming.empty()) {
211  return true;
212  }
213  if (myCity->cityGates.empty()) {
214  return false;
215  }
216  int num = 1;
217  std::list<AGAdult>::iterator itA;
218 
219  for (itA = myCity->peopleIncoming.begin(); itA != myCity->peopleIncoming.end(); ++itA) {
221  std::string nom(generateName(num, "carIn"));
222  AGTrip wayTrip(myCity->cityGates[posi], itA->getWorkPosition().getPosition(), nom, itA->getWorkPosition().getOpening());
223  //now we put the estimated time of entrance in the city.
224  wayTrip.setDepTime(wayTrip.estimateDepTime(wayTrip.getTime(), myCity->statData.speedTimePerKm));
225  AGTrip retTrip(itA->getWorkPosition().getPosition(), myCity->cityGates[posi], nom, itA->getWorkPosition().getClosing());
226  trips.push_back(wayTrip);
227  trips.push_back(retTrip);
228  ++num;
229  }
230  return true;
231 }
232 
233 std::string
234 AGActivities::generateName(int i, std::string prefix) {
235  std::ostringstream os;
236  os << i;
237  return prefix + os.str();
238 }
239 
240 bool
242  //total number of trips during the whole simulation
243  int totalTrips = 0, ttOneDayTrips = 0, ttDailyTrips = 0;
244  std::list<AGTrip>::iterator it;
245  for (it = trips.begin(); it != trips.end(); ++it) {
246  if (it->isDaily()) {
247  ++ttDailyTrips;
248  } else {
249  ++ttOneDayTrips;
250  }
251  }
252  totalTrips = ttOneDayTrips + ttDailyTrips * nbrDays;
253  //TESTS
254  std::cout << "Before Random traffic generation (days are still entire):" << std::endl;
255  std::cout << "- Total number of trips: " << totalTrips << std::endl;
256  std::cout << "- Total daily trips: " << ttDailyTrips << std::endl;
257  std::cout << "- Total one-day trips: " << ttOneDayTrips << std::endl;
258  //END OF TESTS
259 
260  //random uniform distribution:
261  int nbrRandUni = (int)((float)totalTrips * myCity->statData.uniformRandomTrafficRate / (1.0f - myCity->statData.uniformRandomTrafficRate));
262  //TESTS
263  std::cout << "added uniform random trips: " << nbrRandUni << std::endl;
264  //END OF TESTS
265  for (int i = 0; i < nbrRandUni; ++i) {
268  AGTime depTime(RandHelper::rand(nbrDays * 86400));
269  AGTrip rdtr(dep, arr, generateName(i, "randUni"), depTime.getTime() % 86400, depTime.getDay() + 1);
270  rdtr.setType("random");
271  trips.push_back(rdtr);
272  }
273 
274  //random proportional distribution:
275  //float proportionalPercentage = 0.05f;
276  //TODO generate a proportionally distributed random traffic
277 
278  return true;
279 }
280 
281 /****************************************************************************/
bool generateTrips(AGHousehold &hh)
void addLayOver(AGPosition by)
Definition: AGTrip.cpp:68
void generateActivityTrips()
std::list< AGBus > buses
Definition: AGBusLine.h:62
std::string generateName(int i, std::string prefix)
Definition: AGTime.h:44
std::list< AGPosition > stations
Definition: AGBusLine.h:60
A location in the 2D plane freely positioned on a street.
Definition: AGPosition.h:63
static SUMOReal rand()
Returns a random real number in [0, 1)
Definition: RandHelper.h:62
AGDataAndStatistics & statData
Definition: AGCity.h:88
void setType(std::string type)
Definition: AGTrip.cpp:100
std::list< AGPosition > revStations
Definition: AGBusLine.h:61
#define REBUILD_ITERATION_LIMIT
std::list< AGBusLine > busLines
Definition: AGCity.h:92
void regenerate()
void setDepTime(int time)
Definition: AGTrip.cpp:149
const AGStreet & getRandomStreet()
Definition: AGCity.cpp:419
bool generateInOutTraffic()
std::list< AGBus > revBuses
Definition: AGBusLine.h:63
std::list< AGTrip > trips
Definition: AGActivities.h:63
std::list< AGTrip > & getPartialActivityTrips()
Definition: AGActivity.cpp:139
std::list< AGHousehold > households
Definition: AGCity.h:93
void addTrip(AGTrip t, std::list< AGTrip > *tripSet)
std::list< AGAdult > peopleIncoming
Definition: AGCity.h:95
AGCity * myCity
Definition: AGActivities.h:76
std::vector< AGPosition > cityGates
Definition: AGCity.h:94
void addTrips(std::list< AGTrip > t, std::list< AGTrip > *tripSet)
Definition: AGTrip.h:48
bool generateRandomTraffic()
bool generateBusTraffic(AGBusLine bl)