Eclipse SUMO - Simulation of Urban MObility
MSVehicleControl.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/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#pragma once
23#include <config.h>
24
25#include <cmath>
26#include <string>
27#include <map>
28#include <set>
29#ifdef HAVE_FOX
32#endif
36#include "MSNet.h"
37
38
39// ===========================================================================
40// class declarations
41// ===========================================================================
42class SUMOVehicle;
44class MSBaseVehicle;
45class MSVehicle;
46class MSRoute;
47class MSVehicleType;
48class OutputDevice;
49class MSEdge;
50
51typedef std::shared_ptr<const MSRoute> ConstMSRoutePtr;
52
53
54// ===========================================================================
55// class definitions
56// ===========================================================================
73public:
75 typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;
76
77public:
80
81
83 virtual ~MSVehicleControl();
84
87
101 MSVehicleType* type,
102 const bool ignoreStopErrors, const bool fromRouteFile = true,
103 bool addRouteStops = true);
105
106
107
110
124 virtual bool addVehicle(const std::string& id, SUMOVehicle* v);
125
126
135 SUMOVehicle* getVehicle(const std::string& id) const;
136
137
144 virtual void deleteVehicle(SUMOVehicle* v, bool discard = false);
145
148 myEndedVehNo++;
149 myDiscarded++;
150 }
151
163 void scheduleVehicleRemoval(SUMOVehicle* veh, bool checkDuplicate = false);
164
165
177 void removePending();
178
179
184 return myVehicleDict.begin();
185 }
186
187
192 return myVehicleDict.end();
193 }
195
196
197
200
208 void vehicleDeparted(const SUMOVehicle& v);
210
211
212
215
219 int getLoadedVehicleNo() const {
220 return myLoadedVehNo;
221 }
222
223
227 virtual int getHaltingVehicleNo() const;
228
230 virtual std::pair<double, double> getVehicleMeanSpeeds() const;
231 double getVehicleMeanSpeed() const {
232 return getVehicleMeanSpeeds().first;
233 }
235 return getVehicleMeanSpeeds().second;
236 }
237
241 int getEndedVehicleNo() const {
242 return myEndedVehNo;
243 }
244
249 return myEndedVehNo - myDiscarded;
250 }
251
256 return myDiscarded;
257 }
258
259
264 return myRunningVehNo;
265 }
266
267
273 }
274
275
283 int getQuota(double frac = -1, int loaded = -1) const;
284
285
292 }
293
297 }
298
299
301 int getCollisionCount() const {
302 return myCollisions;
303 }
304
308 }
309
311 int getTeleportsJam() const {
312 return myTeleportsJam;
313 }
314
316 int getTeleportsYield() const {
317 return myTeleportsYield;
318 }
319
323 }
324
326 int getTeleportCount() const;
327
329 int getEmergencyStops() const {
330 return myEmergencyStops;
331 }
332
335 return myStoppedVehicles;
336 }
337
341 double getTotalDepartureDelay() const {
343 }
344
345
349 double getTotalTravelTime() const {
350 return myTotalTravelTime;
351 }
353
354
355
358
371 bool addVType(MSVehicleType* vehType);
372
373 /*
374 * @param[in] vehType The vehicle type to remove
375 * @return Whether the vehicle type could be removed
376 */
377 void removeVType(const MSVehicleType* vehType);
378
379
393 bool addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*>* vehTypeDistribution);
394
395
403 bool hasVType(const std::string& id) const;
404
405
413 bool hasVTypeDistribution(const std::string& id) const;
414
415
420 MSVehicleType* getVType(const std::string& id = DEFAULT_VTYPE_ID, SumoRNG* rng = nullptr, bool readOnly = false);
421
422
426 void insertVTypeIDs(std::vector<std::string>& into) const;
427
428
432 const std::set<std::string> getVTypeDistributionMembership(const std::string& id) const;
433
435 const RandomDistributor<MSVehicleType*>* getVTypeDistribution(const std::string& typeDistID) const;
436
438
443 }
444
449 }
450
452 void registerCollision(bool teleport) {
453 myCollisions++;
454 if (teleport) {
456 }
457 }
458
462 }
463
467 }
468
472 }
473
477 }
478
482 }
483
487 }
488
491
494 void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime);
495
498 void saveState(OutputDevice& out);
499
501 void clearState(const bool reinit);
503
506 myRunningVehNo -= n;
507 myDiscarded += n;
508 myEndedVehNo += n;
509 }
510
511
514 void abortWaiting();
515
517 double getMaxSpeedFactor() const {
518 return myMaxSpeedFactor;
519 }
520
522 double getMinDeceleration() const {
523 return myMinDeceleration;
524 }
525
527 double getMinDecelerationRail() const {
529 }
530
532
534 void setScale(double scale) {
535 myScale = scale;
536 }
537
539 double getScale() const {
540 return myScale;
541 }
542
543private:
545 void initDefaultTypes();
546
553 bool checkVType(const std::string& id);
554
556 bool isPendingRemoval(SUMOVehicle* veh);
557
558protected:
559 void initVehicle(MSBaseVehicle* built, const bool ignoreStopErrors, bool addRouteStops);
560
561private:
564
567
570
573
576
579
582
585
588
591
594
598
599
602
605
609
610
611protected:
614
616 typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
620
621
622private:
625
627 typedef std::map< std::string, MSVehicleType* > VTypeDictType;
630
632 typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
635
637 std::map<std::string, std::set<std::string>> myVTypeToDist;
638
640 std::set<std::string> myReplaceableDefaultVTypes;
641
644
646 double myScale;
647
650
655
657 std::vector<SUMOVehicle*> myPTVehicles;
658
660#ifdef HAVE_FOX
662#else
663 std::vector<SUMOVehicle*> myPendingRemovals;
664#endif
665
666private:
669
672
673
674};
std::shared_ptr< const MSRoute > ConstMSRoutePtr
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition: Route.h:32
const std::string DEFAULT_VTYPE_ID
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
A road/street connecting two junctions.
Definition: MSEdge.h:77
The class responsible for building and deletion of vehicles.
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.
std::map< std::string, SUMOVehicle * > VehicleDictType
Vehicle dictionary 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.
int getRunningVehicleNo() const
Returns the number of build and inserted, but not yet deleted vehicles.
double getScale() const
sets the demand scaling factor
void registerEmergencyStop()
register emergency stop
void removePending()
Removes a vehicle after it has ended.
std::set< std::string > myReplaceableDefaultVTypes
the default vehicle types which may still be replaced
double getTotalTravelTime() const
Returns the total travel time.
void adaptIntermodalRouter(MSNet::MSIntermodalRouter &router) const
void setScale(double scale)
sets the demand scaling factor
std::vector< SUMOVehicle * > myPendingRemovals
List of vehicles which are going to be removed.
int getTriggeredVehicleCount() const
return the number of vehicles that are waiting for a transportable or a join
int myLoadedVehNo
The number of build vehicles.
void registerTeleportYield()
register one non-collision-related teleport
void discountStateRemoved(int n)
discount vehicles that were removed during state loading
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.
int getLoadedVehicleNo() const
Returns the number of build vehicles.
double getMinDeceleration() const
return the minimum deceleration capability for all road vehicles that ever entered the network
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 getCollisionCount() const
return the number of collisions
int getTeleportsWrongLane() const
return the number of teleports due to vehicles stuck on the wrong lane
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.
int getStoppedVehiclesCount() const
return the number of vehicles that are currently stopped
double getVehicleMeanSpeed() const
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
int getTeleportsYield() const
return the number of teleports due to vehicles stuck on a minor road
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.
int getEmergencyStops() const
return the number of emergency stops
double myMinDeceleration
The minimum deceleration capability for all road vehicles in the network.
void registerTeleportJam()
register one non-collision-related teleport
void registerStopEnded()
register emergency stop
double getTotalDepartureDelay() const
Returns the total departure delay.
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 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...
int myWaitingForTransportable
the number of vehicles waiting for persons or containers contained in myWaiting which can only contin...
std::map< std::string, MSVehicleType * > VTypeDictType
Vehicle type dictionary type.
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 getDepartedVehicleNo() const
Returns the number of inserted vehicles.
int getArrivedVehicleNo() const
Returns the number of arrived vehicles.
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.
MSVehicleControl(const MSVehicleControl &s)=delete
invalidated copy constructor
bool addVTypeDistribution(const std::string &id, RandomDistributor< MSVehicleType * > *vehTypeDistribution)
Adds a vehicle type distribution.
int myTeleportsJam
The number of teleports due to jam.
int getActiveVehicleCount() const
Returns the number of build vehicles that have not been removed or need to wait for a passenger or a ...
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
MSVehicleControl & operator=(const MSVehicleControl &s)=delete
invalidated assignment operator
void insertVTypeIDs(std::vector< std::string > &into) const
Inserts ids of all known vehicle types and vehicle type distributions to the given vector.
int getTeleportsJam() const
return the number of teleports due to jamming
double myTotalDepartureDelay
The aggregated time vehicles had to wait for departure (in seconds)
int getEndedVehicleNo() const
Returns the number of removed vehicles.
VTypeDictType myVTypeDict
Dictionary of vehicle types.
double getMaxSpeedFactor() const
return the maximum speed factor for all vehicles that ever entered the network
double getMinDecelerationRail() const
return the minimum deceleration capability for all ral vehicles that ever entered the network
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.
int getTeleportsCollisions() const
return the number of collisions
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)
std::map< std::string, RandomDistributor< MSVehicleType * > * > VTypeDistDictType
Vehicle type distribution dictionary type.
void abortWaiting()
informes about all waiting vehicles (deletion in destructor)
void saveState(OutputDevice &out)
Saves the current state into the given stream.
double getVehicleMeanSpeedRelative() const
void registerTeleportWrongLane()
register one non-collision-related teleport
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)
void registerCollision(bool teleport)
registers one collision-related teleport
int getDiscardedVehicleNo() const
Returns the number of discarded vehicles.
void registerStopStarted()
register emergency stop
VehicleDictType myVehicleDict
Dictionary of vehicles.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
The car-following model and parameter.
Definition: MSVehicleType.h:63
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
Representation of a vehicle.
Definition: SUMOVehicle.h:62
Structure representing possible vehicle parameter.