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>
28 #include <utils/common/ToString.h>
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 
60 void
61 ROPerson::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);
68  RONet* net = RONet::getInstance();
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) {
88  trip->updateMOdes(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 
115 void
116 ROPerson::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 
123 void
124 ROPerson::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 
132 void
133 ROPerson::addStop(std::vector<PlanItem*>& plan, const SUMOVehicleParameter::Stop& stopPar, const ROEdge* const stopEdge) {
134  plan.push_back(new Stop(stopPar, stopEdge));
135 }
136 
137 
138 void
139 ROPerson::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) {
149  os.writeAttr(SUMO_ATTR_TO, to->getID());
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 
182 void
183 ROPerson::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) {
190  os.writeAttr(SUMO_ATTR_DURATION, dur);
191  }
192  if (v > 0) {
193  os.writeAttr(SUMO_ATTR_SPEED, v);
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 
232 void
233 ROPerson::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 
241 void
242 ROPerson::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 
317 SUMOTime
319  SUMOTime result = 0;
320  for (TripItem* tItem : myTripItems) {
321  result += tItem->getDuration();
322  }
323  return result;
324 }
325 
326 bool
328  PersonTrip* const trip, const ROVehicle* const veh, MsgHandler* const errorHandler) {
329  const double speed = getType()->maxSpeed * 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 
387 void
389  const bool /* removeLoops */, MsgHandler* errorHandler) {
390  myRoutingSuccess = true;
391  SUMOTime time = getParameter().depart;
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 
413 void
414 ROPerson::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 /****************************************************************************/
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:55
long long int SUMOTime
Definition: SUMOTime.h:32
@ 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
@ DEPART_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:74
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:117
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 & openTag(const std::string &xmlElement)
Opens an XML tag.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:248
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 & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: ROEdge.cpp:364
double getLength() const
Returns the length of the edge.
Definition: ROEdge.h:210
const ROEdgeVector & getPredecessors() const
Returns the edge at the given position from the list of incoming edges.
Definition: ROEdge.h:361
The router's network representation.
Definition: RONet.h:62
SUMOVTypeParameter * getVehicleTypeSecure(const std::string &id)
Retrieves the named vehicle type.
Definition: RONet.cpp:343
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:842
const std::string getStoppingPlaceName(const std::string &id) const
return the name for the given stopping place id
Definition: RONet.cpp:830
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
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
SUMOTime getDuration() const
return duration sum of all trip items
Definition: ROPerson.cpp:318
double getArrivalPos(bool replaceDefault=true) const
Definition: ROPerson.h:337
const ROEdge * getDestination() const
Definition: ROPerson.h:324
const std::string & getStopOrigin() const
Definition: ROPerson.h:351
virtual void addTripItem(TripItem *tripIt)
Definition: ROPerson.h:312
std::vector< ROVehicle * > & getVehicles()
Definition: ROPerson.h:318
void saveAsXML(OutputDevice &os, const bool extended, const bool asTrip, OptionsCont &options) const
Definition: ROPerson.cpp:242
PlanItem * clone() const
Definition: ROPerson.cpp:224
const std::string & getGroup() const
Definition: ROPerson.h:347
std::vector< TripItem * > myTripItems
the fully specified trips
Definition: ROPerson.h:379
void addVehicle(ROVehicle *veh)
Definition: ROPerson.h:315
const ROEdge * getOrigin() const
Definition: ROPerson.h:321
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
const SUMOVehicleParameter & getParameter() const
Returns the definition of the vehicle / person parameter.
Definition: RORoutable.h:71
const std::string & getID() const
Returns the id of the routable.
Definition: RORoutable.h:91
SUMOVehicleClass getVClass() const
Definition: RORoutable.h:109
const SUMOVTypeParameter * getType() const
Returns the type of the routable.
Definition: RORoutable.h:82
bool myRoutingSuccess
Whether the last routing was successful.
Definition: RORoutable.h:185
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)
double maxSpeed
The vehicle type's maximum speed [m/s].
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