Array Pattern Multiplication: Element Pattern × Array Factor, Scan Loss & Tapering

Phased array series: 1. Introduction → 2. Electronic scanning → 3. Grating lobes → 4. Array pattern multiplication (you are here)

Antenna models series: Maxwell’s equations → Retarded potentials → Near-field / far-field boundary → Far-field retarded potentials → Array pattern multiplication (you are here) → Dipole power gain patterns

In one sentence: if an array is made of identical, identically oriented elements, its far-field pattern is simply the pattern of one element multiplied by the array factor:

$$text{total pattern} = text{element pattern} times text{array factor}.$$

So far in the phased array series, the antennas have been ideal points that radiate equally in every direction. Real elements, such as dipoles and patches, have their own directional patterns. Pattern multiplication says you don’t need to solve Maxwell’s equations again for every new array geometry: work out one element once, work out the array factor once, and multiply.

In this article I’ll show you why the rule works, try it on an example you can do by hand, and then use it to explain two things every array designer runs into: scan loss and amplitude tapering for low sidelobes.

Why the pattern factors: array pattern multiplication

Start with one element at the origin. In the far field, its radiated field in direction $(theta, phi)$ at distance $r$ looks like

$$mathbf E_{text{el}}(r, theta, phi) = mathbf{F}(theta, phi),frac{e^{-jkr}}{r},$$

where $mathbf{F}$ is the element’s radiation vector, which carries its directional pattern and polarization (derived in far-field retarded potentials).

Now move an identical copy to position $mathbf l_n$ and feed it with complex weight $w_n = a_n e^{jpsi_n}$. Far away, the shift doesn’t change the $1/r$ amplitude noticeably, but it does change the phase: the copy is closer to the observer by $hat{mathbf{r}} cdot mathbf l_n$, so its field gains a factor $e^{j k hat{mathbf{r}} cdot mathbf l_n}$. Writing $mathbf{k} = k hat{mathbf{r}}$ for the wave vector toward the observer and adding all $N$ copies:

$$mathbf F_{text{total}}(mathbf{k}) = sum_{n=0}^{N-1} w_n , mathbf{F}(mathbf{k}) , e^{j mathbf{k} cdot mathbf l_n} = mathbf{F}(mathbf{k}) , sum_{n=0}^{N-1} w_n , e^{j mathbf{k} cdot mathbf l_n} = mathbf{F}(mathbf{k}) , A(mathbf{k}).$$

Because every copy has the same $mathbf{F}$, it comes out of the sum. What’s left, $A(mathbf{k})$, is the array factor: it depends only on the positions and weights, not on what kind of antenna sits at each position.

For a uniform linear array along the $x$-axis with spacing $d$, and $theta$ measured from broadside, $mathbf{k} cdot mathbf l_n = n k d sintheta$. That’s the familiar array factor from the introduction:

$$AF(theta) = sum_{n=0}^{N-1} a_n , e^{j n k d (sintheta – sintheta_0)}.$$

In terms of power, magnitudes square, so the rule becomes a product, which is a sum in decibels:

$$G_{text{total}}(theta, phi) = G_{text{el}}(theta, phi),left| AF(theta, phi) right|^2, qquad G_{text{total,dB}} = G_{text{el,dB}} + left| AF right|^2_{text{dB}}.$$

The rule rests on three assumptions:

  • Identical elements, same orientation. Rotate one element and its $mathbf{F}$ no longer factors out.
  • Far field. The observer is far enough that all elements see the same direction $hat{mathbf{r}}$. See the near-field / far-field boundary.
  • No mutual coupling, or coupling folded into the element. Neighbouring elements disturb each other’s currents. In practice you measure each element inside the array (the embedded element pattern) and use that as $mathbf{F}$. Edge elements still differ a little, so the rule is an excellent approximation, not an exact law, for real hardware.

A first example by hand

Take two elements, spaced $d = lambda/2$ along $x$, fed in phase. Then $k d = pi$ and

$$AF(theta) = 1 + e^{jpisintheta}, qquad left| AF(theta) right| = 2left| cosleft(tfrac{pi}{2}sinthetaright) right|.$$

The array factor is maximum at broadside ($theta = 0$) and zero along the array axis ($theta = pm 90°$), where the two waves arrive half a wavelength apart and cancel.

Now let each element be a short dipole lying along the $x$-axis. A dipole radiates nothing along its own axis, and in this plane its pattern is $|costheta|$. Multiply:

$$left| E_{text{total}}(theta) right| propto 2 left| cosleft(tfrac{pi}{2}sinthetaright) right| left| costheta right|.$$

Both factors vanish at $pm 90°$, so the total pattern has a double null there and a beam that is narrower than either factor alone. You just designed an array pattern with two lines of algebra.

Element pattern meets array factor

Figure 1 does the same thing for a realistic 5G element. The element is the standard antenna element of 3GPP TR 38.901 (Table 7.3-1), which most system simulations use. Its horizontal cut, relative to its 8 dBi peak, is

$$A_{text{el}}(phi) = -minleftlbrace 12left(frac{phi}{65°}right)^2,; 30 rightrbrace text{dB}.$$

That is a 65° half-power beamwidth and a 30 dB front-to-back ratio. The array is 8 elements at $lambda/2$.

array pattern multiplication: Pattern multiplication: 3GPP element pattern times array factor of an 8-element array equals
Figure 1: Pattern multiplication: 3GPP element pattern times array factor of an 8-element array equals the total pattern

Look at the middle panel. A line array of point sources is symmetric: it radiates as much behind the array as in front, because $sintheta$ takes the same values at $theta$ and $180° – theta$. Real panels don’t do that, because each element has a ground plane behind it. In the total pattern on the right, the element factor knocks the back lobe down by 30 dB and also trims the wide-angle sidelobes. The main beam, set by the array factor, is unchanged.

Scan loss: the element pattern is the envelope

When you steer the beam, you move the array factor, but the element pattern stays where it is. The scanned beam therefore rides underneath the element pattern, as Figure 2 shows for a 16-element array.

Scan loss: beams of a 16-element array steered to 0, 30 and 60 degrees under the 3GPP element pattern envelope
Figure 2: Scan loss: beams of a 16-element array steered to 0, 30 and 60 degrees under the 3GPP element pattern envelope

The peak of every steered beam sits on the element curve. Steering to 30° costs 2.5 dB of gain, and steering to 60° costs about 10 dB with this element. That’s scan loss. There’s a second, subtler effect too: at 60° the beam actually peaks at about 57.9°, because the falling element pattern drags the product toward broadside.

This is the main reason base-station panels cover a sector of about ±60° and why a full circle needs three or more panels. Even an ideal, perfectly matched flat array loses gain as $costheta_0$, because its projected aperture shrinks. Real elements usually do worse.

Amplitude taper: trading beamwidth for sidelobes

There’s one more factor you control: the amplitudes $a_n$. With uniform weights the first sidelobe sits at about $-13$ dB, which is often too high. A radar sees false targets there, and a base station leaks interference into neighbouring users.

The fix is to taper the weights, with full amplitude at the centre of the array and less at the edges. This is exactly windowing in DSP. The array factor is a discrete-time Fourier transform of the weights, so every window you know from FFT window functions behaves the same way here.

Amplitude taper on a 16-element array: uniform versus Taylor and Chebyshev weights with sidelobe levels and beamwidths
Figure 3: Amplitude taper on a 16-element array: uniform versus Taylor and Chebyshev weights with sidelobe levels and beamwidths

Figure 3 shows the trade on a 16-element array:

WeightsFirst sidelobeHalf-power beamwidthTaper efficiency
Uniform−13.1 dB6.4°1.00 (0 dB)
Taylor ($bar{n} = 4$, −30 dB)−30.1 dB8.1°0.85 (−0.7 dB)
Chebyshev (−30 dB)−30.0 dB8.0°0.86 (−0.6 dB)

Taper efficiency measures how much peak gain you give up compared with uniform weights. It’s

$$eta_{text{taper}} = frac{left( sum_n a_n right)^2}{N sum_n a_n^2}.$$

So 17 dB lower sidelobes cost about 25% more beamwidth and less than 1 dB of gain. Chebyshev weights give equal-height sidelobes. Taylor weights let the far sidelobes decay, which is why radar designers usually prefer them.

Patterns inside patterns: subarrays

Pattern multiplication nests. Suppose a 5G panel is built from subarrays of 4 elements, each with an analog phase shifter, and those subarrays form a larger array driven digitally (hybrid beamforming). Then

$$text{total} = text{element} times text{subarray factor} times text{array-of-subarrays factor}.$$

The subarrays sit far apart (four element spacings), so their array factor has grating lobes, but the subarray factor puts nulls on top of most of them. This one equation explains a lot of hybrid beamforming behaviour. See grating lobes for why wide spacing causes trouble.

Python code

This script multiplies the 3GPP element pattern with a 16-element array factor, prints the scan loss at a few steering angles, and plots the total pattern with uniform and Taylor weights.

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal.windows import taylor

def element_db(phi_deg, phi3db=65.0, front_back=30.0):
    """3GPP TR 38.901 element, horizontal cut, relative to peak (dB)."""
    return -np.minimum(12*(phi_deg/phi3db)**2, front_back)

def af_db(phi_deg, w, d_lambda=0.5, phi0_deg=0.0):
    """|AF|^2 in dB, normalised to 0 dB at the beam peak."""
    n = np.arange(len(w))
    x = 2*np.pi*d_lambda*(np.sin(np.radians(phi_deg))[:, None]
                          - np.sin(np.radians(phi0_deg)))
    af = (w*np.exp(1j*n*x)).sum(axis=1) / w.sum()
    return 10*np.log10(np.maximum(np.abs(af)**2, 1e-12))

phi = np.linspace(-90, 90, 18001)
N = 16
uniform = np.ones(N)
tay = taylor(N, nbar=4, sll=30, norm=False)

for phi0 in (0, 30, 60):
    total = element_db(phi) + af_db(phi, uniform, phi0_deg=phi0)
    k = np.argmax(total)
    print(f"Steer {phi0:2d} deg: peak at {phi[k]:5.1f} deg, scan loss {abs(total[k]):4.1f} dB")

eff = tay.sum()**2 / (N*(tay**2).sum())
print(f"Taylor taper efficiency: {eff:.3f} ({10*np.log10(eff):.2f} dB)")

for w, name in ((uniform, "uniform"), (tay, "Taylor -30 dB")):
    plt.plot(phi, np.maximum(element_db(phi) + af_db(phi, w), -60), label=name)
plt.plot(phi, element_db(phi), "--", label="element pattern")
plt.xlabel("Angle from broadside (deg)")
plt.ylabel("Total pattern (dB)")
plt.ylim(-60, 2)
plt.grid(alpha=0.3)
plt.legend()
plt.show()

Output:

Steer  0 deg: peak at   0.0 deg, scan loss  0.0 dB
Steer 30 deg: peak at  29.6 deg, scan loss  2.5 dB
Steer 60 deg: peak at  57.9 deg, scan loss  9.8 dB
Taylor taper efficiency: 0.853 (-0.69 dB)

Matlab code

The same element-times-array product in base Matlab (no toolboxes), with a simple cosine-on-pedestal taper for comparison:

N = 16; dLambda = 0.5; phi0 = 30;                  % elements, spacing/lambda, steer (deg)
phi = linspace(-90, 90, 18001).';                  % angle from broadside (deg)
n = 0:N-1;

elementDb = -min(12*(phi/65).^2, 30);              % 3GPP TR 38.901 element
afDb = @(w) 20*log10(abs(exp(1j*2*pi*dLambda*(sind(phi) - sind(phi0))*n) * w(:)) ...
                     / sum(w) + 1e-12);

uniform = ones(1, N);
x = (n - (N-1)/2) / ((N-1)/2);
pedestal = 0.1 + 0.9*cos(pi/2*x);                  % cosine-on-pedestal taper

totalU = elementDb + afDb(uniform);
[peakU, k] = max(totalU);
fprintf('Steer %d deg: peak at %.1f deg, scan loss %.1f dBn', phi0, phi(k), -peakU);

plot(phi, max(totalU, -60), phi, max(elementDb + afDb(pedestal), -60), ...
     phi, elementDb, '--', 'LineWidth', 1.3);
legend('uniform', 'cosine on pedestal', 'element'); grid on; ylim([-60 2]);
xlabel('Angle from broadside (deg)'); ylabel('Total pattern (dB)');

Questions readers often ask

Does pattern multiplication work if the elements are different? No. If elements differ in type or orientation, $mathbf{F}$ can’t be taken out of the sum, and you have to add the full element fields one by one. Arrays are built from identical elements precisely so that the rule holds.

What about mutual coupling? It changes the element pattern but, to a good approximation, the same way for all interior elements. Use the embedded element pattern, measured or simulated with all neighbours present and terminated, as the element factor. Edge elements behave a bit differently, which is why large arrays often have a ring of dummy elements around the edge.

Can the element pattern have a null where the array factor has its beam? Yes, and then the total has a null there too. A product is zero if either factor is zero. That’s why you never point a dipole’s axis in the direction you want the beam to go.

Why add in dB instead of multiplying? It’s the same thing. Multiplying linear power gains is adding their decibel values, which is why datasheets quote “element gain + array gain”. A 64-element panel of 8 dBi elements has a peak gain near $8 + 10log_{10} 64 approx 26$ dBi (minus taper and losses).

Does the rule hold in the near field? No. Close to the array, each element is seen from a different direction and distance, so the common factor no longer comes out. The rule is a far-field result.

The four design levers, in one place

That completes the phased array series. For a linear array you now have four knobs:

  • Spacing $d$ decides whether grating lobes appear (grating lobes).
  • Progressive phase $psi_n$ steers the beam (electronic scanning).
  • Amplitude taper $a_n$ trades sidelobe level against beamwidth and gain.
  • Element pattern multiplies everything and sets the scan envelope.

Mutual coupling, calibration and digital beamforming are built on the same structure.

Keep learning

Want the complete Matlab labs? Path loss, fading and link-budget simulations are worked end to end in Wireless Communication Systems in Matlab. See all ebooks.

References

3GPP TR 38.901, Study on channel model for frequencies from 0.5 to 100 GHz, Section 7.3 and Table 7.3-1 (antenna element and panel model). 3GPP specification page

C. A. Balanis, Antenna Theory: Analysis and Design, 4th ed., Wiley, 2016, Chapter 6 (arrays, pattern multiplication, Dolph–Chebyshev arrays).

R. J. Mailloux, Phased Array Antenna Handbook, 3rd ed., Artech House, 2017 (scan loss, Taylor illumination, subarrays).

S. J. Orfanidis, Electromagnetic Waves and Antennas, Rutgers University, free online edition, chapters on antenna arrays. eceweb1.rutgers.edu/~orfanidi/ewa

T. T. Taylor, “Design of line-source antennas for narrow beamwidth and low side lobes,” IRE Transactions on Antennas and Propagation, vol. 3, no. 1, pp. 16–28, January 1955. doi:10.1109/TPGAP.1955.5720407

Leave a Comment