An Efficient Adaptive and Steep-Convergent Sidelobes Simultaneous Reduction Algorithm for Massive Linear Arrays

Abstract

Antenna arrays have become an essential part of most wireless communications systems. In this paper, the unwanted sidelobes in the symmetric linear array power pattern are reduced efficiently by utilizing a faster simultaneous sidelobes processing algorithm, which generates nulling sub-beams that are adapted to control and maintain steep convergence toward lower sidelobe levels. The proposed algorithm is performed using adaptive damping and heuristic factors which result in learning curve perturbations during the first few loops of the reduction process and is followed by a very steep convergence profile towards deep sidelobe levels. The numerical results show that, using the proposed adaptive sidelobes simultaneous reduction algorithm, a maximum sidelobe level of −50 dB can be achieved after only 10 iteration loops (especially for very large antenna arrays formed by 256 elements, wherein the processing time is reduced to approximately 25% of that required by the conventional fixed damping factor case). On the other hand, the generated array weights can be applied to practical linear antenna arrays under mutual coupling effects, which have shown very similar results to the radiation pattern of the isotropic antenna elements with very deep sidelobe levels and the same beamwidth.

1. Introduction

1.1. Background and Motivation

Wireless communications and networks became an important part in our life and are essential for many fields and involved in various applications including mobile cellular networks, Internet of Things (IoT), radar, sonar, medical networks, aeronautical telecommunication networks (ATN), and many other wireless applications [1,2,3,4,5,6,7]. Therefore, developing wireless communications and networks represents a major objective for improving the quality of service (QoS) and system capacity required by the higher data rates services (and future 6G and other more advance networks) [8]. Antenna arrays and beamforming is one of the very important enabling technologies for wireless communications and networks that effectively enables the delivering of the targeted gigabit rates for current and future applications. For example, massive multi-input multi-output (m-MIMO) systems in the current 5G and future 6G wireless networks depend on massive antenna array structures formed by a few hundreds of antenna elements to serve many users simultaneously. The antenna arrays have many configurations including linear, planar, circular, conical, cylindrical, and spherical geometries [9], while other configurations may include asymmetric antenna array structures [10]. Therefore, improving the performance of antenna arrays and beamforming systems can improve the overall system performance and capacity. For example, the desired signal received by the main lobe is always corrupted and interfered by other co-channel signals received by the sidelobes in the array radiation pattern. Thus, it is essential to reduce the sidelobe level (SLL) to improve the carrier-to-interference ratio (CIR) and hence the overall system capacity. The SLL can be reduced by several techniques and algorithms such as the tapered amplitude windows [11,12,13,14,15,16,17,18] and advanced evolutionary optimization techniques [19,20,21,22,23,24,25,26,27,28,29,30,31,32]. Tapered beamforming applies various amplitude feeding windows to any array geometry which effectively reduces the SLL (with some increase in the main lobe beamwidth). However, most of these windows provide uncontrolled SLL, which is not suitable for real time communications scenarios. For example, triangular, Hamming, Hanning, and binomial amplitude windows produce SLL with certain values depending on the array size which cannot be further improved. Other windows have some control features on the SLL such as Blackman and Dolph-Chebyshev [11] windows (especially for linear arrays). However, the array radiation pattern cannot be optimized for selective spatial filtering scenarios such as the blocking of interference signals from certain directions or angular zones. On the other hand, evolutionary computation techniques [19,20,21,22,23,24,25,26,27,28,29,30,31,32] can be utilized for SLL reduction (especially for linear array configurations). However, several and various parameters require optimization, and it is difficult to tune them to achieve convergence. In addition, the calculation complexity and processing time increases dramatically with the increasing of the array sizes, and convergence may not be assured.

Recently, the sidelobes have been reduced in [33] using a sidelobe sequential damping (SSD) algorithm which starts with array uniform feeding, determines the radiation peaks that are sorted in descending order, excludes the maximum peak that corresponds to the main lobe, and then nulls out the highest sidelobe. The process is repeated to sequentially reduce the maximum SLL to the desired level. The algorithm has been compared with efficient tapering windows and evolutionary optimization techniques and have shown superior performance where deeper SLL can be achieved at lower processing time. This algorithm has been further improved in [34] to increase the speed of convergence by sidelobes simultaneous reduction (SSR) where the manipulation of sidelobes is performed in parallel instead of sequentially one-by-one reduction. The processing time is reduced to about 10% of that required by the SSD algorithm to achieve the same SLL. Also, the SSR algorithm has added a controlling damping factor which should be less than 0.7 to maintain convergence towards lower SLL values especially for large arrays. However, this conventional SSR algorithm, although it provides stable convergent learning curves, still consumes a lot of iterative loops to achieve deep SLL values in the range of −50 dB or less.

1.2. Paper Contribution

Although the conventional SSR has controlled the convergence towards lower SLL values, it has utilized a constant value of the damping factor to only maintain convergence state and did not control the slope profile of the learning curve. This limited adaptation process results in slow learning profile that consumes longer processing time to achieve deeper SLL especially for arrays of large sizes. Therefore, the conventional SSR algorithm in [34] will be further improved in this paper by adding adaptive capabilities which includes initial, loop, and steady state damping factor values to control the learning slope. The proposed adaptive SSR intends to make perturbations in the learning curve in the first few iteration loops by using an initial damping factor in the range from 1 to 1.2 according to the array size which results in redistribution of the different sidelobes values and, more specifically, decrease the dynamic range between them. Then, the loop iterations adapt the damping factor to restore convergence by decrementing its value by a heuristic factor resulting in faster convergence with very steep learning profile. The processing time of the adaptive SSR has been reduced to 25% of that required by the conventional SSR (especially for very large array sizes) and can be applied effectively to practical antenna structures.

1.3. Paper Organization

The remaining sections in the paper are organized as follows. Section 2 demonstrates the symmetrical linear antenna array and the conventional SSR learning curves for very wide range of array sizes. Section 3 demonstrates the proposed adaptive SSR algorithm, and Section 4 provides detailed results and discussion. Finally, Section 5 concludes the paper.

2. Structure of Linear Symmetrical Antenna Array and Conventional SSR Learning Characteristics

A linear array formed by M antenna elements is shown in Figure 1 where it has constant inter-element spacing distance and the elements are considered as isotropic or omnidirectional radiators.

The inter-element spacing distance is set at half-wavelength and the array gain can be written as follows:

$$G\left(\theta \right)={\mathit{w}}_M^H\left({\theta }_o\right){\mathit{a}}_M\left(\theta \right)$$

(1)

where ${\mathit{w}}_M\left({\theta }_o\right)$ is the array weighting vector required to form a main lobe at the direction ${\theta }_o$, H is the Hermitian transpose, and ${\mathit{a}}_M\left(\theta \right)$ is the linear array steering vector which is given for half-wavelength inter-separated elements by:

$${\mathit{a}}_M\left(\theta \right)=\left[\begin{array}{c}1\\ e^{j\left(\pi \cos \left(\theta \right)\right)}\\ \begin{array}{c}{e}^{j\left(2\pi \cos \left(\theta \right)\right)}\\ :\\ e^{j\left(\pi \left(M-1\right)\cos \left(\theta \right)\right)}\end{array}\end{array}\right]$$

(2)

The array feeding profile provided by ${\mathit{w}}_M\left({\theta }_o\right)$ has a direct impact on the SLL performance. In [34], the SLL is reduced by simultaneous manipulation where the radiation peaks are extracted and the main lobe is excluded, then weighted sub-beams at the same directions of the sidelobes are formed and subtracted from the original beam pattern. The secondary sidelobes of the sub-beams may result in algorithm divergence, so a damping factor, c, has been utilized to control and maintain the convergence profile using the following recursive equations [34]:

$${\overline{\mathit{w}}}_{M,L_i,i}={{\displaystyle \sum }}_{l=1}^{L_i}c\frac{G^H\left({\theta }_l\right){\mathit{a}}_M\left({\theta }_l\right)}{{\left|G\left(\theta \right)\right|}_{max}}$$

(3)

$${\mathit{w}}_{M,L_{i+1},i+1}={\mathit{w}}_M\left({\theta }_o\right)-{\overline{\mathit{w}}}_{M,L_i,i}$$

(4)

$${\mathit{w}}_M\left({\theta }_o\right)={\mathit{w}}_{M,L_{i+1},i+1}$$

(5)

where $L_i$ is the number of sidelobe peaks in the $i^{th}$ SLL reduction loop.

The damping factor, c, has constant value in the conventional SSR algorithm [34], so the learning profile becomes slower if deeper SLL is required. Figure 2 demonstrates various learning curves for the conventional SSR algorithm for different array sizes starting from 16-element array (Figure 2a) up to 512-element array (Figure 2f) and at different values for the damping factor ranging from 0.6 to 1.2. As shown in these figures, the convergence towards lower SLL can be achieved at damping factor values almost less than or equal to 0.7 where very rippled learning profile appears at higher values (especially those above 0.8 causing the algorithm divergence). For $c\le 0.7$, smoother convergence is guaranteed, albeit with a slower SLL reduction process requiring longer time to achieve the desired SLL. For example, the number of algorithm execution loops required to achieve −50 dB SLL in most arrays is 50 at c = 0.6 while it only requires 40 loops at c = 0.7. At c = 0.8, it is found that the arrays with sizes 32, 64, and 128 converge to SLL values around −40 dB. However further execution of the algorithm results in learning curve inversion as shown in Figure 2b–d. Therefore, for these array sizes, SLL values around −40 dB can be achieved faster by increasing c to 0.8 with ripples in the learning curve which may exceed 20 dB in dynamic range at very large array sizes as shown in Figure 2f. The unstable algorithm behavior at $c\ge 0.8$ for different array sizes is mainly due to the higher cumulative sum of sub-beams in (3) and their corresponding sidelobes with different directions and levels, causing the learning profile to be close to divergence behavior.

3. The Proposed Adaptive SSR Algorithm

The learning profile of the conventional SSR can be sped up by making some perturbations on the damping factor values in the first few SLL reduction loops. The initial value of the damping factor is intended to be higher than 1 at the first SLL reduction loop which leads to divergence in the few subsequent loops and is then adapted to return to the convergence phase by a heuristic factor, h. The impact of this starting perturbation is great on the learning curve slope which becomes steeper and deep SLL values can be achieved in shorter processing time. Therefore, the loop damping factor is adapted during the whole algorithm runtime and, therefore, (3) becomes:

$${\overline{\mathit{w}}}_{M,L_i,i}={\displaystyle \sum }_{l=1}^{L_i}{c}_i\frac{G^H\left({\theta }_l\right){\mathit{a}}_M\left({\theta }_l\right)}{{\left|G\left(\theta \right)\right|}_{max}}$$

(6)

where $c_i$ is the adapted damping factor which is updated in this paper according to the following conditions:

$$\begin{gathered} \mathit{if}\left(c_i\ge c_t\right),\mathit{then} \\ \mathit{if}(SL{L}_{i+1}>SL{L}_i),\mathit{then} \\ {c}_{i+1}=c_i-h, \\ \mathit{end} \end{gathered}$$

(7)

$$\begin{gathered} \mathit{else} \\ {c}_{i+1}=c_t \\ \mathit{end} \end{gathered}$$

(8)

where $c_{i+1}$ is the updated damping factor in the next execution loop with $c_1=c_o$ and $c_o$ is the initial damping factor that is set to a value greater than 1. $c_t$ is a threshold value for the steady state damping factor and $h$ is a heuristic factor that is responsible for restoring the convergence towards lower SLL in case of diverging to higher SLL values.

The heuristic factor is proposed in this paper as a function of the number of array elements, M, as follows:

$$h=0.2406-1.787 M^{-0.931}$$

(9)

which is a power fit for the optimum values required to revert to convergence state at different array sizes up to 512 elements using MATLAB curve fitting toolbox.

Figure 3 demonstrates the variation of the heuristic factor with the number of elements in the array along with the actual optimum heuristic factor values at array sizes 16, 32, 64, 124, 256, and 512. The smaller the array size, the lower heuristic value is required to restore convergence state. The heuristic factor saturates at 0.2406, while for array sizes between 100 and 500, it is around 0.23 where the damping factor needs faster reduction to maintain proper convergence rate than the case of lower array sizes.

The adaptive SSR algorithm can be summarized in the flowchart shown in Figure 4. The algorithm starts with the calculation of array gain at ${\mathit{w}}_M\left({\theta }_o\right)={\mathit{a}}_M\left({\theta }_o\right)$ which corresponds to the uniform feeding case. The main adaptation in the algorithm is performed on the damping factor which is responsible for maintaining the SLL reduction faster. The first set of sidelobes information including their number, levels, and directions are determined from the calculated array gain. Then, using (3) and (4), the new array weighting vector is calculated. Then the resulting array gain is calculated, and the highest SLL is determined. If the new highest SLL is less than the required SLL_o, then the algorithm has achieved the required task and terminates, otherwise the algorithm is checked for divergence occurrence by comparing the new SLL with the previous one. If the obtained SLL is less than the previous one, then it means convergence is maintained and the damping factor is kept as the previous value. Otherwise, it should be decremented by the heuristic factor to restore convergence in the following loop and the process is continued unless the damping factor is less than the threshold value, $c_t$, or it should be increased to $c_t$ to maintain the convergence state of the learning curve towards lower SLL with a faster rate.

On the other hand, the SLL analysis discussed previously in Section 2 indicates that $c_t$ should be less than or equal to 0.7 to guarantee steady state convergence towards lower SLL values especially for lower array sizes.

4. Results and Discussions

The proposed adaptive SSR algorithm capabilities are investigated in this section. First, the process of adapting the damping factor is discussed showing its impact on the convergence process and the SSL reduction. Second, the impacts of the initial and threshold damping factors are shown and discussed. Following this analysis, the SLLs achieved by the adaptive and conventional SSR algorithms are compared at different array sizes and initial damping factor values. Finally, the application of the proposed algorithm for practical antenna scenario is demonstrated and discussed.

4.1. SLL Reduction with Damping Factor Adaptation

In this section, the array power pattern is examined at different algorithm loops during which the damping factor is adapted. Consider an array of 32 elements with an initial damping factor $c_o=1.1$, threshold steady state damping factor $c_t=0.5$, and a targeted SLL of maximum −50 dB relative to the main lobe gain. For this array size, the heuristic factor is approximately 0.17 according to (9). The proposed algorithm requires 15 iteration loops to achieve the required SLL, where the damping factor is updated during these loops as shown in Figure 5a for maintaining convergence towards the desired SLL. The damping factor has key loops 1, 3, 4, 5, 7, and 15, and the corresponding normalized power patterns in dB are shown in Figure 5b where these loop indices correspond to the start and transitions between convergence and divergence states. The algorithm undergoes divergence state at i = 3, 5, and 6, so the damping factor should be decremented by the heuristic factor. Beyond i = 7, the algorithm has steady state steep convergence profile towards the desired SLL till i = 15 where the resulting final array weights are found as displayed in Figure 5c. Also, the final normalized array power pattern is displayed in Figure 5d where it is compared with the initial normalized uniform weighting pattern. The sidelobes in the optimized radiation pattern has almost the same distribution and directions as in the uniform feeding case, but with deep SLLs.

4.2. Performance of Adaptive SSR at Different Initial and Threshold Damping Factors

In this section, two sets of arrays are examined to achieve a maximum SLL of −50 dB. In the first one, the threshold damping factor is 0.7 while in the second set it is 0.5. The reason for choosing these two values is that in order to maintain steady state convergence for most array sizes, it requires a maximum damping factor of 0.7, while damping factors that are less than 0.5 almost provide much slower convergence profile. The learning curves in the first set of arrays with $c_t=0.7$ is shown in Figure 6 for different array sizes ranging from 16 to 512 elements and with different initial damping factor values ranging from 0.8 to 1.2. The learning profile of the adaptive SSR algorithm shows an important characteristic in all array sizes which is the steeper falling towards deeper SLL at higher values of the initial damping factor, although there is a delay in the convergence of the learning curves due to the temporary divergence occurred in the first few loops. This delay is reduced in very large arrays of sizes 256 and 512 elements as shown in Figure 6e,f. The initial damping factor can be chosen according to how deep the required SLL is. Higher SLL levels above −40 dB can be achieved much faster at $c_o=0.8$, with few reduction loops especially for large-sized arrays. For example, the 512-element array requires only executing the algorithm in four loops to achieve −40 dB. However, starting with smaller damping factor values (although maintaining convergence) results in slower convergence to deeper SLL. Therefore, the algorithm should start with a higher value of c_o which falls between 1.1 and 1.2 for most array sizes as shown by the dotted black lines in the arrays of Figure 6.

On the other hand, the performance of the proposed adaptive SSR algorithm can even be improved by reducing the threshold damping factor as shown in the learning curves of Figure 7 for the same set of arrays previously discussed in Figure 6 but with $c_t=0.5$ which results in faster convergence profiles for deep SLLs of about −50 dB relative to the main lobe level which is very important in the processing of large-sized arrays. For example, the 128-element array requires only 12 successive loops or cycles of the adaptive SSR algorithm to achieve a SLL of −50 dB at $c_t=0.5$ while it requires 32 loops at $c_t=0.7$ and at the same value of the initial damping factor ($c_o=1.2$). This means a reduction in the processing time by 62.5%. Therefore, the impact of reducing c_t to 0.5 reduces the processing time required to achieve the same SLL values by providing learning curves with higher slopes after the divergence period where at a given value of c_o, the divergence occurred in the first few loops is independent on c_t where the loop damping factor is still higher than $c_t$.

4.3. Comparison between the Proposed Adaptive and Conventional SSR Algorithms

The performances of the proposed adaptive and conventional SSR algorithms are compared in this section for different array sizes and threshold and initial damping factors as shown in Figure 8.

The impact of adapting the damping factor with initial divergence is clear on the convergence speed especially for medium and large-sized arrays. The adaptive SSR algorithm almost requires one-quarter of iterative loops required by the conventional SSR for most array sizes. The rapid finding of the required weights for very large arrays to achieve very deep SLL is very important (especially for varying communication environments and real-time applications). However, for higher SLLs before the cross point between the two learning curves, the conventional SSR is faster. Therefore, the initial value of the damping factor should be reduced to reduce the delay in convergence. For example, the 32-element array feeding can be optimized to achieve −40 dB using an initial damping factor of 0.9 as shown in Figure 7b which is faster than the case of using conventional SSR as shown in Figure 8b.

The reduced number of iterations in the adaptive SSR can be interpreted as a reduced processing time as shown in Figure 9 which compares the required processing time for both the conventional and adaptive SSR algorithms. The data in this figure are obtained using i7-8550U CPU with 16 gigabytes RAM platform. The MATLAB is used in executing the conventional SSR algorithm at a damping factor of 0.5 to maintain convergence especially for large arrays while the initial damping factor is chosen 1.1 for 16, 32, and 512 array sizes and 1.2 for 64, 128, and 256 arrays. The required processing time for achieving the required SLL is then measured in each case. The comparison clearly demonstrates the reduction in the processing time required by the proposed adaptive SSR algorithm which is between 20% and 25% of that required by the conventional SSR algorithm.

4.4. Impact of the Adaptive SSR Algorithm Weights on Practical Linear Antenna Arrays

The practical antenna arrays are subjected to some limitations, such as the mutual coupling effect between closely spaced antenna elements. This problem can be partially mitigated by several techniques including physical separation by absorptive materials [35,36,37]. The proposed adaptive SSR algorithm can be applied efficiently in a practical array scenario where the resulted beam pattern is very acceptable and almost appears as the ideal isotropic antenna array elements case. To investigate the impact of the adaptive SSR on the practical uniform linear antenna arrays, consider the array shown in Figure 10a that is formed by 16 half-wavelength dipole elements operating at 5 GHz frequency, interseparated by 0.029979 m. The dipole length is 0.02818 m, and all dipoles are center-fed. The weights are optimized using the proposed adaptive SSR algorithm to reduce the SSL to −50 dB. The resulting radiation pattern with and without the effect of mutual coupling is shown in Figure 10b where the dashed red line corresponds to the ideal array case (without mutual coupling) while the black solid line corresponds to the array under mutual coupling effects. The two patterns are shown very similar except at deep edges near the −35 dB level where the mutual coupling effect appears as a slightly wider beam. However, the maximum SLL is still −50 dB or less. Therefore, the array weights obtained from the adaptive SSR algorithm still provides very acceptable SLL performance (even under the mutual coupling effect).

5. Conclusions

In this paper, the SLL reduction in symmetric linear arrays has been achieved efficiently using SSR with adaptive capabilities to increase the convergence rate towards deeper SLL in the radiation pattern. The proposed adaptive SSR algorithm utilizes higher values of damping factor in the initial reduction cycles to increase the reduction rate by redistributing the levels of sidelobes where the dynamic range between them decreases. Then, the damping factor is decremented by a heuristic factor (which is a function of the array size) in the subsequent cycles to maintain convergence after steep fall to deeper SLL. Finally, a steady state convergence is achieved by using a threshold damping factor that prevents the loop damping factor from being decremented to values less than 0.5 in order to keep the speed of convergence as fast as possible. The simulation results have shown that the processing time can be reduced to less than 25% of that required by the conventional SSR algorithm with fixed damping factor values (especially for massive symmetric arrays). Furthermore, the array weights obtained from the proposed adaptive SSR algorithm can be applied to any practical linear symmetric array structure under mutual coupling effects.