Eclipse SUMO - Simulation of Urban MObility
MSDevice_Taxi.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2013-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 /****************************************************************************/
18 // A device which controls a taxi
19 /****************************************************************************/
20 #pragma once
21 #include <config.h>
22 
23 #include <utils/common/SUMOTime.h>
25 #include "MSVehicleDevice.h"
26 
27 
28 // ===========================================================================
29 // class declarations
30 // ===========================================================================
31 class SUMOTrafficObject;
32 class MSDispatch;
33 class MSIdling;
34 struct Reservation;
35 
36 
37 // ===========================================================================
38 // class definitions
39 // ===========================================================================
49 public:
50 
51  enum TaxiState {
52  EMPTY = 0, // empty (available for servicing customers)
53  PICKUP = 1, // driving to pick up customer
54  OCCUPIED = 2 // occupied with customer
55  };
56 
60  static void insertOptions(OptionsCont& oc);
61 
62 
73  static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
74 
76  static bool isReservation(const std::set<std::string>& lines);
77 
79  static void addReservation(MSTransportable* person,
80  const std::set<std::string>& lines,
81  SUMOTime reservationTime,
82  SUMOTime pickupTime,
83  const MSEdge* from, double fromPos,
84  const MSEdge* to, double toPos,
85  const std::string& group);
86 
88  static void removeReservation(MSTransportable* person,
89  const std::set<std::string>& lines,
90  const MSEdge* from, double fromPos,
91  const MSEdge* to, double toPos,
92  const std::string& group);
93 
95  static SUMOTime triggerDispatch(SUMOTime currentTime);
96 
98  static bool hasServableReservations();
99 
101  static void cleanup();
102 
104  return myDispatcher;
105  }
106 
107  static const std::vector<MSDevice_Taxi*>& getFleet() {
108  return myFleet;
109  }
110 
111 public:
113  ~MSDevice_Taxi();
114 
117 
127  bool notifyMove(SUMOTrafficObject& veh, double oldPos,
128  double newPos, double newSpeed);
129 
130 
139  bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
140 
141 
150  bool notifyLeave(SUMOTrafficObject& veh, double lastPos,
151  MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
153 
154 
156  const std::string deviceName() const {
157  return "taxi";
158  }
159 
161  bool isEmpty();
162 
163  int getState() const {
164  return myState;
165  }
166 
168  static SUMOVehicle* getTaxi();
169 
171  void dispatch(const Reservation& res);
172 
174  void dispatchShared(std::vector<const Reservation*> reservations);
175 
177  bool allowsBoarding(MSTransportable* t) const;
178 
180  void customerEntered(const MSTransportable* t);
181 
183  void customerArrived(const MSTransportable* person);
184 
186  std::string getParameter(const std::string& key) const;
187 
189  void setParameter(const std::string& key, const std::string& value);
190 
197  void generateOutput(OutputDevice* tripinfoOut) const;
198 
200  bool compatibleLine(const Reservation* res);
201 
202  static bool compatibleLine(const std::string& taxiLine, const std::string& rideLine);
203 
204 private:
210  MSDevice_Taxi(SUMOVehicle& holder, const std::string& id);
211 
213  void prepareStop(ConstMSEdgeVector& edges,
214  std::vector<SUMOVehicleParameter::Stop>& stops,
215  double& lastPos, const MSEdge* stopEdge, double stopPos,
216  const std::string& action);
217 
219  MSLane* getStopLane(const MSEdge* edge, const std::string& action);
220 
222  bool hasFuturePickup();
223 
225  static void initDispatch();
226 
227 private:
228 
229  int myState = EMPTY;
233  double myOccupiedDistance = 0;
239  bool myIsStopped = false;
241  std::set<const MSTransportable*> myCustomers;
242 
245 
247  std::set<const Reservation*> myCurrentReservations;
248 
255  // @brief the list of available taxis
256  static std::vector<MSDevice_Taxi*> myFleet;
257  // @brief the maximum personCapacity in the fleet
258  static int myMaxCapacity;
259  // @brief the maximum container capacity in the fleet
261 
262 private:
265 
268 
269 
270 };
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:74
#define SUMOTime_MAX
Definition: SUMOTime.h:33
long long int SUMOTime
Definition: SUMOTime.h:32
Base (microsim) event class.
Definition: Command.h:50
A device which collects info on the vehicle trip (mainly on departure and arrival)
Definition: MSDevice_Taxi.h:48
static void initDispatch()
initialize the dispatch algorithm
static Command * myDispatchCommand
The repeated call to the dispatcher.
void customerArrived(const MSTransportable *person)
called by MSDevice_Transportable upon unloading a person
bool notifyLeave(SUMOTrafficObject &veh, double lastPos, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Saves arrival info.
static SUMOTime triggerDispatch(SUMOTime currentTime)
period command to trigger the dispatch algorithm
void dispatch(const Reservation &res)
service the given reservation
std::set< const MSTransportable * > myCustomers
the customer of the current reservation
SUMOTime myServiceEnd
the time at which the taxi service ends (end the vehicle may leave the simulation)
void generateOutput(OutputDevice *tripinfoOut) const
Called on writing tripinfo output.
static int myMaxCapacity
void dispatchShared(std::vector< const Reservation * > reservations)
service the given reservations
MSIdling * myIdleAlgorithm
algorithm for controlling idle behavior
std::set< const Reservation * > myCurrentReservations
reservations currently being served
bool notifyMove(SUMOTrafficObject &veh, double oldPos, double newPos, double newSpeed)
Checks for waiting steps when the vehicle moves.
MSDevice_Taxi & operator=(const MSDevice_Taxi &)
Invalidated assignment operator.
static const std::vector< MSDevice_Taxi * > & getFleet()
bool hasFuturePickup()
whether the taxi has another pickup scheduled
bool allowsBoarding(MSTransportable *t) const
whether the given person is allowed to board this taxi
static MSDispatch * myDispatcher
the dispatch algorithm
int myCustomersServed
number of customers that were served
static int myMaxContainerCapacity
bool isEmpty()
whether the taxi is empty
const std::string deviceName() const
return the name for this type of device
static std::vector< MSDevice_Taxi * > myFleet
static void removeReservation(MSTransportable *person, const std::set< std::string > &lines, const MSEdge *from, double fromPos, const MSEdge *to, double toPos, const std::string &group)
retract reservation
int getState() const
static SUMOTime myDispatchPeriod
the time between successive calls to the dispatcher
bool notifyEnter(SUMOTrafficObject &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Saves departure info on insertion.
static void cleanup()
resets counters
static bool isReservation(const std::set< std::string > &lines)
whether the given lines description is a taxi call
double myOccupiedDistance
distance driven with customers
MSDevice_Taxi(SUMOVehicle &holder, const std::string &id)
Constructor.
static void addReservation(MSTransportable *person, const std::set< std::string > &lines, SUMOTime reservationTime, SUMOTime pickupTime, const MSEdge *from, double fromPos, const MSEdge *to, double toPos, const std::string &group)
add new reservation
static bool hasServableReservations()
check whether there are still (servable) reservations in the system
void prepareStop(ConstMSEdgeVector &edges, std::vector< SUMOVehicleParameter::Stop > &stops, double &lastPos, const MSEdge *stopEdge, double stopPos, const std::string &action)
prepare stop for the given action
static SUMOVehicle * getTaxi()
returns a taxi if any exist or nullptr
void customerEntered(const MSTransportable *t)
called by MSDevice_Transportable upon loading a person
MSDevice_Taxi(const MSDevice_Taxi &)
Invalidated copy constructor.
bool compatibleLine(const Reservation *res)
whether the given reservation is compatible with the taxi line
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into)
Build devices for the given vehicle, if needed.
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_Taxi-options.
bool myIsStopped
whether the vehicle is currently stopped
void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this device. Throw exception for unsupported key
SUMOTime myOccupiedTime
time spent driving with customers
static MSDispatch * getDispatchAlgorithm()
~MSDevice_Taxi()
Destructor.
MSLane * getStopLane(const MSEdge *edge, const std::string &action)
determine stopping lane for taxi
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key
An algorithm that performs distpach for a taxi fleet.
Definition: MSDispatch.h:102
A road/street connecting two junctions.
Definition: MSEdge.h:77
An algorithm that performs distpach for a taxi fleet.
Definition: MSIdling.h:42
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
Notification
Definition of a vehicle state.
Abstract in-vehicle device.
A storage for options typed value containers)
Definition: OptionsCont.h:89
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
Representation of a vehicle, person, or container.
Representation of a vehicle.
Definition: SUMOVehicle.h:60