Eclipse SUMO - Simulation of Urban MObility
ROPerson.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2002-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/****************************************************************************/
21// A vehicle as used by router
22/****************************************************************************/
23#include <config.h>
24
25#include <string>
26#include <iostream>
35#include "RORouteDef.h"
36#include "RORoute.h"
37#include "ROVehicle.h"
38#include "ROHelper.h"
39#include "RONet.h"
40#include "ROLane.h"
41#include "ROPerson.h"
42
44
45// ===========================================================================
46// method definitions
47// ===========================================================================
49 : RORoutable(pars, type) {
50}
51
52
54 for (std::vector<PlanItem*>::const_iterator it = myPlan.begin(); it != myPlan.end(); ++it) {
55 delete *it;
56 }
57}
58
59
60void
61ROPerson::addTrip(std::vector<PlanItem*>& plan, const std::string& id,
62 const ROEdge* const from, const ROEdge* const to, const SVCPermissions modeSet,
63 const std::string& vTypes,
64 const double departPos, const std::string& stopOrigin,
65 const double arrivalPos, const std::string& busStop,
66 double walkFactor, const std::string& group) {
67 PersonTrip* trip = new PersonTrip(from, to, modeSet, departPos, stopOrigin, arrivalPos, busStop, walkFactor, group);
71 if (departPos != 0) {
73 pars.departPos = departPos;
75 }
76 for (StringTokenizer st(vTypes); st.hasNext();) {
77 pars.vtypeid = st.next();
80 if (type == nullptr) {
81 delete trip;
82 throw InvalidArgument("The vehicle type '" + pars.vtypeid + "' in a trip for person '" + id + "' is not known.");
83 }
84 pars.id = id + "_" + toString(trip->getVehicles().size());
85 trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), type, net));
86 // update modeset with routing-category vClass
87 if (type->vehicleClass == SVC_BICYCLE) {
89 } else {
91 }
92 }
93 if (trip->getVehicles().empty()) {
94 if ((modeSet & SVC_PASSENGER) != 0) {
95 pars.id = id + "_0";
96 trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), net->getVehicleTypeSecure(DEFAULT_VTYPE_ID), net));
97 }
98 if ((modeSet & SVC_BICYCLE) != 0) {
99 pars.id = id + "_b0";
102 trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), net->getVehicleTypeSecure(DEFAULT_BIKETYPE_ID), net));
103 }
104 if ((modeSet & SVC_TAXI) != 0) {
105 // add dummy taxi for routing (never added to output)
106 pars.id = "taxi"; // id is written as 'line'
108 trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), net->getVehicleTypeSecure(DEFAULT_TAXITYPE_ID), net));
109 }
110 }
111 plan.push_back(trip);
112}
113
114
115void
116ROPerson::addRide(std::vector<PlanItem*>& plan, const ROEdge* const from, const ROEdge* const to, const std::string& lines,
117 double arrivalPos, const std::string& destStop, const std::string& group) {
118 plan.push_back(new PersonTrip(to, destStop));
119 plan.back()->addTripItem(new Ride(-1, from, to, lines, group, -1., arrivalPos, -1., destStop));
120}
121
122
123void
124ROPerson::addWalk(std::vector<PlanItem*>& plan, const ConstROEdgeVector& edges, const double duration, const double speed, const double departPos, const double arrivalPos, const std::string& busStop) {
125 if (plan.empty() || plan.back()->isStop()) {
126 plan.push_back(new PersonTrip(edges.back(), busStop));
127 }
128 plan.back()->addTripItem(new Walk(-1, edges, -1., duration, speed, departPos, arrivalPos, busStop));
129}
130
131
132void
133ROPerson::addStop(std::vector<PlanItem*>& plan, const SUMOVehicleParameter::Stop& stopPar, const ROEdge* const stopEdge) {
134 plan.push_back(new Stop(stopPar, stopEdge));
135}
136
137
138void
139ROPerson::Ride::saveAsXML(OutputDevice& os, const bool extended, OptionsCont& options) const {
141 std::string comment = "";
142 if ((extended || options.getBool("write-costs")) && myCost >= 0.) {
144 }
145 if (from != nullptr) {
147 }
148 if (to != nullptr) {
150 }
151 if (destStop != "") {
152 const std::string element = RONet::getInstance()->getStoppingPlaceElement(destStop);
153 os.writeAttr(element, destStop);
154 const std::string name = RONet::getInstance()->getStoppingPlaceName(destStop);
155 if (name != "") {
156 comment = " <!-- " + name + " -->";
157 }
158 } else if (arrPos != 0 && arrPos != std::numeric_limits<double>::infinity()) {
160 }
162 if (group != "") {
164 }
165 if (intended != "" && intended != lines) {
167 }
168 if (depart >= 0) {
170 }
171 if (options.getBool("exit-times")) {
172 os.writeAttr("started", time2string(getStart()));
173 os.writeAttr("ended", time2string(getStart() + getDuration()));
174 }
175 if (options.getBool("route-length") && length != -1) {
176 os.writeAttr("routeLength", length);
177 }
178 os.closeTag(comment);
179}
180
181
182void
183ROPerson::Walk::saveAsXML(OutputDevice& os, const bool extended, OptionsCont& options) const {
185 std::string comment = "";
186 if ((extended || options.getBool("write-costs")) && myCost >= 0.) {
187 os.writeAttr(SUMO_ATTR_COST, myCost);
188 }
189 if (dur > 0) {
191 }
192 if (v > 0) {
194 }
195 os.writeAttr(SUMO_ATTR_EDGES, edges);
196 if (options.getBool("exit-times")) {
197 os.writeAttr("started", time2string(getStart()));
198 os.writeAttr("ended", time2string(getStart() + getDuration()));
199 if (!exitTimes.empty()) {
200 os.writeAttr("exitTimes", exitTimes);
201 }
202 }
203 if (options.getBool("route-length")) {
204 double length = 0;
205 for (const ROEdge* roe : edges) {
206 length += roe->getLength();
207 }
208 os.writeAttr("routeLength", length);
209 }
210 if (destStop != "") {
211 const std::string element = RONet::getInstance()->getStoppingPlaceElement(destStop);
212 os.writeAttr(element, destStop);
213 const std::string name = RONet::getInstance()->getStoppingPlaceName(destStop);
214 if (name != "") {
215 comment = " <!-- " + name + " -->";
216 }
217 } else if (arr != 0 && arr != std::numeric_limits<double>::infinity()) {
219 }
220 os.closeTag(comment);
221}
222
225 PersonTrip* result = new PersonTrip(from, to, modes, dep, stopOrigin, arr, stopDest, walkFactor, group);
226 for (auto* item : myTripItems) {
227 result->myTripItems.push_back(item->clone());
228 }
229 return result;
230}
231
232void
233ROPerson::PersonTrip::saveVehicles(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const {
234 for (ROVehicle* veh : myVehicles) {
235 if (!RONet::getInstance()->knowsVehicle(veh->getID())) {
236 veh->saveAsXML(os, typeos, asAlternatives, options);
237 }
238 }
239}
240
241void
242ROPerson::PersonTrip::saveAsXML(OutputDevice& os, const bool extended, const bool asTrip, OptionsCont& options) const {
243 if ((asTrip || extended) && from != nullptr) {
244 const bool writeGeoTrip = asTrip && options.getBool("write-trips.geo");
246 if (writeGeoTrip) {
247 Position fromPos = from->getLanes()[0]->getShape().positionAtOffset2D(getDepartPos());
248 if (GeoConvHelper::getFinal().usingGeoProjection()) {
251 os.writeAttr(SUMO_ATTR_FROMLONLAT, fromPos);
253 } else {
254 os.writeAttr(SUMO_ATTR_FROMXY, fromPos);
255 }
256 } else {
257 os.writeAttr(SUMO_ATTR_FROM, from->getID());
258 }
259 if (writeGeoTrip) {
260 Position toPos = to->getLanes()[0]->getShape().positionAtOffset2D(MIN2(getArrivalPos(), to->getLanes()[0]->getShape().length2D()));
261 if (GeoConvHelper::getFinal().usingGeoProjection()) {
264 os.writeAttr(SUMO_ATTR_TOLONLAT, toPos);
266 } else {
267 os.writeAttr(SUMO_ATTR_TOXY, toPos);
268 }
269 } else {
270 os.writeAttr(SUMO_ATTR_TO, to->getID());
271 }
272 std::vector<std::string> allowedModes;
273 if ((modes & SVC_BUS) != 0) {
274 allowedModes.push_back("public");
275 }
276 if ((modes & SVC_PASSENGER) != 0) {
277 allowedModes.push_back("car");
278 }
279 if ((modes & SVC_TAXI) != 0) {
280 allowedModes.push_back("taxi");
281 }
282 if ((modes & SVC_BICYCLE) != 0) {
283 allowedModes.push_back("bicycle");
284 }
285 if (allowedModes.size() > 0) {
286 os.writeAttr(SUMO_ATTR_MODES, toString(allowedModes));
287 }
288 if (!writeGeoTrip) {
289 if (dep != 0 && dep != std::numeric_limits<double>::infinity()) {
291 }
292 if (arr != 0 && arr != std::numeric_limits<double>::infinity()) {
294 }
295 }
296 if (getStopDest() != "") {
297 os.writeAttr(SUMO_ATTR_BUS_STOP, getStopDest());
298 }
299 if (walkFactor != 1) {
300 os.writeAttr(SUMO_ATTR_WALKFACTOR, walkFactor);
301 }
302 if (extended && myTripItems.size() != 0) {
303 std::vector<double> costs;
304 for (const TripItem* const tripItem : myTripItems) {
305 costs.push_back(tripItem->getCost());
306 }
307 os.writeAttr(SUMO_ATTR_COSTS, costs);
308 }
309 os.closeTag();
310 } else {
311 for (const TripItem* const it : myTripItems) {
312 it->saveAsXML(os, extended, options);
313 }
314 }
315}
316
319 SUMOTime result = 0;
320 for (TripItem* tItem : myTripItems) {
321 result += tItem->getDuration();
322 }
323 return result;
324}
325
326bool
328 PersonTrip* const trip, const ROVehicle* const veh, MsgHandler* const errorHandler) {
329 const double speed = getMaxSpeed() * trip->getWalkFactor();
330 std::vector<ROIntermodalRouter::TripItem> result;
331 provider.getIntermodalRouter().compute(trip->getOrigin(), trip->getDestination(),
332 trip->getDepartPos(), trip->getStopOrigin(),
333 trip->getArrivalPos(), trip->getStopDest(),
334 speed, veh, trip->getModes(), time, result);
335 bool carUsed = false;
336 SUMOTime start = time;
337 for (const ROIntermodalRouter::TripItem& item : result) {
338 if (!item.edges.empty()) {
339 if (item.line == "") {
340 double depPos = trip->getDepartPos(false);
341 double arrPos = trip->getArrivalPos(false);
342 if (trip->getOrigin()->isTazConnector()) {
343 // walk the whole length of the first edge
344 const ROEdge* first = item.edges.front();
345 if (std::find(first->getPredecessors().begin(), first->getPredecessors().end(), trip->getOrigin()) != first->getPredecessors().end()) {
346 depPos = 0;
347 } else {
348 depPos = first->getLength();
349 }
350 }
351 if (trip->getDestination()->isTazConnector()) {
352 // walk the whole length of the last edge
353 const ROEdge* last = item.edges.back();
354 if (std::find(last->getSuccessors().begin(), last->getSuccessors().end(), trip->getDestination()) != last->getSuccessors().end()) {
355 arrPos = last->getLength();
356 } else {
357 arrPos = 0;
358 }
359 }
360 if (&item == &result.back() && trip->getStopDest() == "") {
361 trip->addTripItem(new Walk(start, item.edges, item.cost, item.exitTimes, depPos, arrPos));
362 } else {
363 trip->addTripItem(new Walk(start, item.edges, item.cost, item.exitTimes, depPos, arrPos, item.destStop));
364 }
365 } else if (veh != nullptr && item.line == veh->getID()) {
366 trip->addTripItem(new Ride(start, item.edges.front(), item.edges.back(), veh->getID(), trip->getGroup(), item.cost, item.arrivalPos, item.length, item.destStop));
367 if (veh->getVClass() != SVC_TAXI) {
368 RORoute* route = new RORoute(veh->getID() + "_RouteDef", item.edges);
369 route->setProbability(1);
371 carUsed = true;
372 }
373 } else {
374 trip->addTripItem(new Ride(start, nullptr, nullptr, item.line, trip->getGroup(), item.cost, item.arrivalPos, item.length, item.destStop, item.intended, TIME2STEPS(item.depart)));
375 }
376 }
377 start += TIME2STEPS(item.cost);
378 }
379 if (result.empty()) {
380 errorHandler->inform("No route for trip in person '" + getID() + "'.");
381 myRoutingSuccess = false;
382 }
383 return carUsed;
384}
385
386
387void
389 const bool /* removeLoops */, MsgHandler* errorHandler) {
390 myRoutingSuccess = true;
392 for (std::vector<PlanItem*>::iterator it = myPlan.begin(); it != myPlan.end(); ++it) {
393 if ((*it)->needsRouting()) {
394 PersonTrip* trip = static_cast<PersonTrip*>(*it);
395 std::vector<ROVehicle*>& vehicles = trip->getVehicles();
396 if (vehicles.empty()) {
397 computeIntermodal(time, provider, trip, nullptr, errorHandler);
398 } else {
399 for (std::vector<ROVehicle*>::iterator v = vehicles.begin(); v != vehicles.end();) {
400 if (!computeIntermodal(time, provider, trip, *v, errorHandler)) {
401 v = vehicles.erase(v);
402 } else {
403 ++v;
404 }
405 }
406 }
407 }
408 time += (*it)->getDuration();
409 }
410}
411
412
413void
414ROPerson::saveAsXML(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const {
415 // write the person's vehicles
416 const bool writeTrip = options.exists("write-trips") && options.getBool("write-trips");
417 if (!writeTrip) {
418 for (const PlanItem* const it : myPlan) {
419 it->saveVehicles(os, typeos, asAlternatives, options);
420 }
421 }
422
423 if (typeos != nullptr && getType() != nullptr && !getType()->saved) {
424 getType()->write(*typeos);
425 getType()->saved = true;
426 }
427 if (getType() != nullptr && !getType()->saved) {
428 getType()->write(os);
429 getType()->saved = asAlternatives;
430 }
431
432 // write the person
433 getParameter().write(os, options, SUMO_TAG_PERSON);
434
435 for (const PlanItem* const it : myPlan) {
436 it->saveAsXML(os, asAlternatives, writeTrip, options);
437 }
438
439 // write params
441 os.closeTag();
442}
443
444
445/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
std::vector< const ROEdge * > ConstROEdgeVector
Definition: ROEdge.h:54
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
#define TIME2STEPS(x)
Definition: SUMOTime.h:56
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_TAXI
vehicle is a taxi
@ SVC_BUS
vehicle is a bus
const std::string DEFAULT_TAXITYPE_ID
const std::string DEFAULT_VTYPE_ID
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
const std::string DEFAULT_BIKETYPE_ID
@ GIVEN
The position is given.
const int VEHPARS_DEPARTPOS_SET
const int VEHPARS_VTYPE_SET
@ TRIGGERED
The departure is person triggered.
@ SUMO_TAG_WALK
@ SUMO_TAG_RIDE
@ SUMO_TAG_PERSON
@ SUMO_TAG_PERSONTRIP
@ SUMO_ATTR_COSTS
@ SUMO_ATTR_LINES
@ SUMO_ATTR_DEPART
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_TOLONLAT
@ SUMO_ATTR_MODES
@ SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_GROUP
@ SUMO_ATTR_COST
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_FROMXY
@ SUMO_ATTR_WALKFACTOR
@ SUMO_ATTR_TOXY
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_FROMLONLAT
@ SUMO_ATTR_INTENDED
int gPrecision
the precision for floating point outputs
Definition: StdDefs.cpp:25
int gPrecisionGeo
Definition: StdDefs.cpp:26
T MIN2(T a, T b)
Definition: StdDefs.h:71
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:116
const std::string & getID() const
Returns the id.
Definition: Named.h:74
A storage for options typed value containers)
Definition: OptionsCont.h:89
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:251
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.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A basic edge for routing applications.
Definition: ROEdge.h:70
bool isTazConnector() const
Definition: ROEdge.h:159
const ROEdgeVector & getPredecessors() const
Returns the edge at the given position from the list of incoming edges.
Definition: ROEdge.h:361
const ROEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: ROEdge.cpp:366
double getLength() const
Returns the length of the edge.
Definition: ROEdge.h:210
The router's network representation.
Definition: RONet.h:62
SUMOVTypeParameter * getVehicleTypeSecure(const std::string &id)
Retrieves the named vehicle type.
Definition: RONet.cpp:353
static RONet * getInstance()
Returns the pointer to the unique instance of RONet (singleton).
Definition: RONet.cpp:56
const std::string getStoppingPlaceElement(const std::string &id) const
return the element name for the given stopping place id
Definition: RONet.cpp:862
const std::string getStoppingPlaceName(const std::string &id) const
return the name for the given stopping place id
Definition: RONet.cpp:850
A planItem can be a Trip which contains multiple tripItems.
Definition: ROPerson.h:292
double getDepartPos(bool replaceDefault=true) const
Definition: ROPerson.h:334
void saveVehicles(OutputDevice &os, OutputDevice *const typeos, bool asAlternatives, OptionsCont &options) const
Definition: ROPerson.cpp:233
const std::string & getStopOrigin() const
Definition: ROPerson.h:351
SVCPermissions getModes() const
Definition: ROPerson.h:340
void updateMOdes(SVCPermissions additionalModes)
Definition: ROPerson.h:343
const std::string & getStopDest() const
Definition: ROPerson.h:355
double getWalkFactor() const
Definition: ROPerson.h:364
const ROEdge * getDestination() const
Definition: ROPerson.h:324
SUMOTime getDuration() const
return duration sum of all trip items
Definition: ROPerson.cpp:318
double getArrivalPos(bool replaceDefault=true) const
Definition: ROPerson.h:337
virtual void addTripItem(TripItem *tripIt)
Definition: ROPerson.h:312
std::vector< ROVehicle * > & getVehicles()
Definition: ROPerson.h:318
const std::string & getGroup() const
Definition: ROPerson.h:347
void saveAsXML(OutputDevice &os, const bool extended, const bool asTrip, OptionsCont &options) const
Definition: ROPerson.cpp:242
const ROEdge * getOrigin() const
Definition: ROPerson.h:321
PlanItem * clone() const
Definition: ROPerson.cpp:224
std::vector< TripItem * > myTripItems
the fully specified trips
Definition: ROPerson.h:379
void addVehicle(ROVehicle *veh)
Definition: ROPerson.h:315
Every person has a plan comprising of multiple planItems.
Definition: ROPerson.h:82
static const std::string UNDEFINED_STOPPING_PLACE
Definition: ROPerson.h:109
A ride is part of a trip, e.g., go from here to here by car or bus.
Definition: ROPerson.h:196
const double length
Definition: ROPerson.h:237
const std::string lines
Definition: ROPerson.h:231
const std::string destStop
Definition: ROPerson.h:233
const std::string group
Definition: ROPerson.h:232
const std::string intended
Definition: ROPerson.h:234
const SUMOTime depart
Definition: ROPerson.h:235
const ROEdge *const to
Definition: ROPerson.h:230
void saveAsXML(OutputDevice &os, const bool extended, OptionsCont &options) const
Definition: ROPerson.cpp:139
const double arrPos
Definition: ROPerson.h:236
const ROEdge *const from
Definition: ROPerson.h:229
A planItem can be a Stop.
Definition: ROPerson.h:116
A TripItem is part of a trip, e.g., go from here to here by car.
Definition: ROPerson.h:161
SUMOTime getStart() const
Definition: ROPerson.h:176
SUMOTime getDuration() const
Definition: ROPerson.h:180
const double myCost
Definition: ROPerson.h:189
A walk is part of a trip, e.g., go from here to here by foot.
Definition: ROPerson.h:249
void saveAsXML(OutputDevice &os, const bool extended, OptionsCont &options) const
Definition: ROPerson.cpp:183
virtual ~ROPerson()
Destructor.
Definition: ROPerson.cpp:53
ROPerson(const SUMOVehicleParameter &pars, const SUMOVTypeParameter *type)
Constructor.
Definition: ROPerson.cpp:48
static void addTrip(std::vector< PlanItem * > &plan, const std::string &id, const ROEdge *const from, const ROEdge *const to, const SVCPermissions modeSet, const std::string &vTypes, const double departPos, const std::string &stopOrigin, const double arrivalPos, const std::string &busStop, double walkFactor, const std::string &group)
Definition: ROPerson.cpp:61
static void addStop(std::vector< PlanItem * > &plan, const SUMOVehicleParameter::Stop &stopPar, const ROEdge *const stopEdge)
Definition: ROPerson.cpp:133
static void addRide(std::vector< PlanItem * > &plan, const ROEdge *const from, const ROEdge *const to, const std::string &lines, double arrivalPos, const std::string &destStop, const std::string &group)
Definition: ROPerson.cpp:116
void computeRoute(const RORouterProvider &provider, const bool removeLoops, MsgHandler *errorHandler)
Definition: ROPerson.cpp:388
static void addWalk(std::vector< PlanItem * > &plan, const ConstROEdgeVector &edges, const double duration, const double speed, const double departPos, const double arrivalPos, const std::string &busStop)
Definition: ROPerson.cpp:124
bool computeIntermodal(SUMOTime time, const RORouterProvider &provider, PersonTrip *const trip, const ROVehicle *const veh, MsgHandler *const errorHandler)
Definition: ROPerson.cpp:327
void saveAsXML(OutputDevice &os, OutputDevice *const typeos, bool asAlternatives, OptionsCont &options) const
Saves the complete person description.
Definition: ROPerson.cpp:414
std::vector< PlanItem * > myPlan
The plan of the person.
Definition: ROPerson.h:431
A routable thing such as a vehicle or person.
Definition: RORoutable.h:52
SUMOVehicleClass getVClass() const
Definition: RORoutable.h:109
bool myRoutingSuccess
Whether the last routing was successful.
Definition: RORoutable.h:185
const SUMOVTypeParameter * getType() const
Returns the type of the routable.
Definition: RORoutable.h:82
const std::string & getID() const
Returns the id of the routable.
Definition: RORoutable.h:91
const SUMOVehicleParameter & getParameter() const
Returns the definition of the vehicle / person parameter.
Definition: RORoutable.h:71
double getMaxSpeed() const
Returns the vehicle's maximum speed.
Definition: RORoutable.h:115
Base class for a vehicle's route definition.
Definition: RORouteDef.h:53
void addLoadedAlternative(RORoute *alternative)
Adds a single alternative loaded from the file An alternative may also be generated during DUA.
Definition: RORouteDef.cpp:69
A complete router's route.
Definition: RORoute.h:52
void setProbability(double prob)
Sets the probability of the route.
Definition: RORoute.cpp:70
A vehicle as used by router.
Definition: ROVehicle.h:50
RORouteDef * getRouteDefinition() const
Returns the definition of the route the vehicle takes.
Definition: ROVehicle.h:73
IntermodalRouter< E, L, N, V > & getIntermodalRouter() const
Structure representing possible vehicle parameter.
void write(OutputDevice &dev) const
Writes the vtype.
bool saved
Information whether this type was already saved (needed by routers)
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition of vehicle stop (position and duration)
Structure representing possible vehicle parameter.
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
std::string vtypeid
The vehicle's type id.
void write(OutputDevice &dev, const OptionsCont &oc, const SumoXMLTag altTag=SUMO_TAG_VEHICLE, const std::string &typeID="") const
Writes the parameters as a beginning element.
double departPos
(optional) The position the vehicle shall depart from
std::string id
The vehicle's id.
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
bool hasNext()
returns the information whether further substrings exist