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.dev/sumo
3// Copyright (C) 2013-2023 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 const MSEdge* from, double fromPos,
85 const MSEdge* to, double toPos,
86 const std::string& group);
87
89 static void removeReservation(MSTransportable* person,
90 const std::set<std::string>& lines,
91 const MSEdge* from, double fromPos,
92 const MSEdge* to, double toPos,
93 const std::string& group);
94
96 static SUMOTime triggerDispatch(SUMOTime currentTime);
97
99 static bool hasServableReservations();
100
102 static void cleanup();
103
105 return myDispatcher;
106 }
107
108 static const std::vector<MSDevice_Taxi*>& getFleet() {
109 return myFleet;
110 }
111
112public:
115
118
128 bool notifyMove(SUMOTrafficObject& veh, double oldPos,
129 double newPos, double newSpeed);
130
131
140 bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
142
143
145 const std::string deviceName() const {
146 return "taxi";
147 }
148
150 bool isEmpty();
151
152 int getState() const {
153 return myState;
154 }
155
157 static SUMOVehicle* getTaxi();
158
160 void dispatch(const Reservation& res);
161
163 void dispatchShared(std::vector<const Reservation*> reservations);
164
166 bool allowsBoarding(const MSTransportable* t) const;
167
169 void customerEntered(const MSTransportable* t);
170
172 void customerArrived(const MSTransportable* person);
173
175 std::string getParameter(const std::string& key) const;
176
178 void setParameter(const std::string& key, const std::string& value);
179
186 void generateOutput(OutputDevice* tripinfoOut) const;
187
189 bool compatibleLine(const Reservation* res);
190
191 static bool compatibleLine(const std::string& taxiLine, const std::string& rideLine);
192
193protected:
198 const double frontOnLane,
199 const double timeOnLane,
200 const double meanSpeedFrontOnLane,
201 const double meanSpeedVehicleOnLane,
202 const double travelledDistanceFrontOnLane,
203 const double travelledDistanceVehicleOnLane,
204 const double meanLengthOnLane);
205
206private:
212 MSDevice_Taxi(SUMOVehicle& holder, const std::string& id);
213
214 void updateMove(const SUMOTime traveltime, const double travelledDist);
215
217 void prepareStop(ConstMSEdgeVector& edges,
218 std::vector<SUMOVehicleParameter::Stop>& stops,
219 double& lastPos, const MSEdge* stopEdge, double stopPos,
220 const std::string& action);
221
223 MSLane* getStopLane(const MSEdge* edge, const std::string& action);
224
226 bool hasFuturePickup();
227
229 static void initDispatch();
230
231private:
232
243 bool myIsStopped = false;
245 std::set<const MSTransportable*> myCustomers;
246
249
252
254 std::set<const Reservation*> myCurrentReservations;
255
258
265 // @brief the list of available taxis
266 static std::vector<MSDevice_Taxi*> myFleet;
267 // @brief the maximum personCapacity in the fleet
268 static int myMaxCapacity;
269 // @brief the maximum container capacity in the fleet
271
272private:
275
278
279
280};
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)
Definition: MSDevice_Taxi.h:49
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)
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.
bool hasFuturePickup()
whether the taxi has another pickup scheduled
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
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
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
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
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 it's schedule service end
~MSDevice_Taxi()
Destructor.
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:102
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.
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:62