Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
ROPerson.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2002-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/****************************************************************************/
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 (PlanItem* const it : myPlan) {
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 double cost = item.cost;
367 if (veh->getVClass() != SVC_TAXI) {
368 RORoute* route = new RORoute(veh->getID() + "_RouteDef", item.edges);
369 route->setProbability(1);
371 carUsed = true;
372 } else if (trip->needsRouting()) {
373 // if this is the first plan item the initial taxi waiting time wasn't added yet
374 const double taxiWait = STEPS2TIME(string2time(OptionsCont::getOptions().getString("persontrip.taxi.waiting-time")));
375 cost += taxiWait;
376 }
377 trip->addTripItem(new Ride(start, item.edges.front(), item.edges.back(), veh->getID(), trip->getGroup(), cost, item.arrivalPos, item.length, item.destStop));
378 } else {
379 // write origin for first element of the plan
380 const ROEdge* origin = trip == myPlan.front() && trip->needsRouting() ? trip->getOrigin() : nullptr;
381 trip->addTripItem(new Ride(start, origin, nullptr, item.line, trip->getGroup(), item.cost, item.arrivalPos, item.length, item.destStop, item.intended, TIME2STEPS(item.depart)));
382 }
383 }
384 start += TIME2STEPS(item.cost);
385 }
386 if (result.empty()) {
387 errorHandler->inform("No route for trip in person '" + getID() + "'.");
388 myRoutingSuccess = false;
389 }
390 return carUsed;
391}
392
393
394void
396 const bool /* removeLoops */, MsgHandler* errorHandler) {
397 myRoutingSuccess = true;
399 for (PlanItem* const it : myPlan) {
400 if (it->needsRouting()) {
401 PersonTrip* trip = static_cast<PersonTrip*>(it);
402 std::vector<ROVehicle*>& vehicles = trip->getVehicles();
403 if (vehicles.empty()) {
404 computeIntermodal(time, provider, trip, nullptr, errorHandler);
405 } else {
406 double bestCost = std::numeric_limits<double>::infinity();
407 PersonTrip* best = nullptr;
408 ROVehicle* bestVeh = nullptr;
409 for (std::vector<ROVehicle*>::iterator v = vehicles.begin(); v != vehicles.end();) {
410 if (!computeIntermodal(time, provider, trip, *v, errorHandler)) {
411 delete (*v)->getRouteDefinition();
412 delete *v;
413 v = vehicles.erase(v);
414 } else {
415 const double cost = trip->getCost();
416 if (cost < bestCost) {
417 bestCost = cost;
418 if (best != nullptr) {
419 delete best;
420 }
421 best = static_cast<PersonTrip*>(trip->clone());
422 bestVeh = *v;
423 }
424 trip->clearItems();
425 ++v;
426 }
427 }
428 if (best != nullptr) {
429 trip->copyItems(best, bestVeh);
430 }
431 }
432 }
433 time += it->getDuration();
434 }
435}
436
437
438void
439ROPerson::saveAsXML(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const {
440 // write the person's vehicles
441 const bool writeTrip = options.exists("write-trips") && options.getBool("write-trips");
442 if (!writeTrip) {
443 for (const PlanItem* const it : myPlan) {
444 it->saveVehicles(os, typeos, asAlternatives, options);
445 }
446 }
447
448 if (typeos != nullptr && getType() != nullptr && !getType()->saved) {
449 getType()->write(*typeos);
450 getType()->saved = true;
451 }
452 if (getType() != nullptr && !getType()->saved) {
453 getType()->write(os);
454 getType()->saved = asAlternatives;
455 }
456
457 // write the person
458 getParameter().write(os, options, SUMO_TAG_PERSON);
459
460 for (const PlanItem* const it : myPlan) {
461 it->saveAsXML(os, asAlternatives, writeTrip, options);
462 }
463
464 // write params
466 os.closeTag();
467}
468
469
470/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
std::vector< const ROEdge * > ConstROEdgeVector
Definition ROEdge.h:54
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
#define STEPS2TIME(x)
Definition SUMOTime.h:55
#define TIME2STEPS(x)
Definition SUMOTime.h:57
@ 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:26
int gPrecisionGeo
Definition StdDefs.cpp:27
T MIN2(T a, T b)
Definition StdDefs.h:76
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
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 OptionsCont & getOptions()
Retrieves the options.
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.
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:164
const ROEdgeVector & getPredecessors() const
Returns the edge at the given position from the list of incoming edges.
Definition ROEdge.h:366
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:215
The router's network representation.
Definition RONet.h:62
SUMOVTypeParameter * getVehicleTypeSecure(const std::string &id)
Retrieves the named vehicle type.
Definition RONet.cpp:364
static RONet * getInstance()
Returns the pointer to the unique instance of RONet (singleton).
Definition RONet.cpp:56
bool knowsVehicle(const std::string &id) const
returns whether a vehicle with the given id was already loaded
Definition RONet.cpp:488
const std::string getStoppingPlaceElement(const std::string &id) const
return the element name for the given stopping place id
Definition RONet.cpp:896
const std::string getStoppingPlaceName(const std::string &id) const
return the name for the given stopping place id
Definition RONet.cpp:884
A planItem can be a Trip which contains multiple tripItems.
Definition ROPerson.h:298
double getDepartPos(bool replaceDefault=true) const
Definition ROPerson.h:340
void saveVehicles(OutputDevice &os, OutputDevice *const typeos, bool asAlternatives, OptionsCont &options) const
Definition ROPerson.cpp:233
const std::string & getStopOrigin() const
Definition ROPerson.h:357
SVCPermissions getModes() const
Definition ROPerson.h:346
double getCost() const
Definition ROPerson.h:368
const std::string & getStopDest() const
Definition ROPerson.h:361
double getWalkFactor() const
Definition ROPerson.h:402
const ROEdge * getDestination() const
Definition ROPerson.h:330
SUMOTime getDuration() const
return duration sum of all trip items
Definition ROPerson.cpp:318
double getArrivalPos(bool replaceDefault=true) const
Definition ROPerson.h:343
void copyItems(PersonTrip *trip, ROVehicle *veh)
Definition ROPerson.h:383
virtual void addTripItem(TripItem *tripIt)
Definition ROPerson.h:318
std::vector< ROVehicle * > & getVehicles()
Definition ROPerson.h:324
const std::string & getGroup() const
Definition ROPerson.h:353
void saveAsXML(OutputDevice &os, const bool extended, const bool asTrip, OptionsCont &options) const
Definition ROPerson.cpp:242
virtual bool needsRouting() const
Definition ROPerson.h:364
const ROEdge * getOrigin() const
Definition ROPerson.h:327
PlanItem * clone() const
Definition ROPerson.cpp:224
std::vector< TripItem * > myTripItems
the fully specified trips
Definition ROPerson.h:417
void addVehicle(ROVehicle *veh)
Definition ROPerson.h:321
void updateModes(SVCPermissions additionalModes)
Definition ROPerson.h:349
Every person has a plan comprising of multiple planItems.
Definition ROPerson.h:82
static const std::string UNDEFINED_STOPPING_PLACE
Definition ROPerson.h:112
A ride is part of a trip, e.g., go from here to here by car or bus.
Definition ROPerson.h:202
const double length
Definition ROPerson.h:243
const std::string lines
Definition ROPerson.h:237
const std::string destStop
Definition ROPerson.h:239
const std::string group
Definition ROPerson.h:238
const std::string intended
Definition ROPerson.h:240
const SUMOTime depart
Definition ROPerson.h:241
const ROEdge *const to
Definition ROPerson.h:236
void saveAsXML(OutputDevice &os, const bool extended, OptionsCont &options) const
Definition ROPerson.cpp:139
const double arrPos
Definition ROPerson.h:242
const ROEdge *const from
Definition ROPerson.h:235
A planItem can be a Stop.
Definition ROPerson.h:119
A TripItem is part of a trip, e.g., go from here to here by car.
Definition ROPerson.h:167
SUMOTime getStart() const
Definition ROPerson.h:182
SUMOTime getDuration() const
Definition ROPerson.h:186
const double myCost
Definition ROPerson.h:195
A walk is part of a trip, e.g., go from here to here by foot.
Definition ROPerson.h:255
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:395
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:439
std::vector< PlanItem * > myPlan
The plan of the person.
Definition ROPerson.h:469
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.
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