MSPModel_NonInteracting.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2014-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 pedestrian following model (prototype)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <limits>
#include <utils/common/SUMOTime.h>
#include <utils/common/Command.h>
#include "MSPerson.h"
#include "MSPModel.h"
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLink;
class MSLane;
class MSJunction;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSPModel_NonInteracting : public MSPModel {
public:
 
    MSPModel_NonInteracting(const OptionsCont& oc, MSNet* net);
 
    ~MSPModel_NonInteracting();
 
    MSTransportableStateAdapter* add(MSTransportable* transportable, MSStageMoving* stage, SUMOTime now);
 
    MSTransportableStateAdapter* loadState(MSTransportable* transportable, MSStageMoving* stage, std::istringstream& in);
 
    void clearState();
 
    void remove(MSTransportableStateAdapter* state);
 
    bool usingInternalLanes() {
        return false;
    }
 
    int getActiveNumber() {
        return myNumActivePedestrians;
    }
 
    void registerArrived() {
        myNumActivePedestrians--;
    }
 
private:
    class MoveToNextEdge : public Command {
    public:
        MoveToNextEdge(MSTransportable* transportable, MSStageMoving& walk, MSPModel_NonInteracting* model) :
            myParent(walk), myTransportable(transportable), myModel(model) {}
        SUMOTime execute(SUMOTime currentTime);
        void abortWalk() {
            myTransportable = nullptr;
        }
        const MSTransportable* getTransportable() const {
            return myTransportable;
        }
 
    private:
        MSStageMoving& myParent;
        MSTransportable* myTransportable;
        MSPModel_NonInteracting* myModel;
 
    private:
        MoveToNextEdge& operator=(const MoveToNextEdge&);
    };
 
 
    class PState : public MSTransportableStateAdapter {
    public:
        PState(MoveToNextEdge* cmd, std::istringstream* in = nullptr);
 
        double getEdgePos(SUMOTime now) const;
        int getDirection() const;
        virtual Position getPosition(const MSStageMoving& stage, SUMOTime now) const;
        virtual double getAngle(const MSStageMoving& stage, SUMOTime now) const;
        SUMOTime getWaitingTime() const {
            return 0;
        }
        double getSpeed(const MSStageMoving& stage) const;
        const MSEdge* getNextEdge(const MSStageMoving& stage) const;
 
        virtual SUMOTime computeDuration(const MSEdge* prev, const MSStageMoving& stage, SUMOTime currentTime);
        MoveToNextEdge* getCommand() const {
            return myCommand;
        }
 
        SUMOTime getEventTime() const {
            return myLastEntryTime + myCurrentDuration;
        }
 
        void saveState(std::ostringstream& out);
 
    protected:
        SUMOTime myLastEntryTime;
        SUMOTime myCurrentDuration;
        double myCurrentBeginPos;
        double myCurrentEndPos;
        MoveToNextEdge* myCommand;
    };
 
 
    class CState : public PState {
    public:
        CState(MoveToNextEdge* cmd, std::istringstream* in = nullptr);
 
        static const double LATERAL_OFFSET;
 
        Position getPosition(const MSStageMoving& stage, SUMOTime now) const;
        double getAngle(const MSStageMoving& stage, SUMOTime now) const;
        SUMOTime computeDuration(const MSEdge* prev, const MSStageMoving& stage, SUMOTime currentTime);
 
    private:
        Position myCurrentBeginPosition;  //the position the container is moving from during its tranship stage
        Position myCurrentEndPosition;  //the position the container is moving to during its tranship stage
    };
 
private:
    MSNet* myNet;
 
    int myNumActivePedestrians;
 
};