Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
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-2024 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"
30#include "MSEventControl.h"
31#include "MSStop.h"
35#include <utils/common/Named.h>
41
42
43// ===========================================================================
44// member method definitions
45// ===========================================================================
47 myLoadedVehNo(0),
48 myRunningVehNo(0),
49 myEndedVehNo(0),
50 myDiscarded(0),
51 myCollisions(0),
52 myTeleportsCollision(0),
53 myTeleportsJam(0),
54 myTeleportsYield(0),
55 myTeleportsWrongLane(0),
56 myEmergencyStops(0),
57 myEmergencyBrakingCount(0),
58 myStoppedVehicles(0),
59 myTotalDepartureDelay(0),
60 myTotalTravelTime(0),
61 myWaitingForTransportable(0),
62 myMaxSpeedFactor(1),
63 myMinDeceleration(SUMOVTypeParameter::getDefaultDecel(SVC_IGNORING)),
64 myMinDecelerationRail(SUMOVTypeParameter::getDefaultDecel(SVC_RAIL)),
65 myPendingRemovals(MSGlobals::gNumSimThreads > 1) {
66
69 myKeepTime = string2time(OptionsCont::getOptions().getString("keep-after-arrival"));
70}
71
72
76
77
78void
109
110
113 ConstMSRoutePtr route, MSVehicleType* type,
114 const bool ignoreStopErrors, const VehicleDefinitionSource source, bool addRouteStops) {
116 initVehicle(built, ignoreStopErrors, addRouteStops, source);
117 return built;
118}
119
120
121void
122MSVehicleControl::initVehicle(MSBaseVehicle* built, const bool ignoreStopErrors, bool addRouteStops, const VehicleDefinitionSource source) {
124 try {
125 built->initDevices();
126 if (source != VehicleDefinitionSource::STATE) {
127 built->addStops(ignoreStopErrors, nullptr, addRouteStops);
128 }
129 } catch (ProcessError&) {
130 delete built;
131 throw;
132 }
134}
135
136
137void
139 assert(myRunningVehNo > 0);
140 if (!checkDuplicate || !isPendingRemoval(veh)) {
141 myPendingRemovals.push_back(veh);
142 }
143}
144
145
146bool
148#ifdef HAVE_FOX
149 return myPendingRemovals.contains(veh);
150#else
151 return std::find(myPendingRemovals.begin(), myPendingRemovals.end(), veh) == myPendingRemovals.end();
152#endif
153}
154
155
156void
158 OutputDevice* const tripinfoOut = OptionsCont::getOptions().isSet("tripinfo-output") ? &OutputDevice::getDeviceByOption("tripinfo-output") : nullptr;
159#ifdef HAVE_FOX
160 std::vector<SUMOVehicle*>& vehs = myPendingRemovals.getContainer();
161#else
162 std::vector<SUMOVehicle*>& vehs = myPendingRemovals;
163#endif
164 std::sort(vehs.begin(), vehs.end(), ComparatorNumericalIdLess());
165 for (SUMOVehicle* const veh : vehs) {
166 myTotalTravelTime += STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - veh->getDeparture());
169 // vehicle is equipped with tripinfo device (not all vehicles are)
170 const bool hasTripinfo = veh->getDevice(typeid(MSDevice_Tripinfo)) != nullptr;
171 for (MSVehicleDevice* const dev : veh->getDevices()) {
172 dev->generateOutput(hasTripinfo ? tripinfoOut : nullptr);
173 }
174 if (tripinfoOut != nullptr && hasTripinfo) {
175 // close tag after tripinfo (possibly including emissions from another device) have been written
176 tripinfoOut->closeTag();
177 }
178 if (myKeepTime == 0) {
179 deleteVehicle(veh);
180 } else {
182 }
183 }
184 vehs.clear();
185 if (tripinfoOut != nullptr) {
186 // there seem to be people who think reading an unfinished xml is a good idea ;-)
187 tripinfoOut->flush();
188 }
189#ifdef HAVE_FOX
190 myPendingRemovals.unlock();
191#endif
192}
193
194
195void
200
201void
214
215
216void
217MSVehicleControl::setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime) {
218 myRunningVehNo = runningVehNo;
219 myLoadedVehNo = loadedVehNo;
220 myEndedVehNo = endedVehNo;
221 myTotalDepartureDelay = totalDepartureDelay;
222 myTotalTravelTime = totalTravelTime;
223}
224
225
226void
234 // save vehicle types
235 for (const auto& item : myVTypeDict) {
236 if (myReplaceableDefaultVTypes.count(item.first) == 0) {
237 item.second->getParameter().write(out);
238 }
239 }
240 for (const auto& item : myVTypeDistDict) {
242 out.writeAttr(SUMO_ATTR_VTYPES, item.second->getVals());
243 out.writeAttr(SUMO_ATTR_PROBS, item.second->getProbs());
244 out.closeTag();
245 }
246 for (const auto& item : myVehicleDict) {
247 item.second->saveState(out);
248 }
249}
250
251
252void
254 for (const auto& item : myVehicleDict) {
255 delete item.second;
256 }
257 myVehicleDict.clear();
258 // delete vehicle type distributions
259 for (const auto& item : myVTypeDistDict) {
260 delete item.second;
261 }
262 myVTypeDistDict.clear();
263 // delete vehicle types
264 for (const auto& item : myVTypeDict) {
265 delete item.second;
266 }
267 myVTypeDict.clear();
268 myPendingRemovals.clear(); // could be leftovers from MSVehicleTransfer::checkInsertions (teleport beyond arrival)
269 if (reinit) {
271 }
272 myLoadedVehNo = 0;
273 myRunningVehNo = 0;
274 myEndedVehNo = 0;
275 myDiscarded = 0;
276 myCollisions = 0;
278 myTeleportsJam = 0;
286}
287
288
289bool
290MSVehicleControl::addVehicle(const std::string& id, SUMOVehicle* v) {
291 VehicleDictType::iterator it = myVehicleDict.find(id);
292 if (it == myVehicleDict.end()) {
293 // id not in myVehicleDict.
294 myVehicleDict[id] = v;
295 handleTriggeredDepart(v, true);
296 const SUMOVehicleParameter& pars = v->getParameter();
297 if (v->getVClass() != SVC_TAXI && pars.line != "" && pars.repetitionNumber < 0) {
298 myPTVehicles.push_back(v);
299 }
300 return true;
301 }
302 return false;
303}
304
305
306void
308 const SUMOVehicleParameter& pars = v->getParameter();
310 const MSEdge* const firstEdge = v->getRoute().getEdges()[pars.departEdge];
311 if (add) {
313 // position will be checked against person position later
314 static_cast<MSVehicle*>(v)->setTentativeLaneAndPosition(nullptr, v->getParameter().departPos);
315 }
316 if (firstEdge->isTazConnector()) {
317 for (MSEdge* out : firstEdge->getSuccessors()) {
318 out->addWaiting(v);
319 }
320 } else {
321 firstEdge->addWaiting(v);
322 }
324 } else {
325 if (firstEdge->isTazConnector()) {
326 for (MSEdge* out : firstEdge->getSuccessors()) {
327 out->removeWaiting(v);
328 }
329 } else {
330 firstEdge->removeWaiting(v);
331 }
333 }
334 }
335}
336
337
339MSVehicleControl::getVehicle(const std::string& id) const {
340 VehicleDictType::const_iterator it = myVehicleDict.find(id);
341 if (it == myVehicleDict.end()) {
342 return nullptr;
343 }
344 return it->second;
345}
346
347
348void
349MSVehicleControl::deleteVehicle(SUMOVehicle* veh, bool discard, bool wasKept) {
350 if (!wasKept) {
351 myEndedVehNo++;
352 if (discard) {
353 myDiscarded++;
354 }
355 }
356 if (veh != nullptr) {
357 myVehicleDict.erase(veh->getID());
358 }
359 auto ptVehIt = std::find(myPTVehicles.begin(), myPTVehicles.end(), veh);
360 if (ptVehIt != myPTVehicles.end()) {
361 myPTVehicles.erase(ptVehIt);
362 }
363 delete veh;
364}
365
366
367bool
368MSVehicleControl::checkVType(const std::string& id) {
369 if (myReplaceableDefaultVTypes.erase(id) > 0) {
370 delete myVTypeDict[id];
371 myVTypeDict.erase(myVTypeDict.find(id));
372 } else {
373 if (myVTypeDict.find(id) != myVTypeDict.end() || myVTypeDistDict.find(id) != myVTypeDistDict.end()) {
374 return false;
375 }
376 }
377 return true;
378}
379
380
381bool
383 if (checkVType(vehType->getID())) {
384 myVTypeDict[vehType->getID()] = vehType;
385 return true;
386 }
387 return false;
388}
389
390
391void
393 assert(vehType != nullptr);
394 assert(myVTypeDict.find(vehType->getID()) != myVTypeDict.end());
395 myVTypeDict.erase(vehType->getID());
396 if (myVTypeToDist.find(vehType->getID()) != myVTypeToDist.end()) {
397 myVTypeToDist.erase(vehType->getID());
398 }
399 delete vehType;
400}
401
402
403bool
405 if (checkVType(id)) {
406 myVTypeDistDict[id] = vehTypeDistribution;
407 std::vector<MSVehicleType*> vehTypes = vehTypeDistribution->getVals();
408 for (auto vehType : vehTypes) {
409 if (myVTypeToDist.find(vehType->getID()) != myVTypeToDist.end()) {
410 myVTypeToDist[vehType->getID()].insert(id);
411 } else {
412 myVTypeToDist[vehType->getID()] = { id };
413 }
414 }
415 return true;
416 }
417 return false;
418}
419
420
421bool
422MSVehicleControl::hasVType(const std::string& id) const {
423 return myVTypeDict.count(id) > 0 || myVTypeDistDict.count(id) > 0;
424}
425
426
427bool
428MSVehicleControl::hasVTypeDistribution(const std::string& id) const {
429 return myVTypeDistDict.count(id) > 0;
430}
431
432
434MSVehicleControl::getVType(const std::string& id, SumoRNG* rng, bool readOnly) {
435 VTypeDictType::iterator it = myVTypeDict.find(id);
436 if (it == myVTypeDict.end()) {
437 VTypeDistDictType::iterator it2 = myVTypeDistDict.find(id);
438 if (it2 == myVTypeDistDict.end()) {
439 return nullptr;
440 }
441 return it2->second->get(rng);
442 }
443 if (!readOnly && myReplaceableDefaultVTypes.erase(id) > 0) {
444 it->second->check();
445 }
446 return it->second;
447}
448
449
450void
451MSVehicleControl::insertVTypeIDs(std::vector<std::string>& into) const {
452 into.reserve(into.size() + myVTypeDict.size() + myVTypeDistDict.size());
453 for (VTypeDictType::const_iterator i = myVTypeDict.begin(); i != myVTypeDict.end(); ++i) {
454 into.push_back((*i).first);
455 }
456 for (VTypeDistDictType::const_iterator i = myVTypeDistDict.begin(); i != myVTypeDistDict.end(); ++i) {
457 into.push_back((*i).first);
458 }
459}
460
461
462const std::set<std::string>
464 std::map<std::string, std::set<std::string>>::const_iterator it = myVTypeToDist.find(id);
465 if (it == myVTypeToDist.end()) {
466 return std::set<std::string>();
467 }
468 return it->second;
469}
470
471
473MSVehicleControl::getVTypeDistribution(const std::string& typeDistID) const {
474 const auto it = myVTypeDistDict.find(typeDistID);
475 if (it != myVTypeDistDict.end()) {
476 return it->second;
477 }
478 return nullptr;
479}
480
481
482const std::vector<MSVehicleType*>
484 std::vector<MSVehicleType*> pedestrianTypes;
485 for (auto const& e : myVTypeDict)
486 if (e.second->getVehicleClass() == SUMOVehicleClass::SVC_PEDESTRIAN) {
487 pedestrianTypes.push_back(e.second);
488 }
489 return pedestrianTypes;
490}
491
492
493void
495 for (VehicleDictType::iterator i = myVehicleDict.begin(); i != myVehicleDict.end(); ++i) {
496 SUMOVehicle* veh = i->second;
497 std::string waitReason;
498 if (veh->isStoppedTriggered()) {
499 const MSStop& stop = veh->getNextStop();
500 if (stop.triggered) {
501 waitReason = "for a person that will never come";
502 } else if (stop.containerTriggered) {
503 waitReason = "for a container that will never come";
504 } else if (stop.joinTriggered) {
505 if (stop.pars.join != "") {
506 waitReason = "to be joined to vehicle '" + stop.pars.join + "'";
507 } else {
508 waitReason = "for a joining vehicle that will never come";
509 }
510 } else {
511 waitReason = "for an unknown trigger";
512 }
513 } else if (!veh->hasDeparted()) {
515 waitReason = "for a train from which to split";
517 waitReason = "at insertion for a person that will never come";
519 waitReason = "at insertion for a container that will never come";
520 } else {
521 waitReason = "for an unknown departure trigger";
522 }
523 } else {
524 waitReason = "for an unknown reason";
525 }
526 WRITE_WARNINGF(TL("Vehicle '%' aborted waiting %."), i->first, waitReason);
527 }
528}
529
530
531int
533 int result = 0;
534 for (MSVehicleControl::constVehIt it = loadedVehBegin(); it != loadedVehEnd(); ++it) {
535 const SUMOVehicle* veh = it->second;
536 if ((veh->isOnRoad() || veh->isRemoteControlled()) && veh->getSpeed() < SUMO_const_haltingSpeed) {
537 result++;
538 }
539 }
540 return result;
541}
542
543
544std::pair<double, double>
546 double speedSum = 0;
547 double relSpeedSum = 0;
548 int count = 0;
549 for (MSVehicleControl::constVehIt it = loadedVehBegin(); it != loadedVehEnd(); ++it) {
550 const SUMOVehicle* veh = it->second;
551 if ((veh->isOnRoad() || veh->isRemoteControlled()) && !veh->isStopped()) {
552 count++;
553 speedSum += veh->getSpeed();
554 relSpeedSum += veh->getEdge()->getSpeedLimit() > 0 ? veh->getSpeed() / veh->getEdge()->getSpeedLimit() : 0;
555 }
556 }
557 if (count > 0) {
558 return std::make_pair(speedSum / count, relSpeedSum / count);
559 } else {
560 return std::make_pair(-1, -1);
561 }
562}
563
564
565int
566MSVehicleControl::getQuota(double frac, int loaded) const {
567 frac = frac < 0 ? myScale : frac;
568 const int origLoaded = (loaded < 1
569 // the vehicle in question has already been loaded, hence the '-1'
570 ? frac > 1. ? (int)(myLoadedVehNo / frac) : myLoadedVehNo - 1
571 // given transportable number reflects only previously loaded
572 : frac > 1. ? (int)(loaded / frac) : loaded);
573 return getScalingQuota(frac, origLoaded);
574}
575
576
577int
581
582
583void
585 for (const SUMOVehicle* const veh : myPTVehicles) {
586 // add single vehicles with line attribute which are not part of a flow
587 ConstMSRoutePtr const route = MSRoute::dictionary(veh->getParameter().routeid);
588 router.getNetwork()->addSchedule(veh->getParameter(), route == nullptr ? nullptr : &route->getStops());
589 }
590}
591
592// ===========================================================================
593// MSVehicleControl::DeleteKeptVehicle method definitions
594// ===========================================================================
595
601
602/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:296
#define TL(string)
Definition MsgHandler.h:315
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition Route.h:32
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
#define STEPS2TIME(x)
Definition SUMOTime.h:55
#define STEPFLOOR(x)
Definition SUMOTime.h:58
#define SIMSTEP
Definition SUMOTime.h:61
const long long int VTYPEPARS_VEHICLECLASS_SET
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
@ 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_CONTAINER
@ 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_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:61
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.
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:1158
bool isTazConnector() const
Definition MSEdge.h:291
void addWaiting(SUMOVehicle *vehicle) const
Adds a vehicle to the list of waiting vehicles.
Definition MSEdge.cpp:1451
void removeWaiting(const SUMOVehicle *vehicle) const
Removes a vehicle from the list of waiting vehicles.
Definition MSEdge.cpp:1460
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition MSEdge.cpp:1258
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
static bool gUseMesoSim
Definition MSGlobals.h:106
@ 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:185
MSEventControl * getEndOfTimestepEvents()
Returns the event control for events executed at the end of a time step.
Definition MSNet.h:481
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:1273
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition MSNet.h:378
static SumoRNG * getParsingRNG()
get parsing RNG
const ConstMSEdgeVector & getEdges() const
Definition MSRoute.h:125
static bool dictionary(const std::string &id, ConstMSRoutePtr route)
Adds a route to the dictionary.
Definition MSRoute.cpp:109
bool triggered
whether an arriving person lets the vehicle continue
Definition MSStop.h:69
bool containerTriggered
whether an arriving container lets the vehicle continue
Definition MSStop.h:71
bool joinTriggered
whether coupling another vehicle (train) the vehicle continue
Definition MSStop.h:73
const SUMOVehicleParameter::Stop pars
The stop parameter.
Definition MSStop.h:65
SUMOTime execute(SUMOTime currentTime)
Executes the command.
void adaptIntermodalRouter(MSTransportableRouter &router) const
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.
const std::vector< MSVehicleType * > getPedestrianTypes(void) const
Return all pedestrian vehicle types.
bool addVType(MSVehicleType *vehType)
Adds a vehicle type.
void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime)
Sets the current state variables as loaded from the stream.
VehicleDefinitionSource
possible origins of a vehicle definition
void removePending()
Removes a vehicle after it has ended.
void initVehicle(MSBaseVehicle *built, const bool ignoreStopErrors, bool addRouteStops, const VehicleDefinitionSource source)
std::set< std::string > myReplaceableDefaultVTypes
the default vehicle types which may still be replaced
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 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 deleteKeptVehicle(SUMOVehicle *veh)
when a vehicle is kept after arrival, schedule later deletion
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.
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, ConstMSRoutePtr route, MSVehicleType *type, const bool ignoreStopErrors, const VehicleDefinitionSource source=ROUTEFILE, bool addRouteStops=true)
Builds a vehicle, increases the number of built vehicles.
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.
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false, bool wasKept=false)
Deletes the vehicle.
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.
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.
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.
void check()
Checks whether vehicle type parameters may be problematic (Currently, only the value for the action s...
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.
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.
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.
Represents a generic random distribution.
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 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 bool isStopped() const =0
Returns whether the vehicle is at a stop and waiting for a person or container to continue.
virtual SUMOTime getDeparture() const =0
Returns this vehicle's real departure time.
virtual bool hasDeparted() const =0
Returns whether this vehicle has departed.
virtual bool isStoppedTriggered() const =0
Returns whether the vehicle is at a stop and waiting for a person or container to continue.
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 MSStop & getNextStop()=0
virtual const MSRoute & getRoute() const =0
Returns the current route.
std::string join
the id of the vehicle (train portion) to which this vehicle shall be joined
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