Eclipse SUMO - Simulation of Urban MObility
MSInsertionControl.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-2020 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 /****************************************************************************/
21 // Inserts vehicles into the network when their departure time is reached
22 /****************************************************************************/
23 #pragma once
24 #include <config.h>
25 
26 #include <vector>
27 #include <map>
28 #include <string>
29 #include "MSNet.h"
30 #include "MSVehicleContainer.h"
31 
32 
33 // ===========================================================================
34 // class declarations
35 // ===========================================================================
36 class MSVehicle;
37 class MSVehicleControl;
39 
40 
41 // ===========================================================================
42 // class definitions
43 // ===========================================================================
60 public:
68  MSInsertionControl(MSVehicleControl& vc, SUMOTime maxDepartDelay, bool checkEdgesOnce, int maxVehicleNumber, SUMOTime randomDepartOffset);
69 
70 
73 
74 
91  int emitVehicles(SUMOTime time);
92 
93 
100  void add(SUMOVehicle* veh);
101 
102 
109  bool addFlow(SUMOVehicleParameter* const pars, int index = -1);
110 
111 
119  int getWaitingVehicleNo() const;
120 
121 
126  int getPendingFlowCount() const;
127 
129  void alreadyDeparted(SUMOVehicle* veh);
130 
132  void descheduleDeparture(const SUMOVehicle* veh);
133 
134 
136  void clearPendingVehicles(const std::string& route);
137 
138 
143  void determineCandidates(SUMOTime time);
144 
146  int getPendingEmits(const MSLane* lane);
147 
149 
152 
155  void saveState(OutputDevice& out);
156 
158  void clearState();
159 
161  std::mt19937* getFlowRNG() {
162  return &myFlowRNG;
163  }
164 
165 private:
180  int tryInsert(SUMOTime time, SUMOVehicle* veh,
181  MSVehicleContainer::VehicleVector& refusedEmits);
182 
183 
189  void checkCandidates(SUMOTime time, const bool preCheck);
190 
191 
192 
193 private:
196 
199 
202 
204  std::set<SUMOVehicle*> myEmitCandidates;
205 
207  std::set<const SUMOVehicle*> myAbortedEmits;
208 
212  struct Flow {
216  int index;
217  };
218 
220  std::vector<Flow> myFlows;
221 
223  std::set<std::string> myFlowIDs;
224 
227 
230 
233 
236 
238  std::map<const MSLane*, int> myPendingEmitsForLane;
239 
242 
243 private:
246 
249 
251  std::mt19937 myFlowRNG;
252 
253 };
long long int SUMOTime
Definition: SUMOTime.h:31
Inserts vehicles into the network when their departure time is reached.
std::vector< Flow > myFlows
Container for periodical vehicle parameters.
std::mt19937 myFlowRNG
A random number generator for probabilistic flows.
int getWaitingVehicleNo() const
Returns the number of waiting vehicles.
void clearPendingVehicles(const std::string &route)
clears out all pending vehicles from a route, "" for all routes
std::map< const MSLane *, int > myPendingEmitsForLane
the number of pending emits for each edge in the current time step
int tryInsert(SUMOTime time, SUMOVehicle *veh, MSVehicleContainer::VehicleVector &refusedEmits)
Tries to emit the vehicle.
bool myEagerInsertionCheck
Whether an edge on which a vehicle could not depart should be ignored in the same step.
int emitVehicles(SUMOTime time)
Emits vehicles that want to depart at the given time.
int getPendingEmits(const MSLane *lane)
return the number of pending emits for the given lane
bool addFlow(SUMOVehicleParameter *const pars, int index=-1)
Adds parameter for a vehicle flow for departure.
SUMOTime myPendingEmitsUpdateTime
Last time at which pending emits for each edge where counted.
std::mt19937 * getFlowRNG()
retrieve internal RNG
std::set< SUMOVehicle * > myEmitCandidates
Buffer for vehicles that may be inserted in the current step.
void alreadyDeparted(SUMOVehicle *veh)
stops trying to emit the given vehicle (because it already departed)
SUMOTime myMaxRandomDepartOffset
The maximum random offset to be added to vehicles departure times (non-negative)
MSVehicleContainer::VehicleVector myPendingEmits
Buffers for vehicles that could not be inserted.
MSInsertionControl(MSVehicleControl &vc, SUMOTime maxDepartDelay, bool checkEdgesOnce, int maxVehicleNumber, SUMOTime randomDepartOffset)
Constructor.
MSVehicleControl & myVehicleControl
The assigned vehicle control (needed for vehicle re-insertion and deletion)
void add(SUMOVehicle *veh)
Adds a single vehicle for departure.
void determineCandidates(SUMOTime time)
Checks for all vehicles whether they can be emitted.
void checkCandidates(SUMOTime time, const bool preCheck)
Adds all vehicles that should have been emitted earlier to the refuse container.
MSInsertionControl(const MSInsertionControl &)
Invalidated copy constructor.
int getPendingFlowCount() const
Returns the number of flows that are still active.
std::set< const SUMOVehicle * > myAbortedEmits
Set of vehicles which shall not be inserted anymore.
std::set< std::string > myFlowIDs
Cache for periodical vehicle ids for quicker checking.
void adaptIntermodalRouter(MSNet::MSIntermodalRouter &router) const
void clearState()
Remove all vehicles before quick-loading state.
MSInsertionControl & operator=(const MSInsertionControl &)
Invalidated assignment operator.
int myMaxVehicleNumber
Storage for maximum vehicle number.
void saveState(OutputDevice &out)
Saves the current state into the given stream.
SUMOTime myMaxDepartDelay
The maximum waiting time; vehicles waiting longer are deleted (-1: no deletion)
void descheduleDeparture(const SUMOVehicle *veh)
stops trying to emit the given vehicle (and delete it)
MSVehicleContainer myAllVeh
All loaded vehicles sorted by their departure time.
~MSInsertionControl()
Destructor.
SUMOTime computeRandomDepartOffset() const
compute (optional) random offset to the departure time
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
std::vector< SUMOVehicle * > VehicleVector
definition of a list of vehicles which have the same departure time
The class responsible for building and deletion of vehicles.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:60
Representation of a vehicle.
Definition: SUMOVehicle.h:58
Structure representing possible vehicle parameter.
Definition of vehicle flow with the current index for vehicle numbering.
int index
the running index
SUMOVehicleParameter * pars
The parameters.