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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
17 // The class responsible for building and deletion of vehicles
18 /****************************************************************************/
19 #ifndef MSVehicleControl_h
20 #define MSVehicleControl_h
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 #include <cmath>
29 #include <string>
30 #include <map>
31 #include <set>
32 #ifdef HAVE_FOX
33 #include <fx.h>
35 #endif
37 #include <utils/common/SUMOTime.h>
39 #include "MSNet.h"
40 
41 
42 // ===========================================================================
43 // class declarations
44 // ===========================================================================
45 class SUMOVehicle;
47 class MSVehicle;
48 class MSRoute;
49 class MSVehicleType;
50 class OutputDevice;
51 class MSEdge;
52 
53 
54 // ===========================================================================
55 // class definitions
56 // ===========================================================================
73 public:
75  typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;
76 
77 public:
80 
81 
83  virtual ~MSVehicleControl();
84 
85 
88 
101  virtual SUMOVehicle* buildVehicle(SUMOVehicleParameter* defs, const MSRoute* route,
102  MSVehicleType* type,
103  const bool ignoreStopErrors, const bool fromRouteFile = 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 
146 
158  void scheduleVehicleRemoval(SUMOVehicle* veh, bool checkDuplicate = false);
159 
160 
172  void removePending();
173 
174 
178  constVehIt loadedVehBegin() const {
179  return myVehicleDict.begin();
180  }
181 
182 
186  constVehIt loadedVehEnd() const {
187  return myVehicleDict.end();
188  }
190 
191 
192 
195 
203  void vehicleDeparted(const SUMOVehicle& v);
205 
206 
207 
210 
214  int getLoadedVehicleNo() const {
215  return myLoadedVehNo;
216  }
217 
218 
222  virtual int getHaltingVehicleNo() const;
223 
225  virtual std::pair<double, double> getVehicleMeanSpeeds() const;
226  double getVehicleMeanSpeed() const {
227  return getVehicleMeanSpeeds().first;
228  }
230  return getVehicleMeanSpeeds().second;
231  }
232 
236  int getEndedVehicleNo() const {
237  return myEndedVehNo;
238  }
239 
243  int getArrivedVehicleNo() const {
244  return myEndedVehNo - myDiscarded;
245  }
246 
250  int getDiscardedVehicleNo() const {
251  return myDiscarded;
252  }
253 
254 
258  int getRunningVehicleNo() const {
259  return myRunningVehNo;
260  }
261 
262 
266  int getDepartedVehicleNo() const {
268  }
269 
270 
277  int getQuota(double frac = -1) const;
278 
279 
284  int getActiveVehicleCount() const {
286  }
287 
288 
290  int getCollisionCount() const {
291  return myCollisions;
292  }
293 
295  int getTeleportsJam() const {
296  return myTeleportsJam;
297  }
298 
300  int getTeleportsYield() const {
301  return myTeleportsYield;
302  }
303 
305  int getTeleportsWrongLane() const {
306  return myTeleportsWrongLane;
307  }
308 
310  int getTeleportCount() const;
311 
313  int getEmergencyStops() const {
314  return myEmergencyStops;
315  }
316 
320  double getTotalDepartureDelay() const {
321  return myTotalDepartureDelay;
322  }
323 
324 
328  double getTotalTravelTime() const {
329  return myTotalTravelTime;
330  }
332 
333 
334 
337 
350  bool addVType(MSVehicleType* vehType);
351 
352  /*
353  * @param[in] vehType The vehicle type to remove
354  * @return Whether the vehicle type could be removed
355  */
356  void removeVType(const MSVehicleType* vehType);
357 
358 
372  bool addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*>* vehTypeDistribution);
373 
374 
382  bool hasVType(const std::string& id) const;
383 
384 
392  bool hasVTypeDistribution(const std::string& id) const;
393 
394 
399  MSVehicleType* getVType(const std::string& id = DEFAULT_VTYPE_ID, std::mt19937* rng = nullptr);
400 
401 
405  void insertVTypeIDs(std::vector<std::string>& into) const;
406 
407 
411  const std::set<std::string> getVTypeDistributionMembership(const std::string& id) const;
412 
414 
416  void addWaiting(const MSEdge* const edge, SUMOVehicle* vehicle);
417 
419  void removeWaiting(const MSEdge* const edge, const SUMOVehicle* vehicle);
420 
421  /* @brief returns a vehicle of the given lines that is waiting for a for a person or a container at this edge at the given positions
422  * @param[in] edge The edge at which the vehicle is positioned.
423  * @param[in] lines The set of lines from which at least one must correspond to the line of the vehicle
424  * @param[in] position The vehicle shall be positioned in the interval [position - t, position + t], where t is some tolerance
425  * @param[in] ridingID The id of the person or container that wants to ride
426  */
427  SUMOVehicle* getWaitingVehicle(MSTransportable* transportable, const MSEdge* const edge, const double position);
428 
431  void registerOneWaiting(const bool isPerson) {
432  if (isPerson) {
434  } else {
436  }
437  }
438 
441  void unregisterOneWaiting(const bool isPerson) {
442  if (isPerson) {
444  } else {
446  }
447  }
448 
451  myCollisions++;
452  }
453 
456  myTeleportsJam++;
457  }
458 
462  }
463 
467  }
468 
472  }
473 
476 
479  void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime);
480 
483  void saveState(OutputDevice& out);
485 
487  void discountStateLoaded(bool removed = false) {
488  if (removed) {
489  myRunningVehNo--;
490  myDiscarded++;
491  myEndedVehNo++;
492  } else {
493  myLoadedVehNo--;
494  }
495  }
496 
497 
500  void abortWaiting();
501 
503  double getMaxSpeedFactor() const {
504  return myMaxSpeedFactor;
505  }
506 
508  double getMinDeceleration() const {
509  return myMinDeceleration;
510  }
511 
513 
515  void setScale(double scale) {
516  myScale = scale;
517  }
518 
519 private:
526  bool checkVType(const std::string& id);
527 
528 protected:
531 
534 
535 private:
538 
541 
544 
547 
550 
553 
556 
559 
561 
562 
565 
568 
572 
573 
574 protected:
577 
579  typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
581  VehicleDictType myVehicleDict;
583 
584 
585 private:
588 
590  typedef std::map< std::string, MSVehicleType* > VTypeDictType;
592  VTypeDictType myVTypeDict;
593 
595  typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
597  VTypeDistDictType myVTypeDistDict;
598 
600  std::map<std::string, std::set<std::string>> myVTypeToDist;
601 
604 
607 
610 
612  std::map<const MSEdge* const, std::vector<SUMOVehicle*> > myWaiting;
613 
616 
619 
621  double myScale;
622 
625 
628 
630  std::vector<SUMOVehicle*> myPTVehicles;
631 
634 
636 #ifdef HAVE_FOX
638 #else
639  std::vector<SUMOVehicle*> myPendingRemovals;
640 #endif
641 
642 private:
645 
648 
649 
650 };
651 
652 
653 #endif
654 
655 /****************************************************************************/
656 
bool myDefaultPedTypeMayBeDeleted
Whether the default pedestrian type was already used or can still be replaced.
bool checkVType(const std::string &id)
Checks whether the vehicle type (distribution) may be added.
void discountStateLoaded(bool removed=false)
avoid counting a vehicle twice if it was loaded from state and route input
void addWaiting(const MSEdge *const edge, SUMOVehicle *vehicle)
Adds a vehicle to the list of waiting vehicles for the given edge.
int getEndedVehicleNo() const
Returns the number of removed vehicles.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:80
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false)
Deletes the vehicle.
int myTeleportsWrongLane
The number of teleports due to vehicles stuck on the wrong lane.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
int getArrivedVehicleNo() const
Returns the number of arrived vehicles.
int myEndedVehNo
The number of removed vehicles.
int getRunningVehicleNo() const
Returns the number of build and inserted, but not yet deleted vehicles.
double getMaxSpeedFactor() const
return the maximum speed factor for all vehicles that ever entered the network
int getLoadedVehicleNo() const
Returns the number of build vehicles.
Represents a generic random distribution.
int myDiscarded
The number of vehicles which were discarded while loading.
void registerTeleportYield()
register one non-collision-related teleport
std::map< const MSEdge *const, std::vector< SUMOVehicle * > > myWaiting
the lists of waiting vehicles to a given edge
bool hasVTypeDistribution(const std::string &id) const
Asks for a vehicle type distribution.
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, std::mt19937 *rng=nullptr)
Returns the named vehicle type or a sample from the named distribution.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
int getQuota(double frac=-1) const
Returns the number of instances of the current vehicle that shall be emitted considering that "frac" ...
MSVehicleControl()
Constructor.
const std::set< std::string > getVTypeDistributionMembership(const std::string &id) const
Return the distribution IDs the vehicle type is a member of.
void registerEmergencyStop()
register emergency stop
VehicleDictType myVehicleDict
Dictionary of vehicles.
int getActiveVehicleCount() const
Returns the number of build vehicles that have not been removed or need to wait for a passenger or a ...
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
VTypeDictType myVTypeDict
Dictionary of vehicle types.
int myTeleportsJam
The number of teleports due to jam.
bool myDefaultVTypeMayBeDeleted
Whether the default vehicle type was already used or can still be replaced.
bool hasVType(const std::string &id) const
Asks for existence of a vehicle type.
double myMaxSpeedFactor
The maximum speed factor for all vehicles in the network.
const std::string DEFAULT_VTYPE_ID
void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime)
Sets the current state variables as loaded from the stream.
The car-following model and parameter.
Definition: MSVehicleType.h:66
virtual std::pair< double, double > getVehicleMeanSpeeds() const
get current absolute and relative mean vehicle speed in the network
A road/street connecting two junctions.
Definition: MSEdge.h:76
std::map< std::string, MSVehicleType *> VTypeDictType
Vehicle type dictionary type.
double getTotalDepartureDelay() const
Returns the total departure delay.
std::vector< SUMOVehicle * > myPendingRemovals
List of vehicles which are going to be removed.
void adaptIntermodalRouter(MSNet::MSIntermodalRouter &router) const
Representation of a vehicle.
Definition: SUMOVehicle.h:61
int getTeleportsYield() const
return the number of teleports due to vehicles stuck on a minor road
void registerOneWaiting(const bool isPerson)
increases the count of vehicles waiting for a transport to allow recognition of person / container re...
double getMinDeceleration() const
return the minimum deceleration capability for all vehicles that ever entered the network ...
std::map< std::string, RandomDistributor< MSVehicleType * > *> VTypeDistDictType
Vehicle type distribution dictionary type.
void removeVType(const MSVehicleType *vehType)
double myTotalTravelTime
The aggregated time vehicles needed to aacomplish their route (in seconds)
int getEmergencyStops() const
return the number of emergency stops
int myLoadedVehNo
The number of build vehicles.
double myStopTolerance
The tolerance to apply when matching waiting persons and vehicles.
int myEmergencyStops
The number of emergency stops.
void saveState(OutputDevice &out)
Saves the current state into the given stream.
int getTeleportsJam() const
return the number of teleports due to jamming
double getVehicleMeanSpeedRelative() const
double getTotalTravelTime() const
Returns the total travel time.
int myRunningVehNo
The number of vehicles within the network (build and inserted but not removed)
void registerTeleportJam()
register one non-collision-related teleport
int myWaitingForContainer
the number of vehicles wainting for containers contained in myWaiting which can only continue by bein...
void insertVTypeIDs(std::vector< std::string > &into) const
Inserts ids of all known vehicle types and vehicle type distributions to the given vector...
int getTeleportsWrongLane() const
return the number of teleports due to vehicles stuck on the wrong lane
void abortWaiting()
informes about all waiting vehicles (deletion in destructor)
int myWaitingForPerson
the number of vehicles wainting for persons contained in myWaiting which can only continue by being t...
MSVehicleControl & operator=(const MSVehicleControl &s)
invalidated assignment operator
bool addVType(MSVehicleType *vehType)
Adds a vehicle type.
double myTotalDepartureDelay
The aggregated time vehicles had to wait for departure (in seconds)
Structure representing possible vehicle parameter.
SUMOVehicle * getWaitingVehicle(MSTransportable *transportable, const MSEdge *const edge, const double position)
std::map< std::string, std::set< std::string > > myVTypeToDist
Inverse lookup from vehicle type to distributions it is a member of.
VTypeDistDictType myVTypeDistDict
A distribution of vehicle types (probability->vehicle type)
virtual int getHaltingVehicleNo() const
Returns the number of halting vehicles.
int myCollisions
The number of collisions.
void setScale(double scale)
sets the demand scaling factor
void removePending()
Removes a vehicle after it has ended.
virtual ~MSVehicleControl()
Destructor.
bool addVTypeDistribution(const std::string &id, RandomDistributor< MSVehicleType *> *vehTypeDistribution)
Adds a vehicle type distribution.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
std::map< std::string, SUMOVehicle *> VehicleDictType
Vehicle dictionary type.
void registerCollision()
registers one collision-related teleport
void vehicleDeparted(const SUMOVehicle &v)
Informs this control about a vehicle&#39;s departure.
The class responsible for building and deletion of vehicles.
double myScale
The scaling factor (especially for inc-dua)
double myMinDeceleration
The minimum deceleration capability for all vehicles in the network.
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.
int getDepartedVehicleNo() const
Returns the number of inserted vehicles.
int myTeleportsYield
The number of teleports due to vehicles stuck on a minor road.
int getDiscardedVehicleNo() const
Returns the number of discarded vehicles.
void registerTeleportWrongLane()
register one non-collision-related teleport
int getCollisionCount() const
return the number of collisions
int getTeleportCount() const
return the number of teleports (including collisions)
void scheduleVehicleRemoval(SUMOVehicle *veh, bool checkDuplicate=false)
Removes a vehicle after it has ended.
void unregisterOneWaiting(const bool isPerson)
decreases the count of vehicles waiting for a transport to allow recognition of person / container re...
bool myDefaultBikeTypeMayBeDeleted
Whether the default bicycle type was already used or can still be replaced.
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
void removeWaiting(const MSEdge *const edge, const SUMOVehicle *vehicle)
Removes a vehicle from the list of waiting vehicles for the given edge.
double getVehicleMeanSpeed() const
std::vector< SUMOVehicle * > myPTVehicles
List of vehicles which belong to public transport.