Main Content

This example shows how to model subarrays, commonly used in modern phased array systems, using Phased Array System Toolbox™ and perform analyses.

Phased array antennas provide many benefits over traditional dish antennas. The elements of phased array antennas are easier to manufacture; the entire system suffers less from component failures; and best of all, can be electronically scanned toward different directions.

However, such flexibility does not come for free. Taking full advantage of a phased array requires placing steering circuitry and T/R switches behind each individual element. For applications that require large arrays with thousands or tens of thousands of elements, the cost of doing so is too high to be practical. In addition, in many such applications, the desired performance does not require full degree of freedom from the array. Hence, in practice, deployed systems often use a compromised approach. Elements are grouped into subarrays and then subarrays form the entire array. The elements are still easy to manufacture; the entire array is still robust with respect to component failures; in addition, T/R switches are only needed at each subarray, thus significantly reducing the cost.

The following sections show how to model a subarray network with different configurations for two specific applications: limited field of view (LFOV) arrays and wideband arrays.

LFOV arrays are commonly used in satellite applications. As the name suggests, an LFOV array only scans within a very limited window, normally less than 10 degrees. Because of that, it is possible to use subarrays and such subarrays can be placed at a spacing much larger than half of the wavelength.

The simplest way to construct an array with subarrays is to contiguously tile the subarray. The following code snippet constructs a 64-element ULA consists of eight 8-element ULAs. Within each subarray, the elements are spaced by half the wavelength. Note that there is no steering capability inside each subarray so the array can only be steered using subarrays.

The array geometry can be seen in the following figure.

fc = 3e8; c = 3e8; antenna = phased.IsotropicAntennaElement('BackBaffled',true); N = 64; Nsubarray = 8; subula = phased.ULA(N/Nsubarray,0.5*c/fc,'Element',antenna); replarray = phased.ReplicatedSubarray('Subarray',subula,... 'GridSize',[1 Nsubarray])

replarray = phased.ReplicatedSubarray with properties: Subarray: [1x1 phased.ULA] Layout: 'Rectangular' GridSize: [1 8] GridSpacing: 'Auto' SubarraySteering: 'None'

Next, compare the radiation pattern of this array to the radiation pattern of a 64-element ULA with no subarrays.

refula = phased.ULA(N,0.5*c/fc,'Element',antenna); subplot(2,1,1), pattern(replarray,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c); title('Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2), pattern(refula,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c); title('ULA Azimuth Cut'); axis([-90 90 -50 0]);

From the plot, it is clear that the two responses are identical at broadside. Note that even though the subarrays are widely spaced, there is no grating lobe in the response.

Next, steer both arrays to 2 degrees azimuth.

steerang = 2; steeringvec_replarray = phased.SteeringVector('SensorArray',replarray,... 'PropagationSpeed',c); w = steeringvec_replarray(fc,steerang); steeringvec_refula = phased.SteeringVector('SensorArray',refula,... 'PropagationSpeed',c); wref = steeringvec_refula(fc,steerang); subplot(2,1,1), pattern(replarray,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',w); title('Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2), pattern(refula,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',wref); title('ULA Azimuth Cut'); axis([-90 90 -50 0]);

In this case, the response of the reference array still retains its original shape, but this is not the case for the subarrayed ULA. For the subarrayed ULA, although the mainlobe is correctly steered and stands well above the sidelobes, the response clearly shows what is often referred to as *quantization lobes*. The name comes from the fact that the steering is at the subarray level; hence, the required phase shift for each element is quantized at the subarray level. This effect gets worse when the array is steered further from the broadside. The following plots show the response after steering the arrays toward 6 degrees off broadside.

steerang = 6; w = steeringvec_replarray(fc,steerang); wref = steeringvec_refula(fc,steerang); subplot(2,1,1), pattern(replarray,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',w); title('Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2), pattern(refula,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',wref); title('ULA Azimuth Cut'); axis([-90 90 -50 0]);

Therefore, when forming an LFOV, one needs to be cautious about using contiguous subarrays.

One way to compensate for quantization lobes is to add phase shifters behind each element. Although it increases the cost, it still provides a big saving compared to the full degree of freedom array because the T/R switches, which are the most expensive parts, only need to be implemented at the subarray level. If there is a phase shifter behind each element, then the response becomes much better, as shown in the following plots, assuming the phase shifters behind each element are also configured to point each subarray toward 6 degrees off the broadside.

release(replarray); replarray.SubarraySteering = 'Phase'; replarray.PhaseShifterFrequency = fc; subplot(2,1,1); pattern(replarray,fc,-180:180,0,'Type','powerdb','Weights',w,... 'CoordinateSystem','rectangular','PropagationSpeed',c,'SteerAngle',6); title('Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2); pattern(refula,fc,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',wref); title('ULA Azimuth Cut'); axis([-90 90 -50 0]);

As a side note, the element and the subarrays do not necessarily steer to the same direction. In some applications, the elements inside the subarrays are steered toward a specific direction. The subarrays can then be steered to slightly different directions to search the vicinity.

Although an electronically scanned array is often called a *phased* array, in reality, adjusting the phase is only one way to steer the array. The phase shifters are, by nature, narrowband devices so they only work well within a narrow band, especially for large arrays. The following figure shows the radiation patterns when the reference array is phase steered to 30 degrees, both at the carrier frequency and 3 percent above the carrier frequency.

fsteer = [1 1.03]*fc; steerang = 30; release(steeringvec_refula); wref = squeeze(steeringvec_refula(fc,steerang)); subplot(2,1,1) pattern(refula,fsteer,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',wref); title('ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2) pattern(refula,fsteer,-180:180,0,'Type','powerdb',... 'CoordinateSystem','rectangular','PropagationSpeed',c,'Weights',wref); title('ULA Azimuth Cut, Peak Zoom View'); axis([25 35 -5 0]);

It is obvious from the figure that even though the frequency offset is a mere 3 percent, the peak location moved away from the desired direction. This is referred to as *squint* effect. Thus, to achieve steering across a wideband, one needs to steer using true time delays.

The most popular way to achieve true time delay is to use cables. However, in a big array aperture with thousands of elements, implementing the potentially huge time delay can require a lot of cables. Hence, this approach is not only expensive, but also cumbersome. Subarrays provide a compromise between the accuracy and feasibility. In summary, within each subarray, the steering is achieved by the phase; and among subarrays, the steering is done by true time delays.

The simplest way to build such an array is to contiguously group the subarrays, as in previous sections.

The following plots compare the radiation patterns at three frequencies for a subarrayed ULA. The array is steered toward 30 degrees azimuth at the subarray level using true time delay. Again, within each subarray, the elements are also steered toward 30 degrees azimuth. The radiation pattern is shown at the carrier frequency, 10 percent above the carrier frequency, and 15 percent above the carrier frequency.

steerang = 30; fsteer = [1 1.1 1.15]*fc; release(steeringvec_replarray); release(steeringvec_refula); w = squeeze(steeringvec_replarray(fsteer,steerang)); wref = squeeze(steeringvec_refula(fsteer,steerang)); subplot(2,1,1) pattern(replarray,fsteer,-180:180,0,'Type','powerdb',... 'PropagationSpeed',c,'CoordinateSystem','rectangular','Weights',w,... 'SteerAngle',steerang); title('Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2) pattern(replarray,fsteer,-180:180,0,'Type','powerdb',... 'PropagationSpeed',c,'CoordinateSystem','rectangular','Weights',w,... 'SteerAngle',steerang); title('Subarrayed ULA Azimuth Cut, Peak Zoom View'); axis([25 35 -5 0]);

The plots show that the squint effect has been suppressed even though the bandwidth is much wider compared to the previous case. However, as in the LFOV case, if the required bandwidth extends to 15 percent above the carrier frequency, the radiation pattern becomes undesirable due to quantization lobes.

One way to address this issue is to use a configuration with aperiodic subarrays. Examples of such configurations are interlaced subarrays, overlapped subarrays, and even random subarrays. Next example shows an interlaced subarray, where the ends of the subarray are interlaced and overlapped. Because it is no longer formed by identical subarrays, one needs to start with a large array aperture and partition it to achieve such configuration.

The array geometry can be seen in the following figure.

partarray = ... phased.PartitionedArray('Array',phased.ULA(N,0.5,'Element',antenna),... 'SubarraySteering','Phase'); sel = zeros(Nsubarray,N); Nsec = N/Nsubarray; for m = 1:Nsubarray if m==1 sel(m,(m-1)*Nsec+1:m*Nsec+1) = 1; elseif m==Nsubarray sel(m,(m-1)*Nsec:m*Nsec) = 1; else sel(m,(m-1)*Nsec:m*Nsec+1) = 1; end end partarray.SubarraySelection = sel

partarray = phased.PartitionedArray with properties: Array: [1x1 phased.ULA] SubarraySelection: [8x64 double] SubarraySteering: 'Phase' PhaseShifterFrequency: 300000000 NumPhaseShifterBits: 0

The resulting radiation pattern can be seen in the following figures.

steeringvec_partarray = ... phased.SteeringVector('SensorArray',partarray,'PropagationSpeed',c); wwa = squeeze(steeringvec_partarray(fsteer,steerang)); subplot(2,1,1); pattern(partarray,fsteer,-180:180,0,'Type','powerdb',... 'PropagationSpeed',c,'CoordinateSystem','rectangular','Weights',wwa,... 'SteerAngle',steerang); title('Interlaced and Overlapped Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]); subplot(2,1,2); pattern(replarray,fsteer,-180:180,0,'Type','powerdb',... 'PropagationSpeed',c,'CoordinateSystem','rectangular','Weights',w,... 'SteerAngle',steerang); title('Contiguous Subarrayed ULA Azimuth Cut'); axis([-90 90 -50 0]);

The new radiation pattern suppresses the largest quantization lobe, achieving a gain of around 5 dB. Higher gains can be achieved by designing a more sophisticated overlapped subarray network, but that is outside the scope of this example.

This example shows how to model a phased array with subarrays and illustrates several practical concerns when applying the subarray technique to applications such as LFOV arrays or wideband scanning arrays.

[1] Robert Mailloux, *Electronically Scanned Arrays*, Morgan & Claypool, 2007.