Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-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 AGDataAndStatistics.h
17 : /// @author Piotr Woznica
18 : /// @author Daniel Krajzewicz
19 : /// @author Jakob Erdmann
20 : /// @author Walter Bamberger
21 : /// @date July 2010
22 : ///
23 : // Contains various data, statistical values and functions from input used
24 : // by various objects
25 : /****************************************************************************/
26 : #pragma once
27 : #include <config.h>
28 :
29 : #include <iostream>
30 : #include <map>
31 : #include "AGSchool.h"
32 : #include "AGPosition.h"
33 :
34 :
35 : // ===========================================================================
36 : // class definitions
37 : // ===========================================================================
38 : class AGDataAndStatistics {
39 : public:
40 : /**
41 : * parameters
42 : */
43 : double speedTimePerKm; //number of seconds for one km
44 : double carPreference; //prob. to choose the car (compared to the bus)
45 :
46 : /**
47 : * from General element from XML file.
48 : */
49 : int inhabitants;
50 : int households;
51 : int limitAgeChildren;
52 : int limitAgeRetirement;
53 : int limitEndAge;
54 : double carRate;
55 : double unemployement;
56 : double laborDemand;
57 : double maxFootDistance;
58 : int incomingTraffic;
59 : int outgoingTraffic;
60 : double freeTimeActivityRate;
61 : double uniformRandomTrafficRate;
62 : double departureVariation;
63 :
64 : std::map<int, double> beginWorkHours; //<hour, probability> (number only used in term of PROPORTION: it should be normalized)
65 : std::map<int, double> endWorkHours; //<hour, probability> (number only used in term of PROPORTION: it should be normalized)
66 : std::map<int, AGPosition> busStations; //<id, position>
67 : //std::map<SchoolType, int> schoolCapacity;
68 : std::map<int, double> population; //<bracket's end age, number> (number only used in term of PROPORTION: it should be normalized)
69 : std::map<int, int> ageSpan; // <brachets begin age, endage>
70 : //std::map<int, double> childrenAccompagniment; //<bracket's end age, probability>
71 : /**
72 : * number of incoming or outgoing people through the given city gates
73 : * PROPORTION: it should be normalized
74 : */
75 : std::map<int, double> incoming;
76 : std::map<int, double> outgoing;
77 :
78 : /**
79 : * computed values used during processing
80 : */
81 : int workPositions;
82 : double factorInhabitants;
83 : double factorWorkPositions;
84 :
85 : /**
86 : * data used for household generation
87 : * has to be computed before.
88 : */
89 : //probability of picking an old-people household (compared to working and have children adults)
90 : double oldAgeHhProb;
91 : //probability of having a second adult (old in case of old householders) in the household.
92 : double secondPersProb;
93 : //this s the mean number of children pro household (not old). This value is used in the Poisson-lay for determining the number of children in each family
94 : double meanNbrChildren;
95 :
96 : /**
97 : * numbers not needed but interesting for statistics and TESTING
98 : */
99 : //int childrenNbr;
100 : //int oldPeopleNbr;
101 : int AdultNbr;
102 : int householdsNbr;
103 : //households far from public transports
104 : int hhFarFromPT;
105 :
106 : static AGDataAndStatistics& getDataAndStatistics();
107 :
108 : /**
109 : * function returning a random number between the two given numbers: [n;m[ (m cannot occur)
110 : * it returns 0 if m < n
111 : */
112 : int getRandom(int n, int m);
113 : /**
114 : * function returning a random age between the two numbers satisfying the previous constrains
115 : * this number is in relation to the distribution of the population through the brackets (population's list)
116 : * if the given numbers are both greater than limitEndAge, it returns 0
117 : * if m is greater than limitEndAge, m=limitEndAge
118 : * returns -1 if conditions are not satisfied
119 : */
120 : int getRandomPopDistributed(int n, int m);
121 : /**
122 : * function evaluating the POISSON's lay (probability lay)
123 : * it returns the number of children with a probability of POISSON in a household
124 : * is given the mean of the distribution
125 : *
126 : * TODO Consider reimplementation
127 : */
128 : int getPoissonsNumberOfChildren(double mean);
129 : /**
130 : * these functions return the number of people having more (or less) than the given age
131 : * (inclusive for getPeopleOlderThan; exclusive for getPeopleYoungerThan)
132 : * getPeopleOlderThan(n) + getPeopleYoungerThan(n) = inhabitants
133 : * these first two function are based on the third one.
134 : */
135 : int getPeopleOlderThan(int age);
136 : int getPeopleYoungerThan(int age);
137 : double getPropYoungerThan(int age);
138 : /**
139 : * function consolidating statistics:
140 : * normalizes the maps with probabilities
141 : * completes data which have to be computed before use
142 : */
143 : void consolidateStat();
144 : /**
145 : * function returning a random value corresponding to this distribution:
146 : * -mean is given
147 : * -max variation of the mean (|possible value - mean| <= maxVar
148 : * -the mean is the most probable
149 : * -the probability distribution function is a "scaled exponential" distribution
150 : * from mean-maxVar to mean and from mean to mean+maxVar
151 : */
152 : double getInverseExpRandomValue(double mean, double maxVar);
153 : /**
154 : * function returning a random city gate corresponding to
155 : * the distribution of the incoming/outgoing traffic
156 : * In fact, it returns the position of a city gate in the citygate vector.
157 : */
158 : int getRandomCityGateByIncoming();
159 : int getRandomCityGateByOutgoing();
160 :
161 : private:
162 10 : AGDataAndStatistics() {}
163 :
164 : /**
165 : * returns the POISSON's probability (exp(-m)*m^k/k!)
166 : * @arg: mean of the distribution
167 : * @arg: number of occurrences
168 : *
169 : * TODO Create a Poisson distribution class for this. Or is it in Boost?
170 : */
171 : double poisson(double mean, int occ);
172 : /**
173 : * recursive mathematical function returning the factorial of n: n!
174 : */
175 : int factorial(int n);
176 :
177 : //function normalizing the map's probabilities: Sum(floats) = 1
178 : void normalizeMapProb(std::map<int, double>* myMap);
179 : };
|
