3.1.1 Three-dimensional cityscape generation

To design the flight environment, the approach follows the methodology presented in [Reference Parish and Müller25] to generate 3D terrains and buildings. This process allows for the creation of random 3D cities, providing a diverse and realistic urban landscape. The use of procedural modeling ensures the simulation of complex city layouts, including varying building heights, structures and terrains, offering a comprehensive and dynamic scenario for low-altitude airspace management.

The figures depicted in Fig. 2 illustrate the procedural process utilised for the generation of a three-dimensional cityscape. It presents a step-by-step pipeline employed to construct a realistic urban environment. The initial stage in Fig. 2a involves the generation of a roadmap using an L-system rule, which entails the creation of a network of roads and streets that serve as the foundation for the layout of the city. Subsequently, the polygon generation phase involves the specification of the shape and size of individual city blocks as shown in Fig. 2b. The subsequent step is the generation of buildings as shown in Fig. 2c, where structures are added to the polygons, reflecting the architectural and design characteristics of the buildings within the city. Finally, the complete three-dimensional model is created as in Fig. 2d, which represents a visually appealing and realistic cityscape that can be utilised for low-altitude airspace organisation.

Figure 2.

Random city layout and model generation.

3.1.2 Flight routes generation

After the generation of the 3D terrain and buildings model, the next critical step is to establish multi-layer flight routes based on the geographic information of the city. These flight routes are designed to enable safe and efficient operations of UAM vehicles within the complex urban environment. Each flight level corresponds to a specific altitude range, and multi-layer routes facilitate seamless flight at different heights.

To ensure safety, two-dimensional obstacle and risk maps are derived from the 3D terrain and building models. These maps provide crucial information on potential obstacles and risk areas that UAM vehicles need to avoid. By incorporating the terrain and building data into the maps, potential conflicts and hazardous zones can be identified, allowing for precise route planning.

Let $R\left( {x,y,z} \right)$ represent the 3D model, where $x$ , $y$ and $z$ are the coordinates in the 3D space ${\mathbb{R}^3}$ of the model. The obstacle map ${M_L}\left( {x,y} \right)$ at flight level $L$ can be defined as:

(1) \begin{align}{M_L}\left( {x,y} \right) = \left\{ {\begin{array}{*{20}{l@{\quad}l}}1 {}&{{\mathrm{if}}\ \exists z \geq L}\\0 {}&{{\mathrm{otherwise}}}\end{array}} \right.\end{align}

where $R\left( {x,y,z} \right)$ is a binary function that indicates the presence ( $R\left( {,y,z} \right) = 1$ ) or absence ( $R\left( {x,y,z} \right) = 0$ ) of an obstacle at a given point $\left( {x,y,z} \right)$ in the 3D model. In other words, the ${M_L}\left( {x,y} \right)$ map saves the points in the 2D plane above altitude $L$ from the 3D model $R\left( {x,y,z} \right)$ . If there exists a point $\left( {x,y,z} \right)$ in the 3D space with altitude $z$ greater than or equal to $L$ , the corresponding value in the altitude map ${M_L}\left( {x,y} \right)$ is set to 1, indicating the presence of an obstacle. Otherwise, the value in ${M_L}\left( {x,y} \right)$ is set to 0, representing the availability of space at the specified flight level.

To account for environmental uncertainties and enhance safety during UAM operations, each 2D map ${M_L}$ at flight level $L$ is extended with a safe margin $a$ . This safe margin is added near obstacles to create a buffer zone as depicted in Fig. 3a, ensuring that UAM vehicles maintain a safe distance from potential conflicts with static obstacles. The extended 2D map $M_L^{ext}$ is defined as:

(2) \begin{align}M_L^{ext}\left( {x',y'} \right) = \left\{ {\begin{array}{*{20}{l@{\quad}l}}1 {}&{{\mathrm{if}}\ \exists z \geq L,{\mathrm{where}}\ x' \in \left[ {x - a,x + a} \right],y' \in \left[ {y - a,y + a} \right]}\\0 {}&{{\mathrm{otherwise}}}\end{array}} \right.\end{align}

where $R\left( {x',y',z} \right)$ is the 3D model at point $\left( {x',y',z} \right)$ ; $x'$ and $y'$ are coordinates within the safe margin $a$ around $\left( {x,y} \right)$ . The safe margin $a$ extends the 2D altitude map $M_L^{ext}\left( {x,y} \right)$ around each obstacle, ensuring that potential conflicts are detected early and allowing sufficient space for UAM vehicles to fly safely.

Figure 3.

Flight corridor generation.

The next step is to create flight routes using path-finding algorithms, such as ${A^{\mathrm{*}}}$ , based on the extended 2D obstacle map $M_L^{ext}$ . Especially, ${A^{\mathrm{*}}}$ is an efficient and widely used algorithm for finding the shortest path between two points on a map. The first step is to select collision-free waypoints at specific locations within the map. Let ${P_L} = \left\{ {\left( {{x_1},{y_1}} \right),\left( {{x_2},{y_2}} \right), \ldots ,\left( {{x_n},{y_n}} \right)} \right\}$ be the set of selected collision-free points at level $L$ . Next, the shortest route between each pairwise point in ${P_L}$ is computed using ${A^{\mathrm{*}}}$ . The resulting routes are represented as ${R_{ij}}$ from $\left( {{x_i},{y_i}} \right)$ to $\left( {{x_j},{y_j}} \right)$ , where $i,j \in \left[ {1,n} \right]$ . However, the generated routes ${R_{ij}}$ from ${A^{\mathrm{*}}}$ are not always straight and may contain unnecessary zig-zag paths, which can be inefficient for UAM flights. Hence, the need for path smoothing arises. Path smoothing is essential to optimise the flight trajectory and improve the efficiency of UAM operations. As depicted in Fig. 3b, by applying the path smoothing, the generated routes are modified to create smoother and more direct trajectories, reducing energy consumption and travel time for UAM vehicles. Algorithm 3.1.2 describes the path smoothing approach in detail. It operates using two functions: LineOfSight, which checks for a clear line of sight between two points on the map using Bresenham’s line algorithm [Reference Wright26], and SmoothPath, which iterates through consecutive pairs of points in the original path. The SmoothPath function retains points with a clear line of sight between them, effectively removing intermediate waypoints and generating a smoother path. By reducing unnecessary zig-zagging, the algorithm creates a more efficient trajectory ${\hat R_{ij}}$ , leading to improved performance and safer navigation in complex urban environments.

Algorithm 1:

Path Smoothing Algorithm

The processed routes ${\hat R_{ij}}$ are regarded as prescribed flight corridors. For each flight level $L$ , the prescribed corridors ${C_L}$ are given as:

(3) \begin{align}{C_L} = \bigcup\limits_{\left( {{x_i},{y_i}} \right),\left( {{x_j},{y_j}} \right) \in {P_L},i \ne j} {{{\hat R}_{ij}}} \end{align}

Finally, the flight corridors from all flight levels are combined to create the comprehensive flight path for the UAM system. The overall flight corridor ${C_{{\mathrm{UAM}}}}$ is obtained as the union of all individual flight corridors at different levels:

(4) \begin{align}{C_{{\mathrm{UAM}}}} = \bigcup\limits_L {{C_L}} \end{align}

3.2.1 Graph generation

With the designed flight corridor structure ${C_{{\mathrm{UAM}}}}$ , waypoints $W$ and vertiports $V$ sets are integrated to build a graph $G = \left( {N,E} \right),N = V \cup W \cup I$ , where $V$ represents vertiports, $W$ represents waypoints and $I$ represents the intersections of flight corridors. $E$ represents the set of edges connecting these nodes in the graph. An example of corridor structure is provided in Fig. 4a.

Figure 4.

Flight corridor generation.

3.2.2 Flight generation

We set the flight number ${f_N}$ in the scenario and then for each flight ${f_i}$ , the starting vertiport ${v_{{\mathrm{start}},{f_i}}} \in V$ and the destination vertiport ${v_{{\mathrm{dest}},fi}} \in V\left( {{\mathrm{start}} \ne {\mathrm{dest}}} \right)$ are randomly selected. For each flight, we apply a pathfinding algorithm to find the shortest path ${P_{{f_i}}}$ as the scheduled path from the constructed graph $G$ . And each flight is randomly assigned with flight velocity ${v_{{f_i}}}$ , operation time ${t_{{f_i}}}$ and appropriate flight level.

The flight scheduling process involves constructing multi-view graphs, where each flight schedule is represented as a subgraph ${G_{{f_i}}} = \left( {{V_{{f_i}}},{E_{{f_i}}}} \right)$ extracted from $G$ as depicted in Fig. 4b. ${V_{{f_i}}}$ is the set of nodes specific to flight ${f_i}$ and ${E_{{f_i}}}$ is the set of edges that connect those nodes and can be denoted as follows:

(5) \begin{align}{V_{{f_i}}} = \left\{ {{v_{{f_i},j}}{\mathrm{|}}{v_{{f_i},j}} \in V} \right\}\end{align}

(6) \begin{align}{E_{{f_i}}} = \left\{ {{e_{{f_i},k}}{\mathrm{|}}{e_{{f_i},k}} \in E} \right\}\\[8pt]\nonumber\end{align}

where ${v_{{f_i},j}}$ represents a node in flight ${f_i}$ with the subscript $j$ to indicate the node index in that subgraph, similarly, ${e_{{f_i},k}}$ represents an edge within flight ${f_i}$ with the subscript $k$ to indicate the edge index in that flight.

Meanwhile, an important distinction needs to be mentioned that the node features are not stored in the global graph $G$ . Instead, the node features are specific to each subgraph, even if common nodes appear in different subgraphs.

Let $f\left( {{v_{{f_i},j}}} \right)$ represent the feature vector of node ${v_{{f_i},j}}$ in the subgraph for flight ${f_i}$ . It consists of essential flight information, including the flight ID, arrival time, speed and waypoint coordinates $\left[ {x,y,z} \right]$ . We can express the feature vector $f\left( {{v_{{f_i},j}}} \right)$ of node $j$ as follows:

\begin{align*}f\left( {{v_{{f_i},j}}} \right) = \left[ {{f_i},{t_j},{s_j},{{\bar x}_j},{{\bar y}_j},{{\bar z}_j}} \right]\end{align*}

where:

• • ${f_i}$ represents the flight ID.

• • ${t_j}$ represents the arrival time of flight ${f_i}$ at the node $j$ .

• • ${s_j}$ represents the speed of flight ${f_i}$ at the specified node.

• • ${\bar x_j},{\bar y_j},{\bar z_j}$ represent the normalised $x,y,z$ coordinates of the waypoint of flight ${f_i}$ .

The multiple subgraphs ${G_{{f_1}}},{G_{{f_2}}}, \ldots ,{G_{{f_n}}}$ construct the multi-view representation, where each subgraph ${G_{{f_i}}} = \left( {{V_{{f_i}}},{E_{{f_i}}}} \right)$ is associated with a specific flight ${f_i}$ . This enables efficient representation and management of flight scheduling data within the multiple graph view.

3.2.3 Conflict detection

Real-time conflict detection is of utmost importance to ensure safe and efficient operations in the UAM environment. To achieve this, multi-view subgraphs are employed to comprehensively capture the interactions and dependencies among flights.

The entire operation time is discretised into $s$ discrete time slots $\left\{ {{t_1},{t_2}, \ldots ,{t_s}} \right\}$ with a specific interval ${\mathrm{\Delta }}t$ seconds. In each time slot ${t_i}$ , the current positions of aircraft are represented as ${\mathbf{P}}\left( {{t_i}} \right) = \left\{ {{{\mathbf{p}}_1}\left( {{t_i}} \right),{{\mathbf{p}}_2}\left( {{t_i}} \right), \ldots ,{{\mathbf{p}}_n}\left( {{t_i}} \right)} \right\}$ , where $n$ is the number of aircraft. The distance between any pairwise aircraft positions is calculated as $d\left( {{{\mathbf{p}}_j}\left( {{t_i}} \right),{{\mathbf{p}}_k}\left( {{t_i}} \right)} \right)$ for all $j,k$ . If $d\left( {{{\mathbf{p}}_j}\left( {{t_i}} \right),{{\mathbf{p}}_k}\left( {{t_i}} \right)} \right)$ is less than a predefined safety margin $\delta d$ , then a conflict is detected at time slot ${t_i}$ .

Let ${\mathrm{conf}}\left( {{t_i}} \right)$ be the set of conflict flight index tuples at time slot ${t_i}$ , and denote as:

(7) \begin{align}{\mathrm{Conf}}\!\left( {{t_i}} \right) = \left\{ {\left( {j,k} \right){\mathrm{|}}d\left( {{{\mathbf{p}}_j}\left( {{t_i}} \right),{{\mathbf{p}}_k}\left( {{t_i}} \right)} \right) \lt \delta d\ {\mathrm{for}}\ j,k \in \left[ {1,n} \right]\ {\mathrm{and}}\ j \ne k} \right\}\end{align}

It returns the set of conflict flight index tuples at each time slot ${t_i}$ , representing the detected conflicts between pairs of aircraft.

Moreover, it is possible to look ahead several time intervals for longer-time conflict detection at a specific time ${t_i}$ , $i \in \left\{ {1,2, \ldots ,s} \right\}$ , allowing the system to anticipate and address potential conflicts ( ${\mathrm{conf}}\left( {{t_{i + 1}}} \right),{\mathrm{conf}}\left( {{t_{i + 2}}} \right), \ldots $ ) that may arise in the future time slots ${t_{i + 1}},{t_{i + 2}}, \ldots $ . This time-based conflict detection mechanism ensures continuous monitoring of aircraft positions and facilitates timely and efficient conflict resolution.

In addition, this conflict detection part is only used for ground truth generation. It is essential to highlight that during the model inference process, conflict detection will not be relied upon. Instead, the trained model will directly use the node features of flight schedules for conflict resolution and decision-making.

3.3.1 Graph representation

Graph representation is the critical module in the architecture. It takes the graph ${\mathcal{G}}$ as input, and the node feature matrix is embedded into high-dimensional features ${\mathbf{X}} \in {\mathbb{R}^{N \times d}}$ , where $N$ is the number of nodes and $d$ is the original feature dimension. The RNN is then employed to encode the node features and can be expressed as follows:

\begin{align*}{{\mathbf{h}}_i} = {\mathrm{RNN}}\left( {{{\mathbf{h}}_i},{\mathbf{X}}\left[ i \right]} \right)\end{align*}

where ${{\mathbf{h}}_i}$ is the hidden state of the RNN for node $i$ , ${\mathbf{X}}\left[ i \right]$ is the input feature of node $i$ . The RNN updates the node features to ${\mathbf{H}} \in {\mathbb{R}^{N \times D}}$ based on the graph structure and node interactions.

The updated node features are then used in the message-passing process of the GNN. The information in node-wise message passing is propagated and exchanged between neighboring nodes in a graph in a sequential manner. At each step $t$ , each node $i$ aggregates information from its neighboring nodes, forming a set of messages ${\mathcal{M}}_i^{\left( t \right)}$ :

(8) \begin{align}{{\mathcal{M}}_i} = \psi \left( {\left\{ {{{\mathbf{H}}_j}{\mathrm{\;for\ each\ neighbor\;}}j{\mathrm{\;of\ node\;}}i} \right\}} \right)\end{align}

Here, $\psi $ is a function that combines the neighboring node features in a way that summarises the information for each node $i$ . The node then updates its own feature using the aggregated messages and its current feature:

(9) \begin{align}{{\mathbf{H'}}_i} = \varphi \left( {{{\mathbf{H}}_i},{{\mathcal{M}}_i}} \right)\end{align}

where $\varphi $ is a function that updates the node features based on the aggregated messages and the current node features. The message-passing process is repeated for multiple time steps to allow the nodes to gather and exchange information with their neighbors iteratively to obtain final node features ${{\mathbf{H}}^{\left( F \right)}}$ .

3.3.2 Loss function

In the training process, we utilise a combination of two loss functions: cross-entropy ${\mathcal{L}_{CE}}$ and contrastive ${\mathcal{L}_{CR}}$ loss.

(10) \begin{align}\mathcal{L} = {\mathcal{L}_{CE}} + {\mathcal{L}_{CR}}\end{align}

The cross-entropy loss is employed for predicting whether a given pair represents a conflicted or a non-conflicted pair of flights. This loss function allows us to effectively classify the two classes based on their input features.

(11) \begin{align}{\mathcal{L}_{{\mathrm{CE}}}}\!\left( {p,q} \right) = - \mathop \sum \limits_i {p_i}\log \left( {{q_i}} \right)\end{align}

where $p$ is ground-truth labels obtained from conflict detection, $q$ is the predicted probability distribution from the model, and ${\mathrm{log}}$ is the natural logarithm.

On the other hand, contrastive loss plays a crucial role in enhancing discrimination between the different classes. By enforcing a margin between the embeddings of conflict and non-conflict pairs, the contrastive loss helps the model to learn a more robust representation, effectively distinguishing between conflicting and non-conflicting schedules. The incorporation of both loss functions enables our model to not only accurately predict the conflict class but also to learn meaningful embeddings that facilitate better conflict evaluation.

(12) \begin{align}{\mathcal{L}_{{\mathrm{CR}}}}\!\left( {x,y} \right) = \frac{1}{2}\left( {y \cdot d{{({x_1},{x_2})}^2} + \left( {1 - y} \right) \cdot {{\left( {\max \!\left( {0,\sigma - d\left( {{x_1},{x_2}} \right)} \right)} \right)}^2}} \right)\end{align}

where ${x_1}$ and ${x_2}$ are the embeddings of the two inputs, $d\left( {{x_1},{x_2}} \right)$ is the Euclidean distance between ${x_1}$ and ${x_2}$ , $\sigma $ is a margin hyperparameter, and $y$ is the binary label indicating whether the inputs are from the same class ( $y = 1$ ) or different classes ( $y = 0$ ).

3.3.3 Conflict resolution

After the training process, the model cannot be directly used for conflict resolution. In this way, we build the conflict resolution workflow with the trained model (Fig. 6).

Figure 6.

The workflow of conflict resolution with multi-view graph representation.

The conflict resolution process starts by detecting potential conflicts between flights. If a conflict is detected between two flights ${f_i}$ and ${f_j}$ , the process determines the owner and intruder flights based on their priorities. The flight with lower priority is considered the owner, and the other is considered the intruder.

Next, all reachable routes $\left\{ {r_1^{{\,f_i}},r_2^{{\,f_i}}, \ldots ,r_m^{{\,f_i}}} \right\}$ from the current node to the destination node for the owner flight are searched from the global graph. Each candidate route of flight combines with the intruder route ${r^{{\,f_j}}}$ to check for potential conflicts. All combined pairs $\left\{ {\left( {r_1^{{\,f_i}},{r^{{\,f_j}}}} \right),\left( {r_2^{{\,f_i}},{r^{{\,f_j}}}} \right), \ldots ,\left( {r_m^{{\,f_i}},{r^{{\,f_j}}}} \right)} \right\}$ are then input into the trained model to obtain the conflict status.

If the input pair is predicted as a non-conflict, the route $r_m^{{\,f_i}}$ in the pair $\left\{ {\left( {r_m^{{\,f_i}},{r^{{\,f_j}}}} \right)} \right\}$ is considered a valid solution to the tactical conflict, and the flight can proceed with the selected candidate route without conflict.

The incorporation of uncertainties in the flight environment, such as wind turbulence, is of paramount importance in the design and operation of eVTOL vehicles. The micro weather conditions in urban environments are highly complex due to factors like building morphology, which significantly affects the normal flight of eVTOL vehicles. Ignoring these uncertainties can lead to unsafe flight operations and potential accidents.

The 3D wind profile $W$ is defined as a function $W\left( {x,y,z} \right)$ , where $x$ , $y$ , and $z$ represent the three-dimensional spatial coordinates. At each flight level $z$ , the wind turbulence map ${W_{2{\mathrm{D}}}}\left( {x,y} \right)$ is two-dimensional, representing the wind intensity at that level. The discrete wind maps of all levels combine to form the complete 3D wind profile, which is given as:

(13) \begin{align}W\!\left( {x,y,z} \right) = \{ {W_{2{\mathrm{D}}}}\left( {x,y} \right)\} _{z = 0}^H\end{align}

where $H$ represents the maximum flight level in the 3D space.

If the intensity of wind at specific areas, denoted by $w\left( {{x_i},{y_i},{z_i}} \right)$ , is predicted to exceed the maximum wind resistance speed of the eVTOL vehicles, denoted as ${v_{{\mathrm{max}}}}$ , certain nodes in the graph representing the flight environment are not reachable for some vehicles based on their flight performance.

The set of unreachable nodes $U$ can be defined as:

(14) \begin{align}U = \left\{ {{v_i}{\mathrm{|}}w\left( {{x_i},{y_i},{z_i}} \right) \gt {v_{{\mathrm{max}}}}} \right\}\end{align}

where the ${v_i} \in N$ is the node in the corridor graph $G = \left( {N,E} \right)$ , ${x_i},{y_i},{z_i}$ are coordinates of the node ${v_i}$ .

As the flight performance of eVTOL vehicles can vary depending on the specific vehicle’s characteristics, such as its size, weight, propulsion system and other factors, the same wind data may result in different reachable nodes for different vehicles due to those attributes. Each vehicle’s perspective on the global graph can be represented as ${G_{{f_i}}} = \left( {V,{E_{{f_i}}}} \right)$ , where ${E_{{f_i}}}$ denotes the set of edges accessible to ${f_i}$ under the influence of wind turbulence. Thus, wind turbulence affects the node connection in the global graph differently from the perspective view of each vehicle, resulting in different graphs $\left\{ {{G_{{f_i}}},{G_{{f_j}}}, \ldots ,{G_{{f_k}}}} \right\}$ for conflict resolution.

We can observe that the proposed framework adopts a centralised architecture where all flight trajectory data and conflict detection/resolution tasks are processed on a central server. This centralised design enables comprehensive conflict detection across all flights in the airspace, ensures consistent decision-making for conflict resolution and allows for global optimisation of flight path adjustments. The central processing unit receives flight schedules and trajectory information from all UAVs, constructs the conflict and non-conflict view pairs, executes the multi-view representation learning model and generates conflict resolution decisions. This architecture facilitates the efficient processing of multiple conflicts simultaneously while maintaining system consistency and enhanced safety through comprehensive conflict monitoring.

4.1.1 Data generation

We design a simulation environment to generate random 3D cityscapes with diverse building and terrain layouts following the procedure in Section 3.1.1. Specifically, two sample layouts are provided in Fig. 7, one with a map size of $3480m \times 3480m \times 277m$ and another with a map region of $5644m \times 5630m \times 287m$ . These 3D cityscapes showcase various dimensions and morphologies, which have a significant impact on route generation, corridor structures and selection of vertiport locations. By simulating different urban configurations, we aim to generate a diverse and comprehensive dataset for our study, and how uncertainties, such as wind turbulence, affect the reachable nodes in the global graph from the perspective of different vehicles.

Figure 7.

Layout samples of random cities.

The generated 3D models are utilised to extract 2D map slices by cutting height cross-sections from the 3D space. Subsequently, we employ these 2D map slices to generate flight routes by selecting conflict-free waypoints at each flight level following steps in section 3.1.2.

Flight routes at altitudes of 90 m and 120 m are generated by randomly selecting waypoints as shown in Fig. 8. To ensure safety during flight planning, these routes are generated based on extended binary maps, which include a safe buffer margin around obstacles. The final flight routes are depicted on the original binary map without the buffer margin and heightmap, providing a clear and concise representation of the optimal flight paths. From Fig. 8a and 8b, as the altitude increases, the area occupied by obstacles decreases. This indicates that higher altitudes offer a more obstacle-free path for flight.

Figure 8.

Generated routes at various altitudes.

Once the routes at each level are determined, we establish connections between adjacent levels to facilitate altitude transfer. According to the generated flight corridor structure, flights are simulated from section 3.2.2. Some selective 3D trajectories are depicted in Fig. 9.

Figure 9.

Selective flight trajectories.

After schedules are generated, the dataset for training is constructed by collecting flight schedules on the graphs. For schedules with conflicts involving other flights, random segments of the trajectories containing the conflicts are chosen as samples. This selection process ensures that the dataset includes instances of conflict scenarios. On the other hand, for schedules without conflicts, one random segment of the trajectory is randomly chosen as a sample. By including both conflict and non-conflict samples in the dataset, the model is trained to differentiate between these scenarios, enhancing its performance in resolving conflicts during flight.

The dataset used in this study is summarised in Table 1. It consists of 100 total flight instances and 10 vertiports, resulting in a total of 10,000 randomly generated route slices. The flight speed range spans from 4 m/s to 10 m/s, and the initial takeoff time varies between 0 s and 200 s. Additionally, the dataset includes flights at different altitudes, specifically from 30 m to 210 m. The operation time horizon extends from 0 s to 3600 s.

Table 1.

Dataset summary

4.1.2 Model configuration

The model configuration is a multi-view representation learning architecture that combines GNN and RNN as depicted in Table 2. It takes two graphs along with their corresponding node features as inputs. The GNN comprises two GraphConv layers with hidden sizes 20 and 5, respectively, which process the node features to extract informative representations. In the GraphConv layers, the node aggregation is performed using an RNN layer. The outputs from both branches of the GNN are then concatenated and passed through another RNN layer with a hidden size of 2. The RNN further processes the concatenated features, capturing temporal dependencies and interactions between nodes. Finally, the model computes the mean across the batch dimension to obtain the final output. This configuration enables the model to learn expressive and informative representations from multiple views of the input graphs, facilitating effective conflict resolution and uncertainty handling in the context of urban air traffic management.

Table 2.

Model configuration for multi-view representation learning

4.2.1 Model training

The Fig. 10 depicts the training accuracy and training loss over 500 epochs. As the training progresses, the loss consistently decreases from an initial value of 0.7 to a final value of 0.19, indicating the effective learning process of the model. Simultaneously, the accuracy of classifying conflict and non-conflict pairs steadily increases and reaches an impressive accuracy of 97.4%. These promising training results demonstrate the efficacy of the proposed multi-view representation learning approach, and its ability to effectively differentiate between conflicting and non-conflicting flights.

Figure 10.

Training loss and accuracy.

Figure 11.

Clusters separation at each epoch.

Figure 11 illustrates the results of two-class clustering obtained during the training process using contrastive loss. Each subplot displays data points in two distinct colors, representing the conflict flight pair and non-conflict flight pair, respectively. The x and y coordinates of the points correspond to the embeddings generated by the networks. These embeddings serve as a measure of the relative separation between the different classes. As the training proceeds, the embeddings are continuously adjusted, leading to an increased separation between the two classes. This enhanced separation is visually represented by the growing distance between the clusters of points.

For evaluating contrastive learning quantitatively, common metrics, e.g. silhouette coefficient, Calinski-Harabasz index and Davies-Bouldin index are used for clustering evaluation. The silhouette coefficient is a metric used to assess the quality of clustering results and measures how well-separated the clusters are, with values closer to 1 indicating well-separated clusters. Given a set of data points $X = \left\{ {{x_1},{x_2}, \ldots ,{x_n}} \right\}$ and their corresponding cluster assignments $C = \left\{ {{c_1},{c_2}, \ldots ,{c_n}} \right\}$ , the silhouette coefficient is calculated as follows:

(15) \begin{align}{\mathrm{Si}}\!\left( {X,C} \right) = {1 \over n}\mathop \sum \limits_{i = 1}^n {{b\left( {{x_i},C} \right) - a\left( {{x_i},C} \right)} \over {\max \!\left( {a\left( {{x_i},C} \right),b\left( {{x_i},C} \right)} \right)}}\end{align}

where:

• • $a\left( {{x_i},C} \right)$ is the average distance between data point ${x_i}$ and all other points in the same cluster as ${x_i}$ .

• • $b\left( {{x_i},C} \right)$ is the average distance between data point ${x_i}$ and all points in the nearest cluster to which ${x_i}$ does not belong.

The silhouette coefficient ranges from −1 to 1, where a higher value indicates better-defined and well-separated clusters.

The Calinski-Harabasz index is another clustering evaluation metric that measures the ratio of between-cluster dispersion to within-cluster dispersion. It is given by:

(16) \begin{align}{\mathrm{CHI}}\!\left( {X,C} \right) = \frac{{{\mathrm{Tr}}\!\left( {B\left( C \right)} \right)}}{{{\mathrm{Tr}}\!\left( {W\left( C \right)} \right)}} \times \frac{{n - k}}{{k - 1}}\end{align}

where:

• • $n$ is the total number of data points.

• • $k$ is the number of clusters.

• • $B\left( C \right)$ is the between-cluster dispersion matrix.

• • $W\left( C \right)$ is the within-cluster dispersion matrix.

• • $Tr$ is the trace of matrix.

A higher Calinski-Harabasz index value indicates better-defined and more separated clusters.

The Davies-Bouldin index is yet another clustering evaluation metric that measures the average similarity between each cluster and its most similar cluster. It is given by:

(17) \begin{align}{\mathrm{DBI}}\!\left( {X,C} \right) = \frac{1}{k}\mathop \sum \limits_{i = 1}^k \mathop {{\mathrm{max}}}\limits_{j \ne i} \left( {\frac{{{S_i} + {S_j}}}{{{M_{ij}}}}} \right)\end{align}

where:

• • $k$ is the number of clusters.

• • ${S_i}$ is the average distance between data points within cluster $i$ .

• • ${M_{ij}}$ is the distance between cluster centres $i$ and $j$ .

The Davies-Bouldin index measures the average similarity between each cluster and its most similar cluster, with lower values indicating better-defined clusters.

The metrics comparison for data in Fig. 12 is demonstrated in Table 3. Each row represents the metrics’ values at a specific epoch. At epoch 0, the metrics are not valid since the model’s initial predictions only output one class, which results in incorrect clustering and classification. As the training progresses to epoch 200, the model starts to learn more meaningful representations, and the metrics show improved values. For example, the silhouette coefficient increases from 0.791 at epoch 200 to 0.824 at epoch 400, while the Calinski-Harabasz index shows a similar trend, increasing from 997.087 to 1012.026 during the same period. Additionally, the Davies-Bouldin index decreases from 0.317 to 0.219, reflecting the enhancement in clustering quality. These improvements in the evaluation metrics demonstrate the effectiveness of the contrastive learning approach in generating meaningful and separable representations of the data.

Figure 12.

Conflict resolution.

Table 3.

Metrics comparison for contrastive learning

4.2.2 Model test

Once the model is trained and validated, it becomes capable of intelligent conflict resolution. By utilising the learned representations, the model can efficiently analyse and resolve conflicts between different flight schedules in a dynamic and real-time manner.

Following the workflow in section 3.3.3, we can propose several alternative routes and let the trained model select the best route for conflict resolution. The line graph in Fig.12a illustrates the relationship between the number of flights and the corresponding number of conflicts in different simulated scenarios. The x-axis represents the total number of flights, ranging from 10 to 100 with increments of 10, while the y-axis represents the number of conflicts observed for each specific number of flights. As depicted in the graph, there is a positive correlation between the number of flights and the number of conflicts. The number of conflicts gradually increases as the number of flights increases. Specifically, with 10 flights, there are only two conflicts, and as the number of flights increases, the number of conflicts progressively rises.

The graph in Fig. 12b reveals that the conflict resolution rate remains at a remarkable 100% for all flight numbers. This indicates the effectiveness of the multi-view representation learning technique in effectively resolving conflicts among flights. With this approach, regardless of the increasing complexity and number of flights in the airspace, the model successfully identifies and resolves conflicts, ensuring the safety and efficiency of flight operations.

In addition, a test scenario with 1000 aircraft is included, which serves to validate the performance of our model when the number of aircraft within a specific area increases dramatically. As shown in Fig. 12a, it can be observed that the number of tactical conflicts rapidly increases to 233 as the number of aircraft reaches 1000. However, as depicted in Fig. 12b, the model remains capable of resolving these tactical conflicts effectively.

We show one example of conflict resolution. The candidate flight trajectories are shown in Fig. 13a. Table 4 illustrates the variation in traversed nodes for the original path and four candidate paths generated during the search process. Each row in the table represents a candidate path, and it originates and terminates at the same beginning and end nodes. The prediction results in Fig. 13b reveal that the first candidate trajectory, of which node indices [158,159,161,162,288] are predicted to still have a conflict because the traversed nodes are too similar to the original routes. However, three others serve as appropriate candidate solutions to resolve this conflict.

Figure 13.

Conflict resolution example.

Table 4.

Original path nodes and candidate path nodes

To evaluate the impact of the candidate solutions on the flight, we analyse the increased flight time and distance. These metrics provide valuable insights into how each candidate’s trajectory affects the overall flight operations. As depicted in Fig. 14, the increased distance for each candidate trajectory is [ $1484.68{\mathrm{\;}}m$ , $1544.68{\mathrm{\;}}m$ , $1544.68{\mathrm{\;}}m$ , $1604.68{\mathrm{\;}}m$ ], with an average of $1544.68{\mathrm{\;}}m$ . The increased flight time is [ $46.58{\mathrm{\;}}s$ , $61.58{\mathrm{\;}}s$ , $61.58{\mathrm{\;}}s$ , $76.58{\mathrm{\;}}s$ ], with an average of $61.58{\mathrm{\;}}s$ . By quantifying the additional time and distance required for each candidate route compared to the original path, we can assess the trade-offs and benefits of potential conflict resolution strategies. Among all candidate routes, path 2 has the smallest increase in both flight time ( $61.58{\mathrm{\;}}s$ ) and distance ( $1544.68{\mathrm{\;}}m$ ) compared to the original path among the remaining candidate solutions. Therefore, it is the recommended choice for conflict resolution as it minimises the impact on flight time and distance while effectively resolving the conflict.

Figure 14.

The increment parameters of candidate trajectories.

The presented example showcases the process of resolving a specific conflict by selecting the most suitable candidate trajectory while minimising the impact on flight time and distance. However, it is essential to note that this approach is not limited to just one conflict but can be applied iteratively to handle multiple conflicts simultaneously. The multi-view representation learning technique efficiently processes and analyses various conflicts in the environment, providing intelligent and automated solutions for conflict resolution.

4.2.3 Model test with uncertainties involved

This work also investigates the importance of uncertainties, such as wind turbulence, in the flight environment. The 2D wind turbulence map is generated using a Gaussian random field approach by computing the 2D inverse Fourier transform of a noise signal modulated by the amplitude calculated from the power spectrum. This spectral method captures both the spatial correlations and the multi-scale nature of atmospheric turbulence, providing a realistic wind environment for testing our conflict resolution approach.

Through an iterative process, a series of 2D wind maps are generated to represent wind conditions at various flight levels. For instance, some wind maps are demonstrated in Fig. 15. To create a seamless and comprehensive 3D wind model, linear interpolation is utilised to estimate wind turbulence at positions lying between discrete flight levels.

Figure 15.

Random wind turbulence at different flight levels.

Table 5.

Original path nodes and candidate path nodes in the presence of wind

In accordance with the details presented in section 3.3.3, the influence of wind turbulence on flight operations is thoroughly considered. Wind turbulence not only impacts flight performance but also affects the accessibility of certain nodes in different regions. Specifically, in the view of different flights, some node connections within specific areas will be invalidated due to the intensity of wind turbulence. Consequently, this aspect of the model accounts for the variations in reachability across different flight paths and enables a more comprehensive evaluation of potential conflicts in the airspace.

We examine a specific conflicting pair of flight schedules, and the original flight path for the ownership is provided in Table 5. The flight schedule node indices [209,210,223,231,237–239,313] represent the sequence of nodes in the original flight path. However, when considering wind turbulence, it is predicted that the flight performance will be affected within a specific time range [ $140.38{\mathrm{\;}}s$ , $160{\mathrm{\;}}s$ ] and near the coordinate location of [ $ - 410{\mathrm{\;}}m$ , $410{\mathrm{\;}}m$ , $180{\mathrm{\;}}m$ ] within a 100-meter region.

To resolve this conflict, we search for candidate routes that avoid the problematic wind area. As shown in Fig. 16a, among the candidate routes, only route 4 is deemed acceptable as it allows the flight to traverse the wind area at a time ( $154{\mathrm{\;}}s$ ) that is within acceptable flight performance limits. The other routes (1, 2 and 3) are deemed unsuitable as they would lead to the flight encountering adverse wind conditions at an unacceptable time. This process demonstrates the importance of considering wind turbulence and its impact on flight paths during conflict resolution.

Figure 16.

Conflict resolution example in the presence of wind.

The multi-view representation learning approach is further applied to evaluate the suitability of path 4 as a resolution to the tactical conflict. The results shown in Fig. 16b confirm that path 4 indeed serves as a favourable solution for resolving the conflict. Additionally, the increment in the distance ( $1281.57{\mathrm{\;}}m$ ) and increased flight time ( $34.84{\mathrm{\;}}s$ ) resulting from this solution are both deemed acceptable performance measures for the involved flights. The successful application of multi-view representation learning demonstrates the effectiveness of this approach in assessing and resolving tactical conflicts in flight schedules while considering various conditions.

In conclusion, the multi-view representation learning approach has proven to be an efficient method for tactical conflict resolution. Through the generation of wind models, it accurately assesses the impact of wind conditions on flight paths. The multi-view representation learning also enables the identification of suitable candidate routes for resolving conflicts. The successful validation of this approach with multiple conflict scenarios demonstrates its robustness and effectiveness in enhancing safety and efficiency in urban airspace management.