IdmPlusOld.java

  1. package org.opentrafficsim.road.gtu.lane.tactical.following;

  3. import java.io.Serializable;

  5. import org.djunits.unit.AccelerationUnit;
  6. import org.djunits.unit.DurationUnit;
  7. import org.djunits.unit.LengthUnit;
  8. import org.djunits.unit.SpeedUnit;
  9. import org.djunits.value.vdouble.scalar.Acceleration;
  10. import org.djunits.value.vdouble.scalar.Duration;
  11. import org.djunits.value.vdouble.scalar.Length;
  12. import org.djunits.value.vdouble.scalar.Speed;
  13. import org.opentrafficsim.base.parameters.ParameterException;
  14. import org.opentrafficsim.base.parameters.Parameters;
  15. import org.opentrafficsim.road.gtu.lane.perception.PerceptionIterable;
  16. import org.opentrafficsim.road.gtu.lane.perception.headway.Headway;
  17. import org.opentrafficsim.road.network.speed.SpeedLimitInfo;
  18. import org.opentrafficsim.road.network.speed.SpeedLimitTypes;

  20. /**
  21.  * IDMPlus implements the <i>Integrated Lane Change Model with Relaxation and Synchronization</i> as published by Wouter J.
  22.  * Schakel, Bart van Arem, Member, IEEE, and Bart D. Netten. 2012. <br>
  23.  * There are two nasty type setting errors in equation 7 in this published version of the paper. Both times an equals sign
  24.  * (<cite>=</cite>) after <cite>a<sub>gain</sub></cite> should <b>not</b> be there.
  25.  * <p>
  26.  * Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  27.  * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  28.  * </p>
  29.  * @author <a href="https://tudelft.nl/staff/p.knoppers-1">Peter Knoppers</a>
  30.  */
  31. public class IdmPlusOld extends AbstractGtuFollowingModelMobil implements Serializable
  32. {
  33.     /** */
  34.     private static final long serialVersionUID = 20140704L;

  36.     /** Preferred net longitudinal distance when stopped [m]. */
  37.     private final Length s0;

  39.     /** Longitudinal acceleration [m/s^2]. */
  40.     private Acceleration a;

  42.     /** Longitudinal deceleration [m/s^2]. (Should be a positive value even though it is a <b>de</b>celeration.) */
  43.     private final Acceleration b;

  45.     /** Safe time headway. */
  46.     private Duration tSafe;

  48.     /**
  49.      * Mean speed limit adherence (1.0: mean free speed equals the speed limit; 1.1: mean free speed equals 110% of the speed
  50.      * limit, etc.).
  51.      */
  52.     private double delta;

  54.     /**
  55.      * Default step size used by IDMPlus (not defined in the paper, but 0.5s is a reasonable trade-off between computational
  56.      * speed and accuracy).
  57.      */
  58.     private static final Duration DEFAULT_STEP_SIZE = new Duration(0.5, DurationUnit.SECOND);

  60.     /**
  61.      * Construct a new IDM+ car following model with reasonable values (reasonable for passenger cars). <br>
  62.      * These values are from <b>Integrated Lane Change Model with Relaxation and Synchronization</b> by Wouter J. Schakel,
  63.      * Victor L. Knoop, and Bart van Arem, published in Transportation Research Record: Journal of the Transportation Research
  64.      * Board, No. 2316, Transportation Research Board of the National Academies, Washington, D.C., 2012, pp. 47–57.
  65.      */
  66.     public IdmPlusOld()
  67.     {
  68.         this.a = new Acceleration(1.56, AccelerationUnit.METER_PER_SECOND_2);
  69.         this.b = new Acceleration(2.09, AccelerationUnit.METER_PER_SECOND_2);
  70.         this.s0 = new Length(3, LengthUnit.METER);
  71.         this.tSafe = new Duration(1.2, DurationUnit.SECOND);
  72.         this.delta = 1d;
  73.     }

  75.     /**
  76.      * Construct a new IDMPlus car following model.
  77.      * @param a Acceleration; the maximum acceleration of a stationary vehicle (normal value is 1 m/s/s)
  78.      * @param b Acceleration; the maximum deemed-safe deceleration (this is a positive value)
  79.      * @param s0 Length; the minimum stationary headway
  80.      * @param tSafe Duration; the minimum time-headway
  81.      * @param delta double; the speed limit adherence (1.0; mean free speed equals the speed limit; 1.1: mean free speed equals
  82.      *            110% of the speed limit; etc.)
  83.      */
  84.     public IdmPlusOld(final Acceleration a, final Acceleration b, final Length s0, final Duration tSafe, final double delta)
  85.     {
  86.         this.a = a;
  87.         this.b = b;
  88.         this.s0 = s0;
  89.         this.tSafe = tSafe;
  90.         this.delta = delta;
  91.     }

  93.     /**
  94.      * Desired speed (taking into account the urge to drive a little faster or slower than the posted speed limit).
  95.      * @param speedLimit Speed; the speed limit
  96.      * @param followerMaximumSpeed Speed; the maximum speed that the follower can drive
  97.      * @return DoubleScalarRel&lt;SpeedUnit&gt;; the desired speed
  98.      */
  99.     private Speed vDes(final Speed speedLimit, final Speed followerMaximumSpeed)
  100.     {
  101.         return new Speed(Math.min(this.delta * speedLimit.getSI(), followerMaximumSpeed.getSI()), SpeedUnit.SI);
  102.     }

  104.     /** {@inheritDoc} */
  105.     @Override
  106.     public final Acceleration computeAcceleration(final Speed followerSpeed, final Speed followerMaximumSpeed,
  107.             final Speed leaderSpeed, final Length headway, final Speed speedLimit)
  108.     {
  109.         return computeAcceleration(followerSpeed, followerMaximumSpeed, leaderSpeed, headway, speedLimit, DEFAULT_STEP_SIZE);
  110.     }

  112.     /** {@inheritDoc} */
  113.     @Override
  114.     public final Acceleration computeAcceleration(final Speed followerSpeed, final Speed followerMaximumSpeed,
  115.             final Speed leaderSpeed, final Length headway, final Speed speedLimit, final Duration stepSize)
  116.     {
  117.         // TODO maxDistance
  118.         double leftComponent = 1 - Math.pow(followerSpeed.getSI() / vDes(speedLimit, followerMaximumSpeed).getSI(), 4);
  119.         if (Double.isNaN(leftComponent))
  120.         {
  121.             leftComponent = 0;
  122.         }
  123.         // limit deceleration for free term (= leftComponent)
  124.         if (leftComponent * this.a.si < -0.5)
  125.         {
  126.             leftComponent = -0.5 / this.a.si;
  127.         }
  128.         Acceleration logWeightedAccelerationTimes2 =
  129.                 new Acceleration(Math.sqrt(this.a.getSI() * this.b.getSI()), AccelerationUnit.SI).times(2);
  130.         // don't forget the times 2

  132.         Speed dV = followerSpeed.minus(leaderSpeed);
  133.         Length sStar = this.s0.plus(followerSpeed.times(this.tSafe))
  134.                 .plus(dV.times(followerSpeed.divide(logWeightedAccelerationTimes2)));

  136.         /*-
  137.         this.s0.plus(Calc.speedTimesTime(followerSpeed, this.tSafe)).plus(
  138.         Calc.speedTimesTime(dV, Calc.speedDividedByAcceleration(followerSpeed, logWeightedAccelerationTimes2)));
  139.          */
  140.         if (sStar.getSI() < 0)
  141.         {
  142.             // Negative value should be treated as 0? This is NOT in the LMRS paper
  143.             // Without this "fix" a higher speed of the leader may cause a lower acceleration (which is crazy)
  144.             sStar = new Length(0, LengthUnit.SI);
  145.         }

  147.         double rightComponent = 1 - Math.pow(sStar.getSI() / headway.getSI(), 2);
  148.         Acceleration newAcceleration = new Acceleration(this.a).times(Math.min(leftComponent, rightComponent));
  149.         if (newAcceleration.getSI() * stepSize.getSI() + followerSpeed.getSI() < 0)
  150.         {
  151.             newAcceleration = new Acceleration(-followerSpeed.getSI() / stepSize.getSI(), AccelerationUnit.SI);
  152.         }
  153.         return newAcceleration;
  154.     }

  156.     /** {@inheritDoc} */
  157.     @Override
  158.     public final Duration getStepSize()
  159.     {
  160.         return DEFAULT_STEP_SIZE;
  161.     }

  163.     /** {@inheritDoc} */
  164.     @Override
  165.     public final Acceleration getMaximumSafeDeceleration()
  166.     {
  167.         return this.b;
  168.     }

  170.     /** {@inheritDoc} */
  171.     @Override
  172.     public final String getName()
  173.     {
  174.         return "IDM+";
  175.     }

  177.     /** {@inheritDoc} */
  178.     @Override
  179.     public final String getLongName()
  180.     {
  181.         return String.format("%s (a=%.1fm/s\u00b2, b=%.1fm/s\u00b2, s0=%.1fm, tSafe=%.1fs, delta=%.2f)", getName(),
  182.                 this.a.getSI(), this.b.getSI(), this.s0.getSI(), this.tSafe.getSI(), this.delta);
  183.     }

  185.     /** {@inheritDoc} */
  186.     @Override
  187.     public final void setA(final Acceleration a)
  188.     {
  189.         this.a = a;
  190.     }

  192.     /** {@inheritDoc} */
  193.     @Override
  194.     public final void setT(final Duration t)
  195.     {
  196.         this.tSafe = t;
  197.     }

  199.     /** {@inheritDoc} */
  200.     @Override
  201.     public final void setFspeed(final double fSpeed)
  202.     {
  203.         this.delta = fSpeed;
  204.     }

  206.     // The following is inherited from CarFollowingModel

  208.     /** {@inheritDoc} */
  209.     @Override
  210.     public final Speed desiredSpeed(final Parameters parameters, final SpeedLimitInfo speedInfo) throws ParameterException
  211.     {
  212.         throw new UnsupportedOperationException("Old car-following model does not support desired speed.");
  213.     }

  215.     /** {@inheritDoc} */
  216.     @Override
  217.     public final Length desiredHeadway(final Parameters parameters, final Speed speed) throws ParameterException
  218.     {
  219.         throw new UnsupportedOperationException("Old car-following model does not support desired headway.");
  220.     }

  222.     /** {@inheritDoc} */
  223.     @Override
  224.     public final Acceleration followingAcceleration(final Parameters parameters, final Speed speed,
  225.             final SpeedLimitInfo speedInfo, final PerceptionIterable<? extends Headway> leaders) throws ParameterException
  226.     {
  227.         Length headway;
  228.         Speed leaderSpeed;
  229.         if (leaders.isEmpty())
  230.         {
  231.             headway = new Length(Double.MAX_VALUE, LengthUnit.SI);
  232.             leaderSpeed = speed;
  233.         }
  234.         else
  235.         {
  236.             Headway leader = leaders.first();
  237.             headway = leader.getDistance();
  238.             leaderSpeed = leader.getSpeed();
  239.         }
  240.         return this.computeAcceleration(speed, speedInfo.getSpeedInfo(SpeedLimitTypes.MAX_VEHICLE_SPEED), leaderSpeed, headway,
  241.                 speedInfo.getSpeedInfo(SpeedLimitTypes.FIXED_SIGN));
  242.     }

  244.     /** {@inheritDoc} */
  245.     @Override
  246.     public final String toString()
  247.     {
  248.         return "IDMPlusOld [s0=" + this.s0 + ", a=" + this.a + ", b=" + this.b + ", tSafe=" + this.tSafe + ", delta="
  249.                 + this.delta + ", stepSize=" + DEFAULT_STEP_SIZE + "]";
  250.     }

  252. }
Created with JaCoCo 0.8.12.202403310830