MSCFModel_EIDM.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 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 Extended Intelligent Driver Model (EIDM) car-following model
//
// Publication: Salles, Dominik, S. Kaufmann and H. Reuss. “Extending the Intelligent Driver
// Model in SUMO and Verifying the Drive Off Trajectories with Aerial
// Measurements.” (2020).
/****************************************************************************/
#ifndef MSCFMODEL_EIDM_H
#define MSCFMODEL_EIDM_H
 
// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>
 
#include "MSCFModel.h"
#include <microsim/MSLane.h>
#include <microsim/MSVehicle.h>
#include <microsim/MSVehicleType.h>
#include <microsim/lcmodels/MSAbstractLaneChangeModel.h>
#include <utils/xml/SUMOXMLDefinitions.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSCFModel_EIDM : public MSCFModel {
public:
    MSCFModel_EIDM(const MSVehicleType* vtype);

    ~MSCFModel_EIDM();


    double insertionFollowSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred = 0) const;
 

    double insertionStopSpeed(const MSVehicle* const veh, double speed, double gap) const;
 

    double maximumSafeFollowSpeed(double gap, double egoSpeed, double predSpeed, double predMaxDecel, bool onInsertion = false, const CalcReason usage = CalcReason::CURRENT) const;
 

    double maximumSafeStopSpeed(double gap, double decel, double currentSpeed, bool onInsertion = false, double headway = -1) const;
 

    double finalizeSpeed(MSVehicle* const veh, double vPos) const;
 

    double followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed,
                       double predMaxDecel, const MSVehicle* const pred = 0, const CalcReason usage = CalcReason::CURRENT) const;
 

    double stopSpeed(const MSVehicle* const veh, const double speed, double gap, double decel, const CalcReason usage = CalcReason::CURRENT) const;
 

    double freeSpeed(const MSVehicle* const veh, double speed, double seen,
                     double maxSpeed, const bool onInsertion = false, const CalcReason usage = CalcReason::CURRENT) const;
 
    static double freeSpeed(const double currentSpeed, const double decel, const double dist, const double maxSpeed, const bool onInsertion);

    double interactionGap(const MSVehicle* const, double vL) const;

    double getSecureGap(const MSVehicle* const veh, const MSVehicle* const /*pred*/, const double speed, const double leaderSpeed, const double leaderMaxDecel) const;

    double brakeGap(const double speed, const double decel, const double headwayTime) const {
        if (MSGlobals::gComputeLC) {
            return MSCFModel::brakeGap(speed, decel, headwayTime);
        } else {
            // myDecel + 1.0 does not work correctly with the junction model and impatience > 0.
            // Vehicles may first be disregarded because their own arrivalTimeBraking is high (TIME2STEPS(30)).
            // This is amplified by this brakeGap-Term, because they "think" they could still brake in time (low brakeGap),
            // but actually 1.0 was only added for braking at traffic lights. But then when seen < brakeGap(v) happens (see MSVehicle: arrivalTimeBraking),
            // they realize, that they will soon arrive at the junction and other vehicles are notified to maybe then brake hard!
            return MSCFModel::brakeGap(speed, MAX2(decel, myDecel + 1.0), headwayTime);
        }
    }

    double maxNextSafeMin(double speed, const MSVehicle* const veh = 0) const {
        UNUSED_PARAMETER(speed);
        UNUSED_PARAMETER(veh);
        return 0;
    }

    double maximumLaneSpeedCF(const MSVehicle* const /*veh*/, double maxSpeed, double /*maxSpeedLane*/) const {
        return maxSpeed;
    }

    int getModelID() const {
        return SUMO_TAG_CF_EIDM;
    }

    MSCFModel* duplicate(const MSVehicleType* vtype) const;
 
    // @brief Variables that are stored throughout a call to the car-following functions
    VehicleVariables* createVehicleVariables() const {
        VehicleVariables* ret = new VehicleVariables();
        ret->minaccel = 100;
        ret->wouldacc = 100;
        ret->lastacc = 0;
        ret->realacc = 100;
        ret->lastrealacc = 0;
        ret->realleaderacc = 100;
        ret->lastleaderacc = 0;
        ret->v0_int = 0;
        ret->v0_old = 0;
        ret->t_off = -10.;
        ret->myw_gap = 0.;
        ret->myw_speed = 0.;
        ret->myw_error = 0.;
        ret->myv_est_l = 0.;
        ret->myv_est = 0.;
        ret->mys_est = 0.;
        ret->myrespectMinGap = true;
        ret->myap_update = 0;
        return ret;
    }
 
 
private:
    class VehicleVariables : public MSCFModel::VehicleVariables {
    public:
        double minaccel; // @brief saves the intended accel-value between multiple stopSpeed/followSpeed calls to then check which call actually updated the vehicles acceleration (accel-value is without coolness and drive-off)
        double wouldacc; // @brief saves the intended accel-value the CF-model would output, if there is no reaction time (accel-value is without coolness and drive-off)
        double lastacc; // @brief saves the intended accel-value when the driver was last updated (reaction time) (accel-value is without coolness and drive-off)
        double realacc; // @brief saves the resulting accel-value between multiple stopSpeed/followSpeed calls that the CF-model will eventually output
        double lastrealacc; // @brief saves the resulting accel-value the CF-model eventually outputted when the driver was last updated (reaction time)
        double realleaderacc; // @brief saves the leader accel-value from the call that resulted in the new speed
        double lastleaderacc; // @brief saves the leader accel-value from the call that resulted in the new speed when the driver was last updated (reaction time)
        double v0_int; // @brief is the internal desired speed of the vehicle
        double v0_old; // @brief is the previous desired speed of the vehicle needed for calculation purpose
        double t_off; // @brief is the time when the vehicle starts driving off
        double myw_gap; // @brief is the Wiener Process for the gap error calculation
        double myw_speed; // @brief is the Wiener Process for the speed error calculation
        double myw_error; // @brief is the Wiener Process for the driving error calculation
        double myv_est_l; // @brief saves the speed of the leading vehicle / 0 for a stop at the last driver update (reaction time)
        double myv_est; // @brief saves the speed of the vehicle at the last driver update (reaction time)
        double mys_est; // @brief saves the gap to leading vehicle / next stop at the last driver update (reaction time)
        bool myrespectMinGap; // @brief saves the information, if minGap was added to the desired gap s* at the last driver update (reaction time)
        int myap_update; // @brief is a number counting the simulation steps since the last driver/vehicle update (reaction time)
        std::vector<std::pair<double, double>> stop; // @brief saves the intended accelerations and distances from all stopSpeed-calculations of the current time step
                                                     
        void saveState(OutputDevice& out, const MSCFModel& cfm) const;

        void loadState(const SUMOSAXAttributes& attrs);
    };
 
private:

    double patchSpeedBeforeLCEIDM(const MSVehicle* veh, double vMin, double vMax, const VehicleVariables* vars) const;
 
    // @brief calculates the slow to start term when driving off
    double slowToStartTerm(MSVehicle* const veh, const double newSpeed, const double currentSpeed, const double vMax, VehicleVariables* vars) const;
 
    // @brief contains the main CF-model calculations
    double _v(const MSVehicle* const veh, const double gap2pred, const double mySpeed,
              const double predSpeed, const double desSpeed, const bool respectMinGap, const int update, const CalcReason usage) const;
 
    // @brief calculates the internal desired speed for the vehicle depending on myTpreview and upcoming turns, intersections and speed limit changes
    void internalspeedlimit(MSVehicle* const veh, const double oldV) const;
 
    // @brief calculates the SecureGap similar to the MSCFModel-SecureGap-function, yet adding a targetDecel to decelerate with
    double internalsecuregap(const MSVehicle* const veh, const double speed, const double leaderSpeed, const double targetDecel) const;
 
private:
    // @brief The IDM delta exponent
    const double myDelta;
 
    // @brief The number of iterations in speed calculations
    const int myIterations;
 
    // @brief Correlation time of the Wiener Process for the driving error
    const double myTPersDrive;
 
    // @brief The maximal reaction time
    const double myTreaction;
 
    // @brief The preview distance time for the desired speed
    const double myTpreview;
 
    // @brief Correlation time of the Wiener Process for the estimation errors
    const double myTPersEstimate;
 
    // @brief Coolness Parameter of the Enhanced Intelligent Driver Model
    const double myCcoolness;
 
    // @brief Estimation error magnitude of the leading vehicle's speed
    const double mySigmaleader;
 
    // @brief Estimation error magnitude of the distance to the leading vehicle / next stop
    const double mySigmagap;
 
    // @brief Driving error magnitude
    const double mySigmaerror;
 
    // @brief Maximal jerk value
    const double myJerkmax;
 
    // @brief Maximal negative acceleration value before reacting instantaneously to the change in intended acceleration
    const double myEpsilonacc;
 
    // @brief Time until the maximal acceleration when driving off
    const double myTaccmax;
 
    // @brief Flatness of the drive off acceleration term
    const double myMflatness;
 
    // @brief Shift of the drive off acceleration term
    const double myMbegin;
 
    // @brief 1=simulate with the acceleration depending on the vehicle dynamics, 0=don't
    const bool myUseVehDynamics;
 
    // @brief number of vehicles in front, that are used to update the acceleration
    //const int myMaxVehPreview;
 
private:
    MSCFModel_EIDM& operator=(const MSCFModel_EIDM& s);
};
 
#endif /* MSCFMODEL_EIDM_H */