Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2010-2024 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 are made available under the
7 : // terms of the Eclipse Public License 2.0 which is available at
8 : // https://www.eclipse.org/legal/epl-2.0/
9 : // This Source Code may also be made available under the following Secondary
10 : // Licenses when the conditions for such availability set forth in the Eclipse
11 : // Public License 2.0 are satisfied: GNU General Public License, version 2
12 : // or later which is available at
13 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
14 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
15 : /****************************************************************************/
16 : /// @file AGActivities.cpp
17 : /// @author Piotr Woznica
18 : /// @author Daniel Krajzewicz
19 : /// @author Walter Bamberger
20 : /// @author Michael Behrisch
21 : /// @date July 2010
22 : ///
23 : // Main class that manages activities taken in account and generates the
24 : // inhabitants' trip list.
25 : /****************************************************************************/
26 : #include <config.h>
27 :
28 : #include <sstream>
29 : #include <utils/common/RandHelper.h>
30 : #include <activitygen/city/AGTime.h>
31 : #include "AGWorkAndSchool.h"
32 : #include "AGFreeTime.h"
33 : #include "AGActivities.h"
34 :
35 : #define REBUILD_ITERATION_LIMIT 2
36 :
37 :
38 : // ===========================================================================
39 : // method definitions
40 : // ===========================================================================
41 : void
42 0 : AGActivities::addTrip(AGTrip t, std::list<AGTrip>* tripSet) {
43 : tripSet->push_back(t);
44 0 : }
45 :
46 : void
47 4516 : AGActivities::addTrips(std::list<AGTrip> t, std::list<AGTrip>* tripSet) {
48 : std::list<AGTrip>::iterator it;
49 8184 : for (it = t.begin(); it != t.end(); ++it) {
50 : tripSet->push_back(*it);
51 : }
52 4516 : }
53 :
54 : void
55 9 : AGActivities::generateActivityTrips() {
56 : int numbErr;
57 : /**
58 : * trips due to public transportation
59 : */
60 : numbErr = 0;
61 : std::list<AGBusLine>::iterator itBL;
62 20 : for (itBL = myCity->busLines.begin(); itBL != myCity->busLines.end(); ++itBL) {
63 11 : if (! generateBusTraffic(*itBL)) {
64 0 : ++numbErr;
65 : }
66 : }
67 9 : if (numbErr != 0) {
68 0 : std::cerr << "ERROR: " << numbErr << " bus lines couldn't been completely generated ( " << (float)numbErr * 100.0 / (float)myCity->busLines.size() << "% )..." << std::endl;
69 : } else {
70 : std::cout << "no problem during bus line trip generation..." << std::endl;
71 : }
72 :
73 : std::cout << "after public transportation: " << trips.size() << std::endl;
74 : /**
75 : * trips due to activities in the city
76 : * @NOTICE: includes people working in work positions out of the city
77 : */
78 : numbErr = 0;
79 : std::list<AGHousehold>::iterator itHH;
80 1514 : for (itHH = myCity->households.begin(); itHH != myCity->households.end(); ++itHH) {
81 1506 : if (! generateTrips(*itHH)) {
82 0 : ++numbErr;
83 : }
84 : }
85 8 : if (numbErr != 0) {
86 0 : 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;
87 : } else {
88 : std::cout << "no problem during households' trips generation..." << std::endl;
89 : }
90 :
91 : std::cout << "after household activities: " << trips.size() << std::endl;
92 : /**
93 : * trips due to incoming and outgoing traffic
94 : * @WARNING: the outgoing traffic is already done: households in which someone works on a work position that is out of the city.
95 : */
96 8 : if (! generateInOutTraffic()) {
97 : std::cerr << "ERROR while generating in/Out traffic..." << std::endl;
98 : } else {
99 : std::cout << "no problem during in/out traffic generation..." << std::endl;
100 : }
101 :
102 : std::cout << "after incoming/outgoing traffic: " << trips.size() << std::endl;
103 : /**
104 : * random traffic trips
105 : * @NOTICE: this includes uniform and proportional random traffic
106 : */
107 8 : if (! generateRandomTraffic()) {
108 : std::cerr << "ERROR while generating random traffic..." << std::endl;
109 : } else {
110 : std::cout << "no problem during random traffic generation..." << std::endl;
111 : }
112 :
113 : std::cout << "after random traffic: " << trips.size() << std::endl;
114 8 : }
115 :
116 : bool
117 1506 : AGActivities::generateTrips(AGHousehold& hh) {
118 : int iteration = 0;
119 : bool generated = false;
120 : std::list<AGTrip> temporaTrips;
121 3011 : while (!generated && iteration < REBUILD_ITERATION_LIMIT) {
122 1506 : if (!temporaTrips.empty()) {
123 : temporaTrips.clear();
124 : }
125 : // Work and school activities
126 1506 : AGWorkAndSchool ws(&hh, &(myCity->statData), &temporaTrips);
127 1506 : generated = ws.generateTrips();
128 1506 : if (!generated) {
129 0 : hh.regenerate();
130 0 : ++iteration;
131 0 : continue;
132 : }
133 1506 : addTrips(ws.getPartialActivityTrips(), &temporaTrips);
134 :
135 : // free time activities
136 1506 : AGFreeTime ft(&hh, &(myCity->statData), &temporaTrips, nbrDays);
137 1506 : generated = ft.generateTrips();
138 1505 : if (!generated) {
139 0 : hh.regenerate();
140 0 : ++iteration;
141 : continue;
142 : }
143 1505 : addTrips(ft.getPartialActivityTrips(), &temporaTrips);
144 : //cout << "after this hh: " << temporaTrips.size() << " we have: " << trips.size() << endl;
145 : //trips of all activities generated:
146 3011 : addTrips(temporaTrips, &trips);
147 1506 : }
148 1505 : return generated;
149 : }
150 :
151 : bool
152 11 : AGActivities::generateBusTraffic(AGBusLine bl) {
153 : std::list<AGBus>::iterator itB;
154 : std::list<AGPosition>::iterator itS;
155 : /**
156 : * Buses in the first direction
157 : */
158 516 : for (itB = bl.buses.begin(); itB != bl.buses.end(); ++itB) {
159 505 : if (bl.stations.size() < 1) {
160 0 : return false;
161 : }
162 1010 : AGTrip t(bl.stations.front(), bl.stations.back(), *itB, itB->getDeparture());
163 4491 : for (itS = bl.stations.begin(); itS != bl.stations.end(); ++itS) {
164 7467 : if (*itS == t.getDep() || *itS == t.getArr()) {
165 1010 : continue;
166 : }
167 2976 : t.addLayOver(*itS);
168 : }
169 505 : trips.push_back(t);
170 505 : }
171 : /**
172 : * Buses in the return direction
173 : */
174 : //verify that buses return back to the beginning
175 11 : if (bl.revStations.empty()) {
176 : return true; //in this case, no return way: everything is ok.
177 : }
178 516 : for (itB = bl.revBuses.begin(); itB != bl.revBuses.end(); ++itB) {
179 505 : if (bl.revStations.size() < 1) {
180 0 : return false;
181 : }
182 1010 : AGTrip t(bl.revStations.front(), bl.revStations.back(), *itB, itB->getDeparture());
183 4491 : for (itS = bl.revStations.begin(); itS != bl.revStations.end(); ++itS) {
184 7467 : if (*itS == t.getDep() || *itS == t.getArr()) {
185 1010 : continue;
186 : }
187 2976 : t.addLayOver(*itS);
188 : }
189 505 : trips.push_back(t);
190 505 : }
191 : return true;
192 : }
193 :
194 : bool
195 8 : AGActivities::generateInOutTraffic() {
196 : /**
197 : * outgoing traffic already done by generateTrips():
198 : * people who work out of the city.
199 : * Here are people from outside the city coming to work.
200 : */
201 8 : if (myCity->peopleIncoming.empty()) {
202 : return true;
203 : }
204 3 : if (myCity->cityGates.empty()) {
205 : return false;
206 : }
207 : int num = 1;
208 : std::list<AGAdult>::iterator itA;
209 :
210 402 : for (itA = myCity->peopleIncoming.begin(); itA != myCity->peopleIncoming.end(); ++itA) {
211 400 : int posi = myCity->statData.getRandomCityGateByIncoming();
212 800 : std::string nom(generateName(num, "carIn"));
213 800 : AGTrip wayTrip(myCity->cityGates[posi], itA->getWorkPosition().getPosition(), nom, itA->getWorkPosition().getOpening());
214 : //now we put the estimated time of entrance in the city.
215 400 : wayTrip.setDepTime(wayTrip.estimateDepTime(wayTrip.getTime(), myCity->statData.speedTimePerKm));
216 800 : AGTrip retTrip(itA->getWorkPosition().getPosition(), myCity->cityGates[posi], nom, itA->getWorkPosition().getClosing());
217 400 : trips.push_back(wayTrip);
218 : trips.push_back(retTrip);
219 400 : ++num;
220 400 : }
221 : return true;
222 : }
223 :
224 : std::string
225 1925 : AGActivities::generateName(int i, std::string prefix) {
226 1925 : std::ostringstream os;
227 1925 : os << i;
228 3850 : return prefix + os.str();
229 1925 : }
230 :
231 : bool
232 8 : AGActivities::generateRandomTraffic() {
233 : //total number of trips during the whole simulation
234 : int totalTrips = 0, ttOneDayTrips = 0, ttDailyTrips = 0;
235 : std::list<AGTrip>::iterator it;
236 3404 : for (it = trips.begin(); it != trips.end(); ++it) {
237 3396 : if (it->isDaily()) {
238 2744 : ++ttDailyTrips;
239 : } else {
240 652 : ++ttOneDayTrips;
241 : }
242 : }
243 8 : totalTrips = ttOneDayTrips + ttDailyTrips * nbrDays;
244 : //TESTS
245 : std::cout << "Before Random traffic generation (days are still entire):" << std::endl;
246 8 : std::cout << "- Total number of trips: " << totalTrips << std::endl;
247 8 : std::cout << "- Total daily trips: " << ttDailyTrips << std::endl;
248 8 : std::cout << "- Total one-day trips: " << ttOneDayTrips << std::endl;
249 : //END OF TESTS
250 :
251 : //random uniform distribution:
252 8 : int nbrRandUni = (int)((float)totalTrips * myCity->statData.uniformRandomTrafficRate / (1.0f - myCity->statData.uniformRandomTrafficRate));
253 : //TESTS
254 8 : std::cout << "added uniform random trips: " << nbrRandUni << std::endl;
255 : //END OF TESTS
256 1533 : for (int i = 0; i < nbrRandUni; ++i) {
257 1525 : AGPosition dep(myCity->getRandomStreet());
258 1525 : AGPosition arr(myCity->getRandomStreet());
259 1525 : AGTime depTime(RandHelper::rand(nbrDays * 86400));
260 1525 : AGTrip rdtr(dep, arr, generateName(i, "randUni"), depTime.getTime() % 86400, depTime.getDay() + 1);
261 1525 : rdtr.setType("random");
262 1525 : trips.push_back(rdtr);
263 1525 : }
264 :
265 : //random proportional distribution:
266 : //float proportionalPercentage = 0.05f;
267 : //TODO generate a proportionally distributed random traffic
268 :
269 8 : return true;
270 : }
271 :
272 :
273 : /****************************************************************************/
|
