MSStageWalking.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
/****************************************************************************/
// A stage performing walking on a sequence of edges.
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <set>
#include <utils/common/SUMOTime.h>
#include <utils/common/Command.h>
#include <utils/geom/Position.h>
#include <utils/geom/PositionVector.h>
#include <microsim/transportables/MSTransportable.h>
#include <microsim/transportables/MSStageMoving.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSEdge;
class MSLane;
class OutputDevice;
class SUMOVehicleParameter;
class MSStoppingPlace;
class SUMOVehicle;
class MSVehicleType;
class MSPModel;
class MSMoveReminder;
 
typedef std::vector<const MSEdge*> ConstMSEdgeVector;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSStageWalking : public MSStageMoving {
public:
    MSStageWalking(const std::string& personID, const ConstMSEdgeVector& route, MSStoppingPlace* toStop, SUMOTime walkingTime,
                   double speed, double departPos, double arrivalPos, double departPosLat, int departLane = -1, const std::string& routeID = "");
 
    ~MSStageWalking();
 
    MSStage* clone() const;
 
    virtual void proceed(MSNet* net, MSTransportable* person, SUMOTime now, MSStage* previous);
 
    void abort(MSTransportable*);
 
    void setSpeed(double speed);
 
    double getDistance() const {
        return walkDistance();
    }
 
    int getRoutePosition() const;
 
    std::string getStageDescription(const bool isPerson) const {
        UNUSED_PARAMETER(isPerson);
        return "walking";
    }
 
    std::string getStageSummary(const bool isPerson) const;
 
    void saveState(std::ostringstream& out);
 
    void loadState(MSTransportable* transportable, std::istringstream& state);
 
    virtual void tripInfoOutput(OutputDevice& os, const MSTransportable* const transportable) const;
 
    virtual void routeOutput(const bool isPerson, OutputDevice& os, const bool withRouteLength, const MSStage* const previous) const;
 
    bool moveToNextEdge(MSTransportable* person, SUMOTime currentTime, int prevDir, MSEdge* nextInternal = nullptr);
 
    void activateEntryReminders(MSTransportable* person, const bool isDepart = false);
 
    void activateLeaveReminders(MSTransportable* person, const MSLane* lane, double lastPos, SUMOTime t, bool arrived);
 
 
    double getMaxSpeed(const MSTransportable* const person) const;
 
    inline double getArrivalPos() const {
        return myArrivalPos;
    }
 
    inline const MSEdge* getNextRouteEdge() const {
        return myRouteStep == myRoute.end() - 1 ? nullptr : *(myRouteStep + 1);
    }
 
    bool isWalk() const {
        return true;
    }
 
    SUMOTime getTimeLoss(const MSTransportable* transportable) const;
 
private:
    double walkDistance(bool partial = false) const;
 
    /* @brief compute average speed if the total walking duration is given
        * @note Must be called when the previous stage changes myDepartPos from the default*/
    double computeAverageSpeed() const;
 
private:
    SUMOTime myWalkingTime;
 
    SUMOTime myLastEdgeEntryTime;
 
    std::vector<MSMoveReminder*> myMoveReminders;
 
    std::vector<SUMOTime>* myExitTimes;
 
    double myInternalDistance;
 
    static bool myWarnedInvalidTripinfo;
 
private:
    MSStageWalking(const MSStageWalking&);
 
    MSStageWalking& operator=(const MSStageWalking&);
 
};