MSCFModel_CACC.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
/****************************************************************************/
// CACC car-following model based on [1], [2].
// [1] Milanes, V., and S. E. Shladover. Handling Cut-In Vehicles in Strings
//    of Cooperative Adaptive Cruise Control Vehicles. Journal of Intelligent
//     Transportation Systems, Vol. 20, No. 2, 2015, pp. 178-191.
// [2] Xiao, L., M. Wang and B. van Arem. Realistic Car-Following Models for
//    Microscopic Simulation of Adaptive and Cooperative Adaptive Cruise
//     Control Vehicles. Transportation Research Record: Journal of the
//     Transportation Research Board, No. 2623, 2017. (DOI: 10.3141/2623-01).
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "MSCFModel.h"
#include "MSCFModel_ACC.h"
#include <utils/xml/SUMOXMLDefinitions.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSVehicle;
class MSVehicleType;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSCFModel_CACC : public MSCFModel {
public:
    MSCFModel_CACC(const MSVehicleType* vtype);
 
    ~MSCFModel_CACC();
 
 
 
    double freeSpeed(const MSVehicle* const veh, double speed, double seen,
                     double maxSpeed, const bool onInsertion = false, const CalcReason usage = CalcReason::CURRENT) 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 gap2pred, double decel, const CalcReason usage = CalcReason::CURRENT) const;
 
 
    double getSecureGap(const MSVehicle* const veh, const MSVehicle* const pred, const double speed, const double leaderSpeed, const double leaderMaxDecel) const;
 
    double insertionFollowSpeed(const MSVehicle* const v, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred = 0) const;
 
 
    double interactionGap(const MSVehicle* const, double vL) const;
 
    void setHeadwayTime(double headwayTime) {
        myHeadwayTime = headwayTime;
        myHeadwayTimeACC = headwayTime;
        acc_CFM.setHeadwayTime(headwayTime);
    }
 
    virtual std::string getParameter(const MSVehicle* veh, const std::string& key) const;
 
 
    virtual void setParameter(MSVehicle* veh, const std::string& key, const std::string& value) const;
 
 
    int getModelID() const {
        return SUMO_TAG_CF_CACC;
    }
 
    double maximumLaneSpeedCF(const MSVehicle* const veh, double maxSpeed, double maxSpeedLane) const {
        double result = MIN2(maxSpeed, maxSpeedLane);
        if (myApplyDriverstate) {
            applyOwnSpeedPerceptionError(veh, result);
        }
        return result;
    }
 
 
 
    MSCFModel* duplicate(const MSVehicleType* vtype) const;
 
    virtual MSCFModel::VehicleVariables* createVehicleVariables() const {
        CACCVehicleVariables* ret = new CACCVehicleVariables();
        ret->ACC_ControlMode = 0;
        ret->CACC_ControlMode = 0;
        ret->CACC_CommunicationsOverrideMode = CACC_NO_OVERRIDE;
        ret->lastUpdateTime = 0;
        return ret;
    }
 
 
private:
    enum CommunicationsOverrideMode {
        CACC_NO_OVERRIDE = 0,
        CACC_MODE_NO_LEADER = 1,
        CACC_MODE_LEADER_NO_CAV = 2,
        CACC_MODE_LEADER_CAV = 3
    };
 
    static std::map<std::string, CommunicationsOverrideMode> CommunicationsOverrideModeMap;
 
    enum VehicleMode {
        CC_MODE = 0,
        ACC_MODE,
        CACC_GAP_MODE,
        CACC_GAP_CLOSING_MODE,
        CACC_COLLISION_AVOIDANCE_MODE
    };
 
    static std::map<VehicleMode, std::string> VehicleModeNames;
 
    class CACCVehicleVariables : public MSCFModel_ACC::ACCVehicleVariables {
    public:
        CACCVehicleVariables() : CACC_ControlMode(0), CACC_CommunicationsOverrideMode(CACC_NO_OVERRIDE) {}
        int    CACC_ControlMode;
        CommunicationsOverrideMode CACC_CommunicationsOverrideMode;
    };
 
private:
    double _v(const MSVehicle* const veh, const MSVehicle* const pred, const double gap2pred, const double mySpeed,
              const double predSpeed, const double desSpeed, const bool respectMinGap, const CalcReason usage = CalcReason::CURRENT) const;
 
    double speedSpeedControl(const double speed, double vErr, VehicleMode& vehMode) const;
    double speedGapControl(const MSVehicle* const veh, const double gap2pred,
                           const double speed, const double predSpeed, const double desSpeed, double vErr,
                           const MSVehicle* const pred, VehicleMode& vehMode) const;
 
private:
    MSCFModel_ACC acc_CFM;
    double mySpeedControlGain;
    double myGapClosingControlGainGap;
    double myGapClosingControlGainGapDot;
    double myGapControlGainGap;
    double myGapControlGainGapDot;
    double myCollisionAvoidanceGainGap;
    double myCollisionAvoidanceGainGapDot;
    double myHeadwayTimeACC;
    double myApplyDriverstate;
    double myEmergencyThreshold;
    double mySpeedControlMinGap;
 
private:
    MSCFModel_CACC& operator=(const MSCFModel_CACC& s);
};