MSBaseVehicle.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2010-2025 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
/****************************************************************************/
// A base class for vehicle implementations
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <iostream>
#include <vector>
#include <set>
#include <utils/common/StdDefs.h>
#include <utils/emissions/EnergyParams.h>
#include <utils/emissions/PollutantsInterface.h>
#include <utils/vehicle/SUMOVehicle.h>
#include "MSRoute.h"
#include "MSMoveReminder.h"
#include "MSVehicleType.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSStop;
class MSDevice_Transportable;
class MSDevice_Emissions;
class MSVehicleDevice;
class MSEdgeWeightsStorage;
class MSChargingStation;
class StoppingPlaceMemory;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSBaseVehicle : public SUMOVehicle {
public:
    // XXX: This definition was introduced to make the MSVehicle's previousSpeed
    //      available in the context of MSMoveReminder::notifyMove(). Another solution
    //      would be to modify notifyMove()'s interface to work with MSVehicle instead
    //      of SUMOVehicle (it is only called with MSVehicles!). Refs. #2579
    double getPreviousSpeed() const;
 
    friend class GUIBaseVehicle;
 
    enum RouteValidity {
        ROUTE_VALID = 0,
        ROUTE_UNCHECKED = 1 << 0,
        ROUTE_INVALID = 1 << 1,
        // starting edge permissions invalid (could change)
        ROUTE_START_INVALID_PERMISSIONS = 1 << 2,
        // insertion lane does not exist
        ROUTE_START_INVALID_LANE = 1 << 3
    };
 
    MSBaseVehicle(SUMOVehicleParameter* pars, ConstMSRoutePtr route,
                  MSVehicleType* type, const double speedFactor);
 
 
    virtual ~MSBaseVehicle();
 
    virtual void initDevices();
 
    bool isVehicle() const {
        return true;
    }
 
    void setID(const std::string& newID);
 
    const SUMOVehicleParameter& getParameter() const;
 
    std::string getPrefixedParameter(const std::string& key, std::string& error) const;
 
    void replaceParameter(const SUMOVehicleParameter* newParameter);
 
    bool hasDevice(const std::string& deviceName) const;
 
    void createDevice(const std::string& deviceName);
 
    std::string getDeviceParameter(const std::string& deviceName, const std::string& key) const;
 
    void setDeviceParameter(const std::string& deviceName, const std::string& key, const std::string& value);
 
    void setJunctionModelParameter(const std::string& key, const std::string& value);
 
    void setCarFollowModelParameter(const std::string& key, const std::string& value);
 
    inline const MSRoute& getRoute() const {
        return *myRoute;
    }
 
    inline ConstMSRoutePtr getRoutePtr() const {
        return myRoute;
    }
 
    inline const MSVehicleType& getVehicleType() const {
        return *myType;
    }
 
    inline const SUMOVTypeParameter& getVTypeParameter() const {
        return myType->getParameter();
    }
 
    inline SUMOVehicleClass getVClass() const {
        return myType->getParameter().vehicleClass;
    }
 
    bool ignoreTransientPermissions() const;
 
    double getMaxSpeed() const;
 
    const MSEdge* succEdge(int nSuccs) const;
 
    const MSEdge* getEdge() const;
 
    virtual const MSEdge* getCurrentEdge() const {
        return getEdge();
    }
 
    const std::set<SUMOTrafficObject::NumericalID> getUpcomingEdgeIDs() const;
 
    bool stopsAt(MSStoppingPlace* stop) const;
 
    bool stopsAtEdge(const MSEdge* edge) const;
 
    virtual const MSEdge* getNextEdgePtr() const {
        return nullptr;
    }
 
    virtual bool isOnRoad() const {
        return true;
    }
 
    virtual bool isRemoteControlled() const {
        return false;
    }
 
    virtual bool wasRemoteControlled(SUMOTime lookBack = DELTA_T) const {
        UNUSED_PARAMETER(lookBack);
        return false;
    }
 
    virtual bool isFrontOnLane(const MSLane*) const {
        return true;
    }
 
    virtual double getLateralPositionOnLane() const {
        return 0;
    }
 
    virtual double getRightSideOnEdge(const MSLane* lane = 0) const {
        UNUSED_PARAMETER(lane);
        return 0;
    }
 
    virtual ConstMSEdgeVector::const_iterator getRerouteOrigin() const {
        return myCurrEdge;
    }
 
    virtual const MSEdge* getRerouteDestination() const {
        return myRoute->getLastEdge();
    }
 
    virtual double getTimeLossSeconds() const {
        // better timeLoss for meso?
        return 0;
    }
 
    double getWaitingSeconds() const {
        return STEPS2TIME(getWaitingTime());
    }
 
 
 
    const MSRouteIterator& getCurrentRouteEdge() const {
        return myCurrEdge;
    }
 
 
    bool reroute(SUMOTime t, const std::string& info, SUMOAbstractRouter<MSEdge, SUMOVehicle>& router, const bool onInit = false, const bool withTaz = false, const bool silent = false, const MSEdge* sink = nullptr);
 
 
    bool replaceRouteEdges(ConstMSEdgeVector& edges, double cost, double savings, const std::string& info, bool onInit = false, bool check = false, bool removeStops = true,
                           std::string* msgReturn = nullptr);
 
    virtual bool replaceRoute(ConstMSRoutePtr route, const std::string& info, bool onInit = false, int offset = 0, bool addRouteStops = true, bool removeStops = true,
                              std::string* msgReturn = nullptr);
 
    virtual double getAcceleration() const;
 
    void onDepart();
 
    inline SUMOTime getDeparture() const {
        return myDeparture;
    }
 
    SUMOTime getDepartDelay() const;
 
    virtual double getStopDelay() const {
        return -1;
    }
 
    virtual double getStopArrivalDelay() const {
        return INVALID_DOUBLE;
    }
 
    virtual std::pair<double, double> estimateTimeToNextStop() const {
        return std::make_pair(-1, -1);
    }
 
    inline double getDepartPos() const {
        return myDepartPos;
    }
 
    virtual double getArrivalPos() const {
        return myArrivalPos;
    }
 
    virtual int getArrivalLane() const {
        return myArrivalLane;
    }
 
    virtual void setArrivalPos(double arrivalPos) {
        myArrivalPos = arrivalPos;
    }
 
    virtual void onRemovalFromNet(const MSMoveReminder::Notification /*reason*/) {}
 
    inline bool hasDeparted() const {
        return myDeparture != NOT_YET_DEPARTED;
    }
 
    virtual bool hasArrived() const;
 
    int getRoutePosition() const;
 
    int getArrivalIndex() const {
        return myParameter->arrivalEdge;
    }
 
    void resetRoutePosition(int index, DepartLaneDefinition departLaneProcedure);
 
    double getOdometer() const;
 
    void addToOdometer(double value) {
        myOdometer += value;
    }
 
    inline int getNumberReroutes() const {
        return myNumberReroutes;
    }
 
    double getImpatience() const;
 
    int getPersonNumber() const;
 
    int getLeavingPersonNumber() const;
 
    std::vector<std::string> getPersonIDList() const;
 
    int getContainerNumber() const;
 
 
    inline const std::vector<MSVehicleDevice*>& getDevices() const {
        return myDevices;
    }
 
    bool allowsBoarding(const MSTransportable* t) const;
 
    virtual void addTransportable(MSTransportable* transportable);
 
    void removeTransportable(MSTransportable* t);
 
    const std::vector<MSTransportable*>& getPersons() const;
 
    const std::vector<MSTransportable*>& getContainers() const;
 
    bool isLineStop(double position) const;
 
    bool hasJump(const MSRouteIterator& it) const;
 
    bool hasValidRoute(std::string& msg, ConstMSRoutePtr route = 0) const;
 
    virtual bool hasValidRouteStart(std::string& msg);
 
    int getRouteValidity(bool update = true, bool silent = false, std::string* msgReturn = nullptr);
 
    bool hasReminder(MSMoveReminder* rem) const;
 
    void addReminder(MSMoveReminder* rem, double pos = 0);
 
    void removeReminder(MSMoveReminder* rem);
 
    virtual void activateReminders(const MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
    inline double getLength() const {
        return myType->getLength();
    }
 
    /* @brief Return whether this vehicle must be treated like a railway vehicle
     * either due to its vClass or the vClass of it's edge */
    bool isRail() const;
 
    inline double getWidth() const {
        return myType->getWidth();
    }
 
 
    inline double getChosenSpeedFactor() const {
        return myChosenSpeedFactor;
    }
 
    inline double getDesiredMaxSpeed() const {
        return myType->getDesiredMaxSpeed() * myChosenSpeedFactor;
    }
 
    inline void setChosenSpeedFactor(const double factor) {
        myChosenSpeedFactor = factor;
    }
 
    MSDevice* getDevice(const std::type_info& type) const;
 
 
    virtual void replaceVehicleType(const MSVehicleType* type);
 
 
    MSVehicleType& getSingularType();
 
 
 
    virtual void saveState(OutputDevice& out);
 
 
    virtual bool handleCollisionStop(MSStop& stop, const double distToStop);
 
    bool isStopped() const;
 
    bool isParking() const;
 
    bool isJumping() const;
 
    inline bool isReversed() const {
        return myAmReversed;
    }
 
    bool isStoppedTriggered() const;
 
    bool isStoppedParking() const;
 
    bool isStoppedInRange(const double pos, const double tolerance, bool checkFuture = false) const;
 
    bool hasStops() const {
        return !myStops.empty();
    }
 
    bool replaceParkingArea(MSParkingArea* parkingArea, std::string& errorMsg);
 
    MSParkingArea* getNextParkingArea();
 
    MSParkingArea* getCurrentParkingArea();
 
    const std::vector<std::string>& getParkingBadges() const;
 
    double basePos(const MSEdge* edge) const;
 
    bool addStop(const SUMOVehicleParameter::Stop& stopPar, std::string& errorMsg, SUMOTime untilOffset = 0,
                 MSRouteIterator* searchStart = nullptr);
 
    void addStops(const bool ignoreStopErrors, MSRouteIterator* searchStart = nullptr, bool addRouteStops = true);
 
    bool haveValidStopEdges(bool silent = false) const;
 
    std::vector<std::pair<int, double> > getStopIndices() const;
 
    inline const std::list<MSStop>& getStops() const {
        return myStops;
    }
 
    inline const StopParVector& getPastStops() const {
        return myPastStops;
    }
 
    const MSStop& getNextStop() const;
 
    MSStop& getNextStopMutable();
 
    SUMOTime getStopDuration() const;
 
    MSStop& getStop(int nextStopIndex);
 
    const SUMOVehicleParameter::Stop* getNextStopParameter() const;
 
    virtual bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string& errorMsg);
 
    virtual bool resumeFromStopping() = 0;
 
    void unregisterWaiting();
 
    bool abortNextStop(int nextStopIndex = 0);
 
    bool replaceStop(int nextStopIndex, SUMOVehicleParameter::Stop stop, const std::string& info, bool teleport, std::string& errorMsg);
 
    bool rerouteBetweenStops(int nextStopIndex, const std::string& info, bool teleport, std::string& errorMsg);
 
    bool insertStop(int nextStopIndex, SUMOVehicleParameter::Stop stop, const std::string& info, bool teleport, std::string& errorMsg);
 
 
    virtual bool isSelected() const {
        return false;
    }
 
    int getRNGIndex() const;
 
    SumoRNG* getRNG() const;
 
    inline NumericalID getNumericalID() const {
        return myNumericalID;
    }
 
    const MSDevice_Transportable* getPersonDevice() const {
        return myPersonDevice;
    }
 
    const MSDevice_Transportable* getContainerDevice() const {
        return myContainerDevice;
    }
 
    inline EnergyParams* getEmissionParameters() const {
        if (myEnergyParams == nullptr) {
            myEnergyParams = new EnergyParams(getVehicleType().getEmissionParameters());
        }
        return myEnergyParams;
    }
 
 
 
    template<PollutantsInterface::EmissionType ET>
    double getEmissions() const {
        if (isOnRoad() || isIdling()) {
            return PollutantsInterface::compute(myType->getEmissionClass(), ET, getSpeed(), getAcceleration(), getSlope(), getEmissionParameters());
        }
        return 0.;
    }
 
    double getStateOfCharge() const;
 
    double getRelativeStateOfCharge() const;
 
    double getChargedEnergy() const;
 
    double getMaxChargeRate() const;
 
    double getElecHybridCurrent() const;
 
    double getHarmonoise_NoiseEmissions() const;
 
    class BaseInfluencer {
    public:
        BaseInfluencer();
 
        virtual ~BaseInfluencer() {}
 
        static void init();
        static void cleanup();
 
 
        double getExtraImpatience() const {
            return myExtraImpatience;
        }
 
        void setExtraImpatience(double value) {
            myExtraImpatience = value;
        }
 
    protected:
        double myExtraImpatience = 0;
 
    };
 
 
 
    virtual BaseInfluencer& getBaseInfluencer() = 0;
 
    virtual const BaseInfluencer* getBaseInfluencer() const = 0;
 
    virtual bool hasInfluencer() const  = 0;
 
    int getRoutingMode() const {
        return myRoutingMode;
    }
 
    void setRoutingMode(int value) {
        myRoutingMode = value;
    }
 
 
    SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouterTT() const;
 
    const MSEdgeWeightsStorage& getWeightsStorage() const;
    MSEdgeWeightsStorage& getWeightsStorage();
 
    virtual std::pair<const MSVehicle* const, double> getLeader(double dist = 0, bool considerCrossingFoes = true) const {
        UNUSED_PARAMETER(dist);
        UNUSED_PARAMETER(considerCrossingFoes);
        WRITE_WARNING(TL("getLeader not yet implemented for meso"));
        return std::make_pair(nullptr, -1);
    }
 
    virtual std::pair<const MSVehicle* const, double> getFollower(double dist = 0) const {
        UNUSED_PARAMETER(dist);
        WRITE_WARNING(TL("getFollower not yet implemented for meso"));
        return std::make_pair(nullptr, -1);
    }
 
    void calculateArrivalParams(bool onInit);
 
    void setDepartAndArrivalEdge();
 
    int getDepartEdge() const;
 
    int getInsertionChecks() const;
 
    static MSLane* interpretOppositeStop(SUMOVehicleParameter::Stop& stop);
 
 
    void rememberBlockedParkingArea(const MSStoppingPlace* pa, bool local);
    SUMOTime sawBlockedParkingArea(const MSStoppingPlace* pa, bool local) const;
    void rememberBlockedChargingStation(const MSStoppingPlace* cs, bool local);
    SUMOTime sawBlockedChargingStation(const MSStoppingPlace* cs, bool local) const;
 
    void rememberParkingAreaScore(const MSStoppingPlace* pa, const std::string& score);
    void resetParkingAreaScores();
    void rememberChargingStationScore(const MSStoppingPlace* cs, const std::string& score);
    void resetChargingStationScores();
 
    int getNumberParkingReroutes() const {
        return myNumberParkingReroutes;
    }
    void setNumberParkingReroutes(int value) {
        myNumberParkingReroutes = value;
    }
 
    const StoppingPlaceMemory* getParkingMemory() const {
        return myParkingMemory;
    }
 
    const StoppingPlaceMemory* getChargingMemory() const {
        return myChargingMemory;
    }
 
protected:
    virtual void resetApproachOnReroute() {};
 
    struct StopEdgeInfo {
 
        StopEdgeInfo(const MSEdge* _edge, double _priority, SUMOTime _arrival, double _pos):
            edge(_edge), pos(_pos),
            priority(_priority), arrival(_arrival) {};
        const MSEdge* edge;
        double pos;
        double priority;
        SUMOTime arrival;
        int routeIndex = -1;
        bool skipped = false;
        bool backtracked = false;
        SUMOTime delay = 0;
 
        bool operator==(const StopEdgeInfo& o) const {
            return edge == o.edge;
        }
        bool operator!=(const StopEdgeInfo& o) const {
            return !(*this == o);
        }
    };
 
    std::vector<StopEdgeInfo> getStopEdges(double& firstPos, double& lastPos, std::set<int>& jumps) const;
 
    static double addStopPriority(double p1, double p2);
 
 
    ConstMSEdgeVector optimizeSkipped(SUMOTime t, SUMOAbstractRouter<MSEdge, SUMOVehicle>& router,
                                      const MSEdge* source, double sourcePos, std::vector<StopEdgeInfo>& stops, ConstMSEdgeVector edges, SUMOTime maxDelay) const;
 
    ConstMSEdgeVector routeAlongStops(SUMOTime t, SUMOAbstractRouter<MSEdge, SUMOVehicle>& router,
                                      std::vector<StopEdgeInfo>& stops, ConstMSEdgeVector edges,
                                      int originStop, SUMOTime maxDelay, double& skippedPrio2) const;
 
 
protected:
    const SUMOVehicleParameter* myParameter;
 
    ConstMSRoutePtr myRoute;
 
    const MSVehicleType* myType;
 
    MSRouteIterator myCurrEdge;
 
    double myChosenSpeedFactor;
 
    std::list<MSStop> myStops;
 
    StopParVector myPastStops;
 
 
    //         The double value holds the relative position offset, i.e.,
    //         offset + vehicle-position - moveReminder-position = distance,
    //         i.e. the offset is counted up when the vehicle continues to a
    //         succeeding lane.
    typedef std::vector< std::pair<MSMoveReminder*, double> > MoveReminderCont;
 
    MoveReminderCont myMoveReminders;
 
    std::vector<MSVehicleDevice*> myDevices;
 
    MSDevice_Transportable* myPersonDevice;
 
    MSDevice_Transportable* myContainerDevice;
 
    mutable EnergyParams* myEnergyParams;
 
    SUMOTime myDeparture;
 
    double myDepartPos;
 
    double myArrivalPos;
 
    int myArrivalLane;
 
    int myNumberReroutes;
 
    SUMOTime myStopUntilOffset;
 
    double myOdometer;
 
    int myRouteValidity;
 
    StoppingPlaceMemory* myParkingMemory = nullptr;
    StoppingPlaceMemory* myChargingMemory = nullptr;
    int myNumberParkingReroutes = 0;
 
    bool myAmRegisteredAsWaiting = false;
 
    /* @brief magic value for undeparted vehicles
     * @note: in previous versions this was -1
     */
    static const SUMOTime NOT_YET_DEPARTED;
 
    static std::vector<MSTransportable*> myEmptyTransportableVector;
 
    /* @brief The logical 'reversed' state of the vehicle - intended to be used by drawing functions
     * @note:   only set by vClass rail reversing at the moment
     */
    bool myAmReversed = false;
 
    int myRoutingMode;
 
private:
    const NumericalID myNumericalID;
 
    /* @brief The vehicle's knowledge about edge efforts/travel times; @see MSEdgeWeightsStorage
     * @note member is initialized on first access */
    mutable MSEdgeWeightsStorage* myEdgeWeights;
 
    MSEdgeWeightsStorage& _getWeightsStorage() const;
 
    static NumericalID myCurrentNumericalIndex;
 
    void initTransientModelParams();
 
    std::string getFlowID() const;
 
    void checkRouteRemoval();
 
    bool insertJump(int nextStopIndex, MSRouteIterator itStart, std::string& errorMsg);
 
    void setSkips(MSStop& stop, int prevActiveStops);
 
    SUMOTime activateRemindersOnReroute(SUMOTime currentTime);
 
private:
    MSBaseVehicle& operator=(const MSBaseVehicle& s) = delete;
 
#ifdef _DEBUG
public:
    static void initMoveReminderOutput(const OptionsCont& oc);
 
protected:
    void traceMoveReminder(const std::string& type, MSMoveReminder* rem, double pos, bool keep) const;
 
    const bool myTraceMoveReminders;
private:
    static std::set<std::string> myShallTraceMoveReminders;
#endif
 
 
};