Eclipse SUMO - Simulation of Urban MObility
MSVehicleControl.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
20// The class responsible for building and deletion of vehicles
21/****************************************************************************/
22#include <config.h>
23
24#include "MSVehicleControl.h"
25#include "MSVehicle.h"
26#include "MSLane.h"
27#include "MSEdge.h"
28#include "MSNet.h"
29#include "MSRouteHandler.h"
33#include <utils/common/Named.h>
39
40
41// ===========================================================================
42// member method definitions
43// ===========================================================================
45 myLoadedVehNo(0),
46 myRunningVehNo(0),
47 myEndedVehNo(0),
48 myDiscarded(0),
49 myCollisions(0),
50 myTeleportsCollision(0),
51 myTeleportsJam(0),
52 myTeleportsYield(0),
53 myTeleportsWrongLane(0),
54 myEmergencyStops(0),
55 myEmergencyBrakingCount(0),
56 myStoppedVehicles(0),
57 myTotalDepartureDelay(0),
58 myTotalTravelTime(0),
59 myWaitingForTransportable(0),
60 myMaxSpeedFactor(1),
61 myMinDeceleration(SUMOVTypeParameter::getDefaultDecel(SVC_IGNORING)),
62 myMinDecelerationRail(SUMOVTypeParameter::getDefaultDecel(SVC_RAIL)),
63 myPendingRemovals(MSGlobals::gNumSimThreads > 1) {
64
67}
68
69
71 clearState(false);
72}
73
74
75void
79
83
87
91
95
97 // ISO Container TEU (cannot set this based on vClass)
98 defContainerType.length = 6.1;
99 defContainerType.width = 2.4;
100 defContainerType.height = 2.6;
101 defContainerType.parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
103
105}
106
107
110 ConstMSRoutePtr route, MSVehicleType* type,
111 const bool ignoreStopErrors, const bool fromRouteFile, bool addRouteStops) {
112 MSVehicle* built = new MSVehicle(defs, route, type, type->computeChosenSpeedDeviation(fromRouteFile ? MSRouteHandler::getParsingRNG() : nullptr));
113 initVehicle(built, ignoreStopErrors, addRouteStops);
114 return built;
115}
116
117
118void
119MSVehicleControl::initVehicle(MSBaseVehicle* built, const bool ignoreStopErrors, bool addRouteStops) {
121 try {
122 built->initDevices();
123 built->addStops(ignoreStopErrors, nullptr, addRouteStops);
124 } catch (ProcessError&) {
125 delete built;
126 throw;
127 }
129}
130
131
132void
134 assert(myRunningVehNo > 0);
135 if (!checkDuplicate || !isPendingRemoval(veh)) {
136 myPendingRemovals.push_back(veh);
137 }
138}
139
140
141bool
143#ifdef HAVE_FOX
144 return myPendingRemovals.contains(veh);
145#else
146 return std::find(myPendingRemovals.begin(), myPendingRemovals.end(), veh) == myPendingRemovals.end();
147#endif
148}
149
150
151void
153 OutputDevice* const tripinfoOut = OptionsCont::getOptions().isSet("tripinfo-output") ? &OutputDevice::getDeviceByOption("tripinfo-output") : nullptr;
154#ifdef HAVE_FOX
155 std::vector<SUMOVehicle*>& vehs = myPendingRemovals.getContainer();
156#else
157 std::vector<SUMOVehicle*>& vehs = myPendingRemovals;
158#endif
159 std::sort(vehs.begin(), vehs.end(), ComparatorNumericalIdLess());
160 for (SUMOVehicle* const veh : vehs) {
161 myTotalTravelTime += STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - veh->getDeparture());
164 // vehicle is equipped with tripinfo device (not all vehicles are)
165 const bool hasTripinfo = veh->getDevice(typeid(MSDevice_Tripinfo)) != nullptr;
166 for (MSVehicleDevice* const dev : veh->getDevices()) {
167 dev->generateOutput(hasTripinfo ? tripinfoOut : nullptr);
168 }
169 if (tripinfoOut != nullptr && hasTripinfo) {
170 // close tag after tripinfo (possibly including emissions from another device) have been written
171 tripinfoOut->closeTag();
172 }
173 deleteVehicle(veh);
174 }
175 vehs.clear();
176 if (tripinfoOut != nullptr) {
177 // there seem to be people who think reading an unfinished xml is a good idea ;-)
178 tripinfoOut->flush();
179 }
180#ifdef HAVE_FOX
181 myPendingRemovals.unlock();
182#endif
183}
184
185
186void
192 if ((v.getVClass() & (SVC_PEDESTRIAN | SVC_NON_ROAD)) == 0) {
193 // only worry about deceleration of road users
195 } else if ((v.getVClass() & SVC_RAIL_CLASSES) != 0) {
197 }
198}
199
200
201void
202MSVehicleControl::setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime) {
203 myRunningVehNo = runningVehNo;
204 myLoadedVehNo = loadedVehNo;
205 myEndedVehNo = endedVehNo;
206 myTotalDepartureDelay = totalDepartureDelay;
207 myTotalTravelTime = totalTravelTime;
208}
209
210
211void
219 // save vehicle types
220 for (const auto& item : myVTypeDict) {
221 if (myReplaceableDefaultVTypes.count(item.first) == 0) {
222 item.second->getParameter().write(out);
223 }
224 }
225 for (const auto& item : myVTypeDistDict) {
227 out.writeAttr(SUMO_ATTR_VTYPES, item.second->getVals());
228 out.writeAttr(SUMO_ATTR_PROBS, item.second->getProbs());
229 out.closeTag();
230 }
231 for (const auto& item : myVehicleDict) {
232 item.second->saveState(out);
233 }
234}
235
236
237void
239 for (const auto& item : myVehicleDict) {
240 delete item.second;
241 }
242 myVehicleDict.clear();
243 // delete vehicle type distributions
244 for (const auto& item : myVTypeDistDict) {
245 delete item.second;
246 }
247 myVTypeDistDict.clear();
248 // delete vehicle types
249 for (const auto& item : myVTypeDict) {
250 delete item.second;
251 }
252 myVTypeDict.clear();
253 myPendingRemovals.clear(); // could be leftovers from MSVehicleTransfer::checkInsertions (teleport beyond arrival)
254 if (reinit) {
256 }
257 myLoadedVehNo = 0;
258 myRunningVehNo = 0;
259 myEndedVehNo = 0;
260 myDiscarded = 0;
261 myCollisions = 0;
263 myTeleportsJam = 0;
271}
272
273
274bool
275MSVehicleControl::addVehicle(const std::string& id, SUMOVehicle* v) {
276 VehicleDictType::iterator it = myVehicleDict.find(id);
277 if (it == myVehicleDict.end()) {
278 // id not in myVehicleDict.
279 myVehicleDict[id] = v;
280 handleTriggeredDepart(v, true);
281 const SUMOVehicleParameter& pars = v->getParameter();
282 if (v->getVClass() != SVC_TAXI && pars.line != "" && pars.repetitionNumber < 0) {
283 myPTVehicles.push_back(v);
284 }
285 return true;
286 }
287 return false;
288}
289
290
291void
293 const SUMOVehicleParameter& pars = v->getParameter();
295 const MSEdge* const firstEdge = v->getRoute().getEdges()[pars.departEdge];
296 if (add) {
298 // position will be checked against person position later
299 static_cast<MSVehicle*>(v)->setTentativeLaneAndPosition(nullptr, v->getParameter().departPos);
300 }
301 if (firstEdge->isTazConnector()) {
302 for (MSEdge* out : firstEdge->getSuccessors()) {
303 out->addWaiting(v);
304 }
305 } else {
306 firstEdge->addWaiting(v);
307 }
309 } else {
310 if (firstEdge->isTazConnector()) {
311 for (MSEdge* out : firstEdge->getSuccessors()) {
312 out->removeWaiting(v);
313 }
314 } else {
315 firstEdge->removeWaiting(v);
316 }
318 }
319 }
320}
321
322
324MSVehicleControl::getVehicle(const std::string& id) const {
325 VehicleDictType::const_iterator it = myVehicleDict.find(id);
326 if (it == myVehicleDict.end()) {
327 return nullptr;
328 }
329 return it->second;
330}
331
332
333void
335 myEndedVehNo++;
336 if (discard) {
337 myDiscarded++;
338 }
339 if (veh != nullptr) {
340 myVehicleDict.erase(veh->getID());
341 }
342 auto ptVehIt = std::find(myPTVehicles.begin(), myPTVehicles.end(), veh);
343 if (ptVehIt != myPTVehicles.end()) {
344 myPTVehicles.erase(ptVehIt);
345 }
346 delete veh;
347}
348
349
350bool
351MSVehicleControl::checkVType(const std::string& id) {
352 if (myReplaceableDefaultVTypes.erase(id) > 0) {
353 delete myVTypeDict[id];
354 myVTypeDict.erase(myVTypeDict.find(id));
355 } else {
356 if (myVTypeDict.find(id) != myVTypeDict.end() || myVTypeDistDict.find(id) != myVTypeDistDict.end()) {
357 return false;
358 }
359 }
360 return true;
361}
362
363
364bool
366 if (checkVType(vehType->getID())) {
367 myVTypeDict[vehType->getID()] = vehType;
368 return true;
369 }
370 return false;
371}
372
373
374void
376 assert(vehType != nullptr);
377 assert(myVTypeDict.find(vehType->getID()) != myVTypeDict.end());
378 myVTypeDict.erase(vehType->getID());
379 if (myVTypeToDist.find(vehType->getID()) != myVTypeToDist.end()) {
380 myVTypeToDist.erase(vehType->getID());
381 }
382 delete vehType;
383}
384
385
386bool
388 if (checkVType(id)) {
389 myVTypeDistDict[id] = vehTypeDistribution;
390 std::vector<MSVehicleType*> vehTypes = vehTypeDistribution->getVals();
391 for (auto vehType : vehTypes) {
392 if (myVTypeToDist.find(vehType->getID()) != myVTypeToDist.end()) {
393 myVTypeToDist[vehType->getID()].insert(id);
394 } else {
395 myVTypeToDist[vehType->getID()] = { id };
396 }
397 }
398 return true;
399 }
400 return false;
401}
402
403
404bool
405MSVehicleControl::hasVType(const std::string& id) const {
406 return myVTypeDict.count(id) > 0 || myVTypeDistDict.count(id) > 0;
407}
408
409
410bool
411MSVehicleControl::hasVTypeDistribution(const std::string& id) const {
412 return myVTypeDistDict.count(id) > 0;
413}
414
415
417MSVehicleControl::getVType(const std::string& id, SumoRNG* rng, bool readOnly) {
418 VTypeDictType::iterator it = myVTypeDict.find(id);
419 if (it == myVTypeDict.end()) {
420 VTypeDistDictType::iterator it2 = myVTypeDistDict.find(id);
421 if (it2 == myVTypeDistDict.end()) {
422 return nullptr;
423 }
424 return it2->second->get(rng);
425 }
426 if (!readOnly && myReplaceableDefaultVTypes.erase(id) > 0) {
427 it->second->check();
428 }
429 return it->second;
430}
431
432
433void
434MSVehicleControl::insertVTypeIDs(std::vector<std::string>& into) const {
435 into.reserve(into.size() + myVTypeDict.size() + myVTypeDistDict.size());
436 for (VTypeDictType::const_iterator i = myVTypeDict.begin(); i != myVTypeDict.end(); ++i) {
437 into.push_back((*i).first);
438 }
439 for (VTypeDistDictType::const_iterator i = myVTypeDistDict.begin(); i != myVTypeDistDict.end(); ++i) {
440 into.push_back((*i).first);
441 }
442}
443
444
445const std::set<std::string>
447 std::map<std::string, std::set<std::string>>::const_iterator it = myVTypeToDist.find(id);
448 if (it == myVTypeToDist.end()) {
449 return std::set<std::string>();
450 }
451 return it->second;
452}
453
454
456MSVehicleControl::getVTypeDistribution(const std::string& typeDistID) const {
457 auto it = myVTypeDistDict.find(typeDistID);
458 if (it != myVTypeDistDict.end()) {
459 return it->second;
460 } else {
461 return nullptr;
462 }
463}
464
465
466void
468 for (VehicleDictType::iterator i = myVehicleDict.begin(); i != myVehicleDict.end(); ++i) {
469 WRITE_WARNINGF(TL("Vehicle '%' aborted waiting for a % that will never come."), i->first,
470 i->second->getParameter().departProcedure == DepartDefinition::SPLIT ? "split" : "person or container")
471 }
472}
473
474
475int
477 int result = 0;
478 for (MSVehicleControl::constVehIt it = loadedVehBegin(); it != loadedVehEnd(); ++it) {
479 const SUMOVehicle* veh = it->second;
480 if ((veh->isOnRoad() || veh->isRemoteControlled()) && veh->getSpeed() < SUMO_const_haltingSpeed) {
481 result++;
482 }
483 }
484 return result;
485}
486
487
488std::pair<double, double>
490 double speedSum = 0;
491 double relSpeedSum = 0;
492 int count = 0;
493 for (MSVehicleControl::constVehIt it = loadedVehBegin(); it != loadedVehEnd(); ++it) {
494 const SUMOVehicle* veh = it->second;
495 if ((veh->isOnRoad() || veh->isRemoteControlled()) && !veh->isStopped()) {
496 count++;
497 speedSum += veh->getSpeed();
498 relSpeedSum += veh->getEdge()->getSpeedLimit() > 0 ? veh->getSpeed() / veh->getEdge()->getSpeedLimit() : 0;
499 }
500 }
501 if (count > 0) {
502 return std::make_pair(speedSum / count, relSpeedSum / count);
503 } else {
504 return std::make_pair(-1, -1);
505 }
506}
507
508
509int
510MSVehicleControl::getQuota(double frac, int loaded) const {
511 frac = frac < 0 ? myScale : frac;
512 const int origLoaded = (loaded < 1
513 // the vehicle in question has already been loaded, hence the '-1'
514 ? frac > 1. ? (int)(myLoadedVehNo / frac) : myLoadedVehNo - 1
515 // given transportable number reflects only previously loaded
516 : frac > 1. ? (int)(loaded / frac) : loaded);
517 return getScalingQuota(frac, origLoaded);
518}
519
520
521int
524}
525
526
527void
529 for (const SUMOVehicle* const veh : myPTVehicles) {
530 // add single vehicles with line attribute which are not part of a flow
531 ConstMSRoutePtr const route = MSRoute::dictionary(veh->getParameter().routeid);
532 router.getNetwork()->addSchedule(veh->getParameter(), route == nullptr ? nullptr : &route->getStops());
533 }
534}
535
536/****************************************************************************/
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:271
#define TL(string)
Definition: MsgHandler.h:287
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition: Route.h:32
#define STEPS2TIME(x)
Definition: SUMOTime.h:55
#define STEPFLOOR(x)
Definition: SUMOTime.h:58
const long long int VTYPEPARS_VEHICLECLASS_SET
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_RAIL
vehicle is a not electrified rail
@ SVC_RAIL_CLASSES
classes which drive on tracks
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_NON_ROAD
classes which (normally) do not drive on normal roads
@ SVC_TAXI
vehicle is a taxi
@ SVC_PEDESTRIAN
pedestrian
const std::string DEFAULT_TAXITYPE_ID
const std::string DEFAULT_RAILTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
const std::set< std::string > DEFAULT_VTYPES
const std::string DEFAULT_VTYPE_ID
const std::string DEFAULT_CONTAINERTYPE_ID
const std::string DEFAULT_BIKETYPE_ID
@ SPLIT
The departure is triggered by a train split.
@ CONTAINER_TRIGGERED
The departure is container triggered.
@ TRIGGERED
The departure is person triggered.
@ SUMO_TAG_DELAY
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
@ SUMO_ATTR_NUMBER
@ SUMO_ATTR_DEPART
@ SUMO_ATTR_PROBS
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_VTYPES
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_ID
@ SUMO_ATTR_TIME
trigger: the time of the step
int getScalingQuota(double frac, int loaded)
Returns the number of instances of the current object that shall be emitted given the number of loade...
Definition: StdDefs.cpp:59
T MIN2(T a, T b)
Definition: StdDefs.h:76
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
Definition: StdDefs.h:58
T MAX2(T a, T b)
Definition: StdDefs.h:82
void addSchedule(const SUMOVehicleParameter &pars, const std::vector< SUMOVehicleParameter::Stop > *addStops=nullptr)
Network * getNetwork() const
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
virtual void initDevices()
void addStops(const bool ignoreStopErrors, MSRouteIterator *searchStart=nullptr, bool addRouteStops=true)
Adds stops to the built vehicle.
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
Definition: MSCFModel.h:264
A device which collects info on the vehicle trip (mainly on departure and arrival)
A road/street connecting two junctions.
Definition: MSEdge.h:77
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
Definition: MSEdge.cpp:1056
bool isTazConnector() const
Definition: MSEdge.h:288
void addWaiting(SUMOVehicle *vehicle) const
Adds a vehicle to the list of waiting vehicles.
Definition: MSEdge.cpp:1334
void removeWaiting(const SUMOVehicle *vehicle) const
Removes a vehicle from the list of waiting vehicles.
Definition: MSEdge.cpp:1343
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: MSEdge.cpp:1156
static bool gUseMesoSim
Definition: MSGlobals.h:103
@ BUILT
The vehicle was built, but has not yet departed.
@ ARRIVED
The vehicle arrived at his destination (is deleted)
@ DEPARTED
The vehicle has departed (was inserted into the network)
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
void informVehicleStateListener(const SUMOVehicle *const vehicle, VehicleState to, const std::string &info="")
Informs all added listeners about a vehicle's state change.
Definition: MSNet.cpp:1257
static SumoRNG * getParsingRNG()
get parsing RNG
const ConstMSEdgeVector & getEdges() const
Definition: MSRoute.h:124
static bool dictionary(const std::string &id, ConstMSRoutePtr route)
Adds a route to the dictionary.
Definition: MSRoute.cpp:109
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, ConstMSRoutePtr route, MSVehicleType *type, const bool ignoreStopErrors, const bool fromRouteFile=true, bool addRouteStops=true)
Builds a vehicle, increases the number of built vehicles.
int myTeleportsCollision
The number of teleports due to collision.
double myScale
The scaling factor (especially for inc-dua)
bool hasVType(const std::string &id) const
Asks for existence of a vehicle type.
bool addVType(MSVehicleType *vehType)
Adds a vehicle type.
void initVehicle(MSBaseVehicle *built, const bool ignoreStopErrors, bool addRouteStops)
void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime)
Sets the current state variables as loaded from the stream.
void removePending()
Removes a vehicle after it has ended.
std::set< std::string > myReplaceableDefaultVTypes
the default vehicle types which may still be replaced
void adaptIntermodalRouter(MSNet::MSIntermodalRouter &router) const
std::vector< SUMOVehicle * > myPendingRemovals
List of vehicles which are going to be removed.
int myLoadedVehNo
The number of build vehicles.
bool hasVTypeDistribution(const std::string &id) const
Asks for a vehicle type distribution.
void vehicleDeparted(const SUMOVehicle &v)
Informs this control about a vehicle's departure.
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false)
Deletes the vehicle.
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
void initDefaultTypes()
create default types
int myTeleportsYield
The number of teleports due to vehicles stuck on a minor road.
int myTeleportsWrongLane
The number of teleports due to vehicles stuck on the wrong lane.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
void clearState(const bool reinit)
Remove all vehicles before quick-loading state.
std::map< std::string, std::set< std::string > > myVTypeToDist
Inverse lookup from vehicle type to distributions it is a member of.
double myMinDeceleration
The minimum deceleration capability for all road vehicles in the network.
bool isPendingRemoval(SUMOVehicle *veh)
whether the given vehicle is scheduled for removal
double myMinDecelerationRail
The minimum deceleration capability for all rail vehicles in the network.
virtual ~MSVehicleControl()
Destructor.
void removeVType(const MSVehicleType *vehType)
int myEmergencyBrakingCount
The number of emergency stops.
int myStoppedVehicles
The number of stopped vehicles.
void registerOneWaiting()
increases the count of vehicles waiting for a transport to allow recognition of person / container re...
void unregisterOneWaiting()
decreases the count of vehicles waiting for a transport to allow recognition of person / container re...
virtual std::pair< double, double > getVehicleMeanSpeeds() const
get current absolute and relative mean vehicle speed in the network
bool checkVType(const std::string &id)
Checks whether the vehicle type (distribution) may be added.
int myCollisions
The number of collisions.
int myEmergencyStops
The number of emergency stops.
int getQuota(double frac=-1, int loaded=-1) const
Returns the number of instances of the current vehicle that shall be emitted considering that "frac" ...
MSVehicleControl()
Constructor.
double myMaxSpeedFactor
The maximum speed factor for all vehicles in the network.
int myDiscarded
The number of vehicles which were discarded while loading.
int myEndedVehNo
The number of removed vehicles.
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, SumoRNG *rng=nullptr, bool readOnly=false)
Returns the named vehicle type or a sample from the named distribution.
bool addVTypeDistribution(const std::string &id, RandomDistributor< MSVehicleType * > *vehTypeDistribution)
Adds a vehicle type distribution.
int myTeleportsJam
The number of teleports due to jam.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
void insertVTypeIDs(std::vector< std::string > &into) const
Inserts ids of all known vehicle types and vehicle type distributions to the given vector.
double myTotalDepartureDelay
The aggregated time vehicles had to wait for departure (in seconds)
VTypeDictType myVTypeDict
Dictionary of vehicle types.
const RandomDistributor< MSVehicleType * > * getVTypeDistribution(const std::string &typeDistID) const
return the vehicle type distribution with the given id
virtual int getHaltingVehicleNo() const
Returns the number of halting vehicles.
void scheduleVehicleRemoval(SUMOVehicle *veh, bool checkDuplicate=false)
Removes a vehicle after it has ended.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
double myTotalTravelTime
The aggregated time vehicles needed to aacomplish their route (in seconds)
std::vector< SUMOVehicle * > myPTVehicles
List of vehicles which belong to public transport.
int getTeleportCount() const
return the number of teleports (including collisions)
VTypeDistDictType myVTypeDistDict
A distribution of vehicle types (probability->vehicle type)
void handleTriggeredDepart(SUMOVehicle *v, bool add)
register / unregister depart-triggered vehicles with edges
void abortWaiting()
informes about all waiting vehicles (deletion in destructor)
void saveState(OutputDevice &out)
Saves the current state into the given stream.
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
const std::set< std::string > getVTypeDistributionMembership(const std::string &id) const
Return the distribution IDs the vehicle type is a member of.
int myRunningVehNo
The number of vehicles within the network (build and inserted but not removed)
VehicleDictType myVehicleDict
Dictionary of vehicles.
Abstract in-vehicle device.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
The car-following model and parameter.
Definition: MSVehicleType.h:63
static MSVehicleType * build(SUMOVTypeParameter &from)
Builds the microsim vehicle type described by the given parameter.
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:91
const MSCFModel & getCarFollowModel() const
Returns the vehicle type's car following model definition (const version)
double computeChosenSpeedDeviation(SumoRNG *rng, const double minDev=-1.) const
Computes and returns the speed deviation.
const std::string & getID() const
Returns the id.
Definition: Named.h:74
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:60
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:254
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
const std::vector< T > & getVals() const
Returns the members of the distribution.
virtual const MSVehicleType & getVehicleType() const =0
Returns the object's "vehicle" type.
virtual double getChosenSpeedFactor() const =0
virtual double getSpeed() const =0
Returns the object's current speed.
virtual bool isStopped() const =0
Returns whether the object is at a stop.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
virtual SUMOVehicleClass getVClass() const =0
Returns the object's access class.
virtual const MSEdge * getEdge() const =0
Returns the edge the object is currently at.
Structure representing possible vehicle parameter.
double width
This class' width.
double height
This class' height.
double length
The physical vehicle length.
long long int parametersSet
Information for the router which parameter were set.
Representation of a vehicle.
Definition: SUMOVehicle.h:62
virtual SUMOTime getDeparture() const =0
Returns this vehicle's real departure time.
virtual bool isOnRoad() const =0
Returns the information whether the vehicle is on a road (is simulated)
virtual bool isRemoteControlled() const =0
Returns the information whether the vehicle is fully controlled via TraCI.
virtual const MSRoute & getRoute() const =0
Returns the current route.
Structure representing possible vehicle parameter.
double departPos
(optional) The position the vehicle shall depart from
int departEdge
(optional) The initial edge within the route of the vehicle
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
std::string line
The vehicle's line (mainly for public transport)
Function-object for stable sorting of objects with numerical ids.
Definition: Named.h:39