Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
IntermodalRouter.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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/****************************************************************************/
19// The IntermodalRouter builds a special network and (delegates to a SUMOAbstractRouter)
20/****************************************************************************/
21#pragma once
22#include <config.h>
23
24#include <string>
25#include <vector>
26#include <algorithm>
27#include <assert.h>
32#include "SUMOAbstractRouter.h"
33#include "DijkstraRouter.h"
34#include "AStarRouter.h"
35#include "IntermodalNetwork.h"
36#include "EffortCalculator.h"
37#include "CarEdge.h"
38#include "StopEdge.h"
39#include "PedestrianRouter.h"
40
41//#define IntermodalRouter_DEBUG_ROUTES
42
43
44// ===========================================================================
45// class definitions
46// ===========================================================================
51template<class E, class L, class N, class V>
52class IntermodalRouter : public SUMOAbstractRouter<E, IntermodalTrip<E, N, V> > {
53public:
55
56private:
57 typedef void(*CreateNetCallback)(IntermodalRouter <E, L, N, V>&);
63
64public:
65 struct TripItem {
66 TripItem(const std::string& _line = "") :
67 line(_line), intended(_line) {}
68 std::string line;
69 std::string vType = "";
70 std::string destStop = "";
71 std::string intended; // intended public transport vehicle id
72 double depart = -1.; // intended public transport departure
73 std::vector<const E*> edges;
74 double traveltime = 0.;
75 double cost = 0.;
76 double length = 0.;
79 std::string description = "";
80 std::vector<double> exitTimes;
81 };
82
84 IntermodalRouter(CreateNetCallback callback, const int carWalkTransfer, double taxiWait, const std::string& routingAlgorithm,
85 const int routingMode = 0, EffortCalculator* calc = nullptr) :
86 SUMOAbstractRouter<E, _IntermodalTrip>("IntermodalRouter", true, nullptr, nullptr, false, false),
87 myAmClone(false), myInternalRouter(nullptr), myIntermodalNet(nullptr),
88 myCallback(callback), myCarWalkTransfer(carWalkTransfer), myTaxiWait(taxiWait),
89 myRoutingAlgorithm(routingAlgorithm),
90 myRoutingMode(routingMode), myExternalEffort(calc) {
91 }
92
95 delete myInternalRouter;
96 if (!myAmClone) {
97 delete myIntermodalNet;
98 }
99 }
100
105
106 int getCarWalkTransfer() const {
107 return myCarWalkTransfer;
108 }
109
112 bool compute(const E* from, const E* to,
113 const double departPos, const std::string& originStopID,
114 const double arrivalPos, const std::string& stopID,
115 const double speed, const V* const vehicle, const SVCPermissions modeSet, const SUMOTime msTime,
116 std::vector<TripItem>& into, const double externalFactor = 0.) {
117 createNet();
118 _IntermodalTrip trip(from, to, departPos, arrivalPos, speed, msTime, 0, vehicle, modeSet, myExternalEffort, externalFactor);
119 std::vector<const _IntermodalEdge*> intoEdges;
120 //std::cout << "compute from=" << from->getID() << " to=" << to->getID() << " dPos=" << departPos << " aPos=" << arrivalPos << " stopID=" << stopID << " speed=" << speed << " veh=" << Named::getIDSecure(vehicle) << " modeSet=" << modeSet << " t=" << msTime << " iFrom=" << myIntermodalNet->getDepartEdge(from, trip.departPos)->getID() << " iTo=" << (stopID != "" ? myIntermodalNet->getStopEdge(stopID) : myIntermodalNet->getArrivalEdge(to, trip.arrivalPos))->getID() << "\n";
121 const _IntermodalEdge* iFrom = originStopID != "" ? myIntermodalNet->getStopEdge(originStopID) : myIntermodalNet->getDepartEdge(from, trip.departPos);
122 const _IntermodalEdge* iTo = stopID != "" ? myIntermodalNet->getStopEdge(stopID) : myIntermodalNet->getArrivalEdge(to, trip.arrivalPos);
123 const bool success = myInternalRouter->compute(iFrom, iTo, &trip, msTime, intoEdges, true);
124 if (success) {
125 std::string lastLine = "";
126 double time = STEPS2TIME(msTime);
127 double effort = 0.;
128 double length = 0.;
129 const _IntermodalEdge* prev = nullptr;
130 for (const _IntermodalEdge* iEdge : intoEdges) {
131 bool addedEdge = false;
132 if (iEdge->includeInRoute(false)) {
133 if (iEdge->getLine() == "!stop") {
134 if (into.size() > 0) {
135 // previous stage ends at stop
136 into.back().destStop = iEdge->getID();
137 if (myExternalEffort != nullptr) {
138 into.back().description = myExternalEffort->output(iEdge->getNumericalID());
139 }
140 if (lastLine == "!ped") {
141 lastLine = ""; // a stop always starts a new trip item
142 }
143 } else {
144 // trip starts at stop
145 lastLine = "";
146 into.push_back(TripItem("!stop"));
147 into.back().destStop = iEdge->getID();
148 }
149 } else {
150 if (iEdge->getLine() != lastLine) {
151 lastLine = iEdge->getLine();
152 if (lastLine == "!car") {
153 into.push_back(TripItem(vehicle->getID()));
154 into.back().vType = vehicle->getParameter().vtypeid;
155 } else if (lastLine == "!ped") {
156 into.push_back(TripItem());
157 } else {
158 into.push_back(TripItem(lastLine));
159 into.back().depart = iEdge->getIntended(time, into.back().intended);
160 }
161 into.back().departPos = iEdge->getStartPos();
162 }
163 if (into.back().edges.empty() || into.back().edges.back() != iEdge->getEdge()) {
164 into.back().edges.push_back(iEdge->getEdge());
165 into.back().arrivalPos = iEdge->getEndPos();
166 addedEdge = true;
167 }
168 }
169 }
170 const double prevTime = time, prevEffort = effort, prevLength = length;
171 myInternalRouter->updateViaCost(prev, iEdge, &trip, time, effort, length);
172 // correct intermodal length:
173 length += iEdge->getPartialLength(&trip) - iEdge->getLength();
174 prev = iEdge;
175 if (!into.empty()) {
176 into.back().traveltime += time - prevTime;
177 into.back().cost += effort - prevEffort;
178 into.back().length += length - prevLength;
179 if (into.back().depart < 0) {
180 into.back().depart = prevTime;
181 }
182 if (addedEdge) {
183 into.back().exitTimes.push_back(time);
184 }
185 }
186 }
187 } else {
188 const std::string oType = originStopID != "" ? "stop" : "edge";
189 const std::string oID = originStopID != "" ? originStopID : from->getID();
190 const std::string dType = stopID != "" ? "stop" : "edge";
191 const std::string dID = stopID != "" ? stopID : to->getID();
192 this->myErrorMsgHandler->informf("No connection between % '%' and % '%' found.", oType, oID, dType, dID);
193 }
194 if (into.size() > 0) {
195 into.back().arrivalPos = arrivalPos;
196 }
197#ifdef IntermodalRouter_DEBUG_ROUTES
198 double time = STEPS2TIME(msTime);
199 for (const _IntermodalEdge* iEdge : intoEdges) {
200 const double edgeEffort = myInternalRouter->getEffort(iEdge, &trip, time);
201 time += edgeEffort;
202 std::cout << iEdge->getID() << "(" << iEdge->getLine() << "): " << edgeEffort << " l=" << iEdge->getLength() << " pL=" << iEdge->getPartialLength(&trip) << "\n";
203 }
204 std::cout << TIME2STEPS(msTime) << " trip from " << from->getID() << " to " << (to != nullptr ? to->getID() : stopID)
205 << " departPos=" << trip.departPos
206 << " arrivalPos=" << trip.arrivalPos
207 << " modes=" << getVehicleClassNames(modeSet)
208 << " edges=" << toString(intoEdges)
209// << " resultEdges=" << toString(into)
210 << " time=" << time
211 << "\n";
212#endif
213 return success;
214 }
215
218 bool compute(const E*, const E*, const _IntermodalTrip* const,
219 SUMOTime, std::vector<const E*>&, bool) {
220 throw ProcessError(TL("Do not use this method"));
221 }
222
223 inline void setBulkMode(const bool mode) {
225 if (myInternalRouter != nullptr) {
227 }
228 }
229
230 void prohibit(const std::vector<E*>& toProhibit) {
231 createNet();
232 std::vector<_IntermodalEdge*> toProhibitPE;
233 for (typename std::vector<E*>::const_iterator it = toProhibit.begin(); it != toProhibit.end(); ++it) {
234 toProhibitPE.push_back(myIntermodalNet->getBothDirections(*it).first);
235 toProhibitPE.push_back(myIntermodalNet->getBothDirections(*it).second);
236 toProhibitPE.push_back(myIntermodalNet->getCarEdge(*it));
237 }
238 myInternalRouter->prohibit(toProhibitPE);
239 }
240
242 createNet();
245 dev.writeAttr(SUMO_ATTR_ID, e->getID());
246 dev.writeAttr(SUMO_ATTR_LINE, e->getLine());
247 dev.writeAttr(SUMO_ATTR_LENGTH, e->getLength());
248 dev.writeAttr("successors", toString(e->getSuccessors(SVC_IGNORING)));
249 dev.closeTag();
250 }
251 }
252
254 createNet();
255 _IntermodalTrip trip(nullptr, nullptr, 0., 0., DEFAULT_PEDESTRIAN_SPEED, 0, 0, nullptr, SVC_PASSENGER | SVC_BICYCLE | SVC_BUS);
258 dev.writeAttr(SUMO_ATTR_ID, e->getID());
259 dev.writeAttr("traveltime", e->getTravelTime(&trip, 0.));
260 dev.writeAttr("effort", e->getEffort(&trip, 0.));
261 dev.closeTag();
262 }
263 }
264
266 return myIntermodalNet;
267 }
268
272
273private:
274 IntermodalRouter(Network* net, const int carWalkTransfer, double taxiWait, const std::string& routingAlgorithm,
275 const int routingMode, EffortCalculator* calc) :
276 SUMOAbstractRouter<E, _IntermodalTrip>("IntermodalRouterClone", true, nullptr, nullptr, false, false),
277 myAmClone(true), myInternalRouter(nullptr), myIntermodalNet(net),
278 myCarWalkTransfer(carWalkTransfer),
279 myTaxiWait(taxiWait),
280 myRoutingAlgorithm(routingAlgorithm), myRoutingMode(routingMode), myExternalEffort(calc) {
281 createNet();
282 }
283
284 static inline double getCombined(const _IntermodalEdge* const edge, const _IntermodalTrip* const trip, double time) {
285 return edge->getTravelTime(trip, time) + trip->externalFactor * trip->calc->getEffort(edge->getNumericalID());
286 }
287
288 inline void createNet() {
289 if (myIntermodalNet == nullptr) {
290 myIntermodalNet = new Network(E::getAllEdges(), false, myCarWalkTransfer);
291 myIntermodalNet->addCarEdges(E::getAllEdges(), myTaxiWait);
292 myCallback(*this);
293 }
294 if (myInternalRouter == nullptr) {
295 switch (myRoutingMode) {
296 case 0:
297 if (myRoutingAlgorithm == "astar") {
300 } else {
303 }
304 break;
305 case 1:
307 break;
308 case 2:
310 break;
311 case 3:
312 if (myExternalEffort != nullptr) {
313 std::vector<std::string> edgeLines;
314 for (const auto e : myIntermodalNet->getAllEdges()) {
315 edgeLines.push_back(e->getLine());
316 }
317 myExternalEffort->init(edgeLines);
318 }
320 break;
321 }
322 }
323 }
324
325private:
326 const bool myAmClone;
331 const double myTaxiWait;
332 const std::string myRoutingAlgorithm;
333 const int myRoutingMode;
335
336
337private:
340
341};
long long int SUMOTime
Definition GUI.h:36
#define TL(string)
Definition MsgHandler.h:287
#define STEPS2TIME(x)
Definition SUMOTime.h:55
#define TIME2STEPS(x)
Definition SUMOTime.h:57
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_BUS
vehicle is a bus
const double DEFAULT_PEDESTRIAN_SPEED
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_TAG_EDGE
begin/end of the description of an edge
@ SUMO_ATTR_LINE
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_ID
double gWeightsRandomFactor
Definition StdDefs.cpp:31
const double INVALID_DOUBLE
invalid double
Definition StdDefs.h:64
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
Computes the shortest path through a network using the A* algorithm.
Definition AStarRouter.h:76
Computes the shortest path through a network using the Dijkstra algorithm.
the effort calculator interface
virtual double getEffort(const int numericalID) const =0
virtual std::string output(const int edge) const =0
virtual void init(const std::vector< std::string > &edges)=0
the base edge type that is given to the internal router (SUMOAbstractRouter)
static double getTravelTimeStatic(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
virtual double getTravelTime(const IntermodalTrip< E, N, V > *const, double) const
int getNumericalID() const
static double getEffortStatic(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
virtual double getTravelTimeAggregated(const IntermodalTrip< E, N, V > *const trip, double time) const
static double getTravelTimeStaticRandomized(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
the intermodal network storing edges, connections and the mappings to the "real" edges
const std::vector< _IntermodalEdge * > & getAllEdges()
_IntermodalEdge * getCarEdge(const E *e) const
Returns the associated car edge.
_IntermodalEdge * getStopEdge(const std::string &stopId) const
Returns the associated stop edge.
const EdgePair & getBothDirections(const E *e) const
Returns the pair of forward and backward edge.
void addCarEdges(const std::vector< E * > &edges, double taxiWait)
_IntermodalEdge * getArrivalEdge(const E *e, const double pos) const
Returns the arriving intermodal edge.
const _IntermodalEdge * getDepartEdge(const E *e, const double pos) const
Returns the departing intermodal edge.
EffortCalculator * getExternalEffort() const
SUMOAbstractRouter< _IntermodalEdge, _IntermodalTrip > _InternalRouter
AStarRouter< _IntermodalEdge, _IntermodalTrip > _InternalAStar
IntermodalTrip< E, N, V > _IntermodalTrip
CreateNetCallback myCallback
static double getCombined(const _IntermodalEdge *const edge, const _IntermodalTrip *const trip, double time)
void(* CreateNetCallback)(IntermodalRouter< E, L, N, V > &)
IntermodalEdge< E, L, N, V > _IntermodalEdge
const int myCarWalkTransfer
virtual ~IntermodalRouter()
Destructor.
IntermodalNetwork< E, L, N, V > Network
IntermodalRouter(Network *net, const int carWalkTransfer, double taxiWait, const std::string &routingAlgorithm, const int routingMode, EffortCalculator *calc)
SUMOAbstractRouter< E, _IntermodalTrip > * clone()
IntermodalRouter(CreateNetCallback callback, const int carWalkTransfer, double taxiWait, const std::string &routingAlgorithm, const int routingMode=0, EffortCalculator *calc=nullptr)
Constructor.
bool compute(const E *, const E *, const _IntermodalTrip *const, SUMOTime, std::vector< const E * > &, bool)
Builds the route between the given edges using the minimum effort at the given time The definition of...
DijkstraRouter< _IntermodalEdge, _IntermodalTrip > _InternalDijkstra
const std::string myRoutingAlgorithm
IntermodalRouter & operator=(const IntermodalRouter &s)
Invalidated assignment operator.
const double myTaxiWait
void prohibit(const std::vector< E * > &toProhibit)
Network * getNetwork() const
void writeWeights(OutputDevice &dev)
void setBulkMode(const bool mode)
bool compute(const E *from, const E *to, const double departPos, const std::string &originStopID, const double arrivalPos, const std::string &stopID, const double speed, const V *const vehicle, const SVCPermissions modeSet, const SUMOTime msTime, std::vector< TripItem > &into, const double externalFactor=0.)
Builds the route between the given edges using the minimum effort at the given time The definition of...
EffortCalculator *const myExternalEffort
_InternalRouter * myInternalRouter
int getCarWalkTransfer() const
void writeNetwork(OutputDevice &dev)
the "vehicle" type that is given to the internal router (SUMOAbstractRouter)
const EffortCalculator *const calc
const double departPos
const double arrivalPos
const double externalFactor
void informf(const std::string &format, T value, Targs... Fargs)
adds a new formatted message
Definition MsgHandler.h:122
const std::string & getID() const
Returns the id.
Definition Named.h:74
Static storage of an output device and its base (abstract) implementation.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
MsgHandler *const myErrorMsgHandler
the handler for routing errors
virtual void setBulkMode(const bool mode)
virtual void prohibit(const std::vector< E * > &toProhibit)
void updateViaCost(const E *const prev, const E *const e, const V *const v, double &time, double &effort, double &length) const
double getEffort(const E *const e, const V *const v, double t) const
virtual bool compute(const E *from, const E *to, const V *const vehicle, SUMOTime msTime, std::vector< const E * > &into, bool silent=false)=0
Builds the route between the given edges using the minimum effort at the given time The definition of...
TripItem(const std::string &_line="")
std::vector< double > exitTimes
std::vector< const E * > edges