Eclipse SUMO - Simulation of Urban MObility
libsumo/Edge.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2017-2022 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // C++ TraCI client API implementation
19 /****************************************************************************/
20 
21 #include <iterator>
22 #include <microsim/MSEdge.h>
23 #include <microsim/MSLane.h>
26 #include <microsim/MSVehicle.h>
28 #include <libsumo/TraCIDefs.h>
29 #include <libsumo/TraCIConstants.h>
31 #include "Edge.h"
32 
33 
34 namespace libsumo {
35 // ===========================================================================
36 // static member initializations
37 // ===========================================================================
38 SubscriptionResults Edge::mySubscriptionResults;
39 ContextSubscriptionResults Edge::myContextSubscriptionResults;
40 
41 
42 // ===========================================================================
43 // static member definitions
44 // ===========================================================================
45 std::vector<std::string>
46 Edge::getIDList() {
47  std::vector<std::string> ids;
48  MSEdge::insertIDs(ids);
49  return ids;
50 }
51 
52 
53 int
54 Edge::getIDCount() {
55  return (int)getIDList().size();
56 }
57 
58 
59 double
60 Edge::getAdaptedTraveltime(const std::string& edgeID, double time) {
61  const MSEdge* e = getEdge(edgeID);
62  double value;
63  if (!MSNet::getInstance()->getWeightsStorage().retrieveExistingTravelTime(e, time, value)) {
64  return -1.;
65  }
66  return value;
67 }
68 
69 
70 double
71 Edge::getEffort(const std::string& edgeID, double time) {
72  const MSEdge* e = getEdge(edgeID);
73  double value;
74  if (!MSNet::getInstance()->getWeightsStorage().retrieveExistingEffort(e, time, value)) {
75  return -1.;
76  }
77  return value;
78 }
79 
80 
81 double
82 Edge::getTraveltime(const std::string& edgeID) {
83  return getEdge(edgeID)->getCurrentTravelTime();
84 }
85 
86 
87 MSEdge*
88 Edge::getEdge(const std::string& edgeID) {
89  MSEdge* e = MSEdge::dictionary(edgeID);
90  if (e == nullptr) {
91  throw TraCIException("Edge '" + edgeID + "' is not known");
92  }
93  return e;
94 }
95 
96 
97 double
98 Edge::getWaitingTime(const std::string& edgeID) {
99  return getEdge(edgeID)->getWaitingSeconds();
100 }
101 
102 
103 const std::vector<std::string>
104 Edge::getLastStepPersonIDs(const std::string& edgeID) {
105  std::vector<std::string> personIDs;
106  std::vector<MSTransportable*> persons = getEdge(edgeID)->getSortedPersons(MSNet::getInstance()->getCurrentTimeStep(), true);
107  personIDs.reserve(persons.size());
108  for (MSTransportable* p : persons) {
109  personIDs.push_back(p->getID());
110  }
111  return personIDs;
112 }
113 
114 
115 const std::vector<std::string>
116 Edge::getLastStepVehicleIDs(const std::string& edgeID) {
117  std::vector<std::string> vehIDs;
118  for (const SUMOVehicle* veh : getEdge(edgeID)->getVehicles()) {
119  vehIDs.push_back(veh->getID());
120  }
121  return vehIDs;
122 }
123 
124 
125 double
126 Edge::getCO2Emission(const std::string& edgeID) {
127  double sum = 0;
128  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
129  sum += lane->getCO2Emissions();
130  }
131  return sum;
132 }
133 
134 
135 double
136 Edge::getCOEmission(const std::string& edgeID) {
137  double sum = 0;
138  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
139  sum += lane->getCOEmissions();
140  }
141  return sum;
142 }
143 
144 
145 double
146 Edge::getHCEmission(const std::string& edgeID) {
147  double sum = 0;
148  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
149  sum += lane->getHCEmissions();
150  }
151  return sum;
152 }
153 
154 
155 double
156 Edge::getPMxEmission(const std::string& edgeID) {
157  double sum = 0;
158  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
159  sum += lane->getPMxEmissions();
160  }
161  return sum;
162 }
163 
164 
165 double
166 Edge::getNOxEmission(const std::string& edgeID) {
167  double sum = 0;
168  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
169  sum += lane->getNOxEmissions();
170  }
171  return sum;
172 }
173 
174 
175 double
176 Edge::getFuelConsumption(const std::string& edgeID) {
177  double sum = 0;
178  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
179  sum += lane->getFuelConsumption();
180  }
181  return sum;
182 }
183 
184 
185 double
186 Edge::getNoiseEmission(const std::string& edgeID) {
187  double sum = 0;
188  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
189  sum += pow(10., (lane->getHarmonoise_NoiseEmissions() / 10.));
190  }
191  if (sum != 0) {
192  return HelpersHarmonoise::sum(sum);
193  }
194  return sum;
195 }
196 
197 
198 double
199 Edge::getElectricityConsumption(const std::string& edgeID) {
200  double sum = 0;
201  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
202  sum += lane->getElectricityConsumption();
203  }
204  return sum;
205 }
206 
207 
208 int
209 Edge::getLastStepVehicleNumber(const std::string& edgeID) {
210  return getEdge(edgeID)->getVehicleNumber();
211 }
212 
213 
214 double
215 Edge::getLastStepMeanSpeed(const std::string& edgeID) {
216  return getEdge(edgeID)->getMeanSpeed();
217 }
218 
219 
220 double
221 Edge::getLastStepOccupancy(const std::string& edgeID) {
222  return getEdge(edgeID)->getOccupancy();
223 }
224 
225 
226 int
227 Edge::getLastStepHaltingNumber(const std::string& edgeID) {
228  int result = 0;
229  for (const SUMOVehicle* veh : getEdge(edgeID)->getVehicles()) {
230  if (veh->getSpeed() < SUMO_const_haltingSpeed) {
231  result++;
232  }
233  }
234  return result;
235 }
236 
237 
238 double
239 Edge::getLastStepLength(const std::string& edgeID) {
240  double lengthSum = 0;
241  int numVehicles = 0;
242  for (const SUMOVehicle* veh : getEdge(edgeID)->getVehicles()) {
243  numVehicles++;
244  lengthSum += dynamic_cast<const MSBaseVehicle*>(veh)->getVehicleType().getLength();
245  }
246  if (numVehicles == 0) {
247  return 0;
248  }
249  return lengthSum / numVehicles;
250 }
251 
252 
253 int
254 Edge::getLaneNumber(const std::string& edgeID) {
255  return (int)getEdge(edgeID)->getLanes().size();
256 }
257 
258 
259 std::string
260 Edge::getStreetName(const std::string& edgeID) {
261  return getEdge(edgeID)->getStreetName();
262 }
263 
264 
265 const std::vector<std::string>
266 Edge::getPendingVehicles(const std::string& edgeID) {
267  getEdge(edgeID); // validate edgeID
268  std::vector<std::string> vehIDs;
269  for (const SUMOVehicle* veh : MSNet::getInstance()->getInsertionControl().getPendingVehicles()) {
270  if (veh->getEdge()->getID() == edgeID) {
271  vehIDs.push_back(veh->getID());
272  }
273  }
274  return vehIDs;
275 }
276 
277 std::string
278 Edge::getParameter(const std::string& edgeID, const std::string& param) {
279  return getEdge(edgeID)->getParameter(param, "");
280 }
281 
282 
284 
285 
286 void
287 Edge::setAllowedVehicleClasses(const std::string& edgeID, std::vector<std::string> classes) {
288  SVCPermissions permissions = parseVehicleClasses(classes);
289  setAllowedSVCPermissions(edgeID, permissions);
290 }
291 
292 
293 void
294 Edge::setDisallowedVehicleClasses(const std::string& edgeID, std::vector<std::string> classes) {
295  SVCPermissions permissions = invertPermissions(parseVehicleClasses(classes));
296  setAllowedSVCPermissions(edgeID, permissions);
297 }
298 
299 
300 void
301 Edge::setAllowedSVCPermissions(const std::string& edgeID, int permissions) {
302  MSEdge* e = getEdge(edgeID);
303  for (MSLane* lane : e->getLanes()) {
304  lane->setPermissions(permissions, MSLane::CHANGE_PERMISSIONS_PERMANENT);
305  }
306  e->rebuildAllowedLanes();
307 }
308 
309 
310 void
311 Edge::adaptTraveltime(const std::string& edgeID, double time, double beginSeconds, double endSeconds) {
312  MSNet::getInstance()->getWeightsStorage().addTravelTime(getEdge(edgeID), beginSeconds, endSeconds, time);
313 }
314 
315 
316 void
317 Edge::setEffort(const std::string& edgeID, double effort, double beginSeconds, double endSeconds) {
318  MSNet::getInstance()->getWeightsStorage().addEffort(getEdge(edgeID), beginSeconds, endSeconds, effort);
319 }
320 
321 
322 void
323 Edge::setMaxSpeed(const std::string& edgeID, double speed) {
324  for (MSLane* lane : getEdge(edgeID)->getLanes()) {
325  lane->setMaxSpeed(speed);
326  }
327 }
328 
329 
330 void
331 Edge::setParameter(const std::string& edgeID, const std::string& name, const std::string& value) {
332  getEdge(edgeID)->setParameter(name, value);
333 }
334 
335 
337 
338 
339 void
340 Edge::storeShape(const std::string& edgeID, PositionVector& shape) {
341  const MSEdge* const e = getEdge(edgeID);
342  const std::vector<MSLane*>& lanes = e->getLanes();
343  shape = lanes.front()->getShape();
344  if (lanes.size() > 1) {
345  copy(lanes.back()->getShape().begin(), lanes.back()->getShape().end(), back_inserter(shape));
346  }
347 }
348 
349 
350 std::shared_ptr<VariableWrapper>
351 Edge::makeWrapper() {
352  return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
353 }
354 
355 
356 bool
357 Edge::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
358  switch (variable) {
359  case TRACI_ID_LIST:
360  return wrapper->wrapStringList(objID, variable, getIDList());
361  case ID_COUNT:
362  return wrapper->wrapInt(objID, variable, getIDCount());
364  return wrapper->wrapDouble(objID, variable, getTraveltime(objID));
365  case VAR_WAITING_TIME:
366  return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
368  return wrapper->wrapStringList(objID, variable, getLastStepPersonIDs(objID));
370  return wrapper->wrapStringList(objID, variable, getLastStepVehicleIDs(objID));
371  case VAR_CO2EMISSION:
372  return wrapper->wrapDouble(objID, variable, getCO2Emission(objID));
373  case VAR_COEMISSION:
374  return wrapper->wrapDouble(objID, variable, getCOEmission(objID));
375  case VAR_HCEMISSION:
376  return wrapper->wrapDouble(objID, variable, getHCEmission(objID));
377  case VAR_PMXEMISSION:
378  return wrapper->wrapDouble(objID, variable, getPMxEmission(objID));
379  case VAR_NOXEMISSION:
380  return wrapper->wrapDouble(objID, variable, getNOxEmission(objID));
381  case VAR_FUELCONSUMPTION:
382  return wrapper->wrapDouble(objID, variable, getFuelConsumption(objID));
383  case VAR_NOISEEMISSION:
384  return wrapper->wrapDouble(objID, variable, getNoiseEmission(objID));
386  return wrapper->wrapDouble(objID, variable, getElectricityConsumption(objID));
388  return wrapper->wrapInt(objID, variable, getLastStepVehicleNumber(objID));
390  return wrapper->wrapDouble(objID, variable, getLastStepMeanSpeed(objID));
391  case LAST_STEP_OCCUPANCY:
392  return wrapper->wrapDouble(objID, variable, getLastStepOccupancy(objID));
394  return wrapper->wrapInt(objID, variable, getLastStepHaltingNumber(objID));
395  case LAST_STEP_LENGTH:
396  return wrapper->wrapDouble(objID, variable, getLastStepLength(objID));
397  case VAR_LANE_INDEX:
398  return wrapper->wrapInt(objID, variable, getLaneNumber(objID));
399  case VAR_NAME:
400  return wrapper->wrapString(objID, variable, getStreetName(objID));
402  return wrapper->wrapStringList(objID, variable, getPendingVehicles(objID));
404  paramData->readUnsignedByte();
405  return wrapper->wrapString(objID, variable, getParameter(objID, paramData->readString()));
407  paramData->readUnsignedByte();
408  return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->readString()));
409  default:
410  return false;
411  }
412 }
413 
414 }
415 
416 
417 /****************************************************************************/
SVCPermissions invertPermissions(SVCPermissions permissions)
negate the given permissions and ensure that only relevant bits are set
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
Definition: StdDefs.h:61
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN)
Definition: TraCIDefs.h:69
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
Definition: TraCIDefs.h:115
C++ TraCI client API implementation.
Definition: Edge.h:34
static double sum(double val)
Computes the resulting noise.
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:51
double getLength() const
Returns the vehicle's length.
A road/street connecting two junctions.
Definition: MSEdge.h:77
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:168
void rebuildAllowedLanes()
Definition: MSEdge.cpp:271
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
Definition: MSEdge.cpp:885
static void insertIDs(std::vector< std::string > &into)
Inserts IDs of all known edges into the given vector.
Definition: MSEdge.cpp:934
double getWaitingSeconds() const
return accumated waiting time for all vehicles on this edges lanes or segments
Definition: MSEdge.cpp:1300
void addTravelTime(const MSEdge *const e, double begin, double end, double value)
Adds a travel time information for an edge and a time span.
void addEffort(const MSEdge *const e, double begin, double end, double value)
Adds an effort information for an edge and a time span.
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
static const long CHANGE_PERMISSIONS_PERMANENT
Definition: MSLane.h:1256
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:174
MSEdgeWeightsStorage & getWeightsStorage()
Returns the net's internal edge travel times/efforts container.
Definition: MSNet.cpp:1082
A list of positions.
Representation of a vehicle.
Definition: SUMOVehicle.h:60
virtual std::string readString()
Definition: storage.cpp:180
virtual int readUnsignedByte()
Definition: storage.cpp:155
TRACI_CONST int LAST_STEP_VEHICLE_ID_LIST
TRACI_CONST int LAST_STEP_VEHICLE_NUMBER
TRACI_CONST int VAR_NOXEMISSION
TRACI_CONST int VAR_NAME
TRACI_CONST int LAST_STEP_PERSON_ID_LIST
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_WAITING_TIME
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
Definition: TraCIDefs.h:279
TRACI_CONST int LAST_STEP_LENGTH
TRACI_CONST int VAR_LANE_INDEX
TRACI_CONST int VAR_PMXEMISSION
TRACI_CONST int VAR_COEMISSION
TRACI_CONST int LAST_STEP_MEAN_SPEED
TRACI_CONST int VAR_CO2EMISSION
TRACI_CONST int VAR_PENDING_VEHICLES
TRACI_CONST int VAR_FUELCONSUMPTION
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
Definition: TraCIDefs.h:278
TRACI_CONST int LAST_STEP_VEHICLE_HALTING_NUMBER
TRACI_CONST int VAR_HCEMISSION
TRACI_CONST int ID_COUNT
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int LAST_STEP_OCCUPANCY
TRACI_CONST int VAR_NOISEEMISSION
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int VAR_CURRENT_TRAVELTIME
TRACI_CONST int VAR_ELECTRICITYCONSUMPTION