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-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 /****************************************************************************/
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
34 #include <utils/common/SUMOTime.h>
36 #include "MSNet.h"
37 
38 
39 // ===========================================================================
40 // class declarations
41 // ===========================================================================
42 class SUMOVehicle;
44 class MSBaseVehicle;
45 class MSVehicle;
46 class MSRoute;
47 class MSVehicleType;
48 class OutputDevice;
49 class MSEdge;
50 
51 
52 // ===========================================================================
53 // class definitions
54 // ===========================================================================
71 public:
73  typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;
74 
75 public:
78 
79 
81  virtual ~MSVehicleControl();
82 
85 
98  virtual SUMOVehicle* buildVehicle(SUMOVehicleParameter* defs, const MSRoute* route,
99  MSVehicleType* type,
100  const bool ignoreStopErrors, const bool fromRouteFile = true);
102 
103 
104 
107 
121  virtual bool addVehicle(const std::string& id, SUMOVehicle* v);
122 
123 
132  SUMOVehicle* getVehicle(const std::string& id) const;
133 
134 
141  virtual void deleteVehicle(SUMOVehicle* v, bool discard = false);
142 
144  myLoadedVehNo++;
145  myEndedVehNo++;
146  myDiscarded++;
147  }
148 
160  void scheduleVehicleRemoval(SUMOVehicle* veh, bool checkDuplicate = false);
161 
162 
174  void removePending();
175 
176 
181  return myVehicleDict.begin();
182  }
183 
184 
189  return myVehicleDict.end();
190  }
192 
193 
194 
197 
205  void vehicleDeparted(const SUMOVehicle& v);
207 
208 
209 
212 
216  int getLoadedVehicleNo() const {
217  return myLoadedVehNo;
218  }
219 
220 
224  virtual int getHaltingVehicleNo() const;
225 
227  virtual std::pair<double, double> getVehicleMeanSpeeds() const;
228  double getVehicleMeanSpeed() const {
229  return getVehicleMeanSpeeds().first;
230  }
232  return getVehicleMeanSpeeds().second;
233  }
234 
238  int getEndedVehicleNo() const {
239  return myEndedVehNo;
240  }
241 
245  int getArrivedVehicleNo() const {
246  return myEndedVehNo - myDiscarded;
247  }
248 
252  int getDiscardedVehicleNo() const {
253  return myDiscarded;
254  }
255 
256 
260  int getRunningVehicleNo() const {
261  return myRunningVehNo;
262  }
263 
264 
268  int getDepartedVehicleNo() const {
270  }
271 
272 
280  int getQuota(double frac = -1, int loaded = -1) const;
281 
282 
287  int getActiveVehicleCount() const {
289  }
290 
291 
293  int getCollisionCount() const {
294  return myCollisions;
295  }
296 
299  return myTeleportsCollision;
300  }
301 
303  int getTeleportsJam() const {
304  return myTeleportsJam;
305  }
306 
308  int getTeleportsYield() const {
309  return myTeleportsYield;
310  }
311 
313  int getTeleportsWrongLane() const {
314  return myTeleportsWrongLane;
315  }
316 
318  int getTeleportCount() const;
319 
321  int getEmergencyStops() const {
322  return myEmergencyStops;
323  }
324 
327  return myStoppedVehicles;
328  }
329 
333  double getTotalDepartureDelay() const {
334  return myTotalDepartureDelay;
335  }
336 
337 
341  double getTotalTravelTime() const {
342  return myTotalTravelTime;
343  }
345 
346 
347 
350 
363  bool addVType(MSVehicleType* vehType);
364 
365  /*
366  * @param[in] vehType The vehicle type to remove
367  * @return Whether the vehicle type could be removed
368  */
369  void removeVType(const MSVehicleType* vehType);
370 
371 
385  bool addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*>* vehTypeDistribution);
386 
387 
395  bool hasVType(const std::string& id) const;
396 
397 
405  bool hasVTypeDistribution(const std::string& id) const;
406 
407 
412  MSVehicleType* getVType(const std::string& id = DEFAULT_VTYPE_ID, SumoRNG* rng = nullptr, bool readOnly = false);
413 
414 
418  void insertVTypeIDs(std::vector<std::string>& into) const;
419 
420 
424  const std::set<std::string> getVTypeDistributionMembership(const std::string& id) const;
425 
427  const RandomDistributor<MSVehicleType*>* getVTypeDistribution(const std::string& typeDistID) const;
428 
430 
435  }
436 
441  }
442 
444  void registerCollision(bool teleport) {
445  myCollisions++;
446  if (teleport) {
448  }
449  }
450 
453  myTeleportsJam++;
454  }
455 
459  }
460 
464  }
465 
469  }
470 
474  }
475 
479  }
480 
483 
486  void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime);
487 
490  void saveState(OutputDevice& out);
491 
493  void clearState(const bool reinit);
495 
497  void discountStateRemoved(int n) {
498  myRunningVehNo -= n;
499  myDiscarded += n;
500  myEndedVehNo += n;
501  }
502 
503 
506  void abortWaiting();
507 
509  double getMaxSpeedFactor() const {
510  return myMaxSpeedFactor;
511  }
512 
514  double getMinDeceleration() const {
515  return myMinDeceleration;
516  }
517 
519 
521  void setScale(double scale) {
522  myScale = scale;
523  }
524 
526  double getScale() const {
527  return myScale;
528  }
529 
530 private:
532  void initDefaultTypes();
533 
540  bool checkVType(const std::string& id);
541 
543  bool isPendingRemoval(SUMOVehicle* veh);
544 
545 protected:
546  void initVehicle(MSBaseVehicle* built, const bool ignoreStopErrors);
547 
548 private:
551 
554 
557 
560 
563 
566 
569 
572 
575 
578 
581 
585 
586 
589 
592 
596 
597 
598 protected:
601 
603  typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
607 
608 
609 private:
612 
614  typedef std::map< std::string, MSVehicleType* > VTypeDictType;
617 
619  typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
622 
624  std::map<std::string, std::set<std::string>> myVTypeToDist;
625 
627  std::set<std::string> myReplaceableDefaultVTypes;
628 
631 
633  double myScale;
634 
637 
640 
642  std::vector<SUMOVehicle*> myPTVehicles;
643 
645 #ifdef HAVE_FOX
647 #else
648  std::vector<SUMOVehicle*> myPendingRemovals;
649 #endif
650 
651 private:
653  MSVehicleControl(const MSVehicleControl& s) = delete;
654 
657 
658 
659 };
const std::string DEFAULT_VTYPE_ID
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:51
A road/street connecting two junctions.
Definition: MSEdge.h:77
The class responsible for building and deletion of 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 * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
std::map< std::string, SUMOVehicle * > VehicleDictType
Vehicle dictionary type.
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.
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 myLoadedVehNo
The number of build vehicles.
MSVehicleControl & operator=(const MSVehicleControl &s)=delete
invalidated assignment operator
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 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 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
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.
void initVehicle(MSBaseVehicle *built, const bool ignoreStopErrors)
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 ...
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
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)
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, const MSRoute *route, MSVehicleType *type, const bool ignoreStopErrors, const bool fromRouteFile=true)
Builds a vehicle, increases the number of built vehicles.
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:75
The car-following model and parameter.
Definition: MSVehicleType.h:62
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
Representation of a vehicle.
Definition: SUMOVehicle.h:60
Structure representing possible vehicle parameter.