org.opentrafficsim.road.gtu.lane.tactical.util.lmrs

Interface Synchronization

All Superinterfaces:

LmrsParameters

public interface Synchronization
extends LmrsParameters

Different forms of synchronization.

Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
BSD-style license. See OpenTrafficSim License.

Version:

$Revision$, $LastChangedDate$, by $Author$, initial version 3 apr. 2017

Author:

Alexander Verbraeck, Peter Knoppers, Wouter Schakel

Field Summary

Fields

Modifier and Type	Field and Description
static Synchronization	ACTIVE Synchronization where a suitable leader is actively targeted, in relation to infrastructure.
static Synchronization	ALIGN_GAP Synchronization by following the adjacent leader or aligning with the middle of the gap, whichever allows the largest acceleration.
static Synchronization	DEADEND Synchronization that only includes stopping for a dead-end.
static Synchronization	PASSIVE Synchronization where current leaders are taken.
static Synchronization	PASSIVE_MOVING Synchronization where current leaders are taken.

Fields inherited from interface org.opentrafficsim.road.gtu.lane.tactical.util.lmrs.LmrsParameters

COURTESY, DCOOP, DFREE, DLC, DLEFT, DRIGHT, DSYNC, SOCIO, VGAIN

Method Summary

Modifier and Type	Method and Description
static boolean	canBeAhead(HeadwayGTU adjacentVehicle, Length xCur, int nCur, Speed ownSpeed, Length ownLength, Speed tagSpeed, double dCoop, Acceleration b, Duration tMin, Duration tMax, Length x0, Duration t0, Duration lc, double desire) Returns whether a driver estimates it can be ahead of an adjacent vehicle for merging.
static Acceleration	gentleUrgency(Acceleration a, double desire, Parameters params) Return limited deceleration.
static HeadwayGTU	getFollower(HeadwayGTU gtu, PerceptionCollectable<HeadwayGTU,LaneBasedGTU> leaders, HeadwayGTU follower, Length ownLength) Returns the upstream gtu of the given gtu.
static Length	getMergeDistance(LanePerception perception, LateralDirectionality lat) Returns the distance to the next merge, stopping within this distance is futile for a lane change.
static HeadwayGTU	getTargetLeader(HeadwayGTU gtu, SortedSet<HeadwayGTU> leaders) Returns the leader of one gtu from a set.
static PerceptionCollectable<HeadwayGTU,LaneBasedGTU>	removeAllUpstreamOfConflicts(PerceptionCollectable<HeadwayGTU,LaneBasedGTU> set, LanePerception perception, RelativeLane relativeLane) Removes all GTUs from the set, that are found upstream on the conflicting lane of a conflict in the current lane.
static Length	requiredBufferSpace(Speed speed, int nCur, Length x0, Duration t0, Duration lc, double dCoop) Returns the required buffer space to perform a lane change and further lane changes.
static Acceleration	stopForEnd(Length xCur, Length xMerge, Parameters params, Speed ownSpeed, CarFollowingModel cfm, SpeedLimitInfo sli) Calculates acceleration to stop for a split or dead-end, accounting for infrastructure.
Acceleration	synchronize(LanePerception perception, Parameters params, SpeedLimitInfo sli, CarFollowingModel cfm, double desire, LateralDirectionality lat, LmrsData lmrsData) Determine acceleration for synchronization.
static Acceleration	tagAlongAcceleration(HeadwayGTU leader, Speed followerSpeed, Length followerLength, Speed tagSpeed, double desire, Parameters params, SpeedLimitInfo sli, CarFollowingModel cfm) Calculates acceleration by following an adjacent vehicle, with tagging along if desire is not very high and speed is low.

Field Detail

DEADEND

static final Synchronization DEADEND

Synchronization that only includes stopping for a dead-end.

PASSIVE

static final Synchronization PASSIVE

Synchronization where current leaders are taken.

ALIGN_GAP

static final Synchronization ALIGN_GAP

Synchronization by following the adjacent leader or aligning with the middle of the gap, whichever allows the largest acceleration. Note that aligning with the middle of the gap then means the gap is too small, as following would cause lower acceleration. Aligning with the middle of the gap will however provide a better starting point for the rest of the process. Mainly, the adjacent follower can decelerate less, allowing more smooth merging.

PASSIVE_MOVING

static final Synchronization PASSIVE_MOVING

Synchronization where current leaders are taken. Synchronization is disabled for d_sync<d<d_coop at low speeds.

ACTIVE

static final Synchronization ACTIVE

Synchronization where a suitable leader is actively targeted, in relation to infrastructure.

Method Detail

getMergeDistance

static Length getMergeDistance(LanePerception perception,
                               LateralDirectionality lat)
                        throws OperationalPlanException

Returns the distance to the next merge, stopping within this distance is futile for a lane change.

Parameters:

perception - LanePerception; perception

lat - LateralDirectionality; lateral direction

Returns:

Length; distance to the next merge

Throws:

OperationalPlanException - if there is no infrastructure perception

synchronize

Acceleration synchronize(LanePerception perception,
                         Parameters params,
                         SpeedLimitInfo sli,
                         CarFollowingModel cfm,
                         double desire,
                         LateralDirectionality lat,
                         LmrsData lmrsData)
                  throws ParameterException,
                         OperationalPlanException

Determine acceleration for synchronization.

Parameters:

perception - LanePerception; perception

params - Parameters; parameters

sli - SpeedLimitInfo; speed limit info

cfm - CarFollowingModel; car-following model

desire - double; level of lane change desire

lat - LateralDirectionality; lateral direction for synchronization

lmrsData - LmrsData; LMRS data

Returns:

acceleration for synchronization

Throws:

ParameterException - if a parameter is not defined

OperationalPlanException - perception exception

removeAllUpstreamOfConflicts

static PerceptionCollectable<HeadwayGTU,LaneBasedGTU> removeAllUpstreamOfConflicts(PerceptionCollectable<HeadwayGTU,LaneBasedGTU> set,
                                                                                   LanePerception perception,
                                                                                   RelativeLane relativeLane)
                                                                            throws OperationalPlanException

Removes all GTUs from the set, that are found upstream on the conflicting lane of a conflict in the current lane.

Parameters:

set - PerceptionCollectable<HeadwayGTU,LaneBasedGTU>; set of GTUs

perception - LanePerception; perception

relativeLane - RelativeLane; relative lane

Returns:

the input set, for chained use

Throws:

OperationalPlanException - if the IntersectionPerception category is not present

gentleUrgency

static Acceleration gentleUrgency(Acceleration a,
                                  double desire,
                                  Parameters params)
                           throws ParameterException

Return limited deceleration. Deceleration is limited to b for d < dCoop. Beyond dCoop the limit is a linear interpolation between b and bCrit.

Parameters:

a - Acceleration; acceleration to limit

desire - double; lane change desire

params - Parameters; parameters

Returns:

limited deceleration

Throws:

ParameterException - when parameter is no available or value out of range

getFollower

static HeadwayGTU getFollower(HeadwayGTU gtu,
                              PerceptionCollectable<HeadwayGTU,LaneBasedGTU> leaders,
                              HeadwayGTU follower,
                              Length ownLength)

Returns the upstream gtu of the given gtu.

Parameters:

gtu - HeadwayGTU; gtu

leaders - PerceptionCollectable<HeadwayGTU,LaneBasedGTU>; leaders of own vehicle

follower - HeadwayGTU; following vehicle of own vehicle

ownLength - Length; own vehicle length

Returns:

upstream gtu of the given gtu

tagAlongAcceleration

static Acceleration tagAlongAcceleration(HeadwayGTU leader,
                                         Speed followerSpeed,
                                         Length followerLength,
                                         Speed tagSpeed,
                                         double desire,
                                         Parameters params,
                                         SpeedLimitInfo sli,
                                         CarFollowingModel cfm)
                                  throws ParameterException

Calculates acceleration by following an adjacent vehicle, with tagging along if desire is not very high and speed is low.

Parameters:

leader - HeadwayGTU; leader

followerSpeed - Speed; follower speed

followerLength - Length; follower length

tagSpeed - Speed; maximum tag along speed

desire - double; lane change desire

params - Parameters; parameters

sli - SpeedLimitInfo; speed limit info

cfm - CarFollowingModel; car-following model

Returns:

acceleration by following an adjacent vehicle including tagging along

Throws:

ParameterException - if a parameter is not present

canBeAhead

static boolean canBeAhead(HeadwayGTU adjacentVehicle,
                          Length xCur,
                          int nCur,
                          Speed ownSpeed,
                          Length ownLength,
                          Speed tagSpeed,
                          double dCoop,
                          Acceleration b,
                          Duration tMin,
                          Duration tMax,
                          Length x0,
                          Duration t0,
                          Duration lc,
                          double desire)
                   throws ParameterException

Returns whether a driver estimates it can be ahead of an adjacent vehicle for merging.

Parameters:

adjacentVehicle - HeadwayGTU; adjacent vehicle

xCur - Length; remaining distance

nCur - int; number of lane changes to perform

ownSpeed - Speed; own speed

ownLength - Length; own length

tagSpeed - Speed; maximum tag along speed

dCoop - double; cooperation threshold

b - Acceleration; critical deceleration

tMin - Duration; minimum headway

tMax - Duration; normal headway

x0 - Length; anticipation distance

t0 - Duration; anticipation time

lc - Duration; lane change duration

desire - double; lane change desire

Returns:

whether a driver estimates it can be ahead of an adjacent vehicle for merging

Throws:

ParameterException - if parameter is not defined

requiredBufferSpace

static Length requiredBufferSpace(Speed speed,
                                  int nCur,
                                  Length x0,
                                  Duration t0,
                                  Duration lc,
                                  double dCoop)

Returns the required buffer space to perform a lane change and further lane changes.

Parameters:

speed - Speed; representative speed

nCur - int; number of required lane changes

x0 - Length; anticipation distance

t0 - Duration; anticipation time

lc - Duration; lane change duration

dCoop - double; cooperation threshold

Returns:

required buffer space to perform a lane change and further lane changes

stopForEnd

static Acceleration stopForEnd(Length xCur,
                               Length xMerge,
                               Parameters params,
                               Speed ownSpeed,
                               CarFollowingModel cfm,
                               SpeedLimitInfo sli)
                        throws ParameterException

Calculates acceleration to stop for a split or dead-end, accounting for infrastructure.

Parameters:

xCur - Length; remaining distance to end

xMerge - Length; distance until merge point

params - Parameters; parameters

ownSpeed - Speed; own speed

cfm - CarFollowingModel; car-following model

sli - SpeedLimitInfo; speed limit info

Returns:

acceleration to stop for a split or dead-end, accounting for infrastructure

Throws:

ParameterException - if parameter is not defined

getTargetLeader

static HeadwayGTU getTargetLeader(HeadwayGTU gtu,
                                  SortedSet<HeadwayGTU> leaders)

Returns the leader of one gtu from a set.

Parameters:

gtu - HeadwayGTU; gtu

leaders - SortedSet<HeadwayGTU>; leaders

Returns:

leader of one gtu from a set