Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
MSDevice_Taxi.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2013-2024 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
25#include "MSVehicleDevice.h"
26
27
28// ===========================================================================
29// class declarations
30// ===========================================================================
32class MSDispatch;
33class MSIdling;
35struct Reservation;
36
37
38// ===========================================================================
39// class definitions
40// ===========================================================================
50public:
51
52 enum TaxiState {
53 EMPTY = 0, // empty (available for servicing customers)
54 PICKUP = 1, // driving to pick up customer
55 OCCUPIED = 2 // occupied with customer
56 };
57
61 static void insertOptions(OptionsCont& oc);
62
63
74 static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
75
77 static bool isReservation(const std::set<std::string>& lines);
78
80 static void addReservation(MSTransportable* person,
81 const std::set<std::string>& lines,
82 SUMOTime reservationTime,
83 SUMOTime pickupTime,
84 SUMOTime earliestPickupTime,
85 const MSEdge* from, double fromPos,
86 const MSStoppingPlace* fromStop,
87 const MSEdge* to, double toPos,
88 const MSStoppingPlace* toStop,
89 const std::string& group);
90
92 static void removeReservation(MSTransportable* person,
93 const std::set<std::string>& lines,
94 const MSEdge* from, double fromPos,
95 const MSEdge* to, double toPos,
96 const std::string& group);
97
99 static void updateReservationFromPos(MSTransportable* person,
100 const std::set<std::string>& lines,
101 const MSEdge* from, double fromPos,
102 const MSEdge* to, double toPos,
103 const std::string& group, double newFromPos);
104
106 static SUMOTime triggerDispatch(SUMOTime currentTime);
107
109 static bool hasServableReservations();
110
112 static void cleanup();
113
115 return myDispatcher;
116 }
117
118 static const std::vector<MSDevice_Taxi*>& getFleet() {
119 return myFleet;
120 }
121
122public:
125
128
138 bool notifyMove(SUMOTrafficObject& veh, double oldPos,
139 double newPos, double newSpeed);
140
141
150 bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
152
153
155 const std::string deviceName() const {
156 return "taxi";
157 }
158
160 bool isEmpty();
161
162 int getState() const {
163 return myState;
164 }
165
167 static SUMOVehicle* getTaxi();
168
170 void dispatch(const Reservation& res);
171
173 void dispatchShared(std::vector<const Reservation*> reservations);
174
177
179 bool cancelCustomer(const MSTransportable* t);
180
182 bool allowsBoarding(const MSTransportable* t) const;
183
185 void customerEntered(const MSTransportable* t);
186
188 void customerArrived(const MSTransportable* person);
189
191 std::string getParameter(const std::string& key) const;
192
194 void setParameter(const std::string& key, const std::string& value);
195
202 void generateOutput(OutputDevice* tripinfoOut) const;
203
205 bool compatibleLine(const Reservation* res);
206
207 static bool compatibleLine(const std::string& taxiLine, const std::string& rideLine);
208
209protected:
214 const double frontOnLane,
215 const double timeOnLane,
216 const double meanSpeedFrontOnLane,
217 const double meanSpeedVehicleOnLane,
218 const double travelledDistanceFrontOnLane,
219 const double travelledDistanceVehicleOnLane,
220 const double meanLengthOnLane);
221
222private:
228 MSDevice_Taxi(SUMOVehicle& holder, const std::string& id);
229
230 void updateMove(const SUMOTime traveltime, const double travelledDist);
231
233 void prepareStop(ConstMSEdgeVector& edges,
234 std::vector<SUMOVehicleParameter::Stop>& stops,
235 double& lastPos, const MSEdge* stopEdge, double stopPos,
236 const MSStoppingPlace* stopPlace,
237 const std::string& action, const Reservation* res, const bool isPickup);
238
240 MSLane* getStopLane(const MSEdge* edge, const std::string& action);
241
243 bool hasFuturePickup();
244
246 static void initDispatch();
247
248private:
249
260 bool myIsStopped = false;
262 std::set<const MSTransportable*> myCustomers;
263
266
269
271 std::set<const Reservation*> myCurrentReservations;
272
275
283 std::vector<const Reservation*> myLastDispatch;
284 // @brief the list of available taxis
285 static std::vector<MSDevice_Taxi*> myFleet;
286 // @brief the maximum personCapacity in the fleet
287 static int myMaxCapacity;
288 // @brief the maximum container capacity in the fleet
290
291 static std::set<std::string> myVClassWarningVTypes;
292
293private:
296
299
300
301};
long long int SUMOTime
Definition GUI.h:36
std::vector< const MSEdge * > ConstMSEdgeVector
Definition MSEdge.h:74
#define SUMOTime_MAX
Definition SUMOTime.h:34
Base (microsim) event class.
Definition Command.h:50
A device that performs vehicle rerouting based on current edge speeds.
A device which collects info on the vehicle trip (mainly on departure and arrival)
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
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)
static void updateReservationFromPos(MSTransportable *person, const std::set< std::string > &lines, const MSEdge *from, double fromPos, const MSEdge *to, double toPos, const std::string &group, double newFromPos)
update reservation's fromPos due to pre-booking
bool cancelCustomer(const MSTransportable *t)
remove person from reservations
void generateOutput(OutputDevice *tripinfoOut) const
Called on writing tripinfo output.
static int myMaxCapacity
static std::set< std::string > myVClassWarningVTypes
void dispatchShared(std::vector< const Reservation * > reservations)
service the given reservations
static void addReservation(MSTransportable *person, const std::set< std::string > &lines, SUMOTime reservationTime, SUMOTime pickupTime, SUMOTime earliestPickupTime, const MSEdge *from, double fromPos, const MSStoppingPlace *fromStop, const MSEdge *to, double toPos, const MSStoppingPlace *toStop, const std::string &group)
add new reservation
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.
bool hasFuturePickup()
whether the taxi has another pickup scheduled
void cancelCurrentCustomers()
remove the persons the taxi is currently waiting for from reservations
std::vector< const Reservation * > myLastDispatch
the last dispatch order
static MSDispatch * myDispatcher
the dispatch algorithm
int myCustomersServed
number of customers that were served
void updateMove(const SUMOTime traveltime, const double travelledDist)
void notifyMoveInternal(const SUMOTrafficObject &veh, const double frontOnLane, const double timeOnLane, const double meanSpeedFrontOnLane, const double meanSpeedVehicleOnLane, const double travelledDistanceFrontOnLane, const double travelledDistanceVehicleOnLane, const double meanLengthOnLane)
Internal notification about the vehicle moves, see MSMoveReminder::notifyMoveInternal()
static int myMaxContainerCapacity
MSDevice_Routing * myRoutingDevice
routing device (if the vehicle has one)
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
bool allowsBoarding(const MSTransportable *t) const
whether the given person is allowed to board this taxi
static bool hasServableReservations()
check whether there are still (servable) reservations in the system
MSDevice_Taxi & operator=(const MSDevice_Taxi &)
Invalidated assignment operator.
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
bool myReachedServiceEnd
whether the taxi has reached its schedule service end
~MSDevice_Taxi()
Destructor.
void prepareStop(ConstMSEdgeVector &edges, std::vector< SUMOVehicleParameter::Stop > &stops, double &lastPos, const MSEdge *stopEdge, double stopPos, const MSStoppingPlace *stopPlace, const std::string &action, const Reservation *res, const bool isPickup)
prepare stop for the given action
static const std::vector< MSDevice_Taxi * > & getFleet()
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
static MSDispatch * getDispatchAlgorithm()
An algorithm that performs distpach for a taxi fleet.
Definition MSDispatch.h:112
A road/street connecting two junctions.
Definition MSEdge.h:77
An algorithm that performs distpach for a taxi fleet.
Definition MSIdling.h:43
Representation of a lane in the micro simulation.
Definition MSLane.h:84
Notification
Definition of a vehicle state.
A lane area vehicles can halt at.
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.
Representation of a vehicle, person, or container.
Representation of a vehicle.
Definition SUMOVehicle.h:62