1 Introduction
2 Literature review
-
Front evasion By extending the transfer points at both ends of a container block (and the rail tracks rail-mounted gantry cranes move on), transfer point access even for the remote twin crane is enabled (see Fig. 1(right)). This requires that the blocking crane always gives way and moves to the foremost position of the transfer point whenever the remote crane has to receive or supply a container to a subsequent position that is still part of the transfer point. This type of workload sharing has rarely been studied. The simulation study of Gharehgozli et al. (2017) where cranes are steered by simple rule-based heuristics indicates that a front evasion leads to a slightly better throughput performance than applying a handshake area. More elaborate heuristics and a mixed-integer programming (MIP) model are presented by Emde and Boysen ( 2014).
-
Cross-over cranes Instead of applying two identical-sized twin cranes, some terminals apply two different-sized cranes, for example, CTA Altenwerder terminal (Hamburg), or even triple (i.e., two small twins spanned by one large crane) cross-over cranes, such as CTB Burchardkai terminal (Hamburg) (Kemme, 2012). A crossing of different-sized cranes is possible if the trolley of the larger crane is moved to the crossing position located at the side of the large crane, beyond the profile of the small one. In this way, both transfer areas can be reached by multiple cranes, and workload sharing is enabled. A simulation study with simple rule-based approaches comparing these different crane configurations is provided by Kemme (2012). More sophisticated optimization approaches coordinating two cross-over cranes are, for instance, introduced by Briskorn (2021), Briskorn and Angeloudis (2016) and Nossack et al. (2018). Scheduling procedures for triple cross-over cranes are provided by Briskorn and Zey (2018) and Dorndorf and Schneider (2010).
-
Any-bay handover Workload sharing between twin cranes can be enabled by a preemptive container processing, which means that one crane receives a container at its dedicated access point and moves the box to an intermediate storage position where the other crane takes over. Any-bay handover allows intermediate storage wherever empty stacking space in the block can be found. Thus, optimization procedures scheduling a preemptive container processing of cooperative twin cranes must additionally decide on appropriate intermediate storage positions or alternatively whether a single crane should execute the move un-preempted. A heuristic procedure based on the famous bucket-brigade protocol (Bartholdi & Eisenstein, 1996) is provided by Briskorn et al. (2016). Their approach is extended by Jaehn and Kress (2018). They consider the case where in addition to a given sequence of seaside-related container moves, a sequence of landside-related operations occurs. An exact solution procedure for this optimization task is introduced by Kress et al. (2019).
-
Handshake area In this paper, we only allow intermediate storage of containers processed in a preemptive mode in a dedicated area, the handshake area. Carlo and Martinez-Acevedo (2015) consider 14 different priority rules for avoiding interference of cranes in the handshake area if both cranes claim access simultaneously. They compare these rules with a branch and bound procedure and identify some rules that lead to small optimality gaps well below 5%. Their study, however, assumes given sequences of container moves, which removes much of the complexity from the scheduling task. Deciding on the sequences of container moves is integrated into the solution approaches of Gharehgozli et al. (2017) and XiaoLong et al. (2019). Both apply a rule-based avoidance of crane interference in the handshake area and integrate them into straightforward heuristics determining the sequences of container moves. The optimality gaps of these approaches are not quantified.
3 Problem description
4 Branch and bound procedures
4.1 Simultaneous sequencing and determination of stacking positions
4.1.1 Branching
-
both j and \(j'\) are in \(n_c\), \(c\in \{1,2\}\), and j precedes \(j'\) in \(n_c\), which means that the drop-off operation of j has to be conducted before the pickup operation of \(j'\) or
-
j and \(j'\) are jobs in different job sequences, have operations in the same stacking position, and among these operations, j’s operation has to be conducted first according to Lemma 1.
-
all (partial) stacking position sequences are feasible and
-
precedence relations among jobs are acyclic.
-
append a job from \(N_1\) not in \(n_1\) to \(n_1\) that, consequently, is not related to a stacking position,
-
append a job from \(R^{k}_c\) not in \(n_c\) to \(n_c\), \(c \in \{ 1,2\}\), according to Rules 1 and 2, and
-
append a job from \(S^{u}_c\), \(c \in \{ 1,2\}\) to \(n_c\), storing a container in every stacking position from \(H_c\) as long as Rule 3 is fulfilled.
4.1.2 Routing
-
crane \(c'\) conducts all operations not yet conducted in \([f_{c'},\dots ,f'_{c'}]\) as early as possible without waiting, starting from its implied position in s, and
-
if \(f_{3-c'}\) is \(f'_{3-c'}\), crane \(3-c'\) simply stays in the bay next to \(b^h\). Otherwise it processes all operations not yet conducted in \([f_{3-c'},\dots ,f_{3-c'}-1]\) without waiting, moves to the bay next to \(b^h\), and positions the trolley according to \(f'_{3-c'}\).
-
\(f_c < f'_c\) and \(f_{3-c} \le f'_{3-c}\) holds, and
-
assuming that cranes 1 and 2 process \(n_c\) and \(n_2\) from s onward and are interrupted only by waiting due to precedence constraints, they would be present in \(b^h\) simultaneously for the first time when conducting \(f'_1\) and \(f'_2\).
4.1.3 Lower bounds
-
We consider a bipartite graph where nodes in the first set correspond to drop-off operation of jobs in \(A_c\) or the last job in \(n_c\), and nodes in the second set correspond to pickup operations of jobs in \(A_c\) or a dummy end job. An edge between a drop-off operation k and a pickup operation \(k'\) represents \(k'\) being carried out immediately after k and, therefore, implies a lower bound (similar to the one in (1)) on the empty travel duration. This lower bound is represented by the edge’s weight. Note that \(n_c\) and \(n_{3-c}\) might imply precedence relations between jobs in \(A_c\) or between jobs in \(A_{3-c}\). If pickup operation \(k\in A_c\) is a predecessor of drop-off operation \(k'\in A_c\), then we can drop the edge connecting \(k'\) and k from consideration. Similar to the approach of Gharehgozli et al. (2014b), we then determine a minimum weight perfect matching. The minimum weight is a lower bound on the total empty travel time. Note that the matching might not imply a proper sequence, and we can determine it in \(O(|A_c|^3)\).
-
Ignoring the time necessary to adjust the trolley position, we can derive a lower bound by applying the approach from Gilmore and Gomory (1964) in order to determine a sequence for the jobs in \(A_c\) with minimum empty travel time. Gilmore and Gomory (1964) consider a scheduling problem where a machine (crane) has to process a set of jobs (corresponding to \(A_c\)) in a sequence that minimizes the total setup time. Here, every job j has a starting state \(S_j\) (corresponding to \({\hat{o}}^b_k\), with \(k \in A_c\)) that the machine needs to be set up to in order to process the job. After finishing j, the machine is left in state \(E_j\) (corresponding to \({\hat{d}}^b_k\) for \(k \in A_c\)). The setup time between jobs j and m amounts to \(|E_j-S_m|\). Furthermore, the machine has a starting state (being related to the last job in either \(n_c\) or \(o^0_c)\) and a predetermined ending state that it has to reach after finishing all jobs. Gilmore and Gomory (1964) developed an optimal algorithm that runs in \(O(|A_c|^2)\) time. Note, however, that we do not know the final position of a crane in advance. A straightforward approach would be to fix each job to be the last one in a separate run and end up with a runtime complexity of \(O(|A_c|^3)\). This type of approach was applied by Briskorn and Zey (2020) and performed well. However, we can adapt our branching scheme to construct sequence \(n_c\) from end to start, which gives us the final position of each crane after the first couple of branching steps. We can then straightforwardly apply the approach by Gilmore and Gomory (1964) in \(O(|A_c|^2)\) time.
4.1.4 Upper bounds
4.2 Non-simultaneous sequencing and determining of stacking positions
4.2.1 Determining job sequences first
-
appending a job from \(N_1\) not in \(n_1\) to \(n_1\),
-
appending a job from \(S_c\) not in \(n_c\) to \(n_c\), \(c \in \{ 1,2\}\), and
-
appending a job from \(R_c\) not in \(n_c\) to \(n_c\), \(c \in \{1,2\}\), according to Rule 1.
4.2.2 Determining stacking positions first
5 Computational study
\(|I^o| + |I^i|\) | 10 | 20 | 30 | 40 |
---|---|---|---|---|
ID | zBZr2Ll | SRHiXWG | cPIxDoT | ddX4GoY |
5.1 Computational performance of our B&B procedures
\(|I^o|+\) | Avg. relative gap LB % | Avg. runtime s | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
\(|I^i|\) | \(Algorithm / b^h\) | 5 | 10 | 15 | 20 | 25 | 5 | 10 | 15 | 20 | 25 | |
Runtime limit: 10s | ||||||||||||
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0.23 | 0.02 | 0.03 | 0.00 | 0.00 | 1.90 | 0.81 | 0.73 | 0.03 | 0.03 | |
SIM | 2.23 | 0.35 | 0.09 | 0.00 | 0.00 | 4.95 | 3.82 | 2.03 | 0.10 | 0.04 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 0.26 | 1.92 | 0.00 | 0.00 | 0.00 | 2.94 | 4.60 | 1.07 | 0.16 | 0.05 | ||
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 6.85 | 4.86 | 0.75 | 0.03 | 0.00 | 10.00 | 6.20 | 4.00 | 0.58 | 0.12 | |
SIM | 4.61 | 3.12 | 1.64 | 0.87 | 0.20 | 8.40 | 7.89 | 6.82 | 3.09 | 0.83 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 4.55 | 1.82 | 0.23 | 0.00 | 0.00 | 7.43 | 5.22 | 3.53 | 0.16 | 0.30 | ||
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 9.18 | 10.95 | 5.42 | 0.66 | 0.08 | 10.00 | 9.62 | 9.04 | 3.15 | 1.20 | |
SIM | 6.73 | 18.43 | 9.39 | 3.87 | 0.65 | 8.98 | 10.00 | 9.91 | 7.63 | 3.36 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 9.97 | 0.97 | 0.21 | 0.03 | 0.02 | 8.88 | 7.12 | 5.44 | 1.75 | 1.24 | ||
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 10.59 | 23.25 | 8.89 | 6.61 | 0.58 | 10.00 | 10.00 | 10.00 | 7.74 | 2.07 | |
SIM | 8.30 | 22.97 | 10.83 | 6.81 | 3.05 | 10.00 | 10.00 | 10.00 | 9.43 | 5.83 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 17.27 | 5.15 | 1.12 | 0.36 | 0.02 | 10.00 | 9.18 | 6.92 | 3.91 | 1.94 | ||
Runtime limit: 300s | ||||||||||||
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 14.45 | 0.84 | 2.81 | 0.03 | 0.03 | |
SIM | 0.13 | 0.11 | 0.00 | 0.00 | 0.00 | 98.93 | 50.53 | 29.43 | 0.10 | 0.04 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 0.00 | 0.12 | 0.00 | 0.00 | 0.00 | 80.28 | 104.56 | 21.37 | 0.16 | 0.05 | ||
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 5.69 | 2.61 | 0.17 | 0.01 | 0.00 | 300.00 | 133.06 | 78.84 | 10.25 | 0.12 | |
SIM | 3.55 | 1.69 | 0.40 | 0.10 | 0.00 | 242.32 | 187.54 | 135.30 | 23.20 | 1.69 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 1.96 | 0.52 | 0.22 | 0.00 | 0.00 | 173.98 | 111.99 | 100.20 | 0.16 | 0.30 | ||
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 9.18 | 9.58 | 4.25 | 0.03 | 0.04 | 300.00 | 280.29 | 242.11 | 25.42 | 23.04 | |
SIM | 4.29 | 8.65 | 4.61 | 1.09 | 0.02 | 260.31 | 259.38 | 272.31 | 143.38 | 29.66 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 4.79 | 0.65 | 0.17 | 0.03 | 0.01 | 226.27 | 154.04 | 111.78 | 30.75 | 21.28 | ||
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 10.59 | 18.26 | 7.18 | 3.87 | 0.04 | 300.00 | 300.00 | 300.00 | 157.04 | 31.15 | |
SIM | 6.41 | 16.04 | 6.40 | 3.77 | 0.40 | 300.00 | 300.00 | 290.56 | 261.96 | 76.93 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 7.99 | 0.31 | 0.16 | 0.04 | 0.02 | 286.96 | 160.71 | 125.30 | 53.06 | 30.94 | ||
Runtime limit: 600s | ||||||||||||
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 14.45 | 0.84 | 2.81 | 0.03 | 0.03 | |
SIM | 0.07 | 0.11 | 0.00 | 0.00 | 0.00 | 144.76 | 80.53 | 49.43 | 0.10 | 0.04 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 0.00 | 0.12 | 0.00 | 0.00 | 0.00 | 160.28 | 194.57 | 41.38 | 0.16 | 0.05 | ||
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 5.67 | 2.22 | 0.13 | 0.01 | 0.00 | 600.00 | 247.15 | 148.84 | 20.25 | 0.12 | |
SIM | 3.52 | 1.61 | 0.30 | 0.06 | 0.00 | 482.32 | 367.54 | 247.35 | 33.20 | 1.69 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 1.85 | 0.39 | 0.18 | 0.00 | 0.00 | 335.41 | 222.00 | 191.66 | 0.16 | 0.30 | ||
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 9.18 | 9.47 | 3.87 | 0.03 | 0.04 | 600.00 | 560.29 | 482.11 | 45.42 | 43.04 | |
SIM | 4.24 | 8.48 | 4.13 | 0.86 | 0.02 | 520.31 | 509.38 | 539.48 | 253.38 | 47.60 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 3.40 | 0.64 | 0.17 | 0.03 | 0.01 | 444.72 | 304.06 | 221.79 | 60.76 | 41.28 | ||
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 10.59 | 18.17 | 7.17 | 2.64 | 0.04 | 600.00 | 600.00 | 600.00 | 297.04 | 61.15 | |
SIM | 6.34 | 15.07 | 5.84 | 3.43 | 0.30 | 600.00 | 600.00 | 580.56 | 491.96 | 131.17 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 7.69 | 0.28 | 0.16 | 0.04 | 0.01 | 567.03 | 307.17 | 245.31 | 103.06 | 55.99 | ||
Runtime limit: 10s | ||||||||||||
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0.13 | 0.02 | 0.03 | 0.00 | 0.00 | 1.94 | 0.83 | 0.72 | 0.04 | 0.03 | |
SIM | 2.41 | 0.35 | 0.09 | 0.00 | 0.00 | 5.06 | 3.96 | 2.06 | 0.10 | 0.04 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 0.32 | 1.88 | 0.00 | 0.00 | 0.00 | 2.72 | 4.62 | 1.08 | 0.15 | 0.05 | ||
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 6.39 | 3.00 | 0.36 | 0.04 | 0.00 | 10.00 | 6.12 | 3.68 | 0.58 | 0.11 | |
SIM | 4.49 | 3.06 | 1.84 | 0.96 | 0.27 | 9.06 | 7.97 | 7.37 | 3.65 | 1.08 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 5.54 | 2.23 | 0.25 | 0.00 | 0.00 | 8.34 | 5.52 | 4.09 | 0.31 | 0.32 | ||
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 8.08 | 7.51 | 3.36 | 0.67 | 0.17 | 10.00 | 9.62 | 9.02 | 3.14 | 1.20 | |
SIM | 6.67 | 18.38 | 8.85 | 4.45 | 0.72 | 8.98 | 10.00 | 10.00 | 7.80 | 3.67 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 11.23 | 3.04 | 1.36 | 0.28 | 0.03 | 9.69 | 8.24 | 7.38 | 2.68 | 1.29 | ||
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 9.69 | 17.64 | 6.56 | 3.68 | 0.40 | 10.00 | 10.00 | 10.00 | 7.66 | 2.10 | |
SIM | 8.18 | 22.21 | 10.00 | 6.05 | 3.19 | 10.00 | 10.00 | 10.00 | 9.43 | 5.93 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 17.82 | 12.79 | 4.99 | 2.33 | 0.38 | 10.00 | 9.99 | 9.52 | 6.89 | 2.58 | ||
Runtime limit: 300s | ||||||||||||
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 19.28 | 0.88 | 3.10 | 0.04 | 0.03 | |
SIM | 0.59 | 0.11 | 0.00 | 0.00 | 0.00 | 103.26 | 53.28 | 30.89 | 0.10 | 0.04 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 0.00 | 0.16 | 0.00 | 0.00 | 0.00 | 80.05 | 106.16 | 21.43 | 0.15 | 0.05 | ||
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 5.23 | 1.15 | 0.17 | 0.01 | 0.00 | 300.00 | 128.65 | 80.81 | 10.25 | 0.11 | |
SIM | 3.53 | 1.69 | 0.43 | 0.17 | 0.00 | 263.67 | 188.71 | 142.46 | 30.36 | 2.29 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 3.14 | 0.80 | 0.22 | 0.00 | 0.00 | 194.34 | 115.01 | 100.99 | 0.31 | 0.32 | ||
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 8.08 | 5.38 | 2.15 | 0.03 | 0.04 | 300.00 | 280.28 | 235.59 | 24.69 | 23.00 | |
SIM | 5.34 | 8.12 | 6.14 | 1.61 | 0.02 | 260.32 | 261.71 | 277.04 | 167.47 | 34.45 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 7.79 | 1.21 | 0.18 | 0.02 | 0.01 | 266.82 | 166.33 | 119.46 | 22.58 | 21.34 | ||
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 9.69 | 11.96 | 5.00 | 1.95 | 0.01 | 300.00 | 300.00 | 291.04 | 150.81 | 31.22 | |
SIM | 7.26 | 17.08 | 6.31 | 4.32 | 0.70 | 300.00 | 300.00 | 290.73 | 271.19 | 86.81 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 13.23 | 1.40 | 0.67 | 0.42 | 0.00 | 300.00 | 194.83 | 185.99 | 89.13 | 15.75 | ||
Runtime limit: 600s | ||||||||||||
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 29.28 | 0.88 | 3.10 | 0.04 | 0.03 | |
SIM | 0.38 | 0.11 | 0.00 | 0.00 | 0.00 | 172.55 | 83.28 | 50.89 | 0.10 | 0.04 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 0.00 | 0.12 | 0.00 | 0.00 | 0.00 | 160.06 | 197.81 | 41.44 | 0.15 | 0.05 | ||
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 5.20 | 0.98 | 0.13 | 0.00 | 0.00 | 600.00 | 237.74 | 150.81 | 14.48 | 0.11 | |
SIM | 3.29 | 1.61 | 0.36 | 0.17 | 0.00 | 523.67 | 368.71 | 260.77 | 50.36 | 2.29 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 2.86 | 0.76 | 0.18 | 0.00 | 0.00 | 384.36 | 225.02 | 192.71 | 0.31 | 0.32 | ||
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 8.08 | 5.12 | 2.15 | 0.03 | 0.04 | 600.00 | 560.28 | 465.59 | 44.69 | 43.00 | |
SIM | 5.33 | 7.82 | 5.17 | 1.28 | 0.02 | 520.32 | 501.71 | 547.04 | 296.04 | 52.99 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 7.12 | 1.21 | 0.18 | 0.02 | 0.01 | 526.86 | 326.35 | 229.47 | 42.58 | 41.34 | ||
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 9.69 | 11.94 | 4.95 | 1.69 | 0.01 | 600.00 | 600.00 | 581.04 | 280.81 | 61.22 | |
SIM | 7.14 | 15.47 | 6.18 | 3.93 | 0.59 | 600.00 | 600.00 | 580.73 | 528.29 | 156.81 | ||
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 11.56 | 1.40 | 0.53 | 0.35 | 0.00 | 600.06 | 364.86 | 341.16 | 159.14 | 25.75 |
-
A first expected result is that all three B&Bs suffer from an increasing solution space. Gaps and runtimes increase the greater the number of containers to be handled and the higher the capacity in the handshake area. A higher capacity increases the alternative intermediate stacking positions to be evaluated for each container move.
-
The same impact is seen moving the handshake area closer to the seaside access point. Recall that the distance from the seaside access point to the handshake area, and thus the workload of crane 1, increases with \(b^h\). Our detailed investigation of the position of the handshake area in Sect. 5.2 will show that its optimal location under seaside workload peaks is somewhere between bays 7 and 10. Any (considerable) deviation from this position will cause one of the cranes to become the bottleneck resource, which reduces throughput performance. A handshake position of \(b^h>10\) leads to crane 1 having to shoulder the lion’s share of the workload, whereas crane 2 is idle most of the time. In these settings, the main focus is on reducing the empty travel and idle time of crane 1, which obviously facilitates the work of all three B&Bs.
-
Naturally, a longer runtime improves the solution quality. Increasing the runtime from 300 to 600 seconds, however, leads to only a minor improvement in solution quality in most cases. Astoundingly, the jump from 10 to 300 seconds also leads to only a relatively small gain, especially for all instances with a badly placed handshake area (\(b^h \ge 15\)) and few containers (\(|I^i|+|I^o| \le 30\)). Only if the handshake area is closer to the seaside, such that the workloads of the two cranes are on a comparable level, and a greater number of container moves increases sequencing flexibility, may more computational time be well spent. We will investigate the development of the solution quality over time in more detail below.
-
When benchmarking our three B&Bs, we can observe that SIM, which sequences and determines stacking positions simultaneously, is clearly outperformed by its two sequential competitors \(\mathrm{SEQ}_{\mathrm{JS}}\) and \(\mathrm{SEQ}_{\mathrm{SJ}}\). Incorporating both types of information, i.e., crane sequences and stacking positions, simultaneously leads to a wider search tree already at the early levels, which obviously makes it more difficult to identify promising parts of the solution space.
-
\(\mathrm{SEQ}_{\mathrm{SJ}}\) and its approach of first determining the stacking positions leads to the best results in most cases. One key advantage of \(\mathrm{SEQ}_{\mathrm{SJ}}\), as compared to \(\mathrm{SEQ}_{\mathrm{JS}}\), is that after the first phase of branching is completed, stacking positions for all containers are given. This allows \(\mathrm{SEQ}_{\mathrm{SJ}}\) to determine tighter lower bounds using the approach of Gilmore and Gomory (1964), see Sect. 4.1.3. Only in the case where just a few containers are processed (\(|I^i|=|I^o|=10\)) will \(\mathrm{SEQ}_{\mathrm{JS}}\) and its approach of first determining job sequences lead to slightly better results. Due to the relatively small number of precedence relations occurring in these instances, an arbitrary pair of sequences determined in the first phase of \(\mathrm{SEQ}_{\mathrm{JS}}\) can more likely be complemented to a feasible schedule, and the search is well guided, whereas this is less likely for larger instances.
\(|I^o|+\) | Algorithm / \(b^h\) | # optimal solutions | ||||
---|---|---|---|---|---|---|
\(|I^i|\) | 5 | 10 | 15 | 20 | 25 | |
10 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 59 | 60 | 60 | 60 | 60 |
SIM | 56 | 56 | 60 | 60 | 60 | |
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 60 | 54 | 60 | 60 | 60 | |
20 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 2 | 41 | 46 | 59 | 60 |
SIM | 10 | 24 | 38 | 57 | 60 | |
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 35 | 38 | 42 | 60 | 60 | |
30 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0 | 4 | 13 | 56 | 56 |
SIM | 8 | 11 | 8 | 37 | 58 | |
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 13 | 29 | 38 | 55 | 58 | |
40 | \(\mathrm{SEQ}_{\mathrm{JS}}\) | 0 | 0 | 1 | 33 | 54 |
SIM | 0 | 0 | 2 | 13 | 48 | |
\(\mathrm{SEQ}_{\mathrm{SJ}}\) | 2 | 29 | 34 | 48 | 57 |
5.2 Where to position the handshake area?
\(|I^o|+|I^i|\) | \(b^h\) | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
---|---|---|---|---|---|---|---|---|---|---|---|---|
5 | \(C_{max}\) | 200 | 189 | 178 | 172 | 166 | 166 | 169 | 176 | 183 | 190 | 196 |
\(W_1\) | 100 | 109 | 118 | 126 | 134 | 141 | 148 | 155 | 161 | 167 | 173 | |
\(W_2\) | 167 | 157 | 146 | 137 | 126 | 118 | 107 | 99 | 90 | 81 | 74 | |
10 | \(C_{max}\) | 401 | 381 | 366 | 347 | 327 | 322 | 328 | 340 | 354 | 368 | 381 |
\(W_1\) | 199 | 217 | 234 | 250 | 266 | 281 | 295 | 309 | 322 | 334 | 345 | |
\(W_2\) | 346 | 324 | 304 | 283 | 263 | 244 | 225 | 208 | 190 | 174 | 159 | |
15 | \(C_{max}\) | 598 | 574 | 549 | 524 | 491 | 482 | 487 | 508 | 528 | 548 | 568 |
\(W_1\) | 299 | 326 | 351 | 376 | 399 | 421 | 443 | 463 | 483 | 501 | 519 | |
\(W_2\) | 513 | 481 | 447 | 418 | 389 | 360 | 334 | 309 | 284 | 258 | 236 | |
20 | \(C_{max}\) | 799 | 771 | 751 | 726 | 679 | 627 | 638 | 666 | 693 | 720 | 744 |
\(W_1\) | 398 | 435 | 469 | 501 | 533 | 563 | 591 | 618 | 644 | 669 | 691 | |
\(W_2\) | 687 | 642 | 599 | 558 | 521 | 482 | 447 | 410 | 376 | 343 | 311 |
Algorithm | \(|I^i|+|I^o|\) | ||||
---|---|---|---|---|---|
10 | 20 | 30 | 40 | ||
NO-SHARING | 50.01 | 52.33 | 51.02 | 50.80 | |
ANY-BAY | 0.04 | 1.35 | 0.83 | 3.00 | |
\(b^h=9\) | HANDSHAKE-HEU-NN | 65.53 | 76.44 | 78.05 | 81.88 |
HANDSHAKE-HEU-LS | 4.67 | 8.24 | 7.80 | 19.25 | |
HANDSHAKE-OPT | 0 | 0 | 0 | 0 | |
\(b^h=15\) | HANDSHAKE-HEU-NN | 59.58 | 67.69 | 67.40 | 71.18 |
HANDSHAKE-HEU-LS | 26.24 | 25.16 | 28.51 | 28.08 | |
HANDSHAKE-OPT | 22.93 | 22.53 | 22.15 | 22.72 |
5.3 Benchmark test
-
NO-SHARING If both cranes are fixedly assigned to their dedicated access point, we have no workload sharing in the strict sense of our definition (see Sect. 2). During seaside workload peaks, the NO-SHARING policy induces that seaside crane 1 has to process all inbound and outbound moves exclusively, while landside crane 2 remains idle. The makespan minimization problem then reduces to a matching of inbound and outbound container moves jointly executed between any successive visits at the access point (see Boysen & Stephan, 2016). Note that, since runtime is less of an issue in this experiment, we can directly apply our B&B procedures for this optimization task and only have to manipulate the input data to a single crane setting. This comparison clarifies research question RQ1, whether workload sharing via a handshake area can substantially improve yard throughput compared to the NO-SHARING policy.
-
ANY-BAY Furthermore, we also compare our optimized crane scheduling with handshake area with an any-bay handover (see Sect. 2). The latter policy allows us to hand over containers between cranes in any bay where free stacking space is available. A previous heuristic algorithm from the literature coordinating twin cranes under the ANY-BAY policy is that of Briskorn et al. (2016). The alterations necessary to adapt their heuristic to our setting with inbound and outbound containers are elaborated in Appendix B. Note, however, that this ANY-BAY heuristic relaxes stacking capacities, so that the results are merely a lower bound and tend to overestimate the advantages of any-bay handover. This benchmark test clarifies research question RQ2, whether the simplified crane coordination via a handshake area comes with the price of excessive throughput loss compared to the more flexible (yet more complicated) coordination of any-bay handover.
-
HANDSHAKE-HEU Previous research on workload sharing in container yards (e.g., Gharehgozli et al., 2017; XiaoLong et al. 2019) mainly focuses on simple heuristic procedures to coordinate container transfers between cranes via a handshake area. Given our sophisticated optimization approach, we benchmark these approaches. In this way, we clarify research question RQ3, whether simple heuristics are sufficient to schedule container transfers via a handshake area or will produce large optimality gaps, such that exact solution approaches like our best-performing B&B approach are the better choice. Specifically, we evaluate two approaches from the literature: a straightforward nearest-neighbor heuristic, where jobs are assigned in a greedy manner while minimizing the empty travel between two consecutive container transports (dubbed HANDSHAKE-HEU-NN), and a local search procedure, which improves the initial solution obtained with HANDSHAKE-HEU-NN by interchanging jobs in the cranes sequences (dubbed HANDSHAKE-HEU-LS). Both approaches are based on the work of Gharehgozli et al. (2017), and we describe them in more detail in Appendix B.
-
RQ 1 Workload sharing via a handshake area has the potential to improve yard throughput substantially compared to the NO-SHARING policy where both cranes are fixedly assigned to their designated access points. The makespan of NO-SHARING is more than 50% higher than our optimization approach.
-
RQ 2 On first sight, the benchmark test between workload sharing with handshake area and its more flexible counterpart based on any-bay handover delivers a surprising result. Although it provides greater flexibility, any-bay handover leads to a slightly higher makespan than its competitor. This is due to the heuristic gap of our solution procedure applied for the ANY-BAY policy. We adapt the heuristic procedure of Briskorn et al. (2016) to our problem setting, which is based on the bucket-brigade protocol (see Appendix B for more details). Obviously, this heuristic is not able to deliver optimal results, because optimal objective values for the ANY-BAY policy cannot exceed those obtained with a handshake area, due to the larger solution space. Thus, it remains a future research task to benchmark HANDSHAKE-OPT with optimal solutions for the ANY-BAY policy. Our results suggest that a handshake area placed in optimal position (i.e., in bay \(b^h=9\) in the case of seaside workload peaks) leads to a comparable yard throughput to that of ANY-BAY.
-
RQ 3 Coordinating workload sharing via a handshake area with simple decision rules seems a bad idea. Applying a straightforward nearest-neighbor heuristic such as HANDSHAKE-HEU-NN leads to an increase in makespan of between 65.53 and 81.88% depending on the number of container moves. Thus, planning that is too simple comes at the price of considerable performance loss. More elaborate heuristics based on local search such as HANDSHAKE-HEU-LS reduce the gap, but still reach a performance loss of 10% and greater if many container moves need to be processed (\(|I^i|+|I^o|=40\)) and/or not enough local search moves are executed. Note that increasing the number of local search moves for HANDSHAKE-HEU-LS to 100,000 moves did not significantly improve the results. Further note that HANDSHAKE-HEU-LS applies our routing procedure of Sect. 4.1.2 based on DP to coordinate the cranes for given container sequences and stacking positions, so that it already contains sophisticated optimization and goes beyond those approaches presented in the literature.
6 Conclusions
-
Introducing a handshake area is an organizational decision to ease the coordination of twin cranes jointly operating a container block. If the handshake bay is positioned in the optimal position, such that both cranes have a similar workload, and their schedules are optimized (e.g., by our B&B approaches), the price for this organizational simplification is low. Compared to an any-bay handover, where each available stacking position is a potential handover position between cranes, the loss in throughput performance is small. Note, however, that our computational test applies a heuristic approach for scheduling the cranes under any-bay handover. Thus, future research must determine whether this finding still holds if two exact solution procedures are benchmarked.
-
This finding, however, is no longer true if the handshake area is poorly placed, e.g., always in the middle bay of the container block. In this case, one crane easily becomes the bottleneck resource and slows container processing considerably. This is especially painful under seaside workload peaks if large container vessels are to be processed under great time pressure.
-
Performance losses also arise when planning is too simple. Existing research only investigates the application of a handshake area when coordinating both cranes with simple rules for job sequencing and handshake access prioritization. Our computational results show that these approaches may lead to considerable performance loss.
-
First, a switching policy could be applied, where a dedicated handshake area and any-bay handover are employed during distinct time intervals. While crane scheduling procedures exist for both operational regimes in isolation (see Sect. 2), future research should investigate the appropriate time for a switch.
-
Under a mixed policy, a handshake area is the default option, but the cranes are exceptionally allowed to cross the handshake area whenever a direct delivery promises a better performance and does not impact the other crane. To account for the mixed policy, our solution frameworks require adaptation when determining the stacking position of a container in \(I^{i,l}\cup I^{o,l}\). This additional option is to not store the container intermediately. To do so, we see at least two algorithmic components that require alteration by future research: the lower bound for the makespan and collision avoidance that is no longer restricted to the handshake area.
-
Another alternative for more flexible crane operations is the application of multiple alternative handshake areas. This requires the additional choice of the right handshake area for each container move and adds potential crane interference. The adaptations to be made to our solution frameworks are similar to the ones sketched above. We could consider each potential stacking position (in each bay of the handshake area) as an optional stacking position. Additionally, if there is at least one handshake area beyond a container’s destination position, it is also possible to deliver it directly. That is, the container can be handled by the seaside crane alone, unless the container passes all bays of the handshake area. The algorithmic components to be adapted are the same as those above.
-
Finally, we can allow a crane to pick up a container a second time for further transport (with or without a potential crossing of the handshake bay). Obviously, in the former case, we would lose the fixed assignment of a crane to each transport job. Our frameworks, then, need an additional decision step of whether the same or the other crane picks up a container after it has been intermediately stored. Again, significant changes to our frameworks are inevitable.