Eclipse SUMO - Simulation of Urban MObility
AGActivities.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2010-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 /****************************************************************************/
19 // Main class that manages activities taken in account and generates the
20 // inhabitants' trip list.
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <config.h>
28 
29 #include "AGActivities.h"
30 #include "AGWorkAndSchool.h"
31 #include "AGFreeTime.h"
32 #include "../city/AGTime.h"
33 #include <sstream>
35 
36 #define REBUILD_ITERATION_LIMIT 2
37 
38 
39 // ===========================================================================
40 // method definitions
41 // ===========================================================================
42 void
43 AGActivities::addTrip(AGTrip t, std::list<AGTrip>* tripSet) {
44  tripSet->push_back(t);
45 }
46 
47 void
48 AGActivities::addTrips(std::list<AGTrip> t, std::list<AGTrip>* tripSet) {
49  std::list<AGTrip>::iterator it;
50  for (it = t.begin(); it != t.end(); ++it) {
51  tripSet->push_back(*it);
52  }
53 }
54 
55 void
57  int numbErr;
61  numbErr = 0;
62  std::list<AGBusLine>::iterator itBL;
63  for (itBL = myCity->busLines.begin(); itBL != myCity->busLines.end(); ++itBL) {
64  if (! generateBusTraffic(*itBL)) {
65  ++numbErr;
66  }
67  }
68  if (numbErr != 0) {
69  std::cerr << "ERROR: " << numbErr << " bus lines couldn't been completely generated ( " << (float)numbErr * 100.0 / (float)myCity->busLines.size() << "% )..." << std::endl;
70  } else {
71  std::cout << "no problem during bus line trip generation..." << std::endl;
72  }
73 
74  std::cout << "after public transportation: " << trips.size() << std::endl;
79  numbErr = 0;
80  std::list<AGHousehold>::iterator itHH;
81  for (itHH = myCity->households.begin(); itHH != myCity->households.end(); ++itHH) {
82  if (! generateTrips(*itHH)) {
83  ++numbErr;
84  }
85  }
86  if (numbErr != 0) {
87  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;
88  } else {
89  std::cout << "no problem during households' trips generation..." << std::endl;
90  }
91 
92  std::cout << "after household activities: " << trips.size() << std::endl;
97  if (! generateInOutTraffic()) {
98  std::cerr << "ERROR while generating in/Out traffic..." << std::endl;
99  } else {
100  std::cout << "no problem during in/out traffic generation..." << std::endl;
101  }
102 
103  std::cout << "after incoming/outgoing traffic: " << trips.size() << std::endl;
108  if (! generateRandomTraffic()) {
109  std::cerr << "ERROR while generating random traffic..." << std::endl;
110  } else {
111  std::cout << "no problem during random traffic generation..." << std::endl;
112  }
113 
114  std::cout << "after random traffic: " << trips.size() << std::endl;
115 }
116 
117 bool
119  int iteration = 0;
120  bool generated = false;
121  std::list<AGTrip> temporaTrips;
122  while (!generated && iteration < REBUILD_ITERATION_LIMIT) {
123  if (!temporaTrips.empty()) {
124  temporaTrips.clear();
125  }
126  // Work and school activities
127  AGWorkAndSchool ws(&hh, &(myCity->statData), &temporaTrips);
128  generated = ws.generateTrips();
129  if (!generated) {
130  hh.regenerate();
131  ++iteration;
132  continue;
133  }
134  addTrips(ws.getPartialActivityTrips(), &temporaTrips);
135 
136  // free time activities
137  AGFreeTime ft(&hh, &(myCity->statData), &temporaTrips, nbrDays);
138  generated = ft.generateTrips();
139  if (!generated) {
140  hh.regenerate();
141  ++iteration;
142  continue;
143  }
144  addTrips(ft.getPartialActivityTrips(), &temporaTrips);
145  //cout << "after this hh: " << temporaTrips.size() << " we have: " << trips.size() << endl;
146  //trips of all activities generated:
147  addTrips(temporaTrips, &trips);
148  }
149  return generated;
150 }
151 
152 bool
154  std::list<AGBus>::iterator itB;
155  std::list<AGPosition>::iterator itS;
159  for (itB = bl.buses.begin(); itB != bl.buses.end(); ++itB) {
160  if (bl.stations.size() < 1) {
161  return false;
162  }
163  AGTrip t(bl.stations.front(), bl.stations.back(), *itB, itB->getDeparture());
164  for (itS = bl.stations.begin(); itS != bl.stations.end(); ++itS) {
165  if (*itS == t.getDep() || *itS == t.getArr()) {
166  continue;
167  }
168  t.addLayOver(*itS);
169  }
170  trips.push_back(t);
171  }
175  //verify that buses return back to the beginning
176  if (bl.revStations.empty()) {
177  return true; //in this case, no return way: everything is ok.
178  }
179  for (itB = bl.revBuses.begin(); itB != bl.revBuses.end(); ++itB) {
180  if (bl.revStations.size() < 1) {
181  return false;
182  }
183  AGTrip t(bl.revStations.front(), bl.revStations.back(), *itB, itB->getDeparture());
184  for (itS = bl.revStations.begin(); itS != bl.revStations.end(); ++itS) {
185  if (*itS == t.getDep() || *itS == t.getArr()) {
186  continue;
187  }
188  t.addLayOver(*itS);
189  }
190  trips.push_back(t);
191  }
192  return true;
193 }
194 
195 bool
202  if (myCity->peopleIncoming.empty()) {
203  return true;
204  }
205  if (myCity->cityGates.empty()) {
206  return false;
207  }
208  int num = 1;
209  std::list<AGAdult>::iterator itA;
210 
211  for (itA = myCity->peopleIncoming.begin(); itA != myCity->peopleIncoming.end(); ++itA) {
213  std::string nom(generateName(num, "carIn"));
214  AGTrip wayTrip(myCity->cityGates[posi], itA->getWorkPosition().getPosition(), nom, itA->getWorkPosition().getOpening());
215  //now we put the estimated time of entrance in the city.
216  wayTrip.setDepTime(wayTrip.estimateDepTime(wayTrip.getTime(), myCity->statData.speedTimePerKm));
217  AGTrip retTrip(itA->getWorkPosition().getPosition(), myCity->cityGates[posi], nom, itA->getWorkPosition().getClosing());
218  trips.push_back(wayTrip);
219  trips.push_back(retTrip);
220  ++num;
221  }
222  return true;
223 }
224 
225 std::string
226 AGActivities::generateName(int i, std::string prefix) {
227  std::ostringstream os;
228  os << i;
229  return prefix + os.str();
230 }
231 
232 bool
234  //total number of trips during the whole simulation
235  int totalTrips = 0, ttOneDayTrips = 0, ttDailyTrips = 0;
236  std::list<AGTrip>::iterator it;
237  for (it = trips.begin(); it != trips.end(); ++it) {
238  if (it->isDaily()) {
239  ++ttDailyTrips;
240  } else {
241  ++ttOneDayTrips;
242  }
243  }
244  totalTrips = ttOneDayTrips + ttDailyTrips * nbrDays;
245  //TESTS
246  std::cout << "Before Random traffic generation (days are still entire):" << std::endl;
247  std::cout << "- Total number of trips: " << totalTrips << std::endl;
248  std::cout << "- Total daily trips: " << ttDailyTrips << std::endl;
249  std::cout << "- Total one-day trips: " << ttOneDayTrips << std::endl;
250  //END OF TESTS
251 
252  //random uniform distribution:
253  int nbrRandUni = (int)((float)totalTrips * myCity->statData.uniformRandomTrafficRate / (1.0f - myCity->statData.uniformRandomTrafficRate));
254  //TESTS
255  std::cout << "added uniform random trips: " << nbrRandUni << std::endl;
256  //END OF TESTS
257  for (int i = 0; i < nbrRandUni; ++i) {
260  AGTime depTime(RandHelper::rand(nbrDays * 86400));
261  AGTrip rdtr(dep, arr, generateName(i, "randUni"), depTime.getTime() % 86400, depTime.getDay() + 1);
262  rdtr.setType("random");
263  trips.push_back(rdtr);
264  }
265 
266  //random proportional distribution:
267  //float proportionalPercentage = 0.05f;
268  //TODO generate a proportionally distributed random traffic
269 
270  return true;
271 }
272 
273 /****************************************************************************/
AGHousehold
Definition: AGHousehold.h:51
AGWorkAndSchool
Definition: AGWorkAndSchool.h:37
AGCity::households
std::list< AGHousehold > households
Definition: AGCity.h:85
AGCity::busLines
std::list< AGBusLine > busLines
Definition: AGCity.h:84
AGTrip
Definition: AGTrip.h:40
AGTrip::getArr
AGPosition getArr() const
Definition: AGTrip.cpp:102
AGDataAndStatistics::uniformRandomTrafficRate
double uniformRandomTrafficRate
Definition: AGDataAndStatistics.h:63
AGActivities::trips
std::list< AGTrip > trips
Definition: AGActivities.h:55
AGActivities::generateName
std::string generateName(int i, std::string prefix)
Definition: AGActivities.cpp:226
AGDataAndStatistics::speedTimePerKm
double speedTimePerKm
Definition: AGDataAndStatistics.h:45
AGWorkAndSchool::generateTrips
bool generateTrips()
Definition: AGWorkAndSchool.cpp:42
AGTime::getTime
int getTime()
: returns the number of seconds from the beginning of the first day of simulation this includes
Definition: AGTime.cpp:123
AGActivities::addTrips
void addTrips(std::list< AGTrip > t, std::list< AGTrip > *tripSet)
Definition: AGActivities.cpp:48
AGTrip::addLayOver
void addLayOver(AGPosition by)
Definition: AGTrip.cpp:60
AGTime
Definition: AGTime.h:36
REBUILD_ITERATION_LIMIT
#define REBUILD_ITERATION_LIMIT
Definition: AGActivities.cpp:36
RandHelper::rand
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
Definition: RandHelper.h:53
AGActivities::myCity
AGCity * myCity
Definition: AGActivities.h:68
AGTrip::setType
void setType(std::string type)
Definition: AGTrip.cpp:92
AGFreeTime
Definition: AGFreeTime.h:38
AGActivities::generateInOutTraffic
bool generateInOutTraffic()
Definition: AGActivities.cpp:196
AGCity::getRandomStreet
const AGStreet & getRandomStreet()
Definition: AGCity.cpp:419
AGBusLine::revStations
std::list< AGPosition > revStations
Definition: AGBusLine.h:53
AGActivities.h
AGActivities::generateRandomTraffic
bool generateRandomTraffic()
Definition: AGActivities.cpp:233
AGTrip::getDep
AGPosition getDep() const
Definition: AGTrip.cpp:97
AGActivities::generateActivityTrips
void generateActivityTrips()
Definition: AGActivities.cpp:56
AGActivities::generateBusTraffic
bool generateBusTraffic(AGBusLine bl)
Definition: AGActivities.cpp:153
AGActivities::nbrDays
int nbrDays
Definition: AGActivities.h:70
AGBusLine::stations
std::list< AGPosition > stations
Definition: AGBusLine.h:52
AGPosition
A location in the 2D plane freely positioned on a street.
Definition: AGPosition.h:55
AGTrip::estimateDepTime
int estimateDepTime(int arrTime, double secPerKm) const
Definition: AGTrip.cpp:146
AGBusLine::buses
std::list< AGBus > buses
Definition: AGBusLine.h:54
AGFreeTime.h
AGTrip::setDepTime
void setDepTime(int time)
Definition: AGTrip.cpp:141
AGCity::cityGates
std::vector< AGPosition > cityGates
Definition: AGCity.h:86
config.h
AGTrip::getTime
int getTime() const
Definition: AGTrip.cpp:107
RandHelper.h
AGWorkAndSchool.h
AGHousehold::regenerate
void regenerate()
Definition: AGHousehold.cpp:132
AGActivities::addTrip
void addTrip(AGTrip t, std::list< AGTrip > *tripSet)
Definition: AGActivities.cpp:43
AGCity::peopleIncoming
std::list< AGAdult > peopleIncoming
Definition: AGCity.h:87
AGActivity::getPartialActivityTrips
std::list< AGTrip > & getPartialActivityTrips()
Definition: AGActivity.cpp:138
AGDataAndStatistics::getRandomCityGateByIncoming
int getRandomCityGateByIncoming()
Definition: AGDataAndStatistics.cpp:182
AGBusLine
Definition: AGBusLine.h:40
AGTime::getDay
int getDay()
Definition: AGTime.cpp:98
AGActivities::generateTrips
bool generateTrips(AGHousehold &hh)
Definition: AGActivities.cpp:118
AGCity::statData
AGDataAndStatistics & statData
Definition: AGCity.h:80
AGFreeTime::generateTrips
bool generateTrips()
Definition: AGFreeTime.cpp:203
AGBusLine::revBuses
std::list< AGBus > revBuses
Definition: AGBusLine.h:55