Eclipse SUMO - Simulation of Urban MObility
AGHousehold.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 /****************************************************************************/
19 // A household contains the people and cars of the city: roughly represents
20 // families with their address, cars, adults and possibly children
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <config.h>
28 
30 #include "AGCar.h"
31 #include "AGChild.h"
32 #include "AGCity.h"
33 #include "AGDataAndStatistics.h"
34 #include "AGHousehold.h"
35 
36 
37 // ===========================================================================
38 // method definitions
39 // ===========================================================================
40 void
41 AGHousehold::generatePeople(int numAdults, int numChilds, bool firstRetired) {
43  //the first adult
45  if (firstRetired) {
47  }
48  myAdults.push_back(pers);
49  //further adults
50  while (static_cast<int>(myAdults.size()) < numAdults) {
51  if (firstRetired) {
53  myAdults.push_back(pers2);
54  } else {
56  myAdults.push_back(pers2);
57  }
58  }
59  //Children
60  while (static_cast<int>(myChildren.size()) < numChilds) {
62  myChildren.push_back(chl);
63  }
64 }
65 
66 void
68  int peopleInNeed = static_cast<int>(myAdults.size()) - static_cast<int>(myCars.size());
69  while (peopleInNeed > 0) {
70  if (RandHelper::rand() < rate) {
71  addACar();
72  }
73  --peopleInNeed;
74  }
75 }
76 
77 void
79  int numCar = static_cast<int>(myCars.size() + 1);
80  myCars.push_back(AGCar(myId, numCar));
81 }
82 
83 int
85  return static_cast<int>(myCars.size());
86 }
87 
88 int
90  return static_cast<int>(myAdults.size() + myChildren.size());
91 }
92 
93 int
95  return static_cast<int>(myAdults.size());
96 }
97 
98 const std::list<AGAdult>&
100  return myAdults;
101 }
102 
103 const std::list<AGChild>&
105  return myChildren;
106 }
107 
108 const std::list<AGCar>&
110  return myCars;
111 }
112 
113 bool
114 AGHousehold::isCloseFromPubTransport(std::list<AGPosition>* pubTransport) {
115  double distToPT = myLocation.minDistanceTo(*pubTransport);
116  if (distToPT > myCity->statData.maxFootDistance) {
117  return false;
118  }
119  return true;
120 }
121 
122 bool
123 AGHousehold::isCloseFromPubTransport(std::map<int, AGPosition>* pubTransport) {
124  double distToPT = myLocation.minDistanceTo(*pubTransport);
125  if (distToPT > myCity->statData.maxFootDistance) {
126  return false;
127  }
128  return true;
129 }
130 
131 void
133  //only allocation of work or school to people will change
134  std::list<AGChild>::iterator itC;
135  std::list<AGAdult>::iterator itA;
136  for (itC = myChildren.begin(); itC != myChildren.end(); ++itC) {
137  if (itC->haveASchool()) {
138  if (itC->leaveSchool()) {
139  itC->allocateASchool(&(myCity->schools), getPosition());
140  }
141  } else {
142  itC->allocateASchool(&(myCity->schools), getPosition());
143  }
144  }
145  for (itA = myAdults.begin(); itA != myAdults.end(); ++itA) {
146  if (itA->isWorking()) {
147  itA->resignFromWorkPosition();
148  }
149 
150  if (myCity->statData.workPositions > 0) {
151  itA->tryToWork(1 - myCity->statData.unemployement, &(myCity->workPositions));
152 
153  } else {
154  std::cout << "Not enough work positions in AGHousehold::regenerate. Should not happen!" << std::endl;
155  }
156  }
157 }
158 
159 bool
161  std::list<AGChild>::iterator it;
162  bool oneRemainsAtHome = false;
163 
164  for (it = myChildren.begin(); it != myChildren.end(); ++it) {
165  if (!it->allocateASchool(&(myCity->schools), myLocation)) {
166  oneRemainsAtHome = true;
167  }
168  }
169  return !oneRemainsAtHome;
170 }
171 
172 bool
174  std::list<AGAdult>::iterator it;
175  for (it = myAdults.begin(); it != myAdults.end(); ++it) {
176  if (myCity->statData.workPositions <= 0) {
177  std::cout << "Not enough free work positions in AGHousehold::allocateAdultsWork. Should not happen." << std::endl;
178  return false;
179 
180  } else {
181  it->tryToWork(1 - myCity->statData.unemployement, &(myCity->workPositions));
182  }
183  }
184  return true;
185 }
186 
189  return myLocation;
190 }
191 
192 AGCity*
194  return myCity;
195 }
196 
197 bool
199  return (myAdults.front().getAge() >= myCity->statData.limitAgeRetirement);
200 }
201 
202 /****************************************************************************/
AGHousehold::getAdultNbr
int getAdultNbr()
Definition: AGHousehold.cpp:94
AGCity::workPositions
std::vector< AGWorkPosition > workPositions
Definition: AGCity.h:82
AGHousehold::generatePeople
void generatePeople(int numAdults, int numChilds, bool firstRetired)
Definition: AGHousehold.cpp:41
AGHousehold::getCarNbr
int getCarNbr()
Definition: AGHousehold.cpp:84
AGHousehold::myCars
std::list< AGCar > myCars
Definition: AGHousehold.h:123
AGHousehold::myAdults
std::list< AGAdult > myAdults
Definition: AGHousehold.h:121
AGDataAndStatistics::workPositions
int workPositions
Definition: AGDataAndStatistics.h:82
AGPosition::minDistanceTo
double minDistanceTo(const std::list< AGPosition > &positions) const
Computes the distance to the closest position in a list.
Definition: AGPosition.cpp:68
AGDataAndStatistics::limitAgeRetirement
int limitAgeRetirement
Definition: AGDataAndStatistics.h:54
AGHousehold::getPosition
AGPosition getPosition()
Definition: AGHousehold.cpp:188
AGHousehold::isCloseFromPubTransport
bool isCloseFromPubTransport(std::list< AGPosition > *pubTransport)
Definition: AGHousehold.cpp:114
AGChild
Definition: AGChild.h:40
AGHousehold::getPeopleNbr
int getPeopleNbr()
Definition: AGHousehold.cpp:89
AGHousehold::myLocation
AGPosition myLocation
Definition: AGHousehold.h:117
AGHousehold::myId
int myId
Definition: AGHousehold.h:118
AGDataAndStatistics
Definition: AGDataAndStatistics.h:40
RandHelper::rand
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
Definition: RandHelper.h:53
AGHousehold::getTheCity
AGCity * getTheCity()
Definition: AGHousehold.cpp:193
AGHousehold::myCity
AGCity * myCity
Definition: AGHousehold.h:116
AGHousehold::generateCars
void generateCars(double rate)
Definition: AGHousehold.cpp:67
AGDataAndStatistics::limitEndAge
int limitEndAge
Definition: AGDataAndStatistics.h:55
AGHousehold::myChildren
std::list< AGChild > myChildren
Definition: AGHousehold.h:122
AGCar
Definition: AGCar.h:38
AGHousehold::retiredHouseholders
bool retiredHouseholders()
Definition: AGHousehold.cpp:198
AGHousehold.h
AGCity
Definition: AGCity.h:52
AGHousehold::getChildren
const std::list< AGChild > & getChildren() const
Definition: AGHousehold.cpp:104
AGCar.h
AGDataAndStatistics::getRandomPopDistributed
int getRandomPopDistributed(int n, int m)
Definition: AGDataAndStatistics.cpp:56
AGHousehold::allocateAdultsWork
bool allocateAdultsWork()
Definition: AGHousehold.cpp:173
AGDataAndStatistics::unemployement
double unemployement
Definition: AGDataAndStatistics.h:57
AGDataAndStatistics::maxFootDistance
double maxFootDistance
Definition: AGDataAndStatistics.h:59
AGPosition
A location in the 2D plane freely positioned on a street.
Definition: AGPosition.h:55
AGHousehold::addACar
void addACar()
Definition: AGHousehold.cpp:78
AGChild.h
config.h
RandHelper.h
AGAdult
An adult person who can have a job.
Definition: AGAdult.h:50
AGHousehold::getAdults
const std::list< AGAdult > & getAdults() const
Definition: AGHousehold.cpp:99
AGHousehold::regenerate
void regenerate()
Definition: AGHousehold.cpp:132
AGCity.h
AGHousehold::getCars
const std::list< AGCar > & getCars() const
Definition: AGHousehold.cpp:109
AGDataAndStatistics::limitAgeChildren
int limitAgeChildren
Definition: AGDataAndStatistics.h:53
AGDataAndStatistics.h
AGHousehold::allocateChildrenSchool
bool allocateChildrenSchool()
Definition: AGHousehold.cpp:160
AGCity::statData
AGDataAndStatistics & statData
Definition: AGCity.h:80
AGCity::schools
std::list< AGSchool > schools
Definition: AGCity.h:83