MSTransportable.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-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
/****************************************************************************/
// The common superclass for modelling transportable objects like persons and containers
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <set>
#include <cassert>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/WrappingCommand.h>
#include <utils/geom/Position.h>
#include <utils/geom/PositionVector.h>
#include <utils/geom/Boundary.h>
#include <utils/router/SUMOAbstractRouter.h>
#include <utils/vehicle/SUMOTrafficObject.h>
#include <microsim/MSRouterDefs.h>
#include <microsim/MSVehicleType.h>
#include "MSStage.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSLane;
class MSNet;
class MSStoppingPlace;
class OutputDevice;
class SUMOVehicleParameter;
class SUMOVehicle;
class MSTransportableDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSTransportable : public SUMOTrafficObject {
public:
    inline bool isPerson() const {
        return myAmPerson;
    }
 
    inline bool isContainer() const {
        return !myAmPerson;
    }
 
    inline std::string getObjectType() {
        return myAmPerson ? "Person" : "Container";
    }
 
    inline NumericalID getNumericalID() const {
        return myNumericalID;
    }
 
    inline bool isStopped() const {
        return getCurrentStageType() == MSStageType::WAITING;
    }
 
    double getSlope() const;
 
    SUMOVehicleClass getVClass() const;
 
    virtual bool isJammed() const {
        return false;
    }
 
    double getMaxSpeed() const;
 
    SUMOTime getWaitingTime(const bool accumulated = false) const;
 
    double getPreviousSpeed() const {
        return getSpeed();
    }
 
    double getAcceleration() const {
        return 0.0;
    }
 
    double getPositionOnLane() const {
        return getEdgePos();
    }
 
    double getBackPositionOnLane(const MSLane* lane) const;
 
    Position getPosition(const double /*offset*/) const {
        return getPosition();
    }
 
    typedef std::vector<MSStage*> MSTransportablePlan;
 
    MSTransportable(const SUMOVehicleParameter* pars, MSVehicleType* vtype, MSTransportablePlan* plan, const bool isPerson);
 
    virtual ~MSTransportable();
 
    /* @brief proceeds to the next step of the route,
     * @return Whether the transportables plan continues  */
    virtual bool proceed(MSNet* net, SUMOTime time, const bool vehicleArrived = false);
 
    virtual bool checkAccess(const MSStage* const prior, const bool waitAtStop = true) {
        UNUSED_PARAMETER(prior);
        UNUSED_PARAMETER(waitAtStop);
        return false;
    }
 
    void setID(const std::string& newID);
 
    inline const SUMOVehicleParameter& getParameter() const {
        return *myParameter;
    }
 
    inline const MSVehicleType& getVehicleType() const {
        return *myVType;
    }
 
    inline const SUMOVTypeParameter& getVTypeParameter() const {
        return myVType->getParameter();
    }
 
    SumoRNG* getRNG() const;
 
    int getRNGIndex() const;
 
    SUMOTime getDesiredDepart() const;
 
    void setDeparted(SUMOTime now);
 
    SUMOTime getDeparture() const;
 
    const MSEdge* getDestination() const {
        return (*myStep)->getDestination();
    }
 
    const MSEdge* getNextDestination() const {
        return (*(myStep + 1))->getDestination();
    }
 
    const MSEdge* getEdge() const {
        return (*myStep)->getEdge();
    }
 
    const MSLane* getLane() const {
        return (*myStep)->getLane();
    }
 
    const MSEdge* getFromEdge() const {
        return (*myStep)->getFromEdge();
    }
 
    virtual double getEdgePos() const;
 
    virtual int getDirection() const;
 
    virtual Position getPosition() const;
 
    virtual double getAngle() const;
 
    virtual double getWaitingSeconds() const;
 
    virtual double getSpeed() const;
 
    virtual double getChosenSpeedFactor() const {
        return 1;
    }
 
    MSStageType getCurrentStageType() const {
        return (*myStep)->getStageType();
    }
 
    MSStageType getStageType(int next) const {
        assert(myStep + next < myPlan->end());
        assert(myStep + next >= myPlan->begin());
        return (*(myStep + next))->getStageType();
    }
 
    std::string getStageSummary(int stageIndex) const;
 
    std::string getCurrentStageDescription() const {
        return (*myStep)->getStageDescription(myAmPerson);
    }
 
    MSStage* getCurrentStage() const {
        return *myStep;
    }
 
    inline MSStage* getNextStage(int offset) const {
        assert(myStep + offset >= myPlan->begin());
        assert(myStep + offset < myPlan->end());
        return *(myStep + offset);
    }
 
    const std::set<NumericalID> getUpcomingEdgeIDs() const;
 
    inline int getNumStages() const {
        return (int)myPlan->size();
    }
 
    inline int getNumRemainingStages() const {
        return (int)(myPlan->end() - myStep);
    }
 
    inline int getCurrentStageIndex() const {
        return (int)(myStep - myPlan->begin());
    }
 
    inline int getRoutePosition() const {
        return (*myStep)->getRoutePosition();
    }
 
    virtual const MSEdge* getNextEdgePtr() const {
        return nullptr;
    }
 
    void tripInfoOutput(OutputDevice& os) const;
 
    void routeOutput(OutputDevice& os, const bool withRouteLength) const;
 
    bool isWaitingFor(const SUMOVehicle* vehicle) const {
        return (*myStep)->isWaitingFor(vehicle);
    }
 
    bool isWaiting4Vehicle() const {
        return (*myStep)->isWaiting4Vehicle();
    }
 
    void setAbortWaiting(const SUMOTime timeout);
 
    SUMOTime abortStage(SUMOTime step);
 
    SUMOVehicle* getVehicle() const {
        return (*myStep)->getVehicle();
    }
 
    void appendStage(MSStage* stage, int next = -1);
 
    void removeStage(int next, bool stayInSim = true);
 
    void setSpeed(double speed);
 
    double getArrivalPos() const {
        return myPlan->back()->getArrivalPos();
    }
 
    const MSEdge* getArrivalEdge() const {
        return myPlan->back()->getEdges().back();
    }
 
    const MSEdge* getRerouteDestination() const  {
        return getArrivalEdge();
    }
 
    bool reroute(SUMOTime t, const std::string& info, MSTransportableRouter& router, const bool onInit = false, const bool withTaz = false, const bool silent = false, const MSEdge* sink = nullptr);
 
    bool replaceRoute(ConstMSRoutePtr route, const std::string& info, bool onInit = false, int offset = 0, bool addStops = true, bool removeStops = true, std::string* msgReturn = nullptr);
 
    void replaceVehicleType(MSVehicleType* type);
 
    MSVehicleType& getSingularType();
 
    PositionVector getBoundingBox() const;
 
    bool hasArrived() const;
 
    bool hasDeparted() const;
 
    void rerouteParkingArea(MSStoppingPlace* orig, MSStoppingPlace* replacement);
 
    MSDevice* getDevice(const std::type_info& type) const;
 
    void setJunctionModelParameter(const std::string& key, const std::string& value);
 
    inline const std::vector<MSTransportableDevice*>& getDevices() const {
        return myDevices;
    }
 
    virtual bool hasInfluencer() const {
        return false;
    }
 
    virtual bool isSelected() const {
        return false;
    }
 
    virtual int getRoutingMode() const;
 
    void saveState(OutputDevice& out);
 
    void loadState(const std::string& state);
 
protected:
    const SUMOVehicleParameter* myParameter;
 
    MSVehicleType* myVType;
 
    bool myWriteEvents;
 
    MSTransportablePlan* myPlan;
 
    MSTransportablePlan::iterator myStep;
 
    std::vector<MSTransportableDevice*> myDevices;
 
private:
    const bool myAmPerson;
 
    const NumericalID myNumericalID;
 
    WrappingCommand<MSTransportable>* myAbortCommand;
 
    static NumericalID myCurrentNumericalIndex;
 
private:
    MSTransportable(const MSTransportable&);
 
    MSTransportable& operator=(const MSTransportable&);
 
};