Visualization system for OHT railway network

Research on the OHT (Overhead Hoist Transport) railway network has predominantly centered around routing algorithms [8–11], dispatching [1, 12–15], design [16, 17], and fault detection [18]. In contrast, few studies have addressed monitoring or visualization systems for the OHT railway network, particularly concerning the vulnerability of links. Despite the importance of evaluating and monitoring vulnerable links for improving network reliability and management, research on quantitatively identifying vulnerable links in the OHT railway network has not advanced significantly relative to its necessity. Aside from the study conducted by Lee et al. [2] in the following section, no additional research has been undertaken, as far as we are aware.

In 2018, S. Lee et al. developed a Congestion Monitoring System (CMS) and explored various congestion metrics, proposing new rerouting algorithms based on these metrics. Their research primarily addressed sections, typically defined as groups of links between intersections, rather than individual links. They not only measured basic metrics such as traffic volume and average speed for each section but also introduced new metrics: the Absolute Congestion Index (ACI) and the Relative Congestion Index (RCI). The ACI, calculated as the average speed of moving OHT divided by the maximum speed at a section, identifies structurally congested sections. On the contrary, the RCI, using a moving average of OHT speed over fixed periods, detects instant congestion since it reflects the typical traffic conditions of a section. These metrics are assessed section-wise every 10 minutes and visualized on the CMS, enabling real-time monitoring by users.

Furthermore, they proposed a new rerouting algorithm, Congestion-Based Routing (CBR), which incorporated ACI as a penalty term to the original Distance-Based Routing (DBR) cost, accounting for dynamic congestion scenarios. The performance of CBR was validated through simulations designed by the researchers. However, it is important to note that their system primarily reflects the current condition of the OHT railway and does not provide a fixed index for ranking structurally vulnerable links in the network.

While their research effectively monitored congestion, continuous monitoring of the CMS was necessary to identify congestion sections because metrics like ACI and RCI were based on dynamic conditions, meaning they change according to the current state of the OHT railway. In other words, their system did not offer a fixed index to determine or rank structurally vulnerable links, though it can reflect the current congestion situation in real-time.

As can be seen from the preceding discussion, the field of quantitatively assessing the vulnerability of the OHT railway network is notably under-researched, with the existing study requiring continual monitoring by operators and lacking the capability to identify vulnerabilities when network structures change. Recognizing these limitations, our research aimed to quantitatively ascertain the inherent structural vulnerabilities using only the network structure. We employed betweenness centrality as a fixed index to assess vulnerability, enabling this approach. In this process, we developed an algorithm that considers the unique node-port structure of the OHT railway network, ensuring a realistic representation of the structure. Subsequently, we developed a visualization system to make the results of vulnerability assessment practically usable. This development is significant as it provides semiconductor industry domain experts with visual information about vulnerable links, enabling them to make more effective management decisions regarding the network.

Betweenness centrality

Betweenness centrality, a popular index in graph analysis, was initially introduced by Freeman (1977) [19] and Anthonisse (1971) [20]. It measures the connectivity of nodes or links within a network and has historically been used to identify critical bridges or bottleneck links in various network structures.

The Brandes algorithm, proposed by Ulrik Brandes in 2001, is the most commonly employed method for calculating betweenness centrality. It calculates centrality scores by accumulating them from the farthest node to the source node following the predecessors. This algorithm improved time and space efficiency over previous methods [21].

However, the Brandes algorithm faces challenges with large-scale graphs due to its computational intensity. This limitation has prompted the development of various modified algorithms that incorporate approximation methods and parallel computation strategies to reduce computation time while retaining the fundamental idea of the Brandes algorithm [22]. Additionally, research has been conducted on updating betweenness centrality in dynamic graphs without requiring full recalculations for each graph update. These update algorithms vary depending on the type of update, such as additions or deletions of nodes/links and weight changes.

Specifically, Nasre et al. (2013) introduced an incremental algorithm updating betweenness centrality scores in a graph when a new link is added or an existing link’s weight is reduced [23]. Similarly, Bhandari et al. (2017) developed methods to efficiently update betweenness centrality in dynamic networks with additions or deletions of links or nodes [24]. In addition, Khopkar et al. (2014) targeted social networks and devised fast, incremental update algorithms for various network metrics, including betweenness centrality [25]. Further enhancing these advancements, Feng et al. (2022) and González et al. (2022) introduced more efficient approaches using parallel computing for large-scale network analysis and improved the scalability of the Brandes algorithm, respectively [26, 27].

Vulnerability

Vulnerability is a concept broadly applied across various domains such as transportation networks (including roads, railways, and airways), supply chains, and even graph neural network models. Vulnerability can be applied to any structure that can be modeled as a graph with nodes and links.

For our study, we adopt Berdica’s definition of vulnerability, which originally pertains to road networks as “susceptibility to incidents that can result in considerable reductions in road network serviceability.” We adapt this definition to the OHT railway network by replacing ‘road network’ with ‘OHT railway network’ and ‘incidents’ with ‘congestion’ [28].

According to the survey paper of S. Pan et al., vulnerability analysis can be categorized into four areas: traditional topology analysis, model optimization, simulation, and data-based approaches, noting that these methods can overlap depending on the research focus and methodology [29]. Topological analysis relies on graph topology and static conditions, utilizing metrics like average distance, global and local efficiency, and centrality scores such as betweenness centrality to identify vulnerabilities.

In contrast, simulation and data-based approaches accommodate both static and dynamic conditions. Simulations often include attack methods that examine the impact of node or link removals on network indices such as betweenness centrality. This attack can be conducted either randomly or according to a specific strategy. Li et al. (2019) combined simulation methods with network topology analysis to assess the robustness of air transport networks under both random failures and targeted attacks [29, 30]. Data-based approaches utilize real data to consider historical trends or real-time conditions.

A noteworthy study by Furno (2018) presented a framework to identify vulnerabilities in extensive road networks while employing a graph corresponding to the dynamic road networks and examined the consequences of eliminating nodes on the functionality and efficiency of multi-modal transportation networks. [31]. Another data-driven study by Zhou et al. (2019) utilized real route data to develop a new efficiency metric for assessing air transport network robustness [32].

Our research aligns with topological analysis, selecting betweenness centrality as a suitable metric due to its relevance in analyzing the unique node-port structure of the OHT railway network where routes are determined by a SSSP algorithm. This choice not only underscores the applicability of betweenness centrality in static condition analysis but also paves the way for extending our study to include attack-based and dynamic condition analyses.

To the best of our knowledge, this is the first research to apply betweenness centrality for identifying and visualizing structurally vulnerable links within the OHT railway network. Furthermore, our study took into account the realistic node-port structure in the FAB and utilized a modified Brandes algorithm tailored to the hierarchical structure. This modification enhanced the practicality of our algorithm, potentially extending its application to other similarly structured systems.

Data and notation

In this study, we used node, link, and port data in the real FAB provided by Samsung Electronics. However, due to the sensitive nature of the information, certain specific details were either preprocessed or not disclosed to maintain confidentiality. For example, the distances of links were normalized, and the exact coordinates of each node and port were not revealed by the company, reflecting their proprietary and confidential status.

The features for each dataset are summarized in Table 1. Each node, link, and port were assigned unique IDs, referred to as Encoded_Id in the ‘Node’ and ‘Link’ datasets, and Encoded_Port in the ‘Port’ dataset. The ‘Link’ data included the IDs of the source and target nodes that correspond in the ‘Node’ dataset (Encoded_From_Node, Encoded_To_Node), as well as normalized encoded distances (Encoded_Distance). In the ‘Port’ dataset, the Encoded_Id feature represents the ID of the nearest node to which it is mapped.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Features of datasets.

https://doi.org/10.1371/journal.pone.0307059.t001

We selected a particular layout for our research due to its size, as it was the largest among the layouts offered by Samsung Electronics. Additionally, it included crucial structural components, such as bridges that connect different areas.

Table 2 below summarizes the size of each node, link, and port data, along with additional statistics pertaining to the OHT railway layout data we utilized.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Statistics of data.

https://doi.org/10.1371/journal.pone.0307059.t002

To further explain the node-port structure in the OHT railway network, nodes do not represent the actual source or target points but serve as sensors that record the positions and velocities of the nearest OHTs. In contrast, ports are the actual stopping points where FOUPs are loaded and unloaded. The conceptual figure depicted in Fig 1 illustrates the node-port structure. In Fig 1, the large orange circles represent nodes, while the smaller blue circles represent ports. Ports are assigned to their nearest node, with each node accommodating multiple ports. The actual travel path was assumed to be from port to port, rather than from node to node, as shown by the navy arrows labeled ‘Allowed path’ in Fig 1. Impractical port-to-port paths within the same node were disregarded, represented by the red arrows labeled ‘Disallowed path.’ Considering the unique structure of the OHT railway network, we developed a new algorithm to calculate betweenness centrality.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Node-port structure of OHT railway.

Nodes are represented by orange circles, and ports are represented by blue circles. Each port is assigned to its nearest node. Paths between ports in different nodes are allowed, while port-to-port paths within the same node are disallowed.

https://doi.org/10.1371/journal.pone.0307059.g001

We have detailed our modified algorithm and its corresponding proof in the subsequent sections. For this purpose, we utilized a range of symbols, with their respective summaries presented in Table 3 below.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Summary of notation.

https://doi.org/10.1371/journal.pone.0307059.t003

Since the data we used is confidential FAB data from Samsung Electronics and cannot be disclosed, we have provided our code and OHT railway layout open data from SMAT 2022 [33] on our GitHub repository instead. The result obtained using this SMAT 2022 layout is also included in S1 Figure in S1 File.

Visualization method

Since the coordinates of the nodes were confidential, we used a force-directed layout algorithm to visualize the OHT railway network and set a strong stiffness constant to maintain distance as much as possible. However, due to the complexity of the network, with its numerous nodes and links, the resulting graph often appeared dense and hairball-like. To improve clarity, we integrated a grid-force into the algorithm to align the nodes to the nearest grid points. The grid size, a predefined hyperparameter, resulted in a more rectangular graph layout, approximating the actual OHT railway layout. To implement the visualization system as a web application, we used Flask, a Python-based web framework, for the backend and MongoDB as the database platform. A detailed explanation of our visualization system is provided in the ‘Results and discussion’ section.

Betweenness centrality calculation algorithm

For the node-only structure, we used the Brandes algorithm to calculate betweenness centrality using the Python NetworkX library.

To account for the node-port structure depicted in Fig 1, we modified the Brandes algorithm, ensuring that its time complexity remains equivalent to that of a node-only structure.

The definition of betweenness centrality is shown in Eq (1). (1)

In this equation, is known as the pair dependency. Betweenness centrality is the sum of all pair dependencies passing through a given node or link. (2)

To incorporate the node-port structure, we modified the conventional definition of betweenness centrality, as provided in Eq (2). Here, p(s) and p(t) denote the number of ports at the source and target nodes, respectively. Using the standard Brandes algorithm while treating ports as additional nodes would increase time complexity proportional to the rise in nodes and links. To address this issue, we adjusted the equation and introduced a modified pair dependency term, defined as follows: (3)

To compute the sum of modified pair dependencies, we followed the original Brandes algorithm proof steps. In Eq (3), δ_s•,p(v) is the sum of all modified pair dependencies from source s to all the targets. δ_st,p(v, {v, w}) represents the modified pair dependency passing through node v and link (v, w). P_s(w) denotes the set of predecessors of w. (4)

δ_st,p(v, {v, w}) can be expressed as two terms, as shown in Eq (4). If t = w, then it simply becomes since σ_sw(v, {v, w}) = σ_sv. In the case of t ≠ w, σ_st(v, {v, w}) = σ_sw(v, {v, w}) ⋅ σ_wt and because σ_st(w) = σ_sw ⋅ σ_wt, σ_wt becomes . So the modified pair dependency term becomes when t ≠ w. (5)

By incorporating this formula into the original sum expression, it is represented as illustrated in the aforementioned Eq (5), and the last term is δ_{s•, p}(w). As a result, we obtained an accumulation similar to that of the Brandes algorithm.

Algorithm 1 Calculation of betweenness centrality

Input: G = (V, E), weight, port, nodes

Output: BC_node(v), BC_link(e) for all v ∈ V and e ∈ E

1: for v ∈ V do

2:  BC(v) ← 0

3: end for

4: for e ∈ V do

5:  BC(e) ←0

6: end for

7: if nodes = None then

8:  nodes = V

9: end if

10: for s ∈ nodes do

11:  if weight = None then

12:   S, P, σ = SSSP(G, s)

13:  else

14:   S, P, σ = SSSP(G, s, weight)

15:  end if

16:  if port = None then

17:   BC = BA(BC, S, P, sigma, s)

18:  else

19:   BC = BA_p(BC, S, P, sigma, s, port)

20:  end if

21: end for

22: BC_node = {}

23: for s ∈ S(v) do

24:  pop BC_s from BC(s)

25:  BC_node(s) ← BC_s

26: end for

27: BC_link = BC

28: return BC_node(v), BC_link(e) for all v ∈ V and e ∈ E

The pseudocode for computing betweenness centrality for both nodes and links is illustrated in Algorithm 1. The algorithm’s inputs include the graph G, selected features for weight, port data, and nodes for parallelization later. In the initial setup, lines 1 to 6, the betweenness centrality values for each node and link in G are initialized to zero. In the next segment, lines 7 to 9, the algorithm manages cases without employing parallelization. If a specific set of nodes is not provided, the algorithm defaults to utilizing all nodes within G. Subsequently, the algorithm proceeds to compute the SSSP for a node s. If no weight parameter is provided, it employs Breadth-First Search (BFS). In contrast, for weighted directed graphs, Dijkstra’s algorithm is utilized instead. Both methodologies yield three key outputs: S, P, and σ. Here, S represents a sequence of nodes commencing from the source s to all target nodes, ordered by proximity. P is a record of predecessors for each node within S, and σ is the total count of shortest paths originating from source s to each target node t.

Subsequently, the algorithm checks if port data is available. If not, the original Brandes algorithm is applied for betweenness centrality calculations. If port data is available, the algorithm employs our modified Brandes algorithm as described above.

In the final stages, encompassed in lines 22 to 27, the algorithm separates the betweenness centrality calculations for nodes and links, ultimately yielding both values.

Algorithm 2 BA_p: Accumulation of modified pair-dependencies

Input: BC, S, P, σ, s, port

Output: BC(x) for all x ∈ V ∪ E

1: for v ∈ S do

2:  δ(v) ←0

3:  if v != s then

4:   sum_ports += port(v)

5:  end if

6: end for

7: BC(s) += port(s) * sum_ports

8: while S do

9:  pop w from S

10:  coeff = (port(s) * port(w) + δ(w))/σ(w)

11:  for v ∈ P(w) do

12:   c = σ(v) * coeff

13:   BC({v, w}) += c

14:   δ(v) += c

15:  end for

16:  if w! = s then

17:   BC(w) += δ(w) + port(s) * port(w)

18:  end if

19: end while

20: return BC(x) for all x ∈ V ∪ E

Algorithm 2 presents our modified Brandes algorithm. The inputs for this algorithm include betweenness centrality BC, sequences S, predecessors P, the count of shortest paths σ, source node s, and port data port. Initially, every δ term is set to zero.

The algorithm then computes the cumulative sum of the fraction of the number of ports to its σ of all target nodes v from source s, excluding the source node s itself. This step incorporates the betweenness centrality of the source, considering that the actual starting point is the ports in s, rather than the node s itself. Therefore, in line 7, the betweenness centrality for source s is calculated by multiplying the number of ports in s with the sum_source_dependency term.

From lines 8 to 19, the algorithm proceeds with the accumulation of modified pair dependencies, working backward from the most distant target node to the source node. The main difference from the standard Brandes algorithm is in the coefficient, specifically port(s) * port(w). In line 17, the factor port(s)*port(w) is also considered to account for the target node t, acknowledging that the actual targets are the ports within t, similar to the source node case above.

This algorithm enables the calculation of modified pair dependencies, taking into account port, from the source node s. By iterating this process over all nodes s in the set V, it is possible to accurately determine the betweenness centrality for both nodes and links in the network.

Along with betweenness centrality, we also calculated stress centrality as a supplementary indicator of structural vulnerability. Stress centrality is the sum of the number of shortest paths passing through a node or link, while betweenness centrality is the sum of pair-dependencies. Both can be calculated for node and node-port structures. Detailed information about stress centrality is provided in S1 Appendix in S1 File, and algorithms for its calculation are given in S1 and S2 Algorithms in S1 File.

Parallelization

In our effort to optimize computational efficiency, we employed a modified accumulation algorithm which notably reduced time complexity. However, for an average OHT railway network graph comprising approximately 10,000 nodes, computation time still ranged between 20 and 30 minutes. To further reduce computation time, we implemented parallelization, particularly in the stages of obtaining the SSSP and the accumulation phase, as outlined from lines 10 to 21 in Algorithm 1. This is why ‘nodes’ is an input of Algorithm 1.

Our parallelization approach employed multiprocessing in Python. We evenly distributed the total set of nodes across the processors and executed Algorithm 1 concurrently. The betweenness centrality values for each node and link were aggregated after computations on each processor, significantly reducing the total computation time to tens of seconds or a maximum of 2–3 minutes.

To evaluate the efficiency of our modified algorithm, we measured computation times across various graph sizes. Additionally, we measured computation time on a fixed-size graph with differing numbers of processors to assess the effect of parallelization. The experimental environment is summarized in Table 4 below.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 4. Experimental environment.

https://doi.org/10.1371/journal.pone.0307059.t004

Visualization system

Fig 2 displays an overview of our visualization system. We divided our system into sections to describe the details of each part.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Visualization system overview.

The A-C panels on the left sidebar with a black background form the ‘Analysis Panel,’ where users can load data and choose visualization options and the section D on the right with a white background is a space where the visualized network results can be viewed.

https://doi.org/10.1371/journal.pone.0307059.g002

Comparative analysis

Identifying vulnerable links using betweenness centrality calculated by our newly modified algorithm demonstrated its significance by more accurately reflecting the operational conditions and traffic flows of the OHT railway network compared to the original Brandes algorithm.

Specifically, its effectiveness was evident in the ‘Bridge’ areas of the OHT railway network. Fig 3 shows the results of visualizing vulnerable links using betweenness centrality on different structure; the left side shows the result of traditional node-only structure with the Brandes algorithm, while the right side incorporates the node-port structure using our modified algorithm.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Comparison between the results of node-only and node-port structure.

(left: node-only, right: node-port). The focused region is where bridge links are located. The betweenness centralities of bridge links are alleviated in the right figure.

https://doi.org/10.1371/journal.pone.0307059.g003

In the network layout, the lower left central section shifts from red in the node-only structure to orange and yellow hues in the node-port structure, indicating a decrease in betweenness centrality. Notably, these bridge areas, characterized by a minimal presence of ports, typically experience lower congestion levels in practical scenarios because they are used merely as passageways without OHT stopping points.

Our modified algorithm reflected the practical realities of the FAB more accurately by considering these conditions. It assigned lower vulnerability ratings to these bridge areas, avoiding the overestimation seen with the node-only structure that does not consider port presence. In a similar vein, our modified algorithm assessed higher vulnerability in areas with concentrated ports where OHTs frequently stop, reflecting the increased traffic since more shortest paths start from and lead to these ports. This inclusion of actual source and target ports in the algorithm better mirrors the real traffic conditions in the FAB.

In order to clearly demonstrate the effect of port, we conducted an experiment varying the number of ports on a small network that includes a bridge, as depicted in Fig 4.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Effect of ports on betweenness centrality.

An experiment on a simple bridge network structure was conducted, varying the number of ports per node in regions indicated by rectangles. (a) node-only, (b) equal port concentration at both ends. (c) higher port concentration at the upper end (d) higher port concentration at the lower end.

https://doi.org/10.1371/journal.pone.0307059.g004

The outcome of Fig 4(a) represents the node-only result. We allocated ports to each individual node within the rectangular area. The color of the rectangle indicates the number of ports assigned to each node in the region: green for one port per node, orange for three ports per node, and red for five ports per node. The most vulnerable links are obviously the links located in the bridge region in Fig 4(a).

However, in Fig 4(b), an equal number of ports was assigned to each node at both ends of bridge. Despite this uniform assignment, the betweenness centralities at the bridge decreased, while those at the ends, where ports were assigned, increased.

This is because there are no ports on the bridge, meaning that the nodes on the bridge only serve as passing nodes and not as the source or target nodes. Furthermore, it can be observed that the region with a higher concentration of ports exhibited a higher level of betweenness centrality, as shown in Fig 4(c) and 4(d).

Computational efficiency

Modified algorithm efficiency.

To evaluate the efficiency of our modified algorithm, we conducted computational time tests on random graphs with node counts of 10, 100, 1000, 2500, and 5000. We opted not to measure time for the 10,000-node scenario due to the impractically long durations required by the original Brandes algorithm, which could extend to several hours. For each graph, the number of links was set to three times the number of nodes, and each node was assigned three ports. The original Brandes algorithm was conducted by treating ports as additional nodes.

The results, presented in Fig 5, utilize a logarithmic scale on both the x and y axes to effectively display the wide range of graph sizes and computation times. The computation time for each algorithm increased with the graph size, ranging from 10 to 5000 nodes, as follows: the original Brandes algorithm recorded times of about 0.01, 1, 200, 600, and 7000 seconds; the modified algorithm showed times of about 0.001, 0.06, 10, 100, and 400 seconds, respectively, when plotted on a logarithmic scale. The results clearly showed a reduction in computation time by approximately an order of magnitude across all tested sizes. Specifically, for the 5000-node graph, it showed a 93.6% reduction in computation time compared to the original Brandes algorithm. Detailed data supporting these findings are shown in S1 Table in S1 File.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Graph of computation time vs number of nodes.

The computation time was measured as the number of nodes increased, comparing the original Brandes algorithm with our modified algorithm. Our algorithm showed a significant improvement in computation time, with a 93.6% reduction for the 5000-node graph.

https://doi.org/10.1371/journal.pone.0307059.g005

This reduction is expected as our modified Brandes algorithm only iterates over the original nodes, whereas the original Brandes algorithm iterates over additional port nodes, increasing the total node and link count. This modification substantially decreases computation time, irrespective of the number of supplementary nodes of ports. The algorithm’s applicability extends to various settings that feature a hierarchical structure similar to the node-port concept shown in Fig 1.

Parallelization efficiency.

While the modification of the Brandes algorithm successfully reduced computation time, its duration was still considerable for practical applications. To address this, we implemented parallelization using Python’s multiprocessing. We evaluated the algorithm’s performance on a graph comprising 10,000 nodes, maintaining the same link and port conditions as in previous experiments. The computation time was measured against varying numbers of processors: 5, 10, 20, 50, 80, and 100. The computation time significantly decreased, reaching the level of tens of seconds as shown in Fig 6. The axes are represented on a linear scale because the time range was narrow enough to be displayed linearly. The specific computation times for different processor counts are detailed in S2 Table in S1 File.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Graph of computation time vs number of processors.

Parallelization efficiency was assessed by measuring computation time with a varying number of processors. A 5.7-times increase in computation speed was achieved with 50 processors.

https://doi.org/10.1371/journal.pone.0307059.g006

Notably, the computation time diminished up to the 50 processors, achieving an 82.4% reduction compared to using 5 processors, beyond which it began to slightly increase again. This rise in time can be attributed to the overhead associated with communication tasks, such as duplicating the entire graph object and port data across each processor’s memory, and the aggregation of results from individual processors. The aggregation process needs iteration a total number of times equal to the product of the number of processes and the combined count of nodes and links, and involves cumulatively summing the betweenness centrality results for each node and link. This factor is believed to be the primary cause of the increased computation time. Additional factors potentially influencing this trend may relate to the operational characteristics of multiprocessing in Python.

For graphs with node counts exceeding 10,000, utilizing a higher number of processors could further reduce computation time. However, considering that typical OHT railway networks approximate 10,000 nodes, we determined that setting the processor count to 50, which demonstrated optimal performance, was the most appropriate choice for our job.

Fast computation time may not be crucial when evaluating only a limited number of FAB layouts, as the results, once calculated, remain fixed. However, we have prioritized rapid computation for several reasons. Firstly, our system is a web-based visualization tool, and users expect immediate results. Secondly, the system can be employed to assess the robustness of virtual FAB layouts before actual construction. Rapid computation enable users to quickly test multiple configurations.