# Retracted: W-GPCR Routing Method for Vehicular Ad Hoc Networks
## 2 Materials and Methods
### Greedy Forwarding Strategy Based on Weight Selection
#### 2.1.1 Influence of Node Movement Direction on Routing Performance  
As shown in Figure 1a, node A sends a data packet to the target node. Node B and node C are closer to the target node than node A. Among these, node C and node A move in opposite directions, while node B and node A move in the same direction. Node C is closer to the target node than node B, so according to the traditional greedy forwarding strategy, node C will be selected as the next-hop node. However, there may be such a situation in which, when the data packet is delivered, the position of the node changes as shown in Figure 1b. When the data packet is delivered to node C, the next-hop node selected by node C will be node B, which causes extra routing hops. Alternatively, when choosing the next-hop node, we introduce the node movement direction as a reference, instead of relying solely on distance as the basis for selection. When node A selects the next-hop node, it can comprehensively consider the movement direction of node B and node C and their distance from the target node. Selecting node B as the next-hop node will greatly reduce the number of routing hops and shorten the end-to-end delay. Figure 1: Schematic diagram of packet delivery: (**a**) before packet delivery; (**b**) after packet delivery. When Algorithm 1 is implemented, the neighbor node with the largest weight is selected as the next-hop node. ```
1.\(loc_{p}=getLocation(currentnode)=(x_{p},y_{p})\)
2.\(\vv_{p}=getSpeed(currentnode)\)
3.\(neig_{p}=getNeig(currentnode)\)
4.\(loc_{d}=getLocation(destnode)=(x_{d},y_{d})\)
5.\(D_{pd}=\sqrt{(x_{p}-x_{d})^{2}+(y_{p}-y_{d})^{2}}\)
6.\(l_{pd}^{\rightarrow}=loc_{d}-loc_{p}=(x_{d}-x_{p},y_{d}-y_{p})\)
7.\(S=\pi r^{2}\)
8.\(G=g_{2}\cos(\vv_{p},\vv_{pd}^{\rightarrow})+g_{3}\vv_{p}\)
9.\(nextnode=currentnode\)
10.for all neighbors of currentnode do
11.\(loc_{i}=getLocation(n_{i})=(x_{i},y_{i})\)
12.\(\vv_{i}=getSpeed(n_{i})\)
13.\(D_{id}=(x_{i}-x_{d})^{2}+(y_{i}-y_{d})^{2}\)
14.\(l_{id}=loc_{d}-loc_{i}=(x_{d}-x_{i},y_{d}-y_{i})\)
15.\(neig_{i}=getNeig(n_{i})\)
16.\(G_{i}=g_{1}(1-\vv_{pd})+g_{2}\cos(\vv_{i},\vv_{id}^{\rightarrow})+g_{3}\vv_{ 3}\vv_{3}\)
17. If \(G_{i}>G\) then
18.\(G=G_{i}\)
19.\(nextnode=n_{i}\)
20.end if
21. end for
22.if.\(nextnode\
eq currentnode\) then
23. forward the packet to \(nextnode\)
24.else carry the packet with \(currentnode\)
25. end if \begin{table}
\begin{tabular}{c c} \hline \hline
**Notation** & **Description** \\ \hline _currentnode_ & the current node \\ _nextnode_ & next-hop node \\ _destnode_ & target node \\ \(loc_{x}\) & the position coordinates of node x \\ \(\vv_{x}\) & the velocity vector of node x \\ \(l_{xd}^{\rightarrow}\) & the vector where node x points to the target node \\ \(neig_{x}\) & the number of neighbors of node x \\ \(n_{i}\) & the i-th neighbor node \\ \(r\) & the communication radius of the node \\ _getLocation_ & to get the position coordinates of the node \\ _getSpeed_ & to get the speed vector of the node \\ _getNeig_ & to get the number of neighbor nodes \\ \hline \hline \end{tabular}
\end{table} 
Table 1: The notations in Algorithm 1. The system is initialized to obtain the position coordinates, the velocity vector, and the number of neighbor nodes of the current node, and the position coordinates of the target node are also obtained. By calculating the Euclidean distance between the current node from the target node on the two-dimensional plane, and the vector of the current node pointing to the target node the area covered by the signal of the node on the two-dimensional plane can be derived. By calculating the weight of the current node and traversing all of its neighbor nodes, the position coordinates, velocity vector, and number of neighbor nodes of each neighbor node, the Euclidean distance of each neighbor node from the target node and the vector pointing to the target node can be obtained. Based on the obtained data, the weight of each neighbor node is calculated.