1 package org.opentrafficsim.road.network.lane.changing;
2
3 import java.io.Serializable;
4 import java.util.Collection;
5
6 import org.djunits.value.vdouble.scalar.Speed;
7 import org.opentrafficsim.core.gtu.GTUType;
8
9 /**
10 * This class implements the overtaking conditions. Examples are:
11 * <ul>
12 * <li>Overtaking on the left is allowed for all GTU types (not likely when there are e.g., both cars and bicycles in the
13 * model).</li>
14 * <li>A GTU type CAR can overtake a GTU type TRACTOR on the left on this road, but no other types of GTUs.</li>
15 * <li>When the speed of the GTU you try to overtake is lower than 50 km/h, you can overtake on the left.</li>
16 * <li>When the speed of the GTU you try to overtake is 25 km/h less than the maximum speed of the lane on which you and the
17 * other GTU are driving, you can overtake on the left or right.</li>
18 * <li>only overtake vehicles that have a maximum speed of under 25 km/h.</li>
19 * <li>Overtaking on the left is allowed for all GTU types, but overtaking on the right is also allowed when traffic density is
20 * below a certain number</li>
21 * <li>Overtaking on the left is allowed for all GTU types, but overtaking on the right is also allowed when the distance to a
22 * traffic light is less than 200 m</li>
23 * <li>Overtaking on the left and the right is allowed for all GTUs. This can e.g. be used on an American highway where all GTUs
24 * that are allowed on the highway can indeed overtake on the right or the left.</li>
25 * </ul>
26 * <b>Note:</b> The class does not check whether it is <b>allowed</b> to overtake another GTU on this road, neither whether it
27 * is possible or safe to do so. That has to be checked by the GTU itself based on e.g., gap acceptance and other behavioral
28 * rules.
29 * <p>
30 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
31 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
32 * <p>
33 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
34 * initial version Sep 13, 2015 <br>
35 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
36 */
37 public interface OvertakingConditions
38 {
39 /********************************************************************************************************************/
40 /********************** IMPLEMENTATION CLASSES OF MOST COMMON OVERTAKING CONDITIONS *****************************/
41 /********************************************************************************************************************/
42
43 /**
44 * Overtaking on the left allowed for all GTUs. Note: overtaking on the right not allowed, so vehicles will stall on a
45 * multilane road near a traffic light. Also, bicycles will overtake cars on the "wrong" side of the road in this simple
46 * condition!
47 * <p>
48 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
49 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
50 * </p>
51 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
52 * initial version Sep 13, 2015
53 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
54 */
55 class LeftOnly implements OvertakingConditions
56 {
57 /** {@inheritDoc} */
58 @Override
59 public final String toString()
60 {
61 return "LeftOnly []";
62 }
63 }
64
65 /**
66 * Overtaking on the right allowed for all GTUs. Note: overtaking on the left not allowed, so vehicles will stall on a
67 * multilane road near a traffic light. Also, bicycles will overtake cars on the "wrong" side of the road in this simple
68 * condition!
69 * <p>
70 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
71 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
72 * </p>
73 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
74 * initial version Sep 13, 2015
75 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
76 */
77 class RightOnly implements OvertakingConditions
78 {
79 /** {@inheritDoc} */
80 @Override
81 public final String toString()
82 {
83 return "RightOnly []";
84 }
85 }
86
87 /**
88 * No overtaking allowed. Note if there are multiple lanes, vehicles will stall near a traffic light.
89 * <p>
90 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
91 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
92 * </p>
93 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
94 * initial version Sep 13, 2015
95 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
96 */
97 class None implements OvertakingConditions
98 {
99 /** {@inheritDoc} */
100 @Override
101 public final String toString()
102 {
103 return "None []";
104 }
105 }
106
107 /**
108 * Overtaking on both sides allowed. This is, e.g., the situation for an American highway.
109 * <p>
110 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
111 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
112 * </p>
113 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
114 * initial version Sep 13, 2015
115 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
116 */
117 class LeftAndRight implements OvertakingConditions
118 {
119 /** {@inheritDoc} */
120 @Override
121 public final String toString()
122 {
123 return "LeftAndRight []";
124 }
125 }
126
127 /**
128 * Overtaking on the left allowed for all GTUs; they stay on the same lane (e.g., bicycles).
129 * <p>
130 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
131 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
132 * </p>
133 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
134 * initial version Sep 13, 2015
135 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
136 */
137 class SameLaneLeft implements OvertakingConditions
138 {
139 /** {@inheritDoc} */
140 @Override
141 public final String toString()
142 {
143 return "SameLaneLeft []";
144 }
145 }
146
147 /**
148 * Overtaking on the right allowed for all GTUs; they stay on the same lane (e.g., bicycles).
149 * <p>
150 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
151 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
152 * </p>
153 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
154 * initial version Sep 13, 2015
155 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
156 */
157 class SameLaneRight implements OvertakingConditions
158 {
159 /** {@inheritDoc} */
160 @Override
161 public final String toString()
162 {
163 return "SameLaneRight []";
164 }
165 }
166
167 /**
168 * Overtaking on both sides allowed for all GTUs; they stay on the same lane (e.g., pedestrians).
169 * <p>
170 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
171 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
172 * </p>
173 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
174 * initial version Sep 13, 2015
175 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
176 */
177 class SameLaneBoth implements OvertakingConditions
178 {
179 /** {@inheritDoc} */
180 @Override
181 public final String toString()
182 {
183 return "SameLaneBoth []";
184 }
185 }
186
187 /**
188 * Overtaking on the left allowed for all GTUs, and overtaking on the right allowed under a given speed.
189 * <p>
190 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
191 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
192 * </p>
193 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
194 * initial version Sep 13, 2015
195 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
196 */
197 class LeftAlwaysRightSpeed implements OvertakingConditions, Serializable
198 {
199 /** */
200 private static final long serialVersionUID = 20150913L;
201
202 /** The speed under which overtaking on the "wrong" side is allowed. */
203 private final Speed rightOvertakingSpeedMax;
204
205 /**
206 * @param rightOvertakingSpeedMax Speed; the speed under which overtaking on the "wrong" side is allowed
207 */
208 public LeftAlwaysRightSpeed(final Speed rightOvertakingSpeedMax)
209 {
210 this.rightOvertakingSpeedMax = rightOvertakingSpeedMax;
211 }
212
213 /** {@inheritDoc} */
214 @Override
215 public final String toString()
216 {
217 return "LeftAlwaysRightSpeed [rightOvertakingSpeedMax=" + this.rightOvertakingSpeedMax + "]";
218 }
219 }
220
221 /**
222 * Overtaking on the left allowed for all GTUs, and overtaking on the right allowed when there is a traffic jam.
223 * <p>
224 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
225 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
226 * </p>
227 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
228 * initial version Sep 13, 2015
229 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
230 */
231 class LeftAlwaysRightJam implements OvertakingConditions, Serializable
232 {
233 /** */
234 private static final long serialVersionUID = 20150913L;
235
236 /** {@inheritDoc} */
237 @Override
238 public final String toString()
239 {
240 return "LeftAlwaysRightJam []";
241 }
242 }
243
244 /**
245 * Overtaking on the right allowed for all GTUs, and overtaking on the left allowed under a given speed.
246 * <p>
247 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
248 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
249 * </p>
250 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
251 * initial version Sep 13, 2015
252 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
253 */
254 class RightAlwaysLeftSpeed implements OvertakingConditions, Serializable
255 {
256 /** */
257 private static final long serialVersionUID = 20150913L;
258
259 /** The speed under which overtaking on the "wrong" side is allowed. */
260 private final Speed leftOvertakingSpeedMax;
261
262 /**
263 * @param leftOvertakingSpeedMax Speed; the speed under which overtaking on the "wrong" side is allowed
264 */
265 public RightAlwaysLeftSpeed(final Speed leftOvertakingSpeedMax)
266 {
267 this.leftOvertakingSpeedMax = leftOvertakingSpeedMax;
268 }
269
270 /** {@inheritDoc} */
271 @Override
272 public final String toString()
273 {
274 return "RightAlwaysLeftSpeed [leftOvertakingSpeedMax=" + this.leftOvertakingSpeedMax + "]";
275 }
276 }
277
278 /**
279 * Overtaking on the right allowed for all GTUs, and overtaking on the left allowed when there is a traffic jam.
280 * <p>
281 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
282 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
283 * </p>
284 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
285 * initial version Sep 13, 2015
286 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
287 */
288 class RightAlwaysLeftJam implements OvertakingConditions, Serializable
289 {
290 /** */
291 private static final long serialVersionUID = 20150913L;
292
293 /** {@inheritDoc} */
294 @Override
295 public final String toString()
296 {
297 return "RightAlwaysLeftJam []";
298 }
299 }
300
301 /**
302 * Provide a collection of GTUs that can overtake another collection of GTUs on the left side, but not vice versa. Example:
303 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE, SCOOTER}.
304 * In the latter case, cars, trucks and busses can overtake all other GTUs, but bicycles and scooters cannot overtake cars,
305 * trucks or busses. Another example is a lane where cars and motors can overtake all other road users, but trucks are not
306 * allowed to overtake. In that case, we would allow {CAR, MOTOR} to overtake {ALL} or {CAR, MOTOR} to overtake {CAR, MOTOR,
307 * TRUCK} in that lane.<br>
308 * TODO: All these "Right/LeftSet" classes should probably use Compatibility instead of full sets.
309 * <p>
310 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
311 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
312 * </p>
313 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
314 * initial version Sep 13, 2015
315 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
316 */
317 class LeftSet implements OvertakingConditions, Serializable
318 {
319 /** */
320 private static final long serialVersionUID = 20150913L;
321
322 /** A collection of GTUs that can overtake another collection of GTUs. */
323 private final Collection<GTUType> overtakingGTUTypes;
324
325 /** A collection of GTUs that can be overtaken by another collection of GTUs. */
326 private final Collection<GTUType> overtakenGTUTypes;
327
328 /**
329 * Provide a collection of GTUs that can overtake another collection of GTUs on the left, but not vice versa. Example:
330 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE,
331 * SCOOTER}, or {CAR, TRUCK, BUS} can overtake {TRACTOR}.
332 * @param overtakingGTUTypes Collection<GTUType>; the GTUs that can overtake a set of other GTUs, e.g., CAR,
333 * TRUCK.
334 * @param overtakenGTUTYpes Collection<GTUType>; the GTUs that can be overtaken, e.g., BICYCLE, SCOOTER.
335 */
336 public LeftSet(final Collection<GTUType> overtakingGTUTypes, final Collection<GTUType> overtakenGTUTYpes)
337 {
338 this.overtakingGTUTypes = overtakingGTUTypes;
339 this.overtakenGTUTypes = overtakenGTUTYpes;
340 }
341
342 /** {@inheritDoc} */
343 @Override
344 public final String toString()
345 {
346 return "LeftSet [overtakingGTUTypes=" + this.overtakingGTUTypes + ", overtakenGTUTypes=" + this.overtakenGTUTypes
347 + "]";
348 }
349 }
350
351 /**
352 * Provide a collection of GTUs that can overtake another collection of GTUs on the right side, but not vice versa. Example:
353 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE, SCOOTER}.
354 * In the latter case, cars, trucks and busses can overtake all other GTUs, but bicycles and scooters cannot overtake cars,
355 * trucks or busses. Another example is a lane where cars and motors can overtake all other road users, but trucks are not
356 * allowed to overtake. In that case, we would allow {CAR, MOTOR} to overtake {ALL} or {CAR, MOTOR} to overtake {CAR, MOTOR,
357 * TRUCK} in that lane.
358 * <p>
359 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
360 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
361 * </p>
362 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
363 * initial version Sep 13, 2015
364 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
365 */
366 class RightSet implements OvertakingConditions, Serializable
367 {
368 /** */
369 private static final long serialVersionUID = 20150913L;
370
371 /** A collection of GTUs that can overtake another collection of GTUs. */
372 private final Collection<GTUType> overtakingGTUTypes;
373
374 /** A collection of GTUs that can be overtaken by another collection of GTUs. */
375 private final Collection<GTUType> overtakenGTUTypes;
376
377 /**
378 * Provide a collection of GTUs that can overtake another collection of GTUs on the right, but not vice versa. Example:
379 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE,
380 * SCOOTER}, or {CAR, TRUCK, BUS} can overtake {TRACTOR}.
381 * @param overtakingGTUs Collection<GTUType>; the GTUs that can overtake a set of other GTUs, e.g., CAR, TRUCK.
382 * @param overtakenGTUs Collection<GTUType>; the GTUs that can be overtaken, e.g., BICYCLE, SCOOTER.
383 */
384 public RightSet(final Collection<GTUType> overtakingGTUs, final Collection<GTUType> overtakenGTUs)
385 {
386 this.overtakingGTUTypes = overtakingGTUs;
387 this.overtakenGTUTypes = overtakenGTUs;
388 }
389
390 /** {@inheritDoc} */
391 @Override
392 public final String toString()
393 {
394 return "RightSet [overtakingGTUTypes=" + this.overtakingGTUTypes + ", overtakenGTUTypes=" + this.overtakenGTUTypes
395 + "]";
396 }
397 }
398
399 /**
400 * Provide a collection of GTUs that can overtake another collection of GTUs on the left side, but not vice versa. Example:
401 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE, SCOOTER}.
402 * In the latter case, cars, trucks and busses can overtake all other GTUs, but bicycles and scooters cannot overtake cars,
403 * trucks or busses. Another example is a lane where cars and motors can overtake all other road users, but trucks are not
404 * allowed to overtake. In that case, we would allow {CAR, MOTOR} to overtake {ALL} or {CAR, MOTOR} to overtake {CAR, MOTOR,
405 * TRUCK} in that lane. In addition, overtaking on the other side is allowed under a given driving speed.
406 * <p>
407 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
408 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
409 * </p>
410 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
411 * initial version Sep 13, 2015
412 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
413 */
414 class LeftSetRightSpeed implements OvertakingConditions, Serializable
415 {
416 /** */
417 private static final long serialVersionUID = 20150913L;
418
419 /** A collection of GTUs that can overtake another collection of GTUs. */
420 private final Collection<GTUType> overtakingGTUTypes;
421
422 /** A collection of GTUs that can be overtaken by another collection of GTUs. */
423 private final Collection<GTUType> overtakenGTUTypes;
424
425 /** The speed under which overtaking on the "wrong" side is allowed. */
426 private final Speed rightOvertakingSpeedMax;
427
428 /**
429 * Provide a collection of GTUs that can overtake another collection of GTUs on the left, but not vice versa. Example:
430 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE,
431 * SCOOTER}, or {CAR, TRUCK, BUS} can overtake {TRACTOR}. In addition, overtaking on the other side is allowed under a
432 * given driving speed.
433 * @param overtakingGTUs Collection<GTUType>; the GTUs that can overtake a set of other GTUs, e.g., CAR, TRUCK.
434 * @param overtakenGTUs Collection<GTUType>; the GTUs that can be overtaken, e.g., BICYCLE, SCOOTER.
435 * @param rightOvertakingSpeedMax Speed; the speed under which overtaking on the "wrong" side is allowed
436 */
437 public LeftSetRightSpeed(final Collection<GTUType> overtakingGTUs, final Collection<GTUType> overtakenGTUs,
438 final Speed rightOvertakingSpeedMax)
439 {
440 this.overtakingGTUTypes = overtakingGTUs;
441 this.overtakenGTUTypes = overtakenGTUs;
442 this.rightOvertakingSpeedMax = rightOvertakingSpeedMax;
443 }
444
445 /** {@inheritDoc} */
446 @Override
447 public final String toString()
448 {
449 return "LeftSetRightSpeed [overtakingGTUTypes=" + this.overtakingGTUTypes + ", overtakenGTUTypes="
450 + this.overtakenGTUTypes + ", rightOvertakingSpeedMax=" + this.rightOvertakingSpeedMax + "]";
451 }
452 }
453
454 /**
455 * Provide a collection of GTUs that can overtake another collection of GTUs on the left side, but not vice versa. Example:
456 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE, SCOOTER}.
457 * In the latter case, cars, trucks and busses can overtake all other GTUs, but bicycles and scooters cannot overtake cars,
458 * trucks or busses. Another example is a lane where cars and motors can overtake all other road users, but trucks are not
459 * allowed to overtake. In that case, we would allow {CAR, MOTOR} to overtake {ALL} or {CAR, MOTOR} to overtake {CAR, MOTOR,
460 * TRUCK} in that lane. In addition, overtaking on the other side is allowed when there is a traffic jam.
461 * <p>
462 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
463 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
464 * </p>
465 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
466 * initial version Sep 13, 2015
467 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
468 */
469 class LeftSetRightJam implements OvertakingConditions, Serializable
470 {
471 /** */
472 private static final long serialVersionUID = 20150913L;
473
474 /** A collection of GTUs that can overtake another collection of GTUs. */
475 private final Collection<GTUType> overtakingGTUTypes;
476
477 /** A collection of GTUs that can be overtaken by another collection of GTUs. */
478 private final Collection<GTUType> overtakenGTUTypes;
479
480 /**
481 * Provide a collection of GTUs that can overtake another collection of GTUs on the left, but not vice versa. Example:
482 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE,
483 * SCOOTER}, or {CAR, TRUCK, BUS} can overtake {TRACTOR}. In addition, overtaking on the other side is allowed when
484 * there is a traffic jam.
485 * @param overtakingGTUs Collection<GTUType>; the GTUs that can overtake a set of other GTUs, e.g., CAR, TRUCK.
486 * @param overtakenGTUs Collection<GTUType>; the GTUs that can be overtaken, e.g., BICYCLE, SCOOTER.
487 */
488 public LeftSetRightJam(final Collection<GTUType> overtakingGTUs, final Collection<GTUType> overtakenGTUs)
489 {
490 this.overtakingGTUTypes = overtakingGTUs;
491 this.overtakenGTUTypes = overtakenGTUs;
492 }
493
494 /** {@inheritDoc} */
495 @Override
496 public final String toString()
497 {
498 return "LeftSetRightSpeed [overtakingGTUTypes=" + this.overtakingGTUTypes + ", overtakenGTUTypes="
499 + this.overtakenGTUTypes + "]";
500 }
501 }
502
503 /**
504 * Provide a collection of GTUs that can overtake another collection of GTUs on the right side, but not vice versa. Example:
505 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE, SCOOTER}.
506 * In the latter case, cars, trucks and busses can overtake all other GTUs, but bicycles and scooters cannot overtake cars,
507 * trucks or busses. Another example is a lane where cars and motors can overtake all other road users, but trucks are not
508 * allowed to overtake. In that case, we would allow {CAR, MOTOR} to overtake {ALL} or {CAR, MOTOR} to overtake {CAR, MOTOR,
509 * TRUCK} in that lane. In addition, overtaking on the other side is allowed under a given driving speed.
510 * <p>
511 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
512 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
513 * </p>
514 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
515 * initial version Sep 13, 2015
516 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
517 */
518 class RightSetLeftSpeed implements OvertakingConditions, Serializable
519 {
520 /** */
521 private static final long serialVersionUID = 20150913L;
522
523 /** A collection of GTUs that can overtake another collection of GTUs. */
524 private final Collection<GTUType> overtakingGTUTypes;
525
526 /** A collection of GTUs that can be overtaken by another collection of GTUs. */
527 private final Collection<GTUType> overtakenGTUTypes;
528
529 /** The speed under which overtaking on the "wrong" side is allowed. */
530 private final Speed leftOvertakingSpeedMax;
531
532 /**
533 * Provide a collection of GTUs that can overtake another collection of GTUs on the left, but not vice versa. Example:
534 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE,
535 * SCOOTER}, or {CAR, TRUCK, BUS} can overtake {TRACTOR}. In addition, overtaking on the other side is allowed under a
536 * given driving speed.
537 * @param overtakingGTUs Collection<GTUType>; the GTUs that can overtake a set of other GTUs, e.g., CAR, TRUCK.
538 * @param overtakenGTUs Collection<GTUType>; the GTUs that can be overtaken, e.g., BICYCLE, SCOOTER.
539 * @param leftOvertakingSpeedMax Speed; the speed under which overtaking on the "wrong" side is allowed
540 */
541 public RightSetLeftSpeed(final Collection<GTUType> overtakingGTUs, final Collection<GTUType> overtakenGTUs,
542 final Speed leftOvertakingSpeedMax)
543 {
544 this.overtakingGTUTypes = overtakingGTUs;
545 this.overtakenGTUTypes = overtakenGTUs;
546 this.leftOvertakingSpeedMax = leftOvertakingSpeedMax;
547 }
548
549 /** {@inheritDoc} */
550 @Override
551 public final String toString()
552 {
553 return "RightSetLeftSpeed [overtakingGTUTypes=" + this.overtakingGTUTypes + ", overtakenGTUTypes="
554 + this.overtakenGTUTypes + ", leftOvertakingSpeedMax=" + this.leftOvertakingSpeedMax + "]";
555 }
556 }
557
558 /**
559 * Provide a collection of GTUs that can overtake another collection of GTUs on the right side, but not vice versa. Example:
560 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE, SCOOTER}.
561 * In the latter case, cars, trucks and busses can overtake all other GTUs, but bicycles and scooters cannot overtake cars,
562 * trucks or busses. Another example is a lane where cars and motors can overtake all other road users, but trucks are not
563 * allowed to overtake. In that case, we would allow {CAR, MOTOR} to overtake {ALL} or {CAR, MOTOR} to overtake {CAR, MOTOR,
564 * TRUCK} in that lane. In addition, overtaking on the other side is allowed when there is a traffic jam.
565 * <p>
566 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
567 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
568 * </p>
569 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
570 * initial version Sep 13, 2015
571 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
572 */
573 class RightSetLeftJam implements OvertakingConditions, Serializable
574 {
575 /** */
576 private static final long serialVersionUID = 20150913L;
577
578 /** A collection of GTUs that can overtake another collection of GTUs. */
579 private final Collection<GTUType> overtakingGTUTypes;
580
581 /** A collection of GTUs that can be overtaken by another collection of GTUs. */
582 private final Collection<GTUType> overtakenGTUTypes;
583
584 /**
585 * Provide a collection of GTUs that can overtake another collection of GTUs on the left, but not vice versa. Example:
586 * {CAR, TRUCK, BUS} can overtake {BICYCLE, SCOOTER}, or {CAR, TRUCK, BUS} can overtake {CAR, TRUCK, BUS, BICYCLE,
587 * SCOOTER}, or {CAR, TRUCK, BUS} can overtake {TRACTOR}. In addition, overtaking on the other side is allowed when
588 * there is a traffic jam.
589 * @param overtakingGTUs Collection<GTUType>; the GTUs that can overtake a set of other GTUs, e.g., CAR, TRUCK.
590 * @param overtakenGTUs Collection<GTUType>; the GTUs that can be overtaken, e.g., BICYCLE, SCOOTER.
591 */
592 public RightSetLeftJam(final Collection<GTUType> overtakingGTUs, final Collection<GTUType> overtakenGTUs)
593 {
594 this.overtakingGTUTypes = overtakingGTUs;
595 this.overtakenGTUTypes = overtakenGTUs;
596 }
597
598 /** {@inheritDoc} */
599 @Override
600 public final String toString()
601 {
602 return "RightSetLeftJam [overtakingGTUTypes=" + this.overtakingGTUTypes + ", overtakenGTUTypes="
603 + this.overtakenGTUTypes + "]";
604 }
605 }
606
607 }