MSCFModel.h

Go to the documentation of this file.

/****************************************************************************/
// The car-following model abstraction
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSCFModel_h
#define MSCFModel_h

// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <cmath>
#include <string>
#include <utils/common/StdDefs.h>
#include <utils/common/FileHelpers.h>

#define INVALID_SPEED 299792458 + 1 // nothing can go faster than the speed of light!

// ===========================================================================
// class declarations
// ===========================================================================
class MSVehicleType;
class MSVehicle;
class MSLane;


// ===========================================================================
// class definitions
// ===========================================================================
class MSCFModel {

public:

    class VehicleVariables {
    public:
        virtual ~VehicleVariables();
    };

    MSCFModel(const MSVehicleType* vtype, double accel, double decel, double emergencyDecel, double apparentDecel, double headwayTime);


    virtual ~MSCFModel();



    virtual double moveHelper(MSVehicle* const veh, double vPos) const;


    virtual double freeSpeed(const MSVehicle* const veh, double speed, double seen,
                             double maxSpeed, const bool onInsertion = false) const;


    virtual double followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel) const = 0;


    virtual double insertionFollowSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel) const;


    virtual double stopSpeed(const MSVehicle* const veh, const double speed, double gap) const = 0;


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

    virtual double followSpeedTransient(double duration, const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel) const;

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


    virtual int getModelID() const = 0;


    virtual MSCFModel* duplicate(const MSVehicleType* vtype) const = 0;


    virtual VehicleVariables* createVehicleVariables() const {
        return 0;
    }


    inline double getMaxAccel() const {
        return myAccel;
    }


    inline double getMaxDecel() const {
        return myDecel;
    }


    inline double getEmergencyDecel() const {
        return myEmergencyDecel;
    }


    inline double getApparentDecel() const {
        return myApparentDecel;
    }



    virtual double getImperfection() const {
        return -1;
    }


    virtual double getHeadwayTime() const {
        return myHeadwayTime;
    }





    virtual double maxNextSpeed(double speed, const MSVehicle* const veh) const;


    virtual double minNextSpeed(double speed, const MSVehicle* const veh = 0) const;


    inline double brakeGap(const double speed) const {
        return brakeGap(speed, myDecel, myHeadwayTime);
    }

    static double brakeGap(const double speed, const double decel, const double headwayTime);

    static double brakeGapEuler(const double speed, const double decel, const double headwayTime);

    static double freeSpeed(const double currentSpeed, const double decel, const double dist, const double maxSpeed, const bool onInsertion);

    inline double getSecureGap(const double speed, const double leaderSpeed, const double leaderMaxDecel) const {
        // The solution approach leaderBrakeGap >= followerBrakeGap is not
        // secure when the follower can brake harder than the leader because the paths may still cross.
        // As a workaround we lower the value of followerDecel which errs on the side of caution
        //
        // xxx (Leo, refs #2548) This is somewhat different from the approach in maximumSafeFollowSpeed, where
        // the leaderMaxDecel is increased instead. This is no perfect estimate either,
        // but without taking into account the reaction time tau it is less conservative than decreasing followDecel.
        // Consider replacement by 'const leaderMaxDecel = MAX2(myDecel, leaderMaxDecel);' below and 'followDecel = myDecel;'
        // With maximumSafeSpeed = maximumSafeFollowSpeed(*secureGap*, speed, leaderSpeed, leaderMaxDecel) we should have:
        //        assert(maximumSafeSpeed <= speed + NUMERICAL_EPS && maximumSafeSpeed >= speed - NUMERICAL_EPS);

        // XXX: this should fix #2548 (postponed after merge of branch {ticket860}):
        //        const double maxDecel = MAX2(myDecel, leaderMaxDecel);
        //        double secureGap = MAX2((double) 0, brakeGap(speed, myDecel, myHeadwayTime) - brakeGap(leaderSpeed, maxDecel, 0));

        const double followDecel = MIN2(myDecel, leaderMaxDecel);
        // XXX: returning 0 can be wrong if the leader is slower than the follower! Why not return negative values? (Leo)
        double secureGap = MAX2((double) 0, brakeGap(speed, followDecel, myHeadwayTime) - brakeGap(leaderSpeed, leaderMaxDecel, 0));
        return secureGap;
    }

    virtual 
    inline double getSpeedAfterMaxDecel(double v) const {
        return MAX2((double) 0, v - (double) ACCEL2SPEED(myDecel));
    }

    SUMOTime getMinimalArrivalTime(double dist, double currentSpeed, double arrivalSpeed) const;


    double estimateArrivalTime(double dist, double speed, double maxSpeed, double accel) const;


    double getMinimalArrivalSpeed(double dist, double currentSpeed) const;

    double getMinimalArrivalSpeedEuler(double dist, double currentSpeed) const;


    static double gapExtrapolation(const double duration, const double currentGap, double v1,  double v2, double a1 = 0, double a2 = 0, const double maxV1 = std::numeric_limits<double>::max(), const double maxV2 = std::numeric_limits<double>::max());

    static double passingTime(const double lastPos, const double passedPos, const double currentPos, const double lastSpeed, const double currentSpeed);



    static double speedAfterTime(const double t, const double oldSpeed, const double dist);


    static double distAfterTime(double t, double speed, double decel);



    /* @brief estimate speed while accelerating for the given distance
     * @param[in] dist The distance during which accelerating takes place
     * @param[in] v The initial speed
     * @param[in] accel The acceleration
     * XXX affected by ticket #860 (the formula is invalid for the Euler position update rule)
     * XXX (Leo) Migrated estimateSpeedAfterDistance() to MSCFModel from MSVehicle as Jakob suggested (removed inline property, because myType is fw-declared)
     */
    double estimateSpeedAfterDistance(const double dist, const double v, const double accel) const;


    virtual void setMaxAccel(double accel) {
        myAccel = accel;
    }


    virtual void setMaxDecel(double decel) {
        myDecel = decel;
    }


    virtual void setEmergencyDecel(double decel) {
        myEmergencyDecel = decel;
    }


    virtual void setApparentDecel(double decel) {
        myApparentDecel = decel;
    }


    virtual void setImperfection(double imperfection) {
        UNUSED_PARAMETER(imperfection);
    }


    virtual void setHeadwayTime(double headwayTime) {
        myHeadwayTime = headwayTime;
    }

    double maximumSafeFollowSpeed(double gap,  double egoSpeed, double predSpeed, double predMaxDecel, bool onInsertion = false) const;


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


    double maximumSafeStopSpeedEuler(double gap) const;


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


protected:
    const MSVehicleType* myType;

    double myAccel;

    double myDecel;
    double myEmergencyDecel;
    double myApparentDecel;

    double myHeadwayTime;

};


#endif /* MSCFModel_h */