AbstractLaneBasedGTU (Open Traffic Sim core classes 0.02.03 API)

java.lang.Object
- org.opentrafficsim.core.gtu.AbstractGTU<ID>
- - org.opentrafficsim.core.gtu.lane.AbstractLaneBasedGTU<ID>

Type Parameters:

ID - The type of ID, e.g., String or Integer

All Implemented Interfaces:

Serializable, LocatableInterface, GTU<ID>, LaneBasedGTU<ID>

Direct Known Subclasses:

AbstractLaneBasedIndividualGTU, AbstractLaneBasedTemplateGTU
```
public abstract class AbstractLaneBasedGTU<ID>
extends AbstractGTU<ID>
implements LaneBasedGTU<ID>
```
This class contains most of the code that is needed to run a lane based GTU.
The starting point of a LaneBasedTU is that it can be in multiple lanes at the same time. This can be due to a lane change (lateral), or due to crossing a link (front of the GTU is on another Lane than rear of the GTU). If a Lane is shorter than the length of the GTU (e.g. when we do node expansion on a crossing, this is very well possible), a GTU could occupy dozens of Lanes at the same time.
When calculating a headway, the GTU has to look in successive lanes. When Lanes (or underlying CrossSectionLinks) diverge, the headway algorithms have to look at multiple Lanes and return the minimum headway in each of the Lanes. When the Lanes (or underlying CrossSectionLinks) converge, "parallel" traffic is not taken into account in the headway calculation. Instead, gap acceptance algorithms or their equivalent should guide the merging behavior.
To decide its movement, an AbstractLaneBasedGTU applies its car following algorithm and lane change algorithm to set the acceleration and any lane change operation to perform. It then schedules the triggers that will add it to subsequent lanes and remove it from current lanes as needed during the time step that is has committed to. Finally, it re-schedules its next movement evaluation with the simulator.
Copyright (c) 2013-2015 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
BSD-style license. See OpenTrafficSim License.

Version:

$Revision: 1178 $, $LastChangedDate: 2015-08-04 02:55:18 +0200 (Tue, 04 Aug 2015) $, by $Author: averbraeck $, initial version Oct 22, 2014

Author:

Alexander Verbraeck, Peter Knoppers

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`AbstractLaneBasedGTU(ID id, GTUType<?> gtuType, GTUFollowingModel gtuFollowingModel, LaneChangeModel laneChangeModel, Map<Lane<?,?>,DoubleScalar.Rel<LengthUnit>> initialLongitudinalPositions, DoubleScalar.Abs<SpeedUnit> initialSpeed, LaneBasedRouteNavigator routeNavigator, OTSDEVSSimulatorInterface simulator)` Construct a Lane Based GTU.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addFrontToSubsequentLane(Lane<?,?> lane)` Register the lane with a GTU, at the start of the lane.
`void`	`addLane(Lane<?,?> lane, DoubleScalar.Rel<LengthUnit> position)` insert GTU at a certain position.
`DoubleScalar.Rel<TimeUnit>`	`deltaTimeForDistance(DoubleScalar.Rel<LengthUnit> distance)` Determine the time since last evaluation when this GTU has covered the specified distance from the position of the last evaluation time.
`void`	`destroy()` destroy the vehicle from the simulation and animation.
`double`	`fractionalPosition(Lane<?,?> lane, RelativePosition relativePosition)` Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane, as a fraction of the length of the lane.
`double`	`fractionalPosition(Lane<?,?> lane, RelativePosition relativePosition, DoubleScalar.Abs<TimeUnit> when)` Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane, as a fraction of the length of the lane.
`Map<Lane<?,?>,Double>`	`fractionalPositions(RelativePosition relativePosition)` Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered, as fractions of the length of the lane.
`Map<Lane<?,?>,Double>`	`fractionalPositions(RelativePosition relativePosition, DoubleScalar.Abs<TimeUnit> when)` Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered, as fractions of the length of the lane.
`DoubleScalar.Abs<AccelerationUnit>`	`getAcceleration()`
`DoubleScalar.Abs<AccelerationUnit>`	`getAcceleration(DoubleScalar.Abs<TimeUnit> when)`
`javax.media.j3d.Bounds`	`getBounds()`
`GTUFollowingModel`	`getGTUFollowingModel()` Retrieve the GTUFollowingModel of this GTU.
`LaneChangeUrgeGTUColorer.LaneChangeDistanceAndDirection`	`getLaneChangeDistanceAndDirection()` Return the distance available for the next needed lane change and the lateral direction of that lane change.
`List<Lane<?,?>>`	`getLanes()`
`DoubleScalar.Abs<TimeUnit>`	`getLastEvaluationTime()`
`DoubleScalar.Abs<SpeedUnit>`	`getLateralVelocity()`
`DirectedPoint`	`getLocation()`
`DoubleScalar.Abs<SpeedUnit>`	`getLongitudinalVelocity()` v(t) = v0 + (t - t0) * a.
`DoubleScalar.Abs<SpeedUnit>`	`getLongitudinalVelocity(DoubleScalar.Abs<TimeUnit> when)` Return the speed of this GTU at the specified time.
`DoubleScalar.Abs<TimeUnit>`	`getNextEvaluationTime()`
`DoubleScalar.Abs<LengthUnit>`	`getOdometer()` Retrieve the odometer value.
`DoubleScalar.Abs<SpeedUnit>`	`getVelocity()`
`HeadwayGTU`	`headway(DoubleScalar.Rel<LengthUnit> maxDistance)` Determine which GTU in front of this GTU, or behind this GTU.
`HeadwayGTU`	`headway(Lane<?,?> lane, DoubleScalar.Rel<LengthUnit> maxDistance)` Determine by what distance the front of this GTU is behind the rear an other GTU, or the rear of this GTU is ahead of the front of an other GTU.
`protected void`	`move()` Move this GTU to it's current location, then compute (and commit to) the next movement step.
`Set<LaneBasedGTU<?>>`	`parallel(Lane<?,?> lane, DoubleScalar.Abs<TimeUnit> when)` Determine which GTUs are parallel with us on another lane, based on fractional positions.
`Set<LaneBasedGTU<?>>`	`parallel(LateralDirectionality lateralDirection, DoubleScalar.Abs<TimeUnit> when)` Determine which GTUs are parallel with us in a certain lateral direction, based on fractional positions.
`DoubleScalar.Rel<LengthUnit>`	`position(Lane<?,?> lane, RelativePosition relativePosition)` Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane at the current simulation time.
`DoubleScalar.Rel<LengthUnit>`	`position(Lane<?,?> lane, RelativePosition relativePosition, DoubleScalar.Abs<TimeUnit> when)` Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane.
`Map<Lane<?,?>,DoubleScalar.Rel<LengthUnit>>`	`positions(RelativePosition relativePosition)` Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered.
`Map<Lane<?,?>,DoubleScalar.Rel<LengthUnit>>`	`positions(RelativePosition relativePosition, DoubleScalar.Abs<TimeUnit> when)` Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered.
`DoubleScalar.Rel<LengthUnit>`	`projectedPosition(Lane<?,?> projectionLane, RelativePosition relativePosition, DoubleScalar.Abs<TimeUnit> when)` Return the longitudinal position that this GTU would have if it were to change to another Lane with a/the current CrossSectionLink.
`void`	`removeLane(Lane<?,?> lane)` Unregister the GTU from a lane.
`DoubleScalar.Abs<TimeUnit>`	`timeAtDistance(DoubleScalar.Rel<LengthUnit> distance)` Determine the time when this GTU will have covered the specified distance from the position of the last evaluation time.
`String`	`toString(Lane<?,?> lane, DoubleScalar.Abs<TimeUnit> when)` Description of Car at specified time.

Methods inherited from class org.opentrafficsim.core.gtu.AbstractGTU
getGTUType, getId, getReference, getRoute, setRoute

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.opentrafficsim.core.gtu.GTU
getFront, getGTUType, getId, getLength, getMaximumVelocity, getRear, getReference, getRelativePositions, getSimulator, getWidth

- Constructor Detail
  - AbstractLaneBasedGTU
```
public AbstractLaneBasedGTU(ID id,
                            GTUType<?> gtuType,
                            GTUFollowingModel gtuFollowingModel,
                            LaneChangeModel laneChangeModel,
                            Map<Lane<?,?>,DoubleScalar.Rel<LengthUnit>> initialLongitudinalPositions,
                            DoubleScalar.Abs<SpeedUnit> initialSpeed,
                            LaneBasedRouteNavigator routeNavigator,
                            OTSDEVSSimulatorInterface simulator)
                     throws RemoteException,
                            NetworkException,
                            SimRuntimeException,
                            GTUException
```
    Construct a Lane Based GTU.
    
    Parameters:
    
    id - the id of the GTU, could be String or Integer
    
    gtuType - the type of GTU, e.g. TruckType, CarType, BusType
    
    gtuFollowingModel - the following model, including a reference to the simulator.
    
    laneChangeModel - LaneChangeModel; the lane change model
    
    initialLongitudinalPositions - the initial positions of the car on one or more lanes
    
    initialSpeed - the initial speed of the car on the lane
    
    routeNavigator - Route; the route that the GTU will take
    
    simulator - to initialize the move method and to get the current time
    
    Throws:
    
    RemoteException - when the simulator cannot be reached
    
    NetworkException - when the GTU cannot be placed on the given lane
    
    SimRuntimeException - when the move method cannot be scheduled
    
    GTUException - when gtuFollowingModel is null
- Method Detail
  - getLongitudinalVelocity
```
public final DoubleScalar.Abs<SpeedUnit> getLongitudinalVelocity(DoubleScalar.Abs<TimeUnit> when)
```
    Return the speed of this GTU at the specified time.
    v(t) = v0 + (t - t0) * a
    
    Specified by:
    
    getLongitudinalVelocity in interface LaneBasedGTU<ID>
    
    Parameters:
    
    when - time for which the speed must be returned
    
    Returns:
    
    DoubleScalarAbs<SpeedUnit>; the speed at the specified time
  - getLongitudinalVelocity
```
public final DoubleScalar.Abs<SpeedUnit> getLongitudinalVelocity()
                                                          throws RemoteException
```
    v(t) = v0 + (t - t0) * a.
    
    Specified by:
    
    getLongitudinalVelocity in interface LaneBasedGTU<ID>
    
    Returns:
    
    the velocity of the GTU, in the direction of the lane
    
    Throws:
    
    RemoteException - in case of problems getting the simulation time.
  - getVelocity
```
public final DoubleScalar.Abs<SpeedUnit> getVelocity()
                                              throws RemoteException
```
    Specified by:
    
    getVelocity in interface GTU<ID>
    
    Returns:
    
    the current velocity of the GTU, combining longitudinal, lateral and vertical speed components.
    
    Throws:
    
    RemoteException - on communications failure
  - getLastEvaluationTime
```
public final DoubleScalar.Abs<TimeUnit> getLastEvaluationTime()
```
    Specified by:
    
    getLastEvaluationTime in interface LaneBasedGTU<ID>
    
    Returns:
    
    DoubleScalarAbs<TimeUnit>; the time of last evaluation.
  - getNextEvaluationTime
```
public final DoubleScalar.Abs<TimeUnit> getNextEvaluationTime()
```
    Specified by:
    
    getNextEvaluationTime in interface LaneBasedGTU<ID>
    
    Returns:
    
    DoubleScalarAbs<TimeUnit>; the time of next evaluation.
  - getAcceleration
```
public final DoubleScalar.Abs<AccelerationUnit> getAcceleration(DoubleScalar.Abs<TimeUnit> when)
```
    Specified by:
    
    getAcceleration in interface LaneBasedGTU<ID>
    
    Parameters:
    
    when - time for which the speed must be returned
    
    Returns:
    
    the acceleration (or deceleration) of the GTU, in the direction of the lane.
  - getAcceleration
```
public final DoubleScalar.Abs<AccelerationUnit> getAcceleration()
                                                         throws RemoteException
```
    Specified by:
    
    getAcceleration in interface GTU<ID>
    
    Specified by:
    
    getAcceleration in interface LaneBasedGTU<ID>
    
    Returns:
    
    the acceleration (or deceleration) of the GTU, in the direction of the lane
    
    Throws:
    
    RemoteException - in case of problems getting the simulation time.
  - getOdometer
```
public final DoubleScalar.Abs<LengthUnit> getOdometer()
                                               throws RemoteException
```
    Retrieve the odometer value.
    
    Specified by:
    
    getOdometer in interface GTU<ID>
    
    Returns:
    
    DoubleScalar.Abs<LengthUnit>; the current odometer value
    
    Throws:
    
    RemoteException - on communications failure
  - getLateralVelocity
```
public final DoubleScalar.Abs<SpeedUnit> getLateralVelocity()
```
    Specified by:
    
    getLateralVelocity in interface LaneBasedGTU<ID>
    
    Returns:
    
    the velocity of the GTU, perpendicular to the direction of the lane. Positive lateral velocity is "left" compared to the driving direction.
  - addFrontToSubsequentLane
```
public final void addFrontToSubsequentLane(Lane<?,?> lane)
                                    throws RemoteException,
                                           NetworkException
```
    Register the lane with a GTU, at the start of the lane. The reference point will be registered at the time and relative position of the last evaluation of the GTU to keep calculations consistent.
    
    Specified by:
    
    addFrontToSubsequentLane in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the lane to add to the list of lanes on which the GTU is registered.
    
    Throws:
    
    RemoteException - on communications failure
    
    NetworkException - on network inconsistency
  - addLane
```
public final void addLane(Lane<?,?> lane,
                          DoubleScalar.Rel<LengthUnit> position)
                   throws NetworkException
```
    insert GTU at a certain position. This can happen at setup (first initialization), and after a lane change of the GTU. The relative position that will be registered is the referencePosition (dx, dy, dz) = (0, 0, 0). Front and rear positions are relative towards this position.
    
    Specified by:
    
    addLane in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the lane to add to the list of lanes on which the GTU is registered.
    
    position - the position on the lane.
    
    Throws:
    
    NetworkException - on network inconsistency
  - removeLane
```
public final void removeLane(Lane<?,?> lane)
```
    Unregister the GTU from a lane.
    
    Specified by:
    
    removeLane in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the lane to remove from the list of lanes on which the GTU is registered.
  - getLanes
```
public final List<Lane<?,?>> getLanes()
```
    Returns:
    
    lanes.
  - move
```
protected final void move()
                   throws RemoteException,
                          NetworkException,
                          GTUException,
                          SimRuntimeException,
                          ValueException
```
    Move this GTU to it's current location, then compute (and commit to) the next movement step.
    
    Throws:
    
    RemoteException - on communications failure
    
    NetworkException - on network inconsistency
    
    GTUException - when GTU has not lane change model
    
    SimRuntimeException - on not being able to reschedule this move() method.
    
    ValueException - cannot happen
  - positions
```
public final Map<Lane<?,?>,DoubleScalar.Rel<LengthUnit>> positions(RelativePosition relativePosition)
                                                            throws NetworkException,
                                                                   RemoteException
```
    Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered.
    Note: If a GTU is registered in multiple parallel lanes, the lateralLaneChangeModel is used to determine the center line of the vehicle at this point in time. Otherwise, the average of the center positions of the lines will be taken.
    
    Specified by:
    
    positions in interface LaneBasedGTU<ID>
    
    Parameters:
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    Returns:
    
    the lanes and the position on the lanes where the GTU is currently registered, for the given position of the GTU.
    
    Throws:
    
    NetworkException - when the vehicle is not on one of the lanes on which it is registered.
    
    RemoteException - when simulator time cannot be retrieved.
  - positions
```
public final Map<Lane<?,?>,DoubleScalar.Rel<LengthUnit>> positions(RelativePosition relativePosition,
                                                                   DoubleScalar.Abs<TimeUnit> when)
                                                            throws NetworkException,
                                                                   RemoteException
```
    Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered.
    
    Specified by:
    
    positions in interface LaneBasedGTU<ID>
    
    Parameters:
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    when - the future time for which to calculate the positions.
    
    Returns:
    
    the lanes and the position on the lanes where the GTU will be registered at the time, for the given position of the GTU.
    
    Throws:
    
    NetworkException - when the vehicle is not on one of the lanes on which it is registered.
    
    RemoteException - on communications failure
  - position
```
public final DoubleScalar.Rel<LengthUnit> position(Lane<?,?> lane,
                                                   RelativePosition relativePosition)
                                            throws NetworkException,
                                                   RemoteException
```
    Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane at the current simulation time.
    
    Specified by:
    
    position in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the position on this lane will be returned.
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    Returns:
    
    DoubleScalarAbs<LengthUnit>; the position, relative to the center line of the Lane.
    
    Throws:
    
    NetworkException - when the vehicle is not on the given lane.
    
    RemoteException - when simulator time cannot be retrieved.
  - projectedPosition
```
public final DoubleScalar.Rel<LengthUnit> projectedPosition(Lane<?,?> projectionLane,
                                                            RelativePosition relativePosition,
                                                            DoubleScalar.Abs<TimeUnit> when)
                                                     throws NetworkException,
                                                            RemoteException
```
    Return the longitudinal position that this GTU would have if it were to change to another Lane with a/the current CrossSectionLink.
    
    Specified by:
    
    projectedPosition in interface LaneBasedGTU<ID>
    
    Parameters:
    
    projectionLane - Lane; the lane onto which the position of this GTU must be projected
    
    relativePosition - RelativePosition; the point on this GTU that must be projected
    
    when - DoubleScalar.Abs<TimeUnit>; the time for which to project the position of this GTU
    
    Returns:
    
    DoubleScalar.Rel<LengthUnit>; the position of this GTU in the projectionLane
    
    Throws:
    
    NetworkException - when projectionLane it not in any of the CrossSectionLink that the GTU is on
    
    RemoteException - on communications failure
  - position
```
public final DoubleScalar.Rel<LengthUnit> position(Lane<?,?> lane,
                                                   RelativePosition relativePosition,
                                                   DoubleScalar.Abs<TimeUnit> when)
                                            throws NetworkException,
                                                   RemoteException
```
    Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane.
    
    Specified by:
    
    position in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the position on this lane will be returned.
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    when - the future time for which to calculate the positions.
    
    Returns:
    
    DoubleScalarAbs<LengthUnit>; the position, relative to the center line of the Lane.
    
    Throws:
    
    NetworkException - when the vehicle is not on the given lane.
    
    RemoteException - on communications failure
  - fractionalPositions
```
public final Map<Lane<?,?>,Double> fractionalPositions(RelativePosition relativePosition)
                                                throws NetworkException,
                                                       RemoteException
```
    Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered, as fractions of the length of the lane. This is important when we want to see if two vehicles are next to each other and we compare an 'inner' and 'outer' curve.
    
    Specified by:
    
    fractionalPositions in interface LaneBasedGTU<ID>
    
    Parameters:
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    Returns:
    
    the lanes and the position on the lanes where the GTU is currently registered, for the given position of the GTU.
    
    Throws:
    
    NetworkException - when the vehicle is not on one of the lanes on which it is registered.
    
    RemoteException - when simulator time cannot be retrieved.
  - fractionalPositions
```
public final Map<Lane<?,?>,Double> fractionalPositions(RelativePosition relativePosition,
                                                       DoubleScalar.Abs<TimeUnit> when)
                                                throws NetworkException,
                                                       RemoteException
```
    Return the longitudinal positions of a point relative to this GTU, relative to the center line of the Lanes in which the vehicle is registered, as fractions of the length of the lane. This is important when we want to see if two vehicles are next to each other and we compare an 'inner' and 'outer' curve.
    
    Specified by:
    
    fractionalPositions in interface LaneBasedGTU<ID>
    
    Parameters:
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    when - the future time for which to calculate the positions.
    
    Returns:
    
    the lanes and the position on the lanes where the GTU will be registered at the time, for the given position of the GTU.
    
    Throws:
    
    NetworkException - when the vehicle is not on one of the lanes on which it is registered.
    
    RemoteException - on communications failure
  - fractionalPosition
```
public final double fractionalPosition(Lane<?,?> lane,
                                       RelativePosition relativePosition,
                                       DoubleScalar.Abs<TimeUnit> when)
                                throws NetworkException,
                                       RemoteException
```
    Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane, as a fraction of the length of the lane. This is important when we want to see if two vehicles are next to each other and we compare an 'inner' and 'outer' curve.
    
    Specified by:
    
    fractionalPosition in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the position on this lane will be returned.
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    when - the future time for which to calculate the positions.
    
    Returns:
    
    the fractional relative position on the lane at the given time.
    
    Throws:
    
    NetworkException - when the vehicle is not on the given lane.
    
    RemoteException - on communications failure
  - fractionalPosition
```
public final double fractionalPosition(Lane<?,?> lane,
                                       RelativePosition relativePosition)
                                throws NetworkException,
                                       RemoteException
```
    Return the longitudinal position of a point relative to this GTU, relative to the center line of the Lane, as a fraction of the length of the lane. This is important when we want to see if two vehicles are next to each other and we compare an 'inner' and 'outer' curve.
    
    Specified by:
    
    fractionalPosition in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the position on this lane will be returned.
    
    relativePosition - the position on the vehicle relative to the reference point.
    
    Returns:
    
    the fractional relative position on the lane at the given time.
    
    Throws:
    
    NetworkException - when the vehicle is not on the given lane.
    
    RemoteException - when simulator time cannot be retrieved.
  - headway
```
public final HeadwayGTU headway(DoubleScalar.Rel<LengthUnit> maxDistance)
                         throws RemoteException,
                                NetworkException
```
    Determine which GTU in front of this GTU, or behind this GTU. This method looks in all lanes where this GTU is registered, and not further than the absolute value of the given maxDistance. The minimum headway is returned of all Lanes where the GTU is registered. When no GTU is found within the given maxDistance, null is returned. The search will extend into successive lanes if the maxDistance is larger than the remaining length on the lane. When Lanes (or underlying CrossSectionLinks) diverge, the headway algorithms have to look at multiple Lanes and return the minimum headway in each of the Lanes. When the Lanes (or underlying CrossSectionLinks) converge, "parallel" traffic is not taken into account in the headway calculation. Instead, gap acceptance algorithms or their equivalent should guide the merging behavior.
    Note: Headway is the net headway and calculated on a front-to-back basis.
    
    Specified by:
    
    headway in interface LaneBasedGTU<ID>
    
    Parameters:
    
    maxDistance - the maximum distance to look for the nearest GTU; positive values search forwards; negative values search backwards
    
    Returns:
    
    HeadwayGTU; the headway and the GTU
    
    Throws:
    
    RemoteException - when simulator time cannot be retrieved.
    
    NetworkException - when there is an error with the next lanes in the network.
  - headway
```
public final HeadwayGTU headway(Lane<?,?> lane,
                                DoubleScalar.Rel<LengthUnit> maxDistance)
                         throws RemoteException,
                                NetworkException
```
    Determine by what distance the front of this GTU is behind the rear an other GTU, or the rear of this GTU is ahead of the front of an other GTU. Only positive values are returned. This method only looks in the given lane, and not further than the given maxDistance. When no vehicle is found within the given maxDistance, new DoubleScalar.Rel<LengthUnit>(Double.MAX_VALUE, LengthUnit.METER) is returned. The search will extend into successive lanes if the maxDistance is larger than the length of the lane.
    Note: Headway is the net headway and calculated on a front-to-back basis.
    
    Specified by:
    
    headway in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the lane to look for another GTU
    
    maxDistance - the maximum distance to look for; if positive, the search is forwards; if negative, the search is backwards
    
    Returns:
    
    HeadwayGTU; the headway and the GTU
    
    Throws:
    
    RemoteException - when simulator time cannot be retrieved
    
    NetworkException - when the vehicle's route is inconclusive or vehicles are not registered correctly on their lanes
  - parallel
```
public final Set<LaneBasedGTU<?>> parallel(Lane<?,?> lane,
                                           DoubleScalar.Abs<TimeUnit> when)
                                    throws RemoteException,
                                           NetworkException
```
    Determine which GTUs are parallel with us on another lane, based on fractional positions.
    Note: When the GTU that calls the method is also registered on the given lane, it is excluded from the return set.
    
    Specified by:
    
    parallel in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lane - the lane to look for parallel (partial or full overlapping) GTUs.
    
    when - the future time for which to calculate the headway
    
    Returns:
    
    the set of GTUs parallel to us on the other lane (partial overlap counts as parallel), based on fractional positions, or an empty set when no GTUs were found.
    
    Throws:
    
    RemoteException - when simulator time cannot be retrieved.
    
    NetworkException - when the vehicle's route is inconclusive, when vehicles are not registered correctly on their lanes, or when the given lane is not parallel to one of the lanes where we are registered.
  - parallel
```
public final Set<LaneBasedGTU<?>> parallel(LateralDirectionality lateralDirection,
                                           DoubleScalar.Abs<TimeUnit> when)
                                    throws RemoteException,
                                           NetworkException
```
    Determine which GTUs are parallel with us in a certain lateral direction, based on fractional positions.
    Note 1: This method will look to the adjacent lanes of all lanes where the vehicle has been registered.
    Note 2: When the GTU that calls the method is also registered on the given lane, it is excluded from the return set.
    
    Specified by:
    
    parallel in interface LaneBasedGTU<ID>
    
    Parameters:
    
    lateralDirection - the direction of the adjacent lane(s) to look for parallel (partial or full overlapping) GTUs.
    
    when - the future time for which to calculate the headway
    
    Returns:
    
    the set of GTUs parallel to us on other lane(s) in the given direction (partial overlap counts as parallel), based on fractional positions, or an empty set when no GTUs were found.
    
    Throws:
    
    RemoteException - when simulator time cannot be retrieved.
    
    NetworkException - when the vehicle's route is inconclusive, when vehicles are not registered correctly on their lanes, or when there are no lanes parallel to one of the lanes where we are registered in the given direction.
  - timeAtDistance
```
public final DoubleScalar.Abs<TimeUnit> timeAtDistance(DoubleScalar.Rel<LengthUnit> distance)
```
    Determine the time when this GTU will have covered the specified distance from the position of the last evaluation time.
    
    Specified by:
    
    timeAtDistance in interface LaneBasedGTU<ID>
    
    Parameters:
    
    distance - DoubleScalar.Rel<LengthUnit>; the distance
    
    Returns:
    
    DoubleScalar.Rel<TimeUnit>; the time, or null if this GTU stops before covering the specified distance
  - deltaTimeForDistance
```
public final DoubleScalar.Rel<TimeUnit> deltaTimeForDistance(DoubleScalar.Rel<LengthUnit> distance)
```
    Determine the time since last evaluation when this GTU has covered the specified distance from the position of the last evaluation time.
    
    Specified by:
    
    deltaTimeForDistance in interface LaneBasedGTU<ID>
    
    Parameters:
    
    distance - DoubleScalar.Rel<LengthUnit>; the distance
    
    Returns:
    
    DoubleScalar.Rel<TimeUnit>; the time difference from last evaluation or null if this GTU stops before covering the specified distance
  - destroy
```
public void destroy()
```
    destroy the vehicle from the simulation and animation.
    
    Specified by:
    
    destroy in interface GTU<ID>
  - getGTUFollowingModel
```
public final GTUFollowingModel getGTUFollowingModel()
```
    Retrieve the GTUFollowingModel of this GTU.
    
    Specified by:
    
    getGTUFollowingModel in interface LaneBasedGTU<ID>
    
    Returns:
    
    GTUFollowingModel
  - getLocation
```
public final DirectedPoint getLocation()
                                throws RemoteException
```
    Specified by:
    
    getLocation in interface LocatableInterface
    
    Throws:
    
    RemoteException
  - getBounds
```
public final javax.media.j3d.Bounds getBounds()
                                       throws RemoteException
```
    Specified by:
    
    getBounds in interface LocatableInterface
    
    Throws:
    
    RemoteException
  - getLaneChangeDistanceAndDirection
```
public LaneChangeUrgeGTUColorer.LaneChangeDistanceAndDirection getLaneChangeDistanceAndDirection()
```
    Description copied from interface: LaneBasedGTU
    
    Return the distance available for the next needed lane change and the lateral direction of that lane change.
    
    Specified by:
    
    getLaneChangeDistanceAndDirection in interface LaneBasedGTU<ID>
    
    Returns:
    
    LaneChangeAndDirection; the available distance and lateral direction for the next required lane change
  - toString
```
public final String toString(Lane<?,?> lane,
                             DoubleScalar.Abs<TimeUnit> when)
```
    Description of Car at specified time.
    
    Parameters:
    
    lane - the position on this lane will be returned.
    
    when - DoubleScalarAbs<TimeUnit>; the time
    
    Returns:
    
    String; description of this Car at the specified time

Class AbstractLaneBasedGTU<ID>

Constructor Summary

Method Summary

Methods inherited from class org.opentrafficsim.core.gtu.AbstractGTU

Methods inherited from class java.lang.Object

Methods inherited from interface org.opentrafficsim.core.gtu.GTU

Constructor Detail

AbstractLaneBasedGTU

Method Detail

getLongitudinalVelocity

getLongitudinalVelocity

getVelocity

getLastEvaluationTime

getNextEvaluationTime

getAcceleration

getAcceleration

getOdometer

getLateralVelocity

addFrontToSubsequentLane

addLane

removeLane

getLanes

move

positions

positions

position

projectedPosition

position

fractionalPositions

fractionalPositions

fractionalPosition

fractionalPosition

headway

headway

parallel

parallel

timeAtDistance

deltaTimeForDistance

destroy

getGTUFollowingModel

getLocation

getBounds

getLaneChangeDistanceAndDirection

toString