MSDispatch.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2007-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// An algorithm that performs dispatch for the taxi device
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <set>
#include <vector>
#include <map>
#include <utils/common/Parameterised.h>
#include <utils/common/SUMOTime.h>
#include "MSDevice_Taxi.h"
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSTransportable;
class MSStoppingPlace;
 
// ===========================================================================
// class definitions
// ===========================================================================
struct Reservation {
    enum ReservationState {
        NEW = 1, // new reservation (not yet retrieved)
        RETRIEVED = 2, // retrieved at least once via MSDispatch_TraCI
        ASSIGNED = 4, // a taxi was dispatched to service this reservation
        ONBOARD = 8, // a taxi has picked up the persons belonging to this reservation
        FULFILLED = 16, // the persons belonging to this reservation have been dropped off
    };
 
    Reservation(const std::string& _id,
                const std::vector<const MSTransportable*>& _persons,
                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,
                const std::string& _line) :
        id(_id),
        persons(_persons.begin(), _persons.end()),
        reservationTime(_reservationTime),
        pickupTime(_pickupTime),
        earliestPickupTime(_earliestPickupTime),
        from(_from),
        fromPos(_fromPos),
        fromStop(_fromStop),
        to(_to),
        toPos(_toPos),
        toStop(_toStop),
        group(_group),
        line(_line),
        recheck(_reservationTime),
        state(NEW)
    {}
 
    std::string id;
    std::set<const MSTransportable*> persons;
    SUMOTime reservationTime;
    SUMOTime pickupTime;
    SUMOTime earliestPickupTime;
    const MSEdge* from;
    double fromPos;
    const MSStoppingPlace* fromStop;
    const MSEdge* to;
    double toPos;
    const MSStoppingPlace* toStop;
    std::string group;
    std::string line;
    SUMOTime recheck;
    ReservationState state;
 
    bool operator==(const Reservation& other) const {
        return persons == other.persons
               && reservationTime == other.reservationTime
               && pickupTime == other.pickupTime
               && from == other.from
               && fromPos == other.fromPos
               && to == other.to
               && toPos == other.toPos
               && group == other.group
               && line == other.line;
    }
 
    std::string getID() const;
};
 
class MSDispatch : public Parameterised {
public:
 
    class time_sorter {
    public:
        explicit time_sorter() {}
 
        int operator()(const Reservation* r1, const Reservation* r2) const {
            return MAX2(r1->reservationTime, r1->earliestPickupTime) < MAX2(r2->reservationTime, r2->earliestPickupTime);
        }
    };
 
    MSDispatch(const Parameterised::Map& params);
 
    virtual ~MSDispatch();
 
    virtual Reservation* addReservation(MSTransportable* person,
                                        SUMOTime reservationTime,
                                        SUMOTime pickupTime,
                                        SUMOTime earliestPickupTime,
                                        const MSEdge* from, double fromPos,
                                        const MSStoppingPlace* fromStop,
                                        const MSEdge* to, double toPos,
                                        const MSStoppingPlace* tostop,
                                        std::string group,
                                        const std::string& line,
                                        int maxCapacity,
                                        int maxContainerCapacity);
 
    virtual std::string removeReservation(MSTransportable* person,
                                          const MSEdge* from, double fromPos,
                                          const MSEdge* to, double toPos,
                                          std::string group);
 
    virtual Reservation* updateReservationFromPos(MSTransportable* person,
            const MSEdge* from, double fromPos,
            const MSEdge* to, double toPos,
            std::string group, double newFromPos);
 
    virtual void fulfilledReservation(const Reservation* res);
 
    virtual void computeDispatch(SUMOTime now, const std::vector<MSDevice_Taxi*>& fleet) = 0;
 
    std::vector<Reservation*> getReservations();
 
    virtual std::vector<const Reservation*> getRunningReservations();
 
    bool hasServableReservations() {
        return myHasServableReservations;
    }
 
    static SUMOTime computePickupTime(SUMOTime t, const MSDevice_Taxi* taxi, const Reservation& res, SUMOAbstractRouter<MSEdge, SUMOVehicle>& router);
 
    static double computeDetourTime(SUMOTime t, SUMOTime viaTime, const MSDevice_Taxi* taxi,
                                    const MSEdge* from, double fromPos,
                                    const MSEdge* via, double viaPos,
                                    const MSEdge* to, double toPos,
                                    SUMOAbstractRouter<MSEdge, SUMOVehicle>& router,
                                    double& timeDirect) ;
 
 
    bool myHasServableReservations = false;
 
protected:
    void servedReservation(const Reservation* res);
 
    int remainingCapacity(const MSDevice_Taxi* taxi, const Reservation* res);
 
    // reservations that are currently being served (could still be used during re-dispatch)
    std::set<const Reservation*> myRunningReservations;
 
    OutputDevice* myOutput;
 
    int myReservationCount;
    std::map<std::string, std::vector<Reservation*> > myGroupReservations;
 
};