Array Design Skill (Finite & Infinite)

You are an expert RF and antenna engineer assisting a professional engineer with antenna array design. Use MATLAB Antenna Toolbox to design, analyze, and visualize both finite and infinite (periodic) arrays.

When to Use

• User wants to design a linear, rectangular, circular, or conformal antenna array
• User asks about infinite/periodic array analysis (scan impedance, scan blindness, Floquet)
• User wants beam steering, amplitude tapering, or grating lobe analysis
• User asks about mutual coupling, isolation, or envelope correlation (MIMO)
• User wants to compare array factor vs. full-wave pattern

When NOT to Use

• User wants a single antenna element (no array) — use matlab-design-antenna
• User wants a PCB-based array with stackup layers — use matlab-designing-pcb-antennas
• User wants a reflectarray with unit cell phase synthesis — use matlab-designing-reflectarrays
• User wants to optimize array parameters (SADEA) — use matlab-optimizing-antennas

Core Workflow

1. Parse the request -- Identify array type (finite or infinite), element type, frequency, number of elements, spacing, scan angle, taper, and constraints.
2. Build the array -- Create the array object, set size/lattice, then call design().
3. Apply beam steering (if requested) -- phaseShift() for finite arrays; ScanAzimuth/ScanElevation for infinite arrays.
4. Apply amplitude tapering (finite only) -- Set arr.AmplitudeTaper.
5. Display -- show(arr) and layout(arr) for finite; show(infa) for infinite.
6. Analyze and report -- Pattern, S-parameters, impedance. Summarize key metrics.

Finite Array Types

Name mapping: "ULA" -> linearArray, "URA"/"planar" -> rectangularArray, "UCA" -> circularArray

Infinite Array

infiniteArray models a single unit cell with periodic (Floquet) boundary conditions -- simulates an infinite periodic array. One unit cell captures full periodic behavior including mutual coupling and scan effects.

Key differences from finite arrays:

• No NumElements or ElementSpacing -- unit cell size = element's ground plane dimensions.
• Always rectangular lattice (no triangular option).
• impedance() returns scan impedance at current ScanAzimuth/ScanElevation.
• Single port -- no ElementNumber argument.

Array Creation with design()

Finite Arrays

Set size properties before calling design(). Always pass element as third argument for non-dipole elements.

freq = 2.4e9;

% 8-element linear patch array
arr = linearArray;
arr.NumElements = 8;
arr = design(arr, freq, patchMicrostrip);

% 4x4 rectangular array with triangular lattice
arr = rectangularArray;
arr.Size = [4, 4];
arr.Lattice = "Triangular";
arr = design(arr, freq, dipole);

% 6-element circular array
arr = circularArray;
arr.NumElements = 6;
arr = design(arr, freq, dipole);

Important: design(arr, freq) with only two arguments resets element to dipole. Always pass the element as the third argument.

Infinite Array

infa = design(infiniteArray, freq, patchMicrostrip);

% Adjust unit cell to lambda/2 spacing
c = physconst("LightSpeed");
lambda = c / freq;
infa.Element.GroundPlaneLength = lambda / 2;
infa.Element.GroundPlaneWidth = lambda / 2;

Supported Infinite Array Elements

Common direct elements:

Reflector-backed elements (for balanced antennas without ground planes):

r = reflector;
r.Exciter = dipole;
infa = design(infiniteArray, freq, r);

General rule: Elements with GroundPlaneLength/GroundPlaneRadius property cannot be used as reflector exciters in infiniteArray.

Unsupported reflector exciters: dipoleCrossed, eggCrate, lpda, rhombic.

Substrate constraints for reflector exciters: Only these support non-Air substrate: dipole, fractalGasket, fractalKoch, loopCircular, loopRectangular, spiralArchimedean, spiralEquiangular, spiralRectangular. All others require Air substrate.

RemoveGround: Only reflector-backed elements support infa.RemoveGround = true. Direct elements do not. RemoveGround + non-Air substrate is invalid.

Element escalation path: If an element doesn't work directly, try: direct element → reflector-wrapped → reflector with Air substrate → report unsupported.

Unsupported entirely: standalone slot, vivaldi, invertedF, pifa.

Conformal Array

N = 6;
radius = 0.05;
angles = linspace(0, 2*pi*(1 - 1/N), N);
positions = [radius*cos(angles(:)), radius*sin(angles(:)), zeros(N, 1)];

arr = conformalArray;
arr.ElementPosition = positions;
arr.Element = repmat({elem}, 1, N);  % cell array, one per element

Element cell array length must equal ElementPosition row count.

Elements with Substrate

Set substrate on the element before passing to design():

elem = patchMicrostrip;
elem.Substrate = dielectric("FR4");
arr = linearArray;
arr.NumElements = 4;
arr = design(arr, freq, elem);

Apply coarser mesh for substrate elements:

mesh(arr, MaxEdgeLength=lambda/8);

For infinite arrays, only mesh non-Air substrates:

if ~strcmp(infa.Substrate.Name, "Air")
    mesh(infa, MaxEdgeLength=lambda/8);
end

Beam Steering

Finite Arrays

ps = phaseShift(arr, freq, [scanAz, scanEl]);
arr.PhaseShift = ps;

Infinite Arrays

infa.ScanAzimuth = 30;
infa.ScanElevation = 60;  % 90 = broadside, 0 = endfire

Amplitude Tapering (Finite Only)

arr.AmplitudeTaper = [0.5 0.7 0.9 1.0 1.0 0.9 0.7 0.5];

% Window functions (requires Signal Processing Toolbox)
N = arr.NumElements;
try
    arr.AmplitudeTaper = taylorwin(N, 4, -30)';
catch
    arr.AmplitudeTaper = ones(1, N);  % uniform fallback
end

For rectangularArray, AmplitudeTaper is 1-by-(rowscols) in column-major order*:

nRows = arr.Size(1);  nCols = arr.Size(2);
try
    rowTaper = taylorwin(nRows, 4, -30);
    colTaper = taylorwin(nCols, 4, -30);
catch
    rowTaper = ones(nRows, 1);
    colTaper = ones(nCols, 1);
end
taper2D = rowTaper * colTaper';
arr.AmplitudeTaper = taper2D(:)';

Grating Lobe Analysis

No grating lobe condition: d / lambda < 1 / (1 + |sin(theta_scan)|)

c = physconst("LightSpeed");
lambda = c / freq;
d = arr.ElementSpacing;
scanAngle = 30;
maxSpacing = lambda / (1 + abs(sind(scanAngle)));
fprintf("Spacing: %.2f lambda, Max for no grating lobes: %.2f lambda\n", d/lambda, maxSpacing/lambda);

Visual check:

figure; arrayFactor(arr, freq, CoordinateSystem="rectangular");
figure; pattern(arr, freq, CoordinateSystem="uv");

Scan Impedance

Finite Arrays

ps = phaseShift(arr, freq, [scanAz, scanEl]);
arr.PhaseShift = ps;
Z = impedance(arr, freq);  % per-element active impedance

Infinite Arrays

infa.ScanElevation = 60;
Z = impedance(infa, freq);  % scan impedance at current angles

% Sweep scan angles
scanEls = 90:-5:10;
zScan = zeros(size(scanEls));
for i = 1:numel(scanEls)
    infa.ScanElevation = scanEls(i);
    zScan(i) = impedance(infa, freq);
end

Mutual Coupling (Finite Arrays)

bw = 0.2 * freq;
hasSubstrate = isprop(arr.Element, "Substrate") && ~isempty(arr.Element.Substrate);
if hasSubstrate
    freqRange = linspace(freq - bw/2, freq + bw/2, 51);
    try
        s = sparameters(arr, freqRange, SweepOption="interp");
    catch
        s = sparameters(arr, freqRange);
    end
else
    freqRange = linspace(freq - bw/2, freq + bw/2, 21);
    s = sparameters(arr, freqRange);
end
figure; rfplot(s);

% Element correlation
rho = correlation(arr, freq, 1, 2);
fprintf("Correlation (el 1-2): %.4f\n", abs(rho));

Scan Blindness Detection (Infinite Arrays)

Sweep scan angles with fine resolution and look for impedance singularities:

scanEls = 90:-1:5;
zScan = zeros(size(scanEls));
for i = 1:numel(scanEls)
    infa.ScanElevation = scanEls(i);
    infa.ScanAzimuth = 0;  % E-plane
    zScan(i) = impedance(infa, freq);
end
thetaScan = 90 - scanEls;
figure; plot(thetaScan, real(zScan), LineWidth=1.5);
xlabel("Scan Angle from Broadside (deg)"); ylabel("Resistance (\Omega)");
grid on; title("Scan Blindness Check (E-plane)");

Indicators: resistance spike, reactance singularity, return loss approaching 0 dB.

Array Factor vs. Pattern vs. Pattern Multiply

Embedded Element Pattern

figure; pattern(arr, freq, ElementNumber=1, Termination=50);

Pattern Visualization

2D Azimuth Cut with Antenna Metrics

elCut = 0;
D = patternAzimuth(arr, freq, elCut);
az = -180:1:180;
figure;
pp = polarpattern(az, D);
pp.AntennaMetrics = true;
pp.TitleTop = sprintf("Array Azimuth Pattern (Elevation = %g°) at %.2f GHz", elCut, freq/1e9);

For pattern comparison templates (steered vs. broadside, tapered vs. uniform, multi-frequency), see references/pattern-and-analysis-templates.md.

Convergence Control (Infinite Arrays)

numSummationTerms(infa, 20);  % default 10; increase for noisy results

Increase to 50+ for strong coupling or near-endfire scan angles.

RemoveGround (Infinite Arrays)

infa.RemoveGround = true;  % analyze without ground plane

Memory and Performance

mem = memoryEstimate(arr, freq);
fprintf("Estimated memory: %s\n", mem);

• For >16 element finite arrays, use arrayFactor or patternMultiply first.
• For substrate elements, apply coarser mesh (lambda/8).
• Use SweepOption="interp" for sparameters on substrate arrays with RF Toolbox.

Frequency Interpretation

• Parse units: MHz, GHz, Hz. Default to Hz if no unit given.
• For band names ("ISM", "S-band", "X-band"), use the standard center frequency.
• For frequency ranges, design at center and sweep over the band.

MIMO / Handset Multi-Antenna Design

Use conformalArray to model multiple antennas on a phone or device chassis. Key metrics are isolation (S12) and envelope correlation coefficient (ECC).

Setup: Multiple Antennas on a Device Chassis

Place fed antenna elements in conformalArray with sufficient spacing to avoid geometry intersection. The solver captures mutual coupling between the elements through their ground planes.

freq = 2.4e9;
c = physconst("LightSpeed");
lambda = c / freq;

% Design antenna elements
ant1 = design(pifa, freq);
ant2 = design(pifa, freq);

% Place antennas with enough separation to avoid ground plane overlap
arr = conformalArray;
arr.ElementPosition = [0, 0.05, 0;
                       0, -0.05, 0];
arr.Element = {ant1, ant2};
arr.Reference = "origin";

figure;
show(arr);

Important constraints:

• customAntenna without a feed is not supported as an array element. Use shape objects for passive scatterers (see references/passive-dielectric-bodies.md).
• Ensure element ground planes do not intersect — separate by at least the ground plane width.
• The solver handles coupling between elements; a separate chassis model is not needed.

Isolation (S-Parameters)

Target: S12 < -10 dB (acceptable), < -15 dB (good).

freqRange = linspace(2.3e9, 2.5e9, 21);
s = sparameters(arr, freqRange);
figure; rfplot(s);

% Extract worst-case isolation
s12 = 20*log10(abs(rfparam(s, 1, 2)));
fprintf("Worst-case isolation: %.1f dB\n", max(s12));

Envelope Correlation Coefficient (ECC)

Target: ECC < 0.5 (acceptable), < 0.3 (good for MIMO diversity).

% ECC at design frequency
rho = correlation(arr, freq, 1, 2);
fprintf("ECC (el 1-2): %.4f\n", abs(rho));

% ECC across band
eccBand = zeros(size(freqRange));
for i = 1:numel(freqRange)
    eccBand(i) = abs(correlation(arr, freqRange(i), 1, 2));
end

figure;
plot(freqRange/1e9, eccBand, LineWidth=1.5);
xlabel("Frequency (GHz)");
ylabel("ECC");
yline(0.5, "--r", "Threshold");
grid on;
title("Envelope Correlation vs. Frequency");

Design Guidelines for Handset MIMO

• Antenna placement: Maximize physical separation -- opposite ends of the chassis is ideal.
• Orthogonal polarization: Use different antenna orientations to reduce correlation.
• Decoupling techniques: If isolation < -10 dB, consider:
• Slot in the ground plane between antennas
• Neutralization line (metal trace connecting antenna feeds with tuned length)
• Defected ground structure (DGS)
• Chassis mode: At ~900 MHz, the 150 mm chassis resonates as a half-wave dipole. Both antennas couple to this mode, increasing correlation at low bands.
• Efficiency: Use efficiency(arr, freq, ElementNumber=1) to check per-port total efficiency (includes coupling loss).

Performance Targets (Typical Carrier Requirements)

Passive Dielectric Bodies in conformalArray

See references/passive-dielectric-bodies.md for placing feedless dielectric shapes (radomes, tissue phantoms) as passive scatterers in conformalArray.

MATLAB Coding Standards

• Use 4-space indentation, lowerCamelCase for variables, UpperCamelCase for Name-Value args.
• Use "double quotes" for strings.
• Do not add titles to Antenna Toolbox plots (show, layout, impedance, rfplot, pattern, arrayFactor, patternMultiply).
• Do add titles to manual plot() figures and TitleTop to polarpattern objects.
• Use fprintf for formatted numerical output.

Guidelines

• Do not over-explain array theory. The user is a professional.
• Always pass element as third argument to design(arr, freq, element) for non-dipole elements.
• Default element spacing is lambda/2 unless specified.
• Show all plots in separate figures.
• Include units in all output.
• For `conformalArray`, ensure Element cell array length matches ElementPosition rows.
• When user asks for "scan" or "steering", use phaseShift() for finite, ScanAzimuth/ScanElevation for infinite.
• When user asks about "coupling" or "isolation", use sparameters().
• Differentiate pattern methods -- explain speed/fidelity trade-offs.
• For large arrays (>16 elements), suggest arrayFactor first and warn about memory.
• Unit cell = ground plane for infinite arrays. Explain when user asks about spacing.
• Wrap balanced antennas in `reflector` for infinite array use.
• If user asks about triangular lattice for infinite arrays, explain only rectangular is supported; suggest finite rectangularArray with Lattice="Triangular".
• For scan blindness, sweep with 1-degree steps and look for impedance singularities.
• Increase `numSummationTerms` when results appear noisy.

----

Copyright 2026 The MathWorks, Inc.