Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2025 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 : /****************************************************************************/
14 : /// @file MSStoppingPlaceRerouter.cpp
15 : /// @author Mirko Barthauer
16 : /// @date Mon, 17 June 2024
17 : ///
18 : // The StoppingPlaceRerouter provides an interface to structure the rerouting
19 : // to the best StoppingPlace according to the evaluation components and
20 : // associated weights.
21 : /****************************************************************************/
22 : #include <utils/vehicle/SUMOVehicle.h>
23 : #include <microsim/MSEdge.h>
24 : #include <microsim/MSGlobals.h>
25 : #include <microsim/MSLane.h>
26 : #include <microsim/MSRoute.h>
27 : #include <microsim/MSParkingArea.h>
28 : #include <microsim/MSStoppingPlace.h>
29 : #include <microsim/MSVehicleType.h>
30 : #include <microsim/trigger/MSChargingStation.h>
31 : #include "MSStoppingPlaceRerouter.h"
32 :
33 : //#define DEBUG_STOPPINGPLACE
34 : #define DEBUGCOND (veh.isSelected())
35 : //#define DEBUGCOND (true)
36 :
37 :
38 : ///@brief Constructor
39 4107 : MSStoppingPlaceRerouter::MSStoppingPlaceRerouter(std::string paramPrefix, bool checkValidity, StoppingPlaceParamMap_t addEvalParams, StoppingPlaceParamSwitchMap_t addInvertParams) :
40 4107 : myParamPrefix(paramPrefix), myCheckValidity(checkValidity) {
41 36963 : myEvalParams = { {"probability", 0.}, {"capacity", 0.}, {"timefrom", 0.}, {"timeto", 0.}, {"distancefrom", 0.}, {"distanceto", 1.}, {"absfreespace", 0.}, {"relfreespace", 0.}, };
42 36963 : myInvertParams = { {"probability", false}, { "capacity", true }, { "timefrom", false }, { "timeto", false }, { "distancefrom", false }, { "distanceto", false }, { "absfreespace", true }, { "relfreespace", true } };
43 4325 : for (auto param : addEvalParams) {
44 218 : myEvalParams[param.first] = param.second;
45 436 : myInvertParams[param.first] = (addInvertParams.count(param.first) > 0) ? addInvertParams[param.first] : false;
46 : }
47 37181 : for (auto param : myEvalParams) {
48 33074 : myNormParams.insert({param.first, param.first != "probability"});
49 : }
50 4325 : }
51 :
52 : MSStoppingPlace*
53 82066 : MSStoppingPlaceRerouter::rerouteStoppingPlace(MSStoppingPlace* destStoppingPlace, const std::vector<StoppingPlaceVisible>& stoppingPlaceCandidates, const std::vector<double>& probs, SUMOVehicle& veh, bool& newDestination, ConstMSEdgeVector& newRoute, StoppingPlaceParamMap_t& scores,
54 : const Prohibitions& closedEdges, const int insertStopIndex, const bool keepCurrentStop) {
55 : // Reroute destination from initial stopping place to an alternative stopping place
56 : // if the following conditions are met:
57 : // - next stop target is a stopping place of the right type
58 : // - target is included in the current alternative set
59 : // - target is visibly full
60 : // Any stopping places that are visibly full at the current location are
61 : // committed to the stopping place memory corresponding to their type
62 :
63 82066 : MSStoppingPlace* nearStoppingPlace = nullptr;
64 :
65 : // get vehicle params
66 : bool destVisible = false;
67 82066 : if (destStoppingPlace != nullptr) {
68 81927 : destVisible = (&destStoppingPlace->getLane().getEdge() == veh.getEdge());
69 : // if the vehicle is on the destination stop edge it is always visible
70 180996 : for (auto stoppingPlace : stoppingPlaceCandidates) {
71 119045 : if (stoppingPlace.first == destStoppingPlace && stoppingPlace.second) {
72 : destVisible = true;
73 : break;
74 : }
75 : }
76 : }
77 82066 : const MSRoute& route = veh.getRoute();
78 :
79 82066 : MSStoppingPlace* onTheWay = nullptr;
80 82066 : const int stopAnywhere = (int)getWeight(veh, "anywhere", -1);
81 82066 : const bool ignoreDest = getWeight(veh, "ignoreDest", destStoppingPlace != nullptr ? 0 : 1) != 0;
82 : // check whether we are ready to accept any free stopping place along the
83 : // way to our destination
84 82066 : if (stopAnywhere < 0 || stopAnywhere > getNumberStoppingPlaceReroutes(veh)) {
85 82031 : if (!destVisible) {
86 : // cannot determine destination occupancy, only register visibly full
87 119806 : for (const StoppingPlaceVisible& stoppingPlace : stoppingPlaceCandidates) {
88 70451 : if (stoppingPlace.second && getLastStepStoppingPlaceOccupancy(stoppingPlace.first) >= getStoppingPlaceCapacity(stoppingPlace.first)) {
89 6334 : rememberStoppingPlaceScore(veh, stoppingPlace.first, "occupied");
90 6334 : rememberBlockedStoppingPlace(veh, stoppingPlace.first, &stoppingPlace.first->getLane().getEdge() == veh.getEdge());
91 : }
92 : }
93 : #ifdef DEBUG_STOPPINGPLACE
94 : if (DEBUGCOND) {
95 : //std::cout << SIMTIME << " veh=" << veh.getID() << " dest=" << ((destStoppingPlace == nullptr)? "null" : destStoppingPlace->getID()) << " stopAnywhere=" << stopAnywhere << " reroutes=" << getNumberStoppingPlaceReroutes(veh) << " stay on original route\n";
96 : }
97 : #endif
98 : }
99 : } else {
100 : double bestDist = std::numeric_limits<double>::max();
101 35 : const double brakeGap = veh.getBrakeGap(true);
102 200 : for (const StoppingPlaceVisible& item : stoppingPlaceCandidates) {
103 165 : if (item.second) {
104 70 : if (&item.first->getLane().getEdge() == veh.getEdge()
105 70 : && getLastStepStoppingPlaceOccupancy(item.first) < getStoppingPlaceCapacity(item.first)) {
106 25 : const double distToStart = item.first->getBeginLanePosition() - veh.getPositionOnLane();
107 25 : const double distToEnd = item.first->getEndLanePosition() - veh.getPositionOnLane();
108 25 : if (distToEnd > brakeGap) {
109 40 : rememberStoppingPlaceScore(veh, item.first, "dist=" + toString(distToStart));
110 20 : if (distToStart < bestDist) {
111 : bestDist = distToStart;
112 20 : onTheWay = item.first;
113 : }
114 : } else {
115 10 : rememberStoppingPlaceScore(veh, item.first, "tooClose");
116 : }
117 : }
118 : }
119 : }
120 : #ifdef DEBUG_STOPPINGPLACE
121 : if (DEBUGCOND) {
122 : std::cout << SIMTIME << " veh=" << veh.getID()
123 : << " dest=" << ((destStoppingPlace == nullptr) ? "null" : destStoppingPlace->getID()) << " stopAnywhere=" << stopAnywhere << " reroutes=" << getNumberStoppingPlaceReroutes(veh) << " alongTheWay=" << Named::getIDSecure(onTheWay) << "\n";
124 : }
125 : #endif
126 : }
127 82066 : if (!ignoreDest && !destVisible && onTheWay == nullptr) {
128 : return nullptr;
129 : }
130 :
131 32861 : if (ignoreDest || getLastStepStoppingPlaceOccupancy(destStoppingPlace) >= getStoppingPlaceCapacity(destStoppingPlace) || onTheWay != nullptr) {
132 : // if the current route ends at the stopping place, the new route will
133 : // also end at the new stopping place
134 38309 : newDestination = (destStoppingPlace != nullptr && &destStoppingPlace->getLane().getEdge() == route.getLastEdge()
135 3900 : && veh.getArrivalPos() >= destStoppingPlace->getBeginLanePosition()
136 3900 : && veh.getArrivalPos() <= destStoppingPlace->getEndLanePosition()
137 20017 : && veh.getStops().size() == 1);
138 :
139 : #ifdef DEBUG_STOPPINGPLACE
140 : if (DEBUGCOND) {
141 : std::cout << SIMTIME << " veh=" << veh.getID()
142 : << " newDest=" << newDestination
143 : << " onTheWay=" << Named::getIDSecure(onTheWay)
144 : << "\n";
145 : }
146 : #endif
147 : std::map<MSStoppingPlace*, ConstMSEdgeVector> newRoutes;
148 : std::map<MSStoppingPlace*, ConstMSEdgeVector> stopApproaches;
149 19224 : StoppingPlaceParamMap_t weights = collectWeights(veh); // add option to patch values for interdependent values
150 : StoppingPlaceParamMap_t maxValues;
151 173270 : for (auto param : weights) {
152 154046 : maxValues[param.first] = 0.;
153 : }
154 :
155 : // a map stores elegible stopping places
156 : StoppingPlaceMap_t stoppingPlaces;
157 19224 : SUMOAbstractRouter<MSEdge, SUMOVehicle>& router = getRouter(veh, closedEdges);
158 19224 : const double brakeGap = veh.getBrakeGap(true);
159 :
160 19224 : if (onTheWay != nullptr) {
161 : // compute new route
162 20 : if (newDestination) {
163 0 : newRoute.push_back(veh.getEdge());
164 : } else {
165 20 : bool valid = evaluateDestination(veh, brakeGap, newDestination, onTheWay, getLastStepStoppingPlaceOccupancy(onTheWay), 1, router, stoppingPlaces, newRoutes, stopApproaches, maxValues, scores, insertStopIndex, keepCurrentStop);
166 20 : if (!valid) {
167 0 : WRITE_WARNINGF(TL("Stopping place '%' along the way cannot be used by vehicle '%' for unknown reason"), onTheWay->getID(), veh.getID());
168 0 : return nullptr;
169 : }
170 20 : newRoute = newRoutes[onTheWay];
171 : }
172 20 : return onTheWay;
173 : }
174 : int numAlternatives = 0;
175 : std::vector<std::tuple<SUMOTime, MSStoppingPlace*, int>> blockedTimes;
176 19204 : resetStoppingPlaceScores(veh);
177 :
178 19204 : if (destStoppingPlace != nullptr) {
179 19065 : rememberStoppingPlaceScore(veh, destStoppingPlace, "occupied");
180 19065 : rememberBlockedStoppingPlace(veh, destStoppingPlace, &destStoppingPlace->getLane().getEdge() == veh.getEdge());
181 : }
182 19204 : const SUMOTime stoppingPlaceMemory = TIME2STEPS(getWeight(veh, "memory", 600));
183 19204 : const double stoppingPlaceFrustration = getWeight(veh, "frustration", 100);
184 19204 : const double stoppingPlaceKnowledge = getWeight(veh, "knowledge", 0);
185 :
186 89882 : for (int i = 0; i < (int)stoppingPlaceCandidates.size(); ++i) {
187 : // alternative occupancy is randomized (but never full) if invisible
188 : // current destination must be visible at this point
189 70678 : if (!useStoppingPlace(stoppingPlaceCandidates[i].first)) {
190 0 : continue;
191 : }
192 70678 : const bool visible = stoppingPlaceCandidates[i].second || (stoppingPlaceCandidates[i].first == destStoppingPlace && destVisible);
193 70678 : double occupancy = getStoppingPlaceOccupancy(stoppingPlaceCandidates[i].first);
194 70678 : if (!visible && (stoppingPlaceKnowledge == 0 || stoppingPlaceKnowledge < RandHelper::rand(veh.getRNG()))) {
195 39633 : double capacity = getStoppingPlaceCapacity(stoppingPlaceCandidates[i].first);
196 39633 : const double minOccupancy = MIN2(capacity - NUMERICAL_EPS, (getNumberStoppingPlaceReroutes(veh) * capacity / stoppingPlaceFrustration));
197 : occupancy = RandHelper::rand(minOccupancy, capacity);
198 : // previously visited?
199 39633 : SUMOTime blockedTime = sawBlockedStoppingPlace(veh, stoppingPlaceCandidates[i].first, false);
200 39633 : if (blockedTime >= 0 && SIMSTEP - blockedTime < stoppingPlaceMemory) {
201 : // assume it's still occupied
202 : occupancy = capacity;
203 21280 : blockedTimes.push_back(std::make_tuple(blockedTime, stoppingPlaceCandidates[i].first, i));
204 : #ifdef DEBUG_STOPPINGPLACE
205 : if (DEBUGCOND) {
206 : std::cout << " altStoppingPlace=" << stoppingPlaceCandidates[i].first->getID() << " was blocked at " << time2string(blockedTime) << "\n";
207 : }
208 : #endif
209 : }
210 : }
211 70678 : if (occupancy < getStoppingPlaceCapacity(stoppingPlaceCandidates[i].first)) {
212 20233 : if (evaluateDestination(veh, brakeGap, newDestination, stoppingPlaceCandidates[i].first, occupancy, probs[i], router, stoppingPlaces, newRoutes, stopApproaches, maxValues, scores, insertStopIndex, keepCurrentStop)) {
213 19843 : numAlternatives++;
214 : }
215 50445 : } else if (visible) {
216 : // might only be visible now (i.e. because it's on the other
217 : // side of the street), so we should remember this for later.
218 28945 : rememberStoppingPlaceScore(veh, stoppingPlaceCandidates[i].first, "occupied");
219 28945 : rememberBlockedStoppingPlace(veh, stoppingPlaceCandidates[i].first, &stoppingPlaceCandidates[i].first->getLane().getEdge() == veh.getEdge());
220 : }
221 : }
222 :
223 19204 : if (numAlternatives == 0) {
224 : // use parkingArea with lowest blockedTime
225 11875 : std::sort(blockedTimes.begin(), blockedTimes.end(),
226 16074 : [](std::tuple<SUMOTime, MSStoppingPlace*, int> const & t1, std::tuple<SUMOTime, MSStoppingPlace*, int> const & t2) {
227 16074 : if (std::get<0>(t1) < std::get<0>(t2)) {
228 : return true;
229 : }
230 9329 : if (std::get<0>(t1) == std::get<0>(t2)) {
231 199 : if (std::get<1>(t1)->getID() < std::get<1>(t2)->getID()) {
232 : return true;
233 : }
234 0 : if (std::get<1>(t1)->getID() == std::get<1>(t2)->getID()) {
235 0 : return std::get<2>(t1) < std::get<2>(t2);
236 : }
237 : }
238 : return false;
239 : }
240 : );
241 11875 : for (auto item : blockedTimes) {
242 : MSStoppingPlace* sp = std::get<1>(item);
243 4816 : double prob = probs[std::get<2>(item)];
244 : // all stopping places are occupied. We have no good basis for
245 : // prefering one or the other based on estimated occupancy
246 4816 : double occupancy = RandHelper::rand(getStoppingPlaceCapacity(sp));
247 4816 : if (evaluateDestination(veh, brakeGap, newDestination, sp, occupancy, prob, router, stoppingPlaces, newRoutes, stopApproaches, maxValues, scores, insertStopIndex, keepCurrentStop)) {
248 : #ifdef DEBUG_STOPPINGPLACE
249 : if (DEBUGCOND) {
250 : std::cout << " altStoppingPlace=" << sp->getID() << " targeting occupied stopping place based on blockTime " << STEPS2TIME(std::get<0>(item)) << " among " << blockedTimes.size() << " alternatives\n";
251 : }
252 : #endif
253 : numAlternatives = 1;
254 : break;
255 : }
256 : //std::cout << " candidate=" << item.second->getID() << " observed=" << time2string(item.first) << "\n";
257 : }
258 11875 : if (numAlternatives == 0) {
259 : // take any random target but prefer one that hasn't been visited yet
260 : std::vector<std::pair<SUMOTime, MSStoppingPlace*>> candidates;
261 23962 : for (const StoppingPlaceVisible& stoppingPlaceCandidate : stoppingPlaceCandidates) {
262 16903 : if (stoppingPlaceCandidate.first == destStoppingPlace) {
263 : continue;
264 : }
265 12707 : SUMOTime dummy = sawBlockedStoppingPlace(veh, stoppingPlaceCandidate.first, true);
266 12707 : if (dummy < 0) {
267 : // randomize among the unvisited
268 929 : dummy = -RandHelper::rand(1000000);
269 : }
270 12707 : candidates.push_back(std::make_pair(dummy, stoppingPlaceCandidate.first));
271 : }
272 7059 : std::sort(candidates.begin(), candidates.end(),
273 : [](std::tuple<SUMOTime, MSStoppingPlace*> const & t1, std::tuple<SUMOTime, MSStoppingPlace*> const & t2) {
274 13204 : return std::get<0>(t1) < std::get<0>(t2) || (std::get<0>(t1) == std::get<0>(t2) && std::get<1>(t1)->getID() < std::get<1>(t2)->getID());
275 : }
276 : );
277 8333 : for (auto item : candidates) {
278 7469 : if (evaluateDestination(veh, brakeGap, newDestination, item.second, 0, 1, router, stoppingPlaces, newRoutes, stopApproaches, maxValues, scores, insertStopIndex, keepCurrentStop)) {
279 : #ifdef DEBUG_STOPPINGPLACE
280 : if (DEBUGCOND) {
281 : std::cout << " altStoppingPlace=" << item.second->getID() << " targeting occupied stopping place (based on pure randomness) among " << candidates.size() << " alternatives\n";
282 : }
283 : #endif
284 : numAlternatives = 1;
285 : break;
286 : }
287 : }
288 7059 : }
289 : }
290 38408 : getRouter(veh); // reset closed edges
291 :
292 : #ifdef DEBUG_STOPPINGPLACE
293 : if (DEBUGCOND) {
294 : std::cout << " maxValues=" << joinToString(maxValues, " ", ":") << "\n";
295 : }
296 : #endif
297 :
298 : // minimum cost to get the parking area
299 : double minStoppingPlaceCost = 0.0;
300 :
301 50058 : for (StoppingPlaceMap_t::iterator it = stoppingPlaces.begin(); it != stoppingPlaces.end(); ++it) {
302 : // get the parking values
303 : StoppingPlaceParamMap_t stoppingPlaceValues = it->second;
304 :
305 41500 : if (weights["probability"] > 0. && maxValues["probability"] > 0.) {
306 : // random search should not drive past a usable parking area
307 : bool dominated = false;
308 10646 : double endPos = it->first->getEndLanePosition();
309 10646 : const ConstMSEdgeVector& to1 = stopApproaches[it->first];
310 : assert(to1.size() > 0);
311 33172 : for (auto altSp : stoppingPlaces) {
312 24454 : if (altSp.first == it->first) {
313 : continue;
314 : }
315 15552 : const ConstMSEdgeVector& to2 = stopApproaches[altSp.first];
316 : assert(to2.size() > 0);
317 15552 : if (to1.size() > to2.size()) {
318 6416 : if (std::equal(to2.begin(), to2.end(), to1.begin())) {
319 : // other target lies on the route to the current candidate
320 : dominated = true;
321 : //std::cout << SIMTIME << " rrP veh=" << veh.getID() << " full=" << destParkArea->getID() << " cand=" << it->first->getID() << " onTheWay=" << altPa.first->getID() << "\n";
322 : break;
323 : }
324 9136 : } else if (to1 == to2 && endPos > altSp.first->getEndLanePosition()) {
325 : // other target is on the same edge but ahead of the current candidate
326 : dominated = true;
327 : //std::cout << SIMTIME << " rrP veh=" << veh.getID() << " full=" << destParkArea->getID() << " cand=" << it->first->getID() << " sameEdge=" << altPa.first->getID() << "\n";
328 : break;
329 : }
330 : }
331 : double prob = 0;
332 : if (!dominated) {
333 8718 : prob = RandHelper::rand(stoppingPlaceValues["probability"], veh.getRNG());
334 8718 : stoppingPlaceValues["probability"] = 1.0 - prob / maxValues["probability"];
335 : } else {
336 : // worst probability score
337 1928 : stoppingPlaceValues["probability"] = 1.0;
338 : }
339 : } else {
340 : // value takes no effect due to weight=0
341 20208 : stoppingPlaceValues["probability"] = 0;
342 : }
343 :
344 : // get the parking area cost
345 30854 : double stoppingPlaceCost = getTargetValue(stoppingPlaceValues, maxValues, weights, myNormParams, myInvertParams);
346 30854 : rememberStoppingPlaceScore(veh, it->first, toString(stoppingPlaceCost));
347 :
348 : // get the parking area with minimum cost
349 30854 : if (nearStoppingPlace == nullptr || stoppingPlaceCost < minStoppingPlaceCost) {
350 : minStoppingPlaceCost = stoppingPlaceCost;
351 22237 : nearStoppingPlace = it->first;
352 22237 : newRoute = newRoutes[nearStoppingPlace];
353 : }
354 : #ifdef DEBUG_STOPPINGPLACE
355 : if (DEBUGCOND) {
356 : std::cout << " altStoppingPlace=" << it->first->getID() << " score=" << stoppingPlaceCost << " vals=" << joinToString(stoppingPlaceValues, " ", ":") << "\n";
357 : }
358 : #endif
359 : }
360 : // expose the scores of the best solution
361 19204 : if (nearStoppingPlace != nullptr) {
362 165236 : for (auto component : stoppingPlaces[nearStoppingPlace]) {
363 146896 : scores[component.first] = component.second;
364 : }
365 : }
366 19204 : setNumberStoppingPlaceReroutes(veh, getNumberStoppingPlaceReroutes(veh) + 1);
367 19204 : } else {
368 : #ifdef DEBUG_STOPPINGPLACE
369 : if (DEBUGCOND) {
370 : std::cout << SIMTIME << " veh=" << veh.getID() << " dest=" << destStoppingPlace->getID() << " sufficient space\n";
371 : }
372 : #endif
373 : }
374 :
375 : #ifdef DEBUG_STOPPINGPLACE
376 : if (DEBUGCOND) {
377 : std::cout << " stoppingPlaceResult=" << Named::getIDSecure(nearStoppingPlace) << "\n";
378 : }
379 : #endif
380 32841 : return nearStoppingPlace;
381 : }
382 :
383 :
384 : bool
385 32538 : MSStoppingPlaceRerouter::evaluateDestination(SUMOVehicle& veh, double brakeGap, bool newDestination, MSStoppingPlace* alternative,
386 : double occupancy, double prob, SUMOAbstractRouter<MSEdge, SUMOVehicle>& router, StoppingPlaceMap_t& stoppingPlaces,
387 : std::map<MSStoppingPlace*, ConstMSEdgeVector>& newRoutes, std::map<MSStoppingPlace*, ConstMSEdgeVector>& stoppingPlaceApproaches,
388 : StoppingPlaceParamMap_t& maxValues, StoppingPlaceParamMap_t& addInput, const int insertStopIndex, const bool keepCurrentStop) {
389 :
390 : // a map stores the stopping place values
391 : StoppingPlaceParamMap_t stoppingPlaceValues;
392 32538 : const SUMOTime now = SIMSTEP;
393 :
394 32538 : const MSRoute& route = veh.getRoute();
395 32538 : const RGBColor& c = route.getColor();
396 32538 : const MSEdge* stoppingPlaceEdge = &(alternative->getLane().getEdge());
397 :
398 32538 : const bool includeInternalLengths = MSGlobals::gUsingInternalLanes && MSNet::getInstance()->hasInternalLinks();
399 :
400 : // Compute the route from the current edge to the stopping place edge
401 : ConstMSEdgeVector edgesToStop;
402 : ConstMSEdgeVector edgesUpstream;
403 32538 : const double targetPos = alternative->getLastFreePos(veh);
404 32538 : MSRouteIterator rerouteOriginIt = determineRerouteOrigin(veh, insertStopIndex);
405 32538 : double posOnLane = veh.getPositionOnLane();
406 32538 : if (insertStopIndex > 0) {
407 : posOnLane = 0.;
408 : // determine preceding edges
409 0 : for (MSRouteIterator it = veh.getCurrentRouteEdge(); it != rerouteOriginIt; ++it) {
410 : if (it != rerouteOriginIt) {
411 0 : edgesUpstream.push_back(*it);
412 : }
413 : }
414 : }
415 32538 : const MSEdge* rerouteOrigin = *rerouteOriginIt;
416 32538 : router.compute(rerouteOrigin, posOnLane, stoppingPlaceEdge, targetPos, &veh, now, edgesToStop, true);
417 32538 : if (edgesToStop.size() > 0) {
418 : // Compute the route from the stopping place edge to the end of the route
419 32062 : if (insertStopIndex == 0 && rerouteOrigin != veh.getEdge()) {
420 5 : edgesToStop.insert(edgesToStop.begin(), veh.getEdge());
421 : }
422 : // prepend preceding edges
423 : std::reverse(edgesUpstream.begin(), edgesUpstream.end());
424 32062 : for (auto edge : edgesUpstream) {
425 0 : edgesToStop.insert(edgesToStop.begin(), edge);
426 : }
427 : ConstMSEdgeVector edgesFromStop;
428 32062 : stoppingPlaceApproaches[alternative] = edgesToStop;
429 :
430 32062 : const MSEdge* nextDestination = route.getLastEdge();
431 32062 : double nextPos = veh.getArrivalPos();
432 32062 : int nextDestinationIndex = route.size() - 1;
433 32062 : if (!newDestination) {
434 30536 : std::vector<std::pair<int, double> > stopIndices = veh.getStopIndices();
435 30536 : int nextDestStopIndex = 1 + insertStopIndex;
436 30536 : if (!keepCurrentStop) {
437 0 : nextDestStopIndex++;
438 : }
439 30536 : if ((int)stopIndices.size() > nextDestStopIndex) {
440 304 : nextDestinationIndex = stopIndices[nextDestStopIndex].first;
441 304 : nextDestination = route.getEdges()[nextDestinationIndex];
442 304 : nextPos = stopIndices[nextDestStopIndex].second;
443 : }
444 30536 : router.compute(stoppingPlaceEdge, targetPos, nextDestination, nextPos, &veh, now, edgesFromStop, true);
445 30536 : }
446 32062 : if (edgesFromStop.size() > 0 || newDestination) {
447 32062 : stoppingPlaceValues["probability"] = prob;
448 32062 : if (stoppingPlaceValues["probability"] > maxValues["probability"]) {
449 18606 : maxValues["probability"] = stoppingPlaceValues["probability"];
450 : }
451 32062 : stoppingPlaceValues["capacity"] = getStoppingPlaceCapacity(alternative);
452 32062 : stoppingPlaceValues["absfreespace"] = stoppingPlaceValues["capacity"] - occupancy;
453 : // if capacity = 0 then absfreespace and relfreespace are also 0
454 63996 : stoppingPlaceValues["relfreespace"] = stoppingPlaceValues["absfreespace"] / MAX2(1.0, stoppingPlaceValues["capacity"]);
455 32062 : MSRoute routeToPark(route.getID() + "!to" + myParamPrefix + "#1", edgesToStop, false,
456 64124 : &c == &RGBColor::DEFAULT_COLOR ? nullptr : new RGBColor(c), route.getStops());
457 :
458 : // The distance from the current edge to the new parking area
459 32062 : double toPos = alternative->getBeginLanePosition();
460 32062 : if (&alternative->getLane().getEdge() == veh.getEdge()) {
461 7358 : toPos = MAX2(veh.getPositionOnLane(), toPos);
462 : }
463 32062 : stoppingPlaceValues["distanceto"] = routeToPark.getDistanceBetween(veh.getPositionOnLane(), toPos,
464 32062 : routeToPark.begin(), routeToPark.end() - 1, includeInternalLengths);
465 :
466 32062 : if (stoppingPlaceValues["distanceto"] == std::numeric_limits<double>::max()) {
467 0 : WRITE_WARNINGF(TL("Invalid distance computation for vehicle '%' to stopping place '%' at time=%."),
468 : veh.getID(), alternative->getID(), time2string(now));
469 : }
470 32062 : const double endPos = getStoppingPlaceOccupancy(alternative) == getStoppingPlaceCapacity(alternative)
471 32062 : ? alternative->getLastFreePos(veh, veh.getPositionOnLane() + brakeGap)
472 10399 : : alternative->getEndLanePosition();
473 32062 : const double distToEnd = stoppingPlaceValues["distanceto"] - toPos + endPos;
474 :
475 32062 : if (distToEnd < brakeGap) {
476 1000 : rememberStoppingPlaceScore(veh, alternative, "tooClose");
477 1000 : return false;
478 : }
479 :
480 : // The time to reach the new stopping place
481 31062 : const double correctionLastEdge = ((alternative->getLane().getLength() - alternative->getEndLanePosition()) / alternative->getLane().getVehicleMaxSpeed(&veh));
482 31062 : const double correctionFirstEdge = veh.getPositionOnLane() / edgesToStop.front()->getVehicleMaxSpeed(&veh);
483 :
484 31062 : stoppingPlaceValues["timeto"] = router.recomputeCosts(edgesToStop, &veh, SIMSTEP) - correctionLastEdge - correctionFirstEdge;
485 31062 : ConstMSEdgeVector newEdges = edgesToStop;
486 31062 : if (newDestination) {
487 1526 : stoppingPlaceValues["distancefrom"] = 0;
488 1526 : stoppingPlaceValues["timefrom"] = 0;
489 : } else {
490 29536 : MSRoute routeFromPark(route.getID() + "!from" + myParamPrefix + "#1", edgesFromStop, false,
491 59072 : &c == &RGBColor::DEFAULT_COLOR ? nullptr : new RGBColor(c), route.getStops());
492 : // The distance from the new parking area to the end of the route
493 29536 : stoppingPlaceValues["distancefrom"] = routeFromPark.getDistanceBetween(alternative->getBeginLanePosition(), routeFromPark.getLastEdge()->getLength(),
494 29536 : routeFromPark.begin(), routeFromPark.end() - 1, includeInternalLengths);
495 29536 : if (stoppingPlaceValues["distancefrom"] == std::numeric_limits<double>::max()) {
496 0 : WRITE_WARNINGF(TL("Invalid distance computation for vehicle '%' from stopping place '%' at time=%."),
497 : veh.getID(), alternative->getID(), time2string(SIMSTEP));
498 : }
499 : // The time to reach this area
500 29536 : stoppingPlaceValues["timefrom"] = router.recomputeCosts(edgesFromStop, &veh, SIMSTEP) - (alternative->getEndLanePosition() / alternative->getLane().getSpeedLimit());
501 29536 : newEdges.insert(newEdges.end(), edgesFromStop.begin() + 1, edgesFromStop.end());
502 29536 : newEdges.insert(newEdges.end(), route.begin() + nextDestinationIndex + 1, route.end());
503 29536 : }
504 :
505 : // add some additional/custom target function components
506 31062 : if (!evaluateCustomComponents(veh, brakeGap, newDestination, alternative, occupancy, prob, router, stoppingPlaceValues, stoppingPlaceApproaches[alternative], newEdges, maxValues, addInput)) {
507 : return false;
508 : }
509 31062 : if (!myCheckValidity || validComponentValues(stoppingPlaceValues)) {
510 30874 : updateMaxValues(stoppingPlaceValues, maxValues);
511 30874 : stoppingPlaces[alternative] = stoppingPlaceValues;
512 30874 : newRoutes[alternative] = newEdges;
513 : return true;
514 : } else {
515 : return false;
516 : }
517 32062 : } else {
518 0 : rememberStoppingPlaceScore(veh, alternative, "unreachable");
519 : }
520 32062 : } else {
521 952 : rememberStoppingPlaceScore(veh, alternative, "unreachable");
522 : }
523 : // unreachable
524 : return false;
525 32538 : }
526 :
527 :
528 : bool
529 30518 : MSStoppingPlaceRerouter::evaluateCustomComponents(SUMOVehicle& /*veh*/, double /*brakeGap*/, bool /*newDestination*/,
530 : MSStoppingPlace* /*alternative*/, double /*occupancy*/, double /*prob*/, SUMOAbstractRouter<MSEdge, SUMOVehicle>& /*router*/,
531 : StoppingPlaceParamMap_t& /*stoppingPlaceValues*/, ConstMSEdgeVector& /*newRoute*/, ConstMSEdgeVector& /*stoppingPlaceApproach*/,
532 : StoppingPlaceParamMap_t& /*maxValues*/, StoppingPlaceParamMap_t& /*addInput*/) {
533 30518 : return true;
534 : }
535 :
536 :
537 : bool
538 0 : MSStoppingPlaceRerouter::validComponentValues(StoppingPlaceParamMap_t& /* stoppingPlaceValues */) {
539 0 : return true;
540 : }
541 :
542 :
543 : bool
544 70218 : MSStoppingPlaceRerouter::useStoppingPlace(MSStoppingPlace* /* stoppingPlace */) {
545 70218 : return true;
546 : }
547 :
548 :
549 : SUMOAbstractRouter<MSEdge, SUMOVehicle>&
550 38174 : MSStoppingPlaceRerouter::getRouter(SUMOVehicle& veh, const Prohibitions& prohibited) {
551 38174 : return MSNet::getInstance()->getRouterTT(veh.getRNGIndex(), prohibited);
552 : }
553 :
554 :
555 : MSStoppingPlaceRerouter::StoppingPlaceParamMap_t
556 19224 : MSStoppingPlaceRerouter::collectWeights(SUMOVehicle& veh) {
557 : MSStoppingPlaceRerouter::StoppingPlaceParamMap_t result;
558 19224 : myEvalParams["distanceto"] = getWeight(veh, "distance.weight", myEvalParams["distanceto"]);
559 173270 : for (auto evalParam : myEvalParams) {
560 154046 : result[evalParam.first] = getWeight(veh, evalParam.first + ".weight", evalParam.second);
561 : }
562 19224 : result["probability"] = getWeight(veh, "probability.weight", 0.);
563 19224 : return result;
564 : }
565 :
566 :
567 : double
568 433696 : MSStoppingPlaceRerouter::getWeight(SUMOVehicle& veh, const std::string param, const double defaultWeight, const bool warn) {
569 : // get custom vehicle parameter
570 433696 : const std::string key = myParamPrefix + "." + param;
571 433696 : if (veh.getParameter().hasParameter(key)) {
572 : try {
573 88 : return StringUtils::toDouble(veh.getParameter().getParameter(key, "-1"));
574 0 : } catch (...) {
575 0 : WRITE_WARNINGF(TL("Invalid value '%' for vehicle parameter '%'"), veh.getParameter().getParameter(key, "-1"), key);
576 0 : }
577 : } else {
578 : // get custom vType parameter
579 433652 : if (veh.getVehicleType().getParameter().hasParameter(key)) {
580 : try {
581 32452 : return StringUtils::toDouble(veh.getVehicleType().getParameter().getParameter(key, "-1"));
582 0 : } catch (...) {
583 0 : WRITE_WARNINGF(TL("Invalid value '%' for vType parameter '%'"), veh.getVehicleType().getParameter().getParameter(key, "-1"), key);
584 0 : }
585 : }
586 : }
587 417426 : if (warn) {
588 0 : WRITE_MESSAGEF("Vehicle '%' does not supply vehicle parameter '%'. Using default of %\n", veh.getID(), key, toString(defaultWeight));
589 : }
590 417426 : return defaultWeight;
591 : }
592 :
593 :
594 : void
595 30874 : MSStoppingPlaceRerouter::updateMaxValues(StoppingPlaceParamMap_t& stoppingPlaceValues, StoppingPlaceParamMap_t& maxValues) {
596 278578 : for (auto it = maxValues.begin(); it != maxValues.end(); ++it) {
597 247704 : if (stoppingPlaceValues[it->first] > it->second) {
598 158667 : it->second = stoppingPlaceValues[it->first];
599 : }
600 : }
601 30874 : }
602 :
603 :
604 : double
605 30854 : MSStoppingPlaceRerouter::getTargetValue(const StoppingPlaceParamMap_t& absValues, const StoppingPlaceParamMap_t& maxValues, const StoppingPlaceParamMap_t& weights, const StoppingPlaceParamSwitchMap_t& norm, const StoppingPlaceParamSwitchMap_t& invert) {
606 : double cost = 0.;
607 278398 : for (StoppingPlaceParamMap_t::const_iterator sc = absValues.begin(); sc != absValues.end(); ++sc) {
608 247544 : double weight = weights.at(sc->first);
609 247544 : double val = sc->second;
610 247544 : if (norm.at(sc->first) && maxValues.at(sc->first) > 0.) {
611 213115 : val /= maxValues.at(sc->first);
612 : }
613 247544 : cost += (invert.at(sc->first)) ? weight * (1. - val) : weight * val;
614 : }
615 30854 : return cost;
616 : }
617 :
618 :
619 : /****************************************************************************/
|
