Eclipse SUMO - Simulation of Urban MObility
IntermodalRouter.h
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 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
15 // The IntermodalRouter builds a special network and (delegates to a SUMOAbstractRouter)
16 /****************************************************************************/
17 #ifndef IntermodalRouter_h
18 #define IntermodalRouter_h
19 
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #include <config.h>
25 
26 #include <string>
27 #include <vector>
28 #include <algorithm>
29 #include <assert.h>
31 #include <utils/common/SUMOTime.h>
32 #include <utils/common/ToString.h>
34 #include "SUMOAbstractRouter.h"
35 #include "DijkstraRouter.h"
36 #include "AStarRouter.h"
37 #include "IntermodalNetwork.h"
38 #include "EffortCalculator.h"
39 #include "CarEdge.h"
40 #include "StopEdge.h"
41 #include "PedestrianRouter.h"
42 
43 //#define IntermodalRouter_DEBUG_ROUTES
44 
45 
46 // ===========================================================================
47 // class definitions
48 // ===========================================================================
53 template<class E, class L, class N, class V>
54 class IntermodalRouter : public SUMOAbstractRouter<E, IntermodalTrip<E, N, V> > {
55 public:
57 
58 private:
65 
66 public:
67  struct TripItem {
68  TripItem(const std::string& _line = "") :
69  line(_line), intended(_line) {}
70  std::string line;
71  std::string vType = "";
72  std::string destStop = "";
73  std::string intended; // intended public transport vehicle id
74  double depart = -1.; // intended public transport departure
75  std::vector<const E*> edges;
76  double traveltime = 0.;
77  double cost = 0.;
78  double length = 0.;
81  std::string description = "";
82  };
83 
85  IntermodalRouter(CreateNetCallback callback, const int carWalkTransfer, const std::string& routingAlgorithm,
86  const int routingMode = 0, EffortCalculator* calc = nullptr) :
87  SUMOAbstractRouter<E, _IntermodalTrip>("IntermodalRouter", true, nullptr, nullptr, false, false),
88  myAmClone(false), myInternalRouter(nullptr), myIntermodalNet(nullptr),
89  myCallback(callback), myCarWalkTransfer(carWalkTransfer), myRoutingAlgorithm(routingAlgorithm),
90  myRoutingMode(routingMode), myExternalEffort(calc) {
91  }
92 
94  virtual ~IntermodalRouter() {
95  delete myInternalRouter;
96  if (!myAmClone) {
97  delete myIntermodalNet;
98  }
99  }
100 
102  createNet();
104  }
105 
108  bool compute(const E* from, const E* to, const double departPos, const double arrivalPos,
109  const std::string stopID, const double speed,
110  const V* const vehicle, const SVCPermissions modeSet, const SUMOTime msTime,
111  std::vector<TripItem>& into, const double externalFactor = 0.) {
112  createNet();
113  _IntermodalTrip trip(from, to, departPos, arrivalPos, speed, msTime, 0, vehicle, modeSet, myExternalEffort, externalFactor);
114  std::vector<const _IntermodalEdge*> intoEdges;
115  //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";
116  const bool success = myInternalRouter->compute(myIntermodalNet->getDepartEdge(from, trip.departPos),
117  stopID != "" ? myIntermodalNet->getStopEdge(stopID) : myIntermodalNet->getArrivalEdge(to, trip.arrivalPos),
118  &trip, msTime, intoEdges);
119  if (success) {
120  std::string lastLine = "";
121  double time = STEPS2TIME(msTime);
122  double effort = 0.;
123  double length = 0.;
124  const _IntermodalEdge* prev = nullptr;
125  for (const _IntermodalEdge* iEdge : intoEdges) {
126  if (iEdge->includeInRoute(false)) {
127  if (iEdge->getLine() == "!stop") {
128  if (into.size() > 0) {
129  // previous stage ends at stop
130  into.back().destStop = iEdge->getID();
131  if (myExternalEffort != nullptr) {
132  into.back().description = myExternalEffort->output(iEdge->getNumericalID());
133  }
134  if (lastLine == "!ped") {
135  lastLine = ""; // a stop always starts a new trip item
136  }
137  } else {
138  // trip starts at stop
139  lastLine = "";
140  into.push_back(TripItem("!stop"));
141  into.back().destStop = iEdge->getID();
142  }
143  } else {
144  if (iEdge->getLine() != lastLine) {
145  lastLine = iEdge->getLine();
146  if (lastLine == "!car") {
147  into.push_back(TripItem(vehicle->getID()));
148  into.back().vType = vehicle->getParameter().vtypeid;
149  } else if (lastLine == "!ped") {
150  into.push_back(TripItem());
151  } else {
152  into.push_back(TripItem(lastLine));
153  into.back().depart = iEdge->getIntended(time, into.back().intended);
154  }
155  into.back().departPos = iEdge->getStartPos();
156  }
157  if (into.back().edges.empty() || into.back().edges.back() != iEdge->getEdge()) {
158  into.back().edges.push_back(iEdge->getEdge());
159  into.back().arrivalPos = iEdge->getEndPos();
160  }
161  }
162  }
163  const double prevTime = time, prevEffort = effort, prevLength = length;
164  myInternalRouter->updateViaCost(prev, iEdge, &trip, time, effort, length);
165  prev = iEdge;
166  if (!into.empty()) {
167  into.back().traveltime += time - prevTime;
168  into.back().cost += effort - prevEffort;
169  into.back().length += length - prevLength;
170  }
171  }
172  }
173 #ifdef IntermodalRouter_DEBUG_ROUTES
174  double time = STEPS2TIME(msTime);
175  for (const _IntermodalEdge* iEdge : intoEdges) {
176  const double edgeEffort = myInternalRouter->getEffort(iEdge, &trip, time);
177  time += edgeEffort;
178  std::cout << iEdge->getID() << "(" << iEdge->getLine() << "): " << edgeEffort << std::endl;
179  }
180  std::cout << TIME2STEPS(msTime) << " trip from " << from->getID() << " to " << (to != nullptr ? to->getID() : stopID)
181  << " departPos=" << trip.departPos
182  << " arrivalPos=" << trip.arrivalPos
183  << " modes=" << getVehicleClassNames(modeSet)
184  << " edges=" << toString(intoEdges)
185 // << " resultEdges=" << toString(into)
186  << " time=" << time
187  << "\n";
188 #endif
189  return success;
190  }
191 
194  bool compute(const E*, const E*, const _IntermodalTrip* const,
195  SUMOTime, std::vector<const E*>&, bool) {
196  throw ProcessError("Do not use this method");
197  }
198 
199  void prohibit(const std::vector<E*>& toProhibit) {
200  createNet();
201  std::vector<_IntermodalEdge*> toProhibitPE;
202  for (typename std::vector<E*>::const_iterator it = toProhibit.begin(); it != toProhibit.end(); ++it) {
203  toProhibitPE.push_back(myIntermodalNet->getBothDirections(*it).first);
204  toProhibitPE.push_back(myIntermodalNet->getBothDirections(*it).second);
205  toProhibitPE.push_back(myIntermodalNet->getCarEdge(*it));
206  }
207  myInternalRouter->prohibit(toProhibitPE);
208  }
209 
211  createNet();
213  dev.openTag(SUMO_TAG_EDGE);
214  dev.writeAttr(SUMO_ATTR_ID, e->getID());
215  dev.writeAttr(SUMO_ATTR_LINE, e->getLine());
216  dev.writeAttr(SUMO_ATTR_LENGTH, e->getLength());
217  dev.writeAttr("successors", toString(e->getSuccessors(SVC_IGNORING)));
218  dev.closeTag();
219  }
220  }
221 
223  createNet();
224  _IntermodalTrip trip(nullptr, nullptr, 0., 0., DEFAULT_PEDESTRIAN_SPEED, 0, 0, nullptr, SVC_PASSENGER | SVC_BICYCLE | SVC_BUS);
226  dev.openTag(SUMO_TAG_EDGE);
227  dev.writeAttr(SUMO_ATTR_ID, e->getID());
228  dev.writeAttr("traveltime", e->getTravelTime(&trip, 0.));
229  dev.writeAttr("effort", e->getEffort(&trip, 0.));
230  dev.closeTag();
231  }
232  }
233 
234  Network* getNetwork() const {
235  return myIntermodalNet;
236  }
237 
239  return myExternalEffort;
240  }
241 
242 private:
243  IntermodalRouter(Network* net, const int carWalkTransfer, const std::string& routingAlgorithm,
244  const int routingMode, EffortCalculator* calc) :
245  SUMOAbstractRouter<E, _IntermodalTrip>("IntermodalRouterClone", true, nullptr, nullptr, false, false), myAmClone(true),
246  myInternalRouter(new _InternalDijkstra(net->getAllEdges(), true,
247  gWeightsRandomFactor > 1 ? & _IntermodalEdge::getTravelTimeStaticRandomized : & _IntermodalEdge::getTravelTimeStatic)),
248  myIntermodalNet(net), myCarWalkTransfer(carWalkTransfer), myRoutingAlgorithm(routingAlgorithm), myRoutingMode(routingMode), myExternalEffort(calc) {}
249 
250  static inline double getEffortAggregated(const _IntermodalEdge* const edge, const _IntermodalTrip* const trip, double time) {
251  return edge == nullptr || !edge->hasEffort() ? 0. : edge->getEffort(trip, time);
252  }
253 
254  static inline double getCombined(const _IntermodalEdge* const edge, const _IntermodalTrip* const trip, double time) {
255  return edge->getTravelTime(trip, time) + trip->externalFactor * trip->calc->getEffort(edge->getNumericalID());
256  }
257 
258  inline void createNet() {
259  if (myIntermodalNet == nullptr) {
260  myIntermodalNet = new Network(E::getAllEdges(), false, myCarWalkTransfer);
261  myIntermodalNet->addCarEdges(E::getAllEdges());
262  myCallback(*this);
263  switch (myRoutingMode) {
264  case 0:
265  if (myRoutingAlgorithm == "astar") {
268  } else {
271  }
272  break;
273  case 1:
275  break;
276  case 2:
278  break;
279  case 3:
280  if (myExternalEffort != nullptr) {
281  std::vector<std::string> edgeLines;
282  for (const auto e : myIntermodalNet->getAllEdges()) {
283  edgeLines.push_back(e->getLine());
284  }
285  myExternalEffort->init(edgeLines);
286  }
288  break;
289  }
290  }
291  }
292 
293 private:
294  const bool myAmClone;
298  const int myCarWalkTransfer;
299  const std::string myRoutingAlgorithm;
300  const int myRoutingMode;
302 
303 
304 private:
307 
308 };
309 
310 
311 #endif
312 
313 /****************************************************************************/
StopEdge.h
SUMOAbstractRouter::compute
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...
IntermodalRouter::compute
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...
Definition: IntermodalRouter.h:194
IntermodalRouter::myExternalEffort
EffortCalculator *const myExternalEffort
Definition: IntermodalRouter.h:301
ToString.h
IntermodalNetwork::getStopEdge
_IntermodalEdge * getStopEdge(const std::string &stopId) const
Returns the associated stop edge.
Definition: IntermodalNetwork.h:434
SUMOTime.h
IntermodalRouter::_InternalRouter
SUMOAbstractRouter< _IntermodalEdge, _IntermodalTrip > _InternalRouter
Definition: IntermodalRouter.h:62
IntermodalNetwork::getDepartEdge
const _IntermodalEdge * getDepartEdge(const E *e, const double pos) const
Returns the departing intermodal edge.
Definition: IntermodalNetwork.h:295
IntermodalRouter::_InternalDijkstra
DijkstraRouter< _IntermodalEdge, _IntermodalTrip > _InternalDijkstra
Definition: IntermodalRouter.h:63
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:393
IntermodalRouter::getEffortAggregated
static double getEffortAggregated(const _IntermodalEdge *const edge, const _IntermodalTrip *const trip, double time)
Definition: IntermodalRouter.h:250
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
IntermodalRouter::operator=
IntermodalRouter & operator=(const IntermodalRouter &s)
Invalidated assignment operator.
IntermodalRouter::TripItem::departPos
double departPos
Definition: IntermodalRouter.h:79
IntermodalRouter::getCombined
static double getCombined(const _IntermodalEdge *const edge, const _IntermodalTrip *const trip, double time)
Definition: IntermodalRouter.h:254
IntermodalRouter
Definition: IntermodalRouter.h:54
SUMO_ATTR_LINE
@ SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:775
IntermodalRouter::writeNetwork
void writeNetwork(OutputDevice &dev)
Definition: IntermodalRouter.h:210
IntermodalRouter::TripItem
Definition: IntermodalRouter.h:67
IntermodalNetwork::getCarEdge
_IntermodalEdge * getCarEdge(const E *e) const
Returns the associated car edge.
Definition: IntermodalNetwork.h:425
MsgHandler.h
IntermodalEdge::getTravelTimeStaticRandomized
static double getTravelTimeStaticRandomized(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
Definition: IntermodalEdge.h:123
IntermodalRouter::TripItem::destStop
std::string destStop
Definition: IntermodalRouter.h:72
SUMOAbstractRouter::getEffort
double getEffort(const E *const e, const V *const v, double t) const
Definition: SUMOAbstractRouter.h:216
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
EffortCalculator::output
virtual std::string output(const int edge) const =0
IntermodalRouter::~IntermodalRouter
virtual ~IntermodalRouter()
Destructor.
Definition: IntermodalRouter.h:94
IntermodalEdge::getTravelTime
virtual double getTravelTime(const IntermodalTrip< E, N, V > *const, double) const
Definition: IntermodalEdge.h:110
SVC_BICYCLE
@ SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:179
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
IntermodalEdge
the base edge type that is given to the internal router (SUMOAbstractRouter)
Definition: IntermodalEdge.h:39
SUMOAbstractRouter::updateViaCost
void updateViaCost(const E *const prev, const E *const e, const V *const v, double &time, double &effort, double &length) const
Definition: SUMOAbstractRouter.h:179
IntermodalTrip::departPos
const double departPos
Definition: IntermodalTrip.h:79
IntermodalEdge::hasEffort
virtual bool hasEffort() const
Definition: IntermodalEdge.h:147
IntermodalEdge::getEffortStatic
static double getEffortStatic(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
Definition: IntermodalEdge.h:131
DijkstraRouter
Computes the shortest path through a network using the Dijkstra algorithm.
Definition: DijkstraRouter.h:61
IntermodalRouter::TripItem::description
std::string description
Definition: IntermodalRouter.h:81
IntermodalRouter::_IntermodalTrip
IntermodalTrip< E, N, V > _IntermodalTrip
Definition: IntermodalRouter.h:61
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:253
gWeightsRandomFactor
double gWeightsRandomFactor
Definition: StdDefs.cpp:30
IntermodalNetwork::addCarEdges
void addCarEdges(const std::vector< E * > &edges)
Definition: IntermodalNetwork.h:385
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:255
IntermodalRouter::myCallback
CreateNetCallback myCallback
Definition: IntermodalRouter.h:297
IntermodalRouter::IntermodalRouter
IntermodalRouter(Network *net, const int carWalkTransfer, const std::string &routingAlgorithm, const int routingMode, EffortCalculator *calc)
Definition: IntermodalRouter.h:243
IntermodalRouter::CreateNetCallback
void(* CreateNetCallback)(IntermodalRouter< E, L, N, V > &)
Definition: IntermodalRouter.h:59
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
IntermodalRouter::IntermodalRouter
IntermodalRouter(CreateNetCallback callback, const int carWalkTransfer, const std::string &routingAlgorithm, const int routingMode=0, EffortCalculator *calc=nullptr)
Constructor.
Definition: IntermodalRouter.h:85
IntermodalRouter::TripItem::TripItem
TripItem(const std::string &_line="")
Definition: IntermodalRouter.h:68
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:58
IntermodalEdge::getTravelTimeStatic
static double getTravelTimeStatic(const IntermodalEdge *const edge, const IntermodalTrip< E, N, V > *const trip, double time)
Definition: IntermodalEdge.h:119
PedestrianRouter.h
IntermodalRouter::myAmClone
const bool myAmClone
Definition: IntermodalRouter.h:294
AStarRouter.h
DEFAULT_PEDESTRIAN_SPEED
const double DEFAULT_PEDESTRIAN_SPEED
IntermodalEdge::getNumericalID
int getNumericalID() const
Definition: IntermodalEdge.h:63
STEPS2TIME
#define STEPS2TIME(x)
Definition: SUMOTime.h:56
SVC_PASSENGER
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:159
IntermodalRouter::TripItem::cost
double cost
Definition: IntermodalRouter.h:77
IntermodalTrip::arrivalPos
const double arrivalPos
Definition: IntermodalTrip.h:80
OutputDevice.h
SUMO_TAG_EDGE
@ SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
ProcessError
Definition: UtilExceptions.h:39
getVehicleClassNames
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
Definition: SUMOVehicleClass.cpp:168
EffortCalculator::init
virtual void init(const std::vector< std::string > &edges)=0
IntermodalNetwork::getArrivalEdge
_IntermodalEdge * getArrivalEdge(const E *e, const double pos) const
Returns the arriving intermodal edge.
Definition: IntermodalNetwork.h:347
IntermodalRouter::TripItem::vType
std::string vType
Definition: IntermodalRouter.h:71
IntermodalTrip::calc
const EffortCalculator *const calc
Definition: IntermodalTrip.h:86
IntermodalRouter::TripItem::length
double length
Definition: IntermodalRouter.h:78
IntermodalRouter::myRoutingAlgorithm
const std::string myRoutingAlgorithm
Definition: IntermodalRouter.h:299
SUMOAbstractRouter::prohibit
virtual void prohibit(const std::vector< E * > &)
Definition: SUMOAbstractRouter.h:163
IntermodalNetwork::getAllEdges
const std::vector< _IntermodalEdge * > & getAllEdges()
Definition: IntermodalNetwork.h:280
IntermodalRouter::TripItem::traveltime
double traveltime
Definition: IntermodalRouter.h:76
EffortCalculator.h
SUMOAbstractRouter
Definition: SUMOAbstractRouter.h:46
IntermodalRouter::createNet
void createNet()
Definition: IntermodalRouter.h:258
IntermodalRouter::prohibit
void prohibit(const std::vector< E * > &toProhibit)
Definition: IntermodalRouter.h:199
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition: OutputDevice.cpp:239
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
IntermodalRouter::myIntermodalNet
Network * myIntermodalNet
Definition: IntermodalRouter.h:296
IntermodalNetwork
the intermodal network storing edges, connections and the mappings to the "real" edges
Definition: IntermodalNetwork.h:76
IntermodalNetwork::getBothDirections
const EdgePair & getBothDirections(const E *e) const
Returns the pair of forward and backward edge.
Definition: IntermodalNetwork.h:285
IntermodalRouter::clone
SUMOAbstractRouter< E, _IntermodalTrip > * clone()
Definition: IntermodalRouter.h:101
IntermodalRouter::TripItem::line
std::string line
Definition: IntermodalRouter.h:70
IntermodalRouter::myInternalRouter
_InternalRouter * myInternalRouter
Definition: IntermodalRouter.h:295
INVALID_DOUBLE
const double INVALID_DOUBLE
Definition: StdDefs.h:62
AStarRouter
Computes the shortest path through a network using the A* algorithm.
Definition: AStarRouter.h:77
EffortCalculator
the effort calculator interface
Definition: EffortCalculator.h:32
IntermodalRouter::TripItem::depart
double depart
Definition: IntermodalRouter.h:74
IntermodalRouter::TripItem::intended
std::string intended
Definition: IntermodalRouter.h:73
IntermodalRouter::_InternalAStar
AStarRouter< _IntermodalEdge, _IntermodalTrip > _InternalAStar
Definition: IntermodalRouter.h:64
IntermodalRouter::writeWeights
void writeWeights(OutputDevice &dev)
Definition: IntermodalRouter.h:222
config.h
IntermodalRouter::TripItem::edges
std::vector< const E * > edges
Definition: IntermodalRouter.h:75
SVC_BUS
@ SVC_BUS
vehicle is a bus
Definition: SUMOVehicleClass.h:165
DijkstraRouter.h
IntermodalRouter::myCarWalkTransfer
const int myCarWalkTransfer
Definition: IntermodalRouter.h:298
IntermodalRouter::_IntermodalEdge
IntermodalEdge< E, L, N, V > _IntermodalEdge
Definition: IntermodalRouter.h:60
IntermodalRouter::compute
bool compute(const E *from, const E *to, const double departPos, 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...
Definition: IntermodalRouter.h:108
IntermodalRouter::getNetwork
Network * getNetwork() const
Definition: IntermodalRouter.h:234
IntermodalRouter::TripItem::arrivalPos
double arrivalPos
Definition: IntermodalRouter.h:80
SVC_IGNORING
@ SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:135
SUMOAbstractRouter.h
IntermodalRouter::getExternalEffort
EffortCalculator * getExternalEffort() const
Definition: IntermodalRouter.h:238
Named::getID
const std::string & getID() const
Returns the id.
Definition: Named.h:76
IntermodalTrip
the "vehicle" type that is given to the internal router (SUMOAbstractRouter)
Definition: IntermodalTrip.h:38
IntermodalEdge::getEffort
virtual double getEffort(const IntermodalTrip< E, N, V > *const, double) const
Definition: IntermodalEdge.h:127
CarEdge.h
IntermodalTrip::externalFactor
const double externalFactor
Definition: IntermodalTrip.h:87
IntermodalRouter::myRoutingMode
const int myRoutingMode
Definition: IntermodalRouter.h:300
IntermodalRouter::Network
IntermodalNetwork< E, L, N, V > Network
Definition: IntermodalRouter.h:56
IntermodalNetwork.h
EffortCalculator::getEffort
virtual double getEffort(const int numericalID) const =0