Generated banner for Matlab Analyze Antenna Structures
Generated logo for Matlab Analyze Antenna Structures

Matlab Analyze Antenna Structures

MathWorksOfficialCreated by MathWorks

  • Skill
  • Tool integration
  • Science and research
  • BSD-2-Clause
  • No issues found

From the author

Design and analyze electrically large antenna structures using MATLAB Antenna Toolbox. Covers reflector antennas (parabolic, Cassegrain, Gregorian, offset, corner, cylindrical, spherical, custom STL), reflectarrays and reconfigurable intelligent surfaces (RIS), antennas installed on platforms (vehicles, aircraft, ships, satellites), and radar cross section (RCS) analysis. Includes solver selection (MoM-PO, PO, MoM, FMM), mesh control, and GPU acceleration. Use when the user wants to design a dish/reflector antenna, reflectarray, analyze an antenna on a platform, or compute RCS.
— the description by MathWorks

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to designing and analyzing electrically large antenna systems, including various reflector types, reflectarrays, reconfigurable intelligent surfaces, and platform-mounted antennas. It leverages the MATLAB Antenna Toolbox to perform electromagnetic analysis, compute radar cross sections (RCS), and select appropriate solvers like MoM-PO, PO, MoM, or FMM based on the specific geometry and material properties of the target.

What it does

  • Designs reflector antennas including parabolic, Cassegrain, Gregorian, and custom STL geometries.
  • Characterizes reflectarrays and reconfigurable intelligent surfaces using unit cell phase control.
  • Analyzes antenna performance when installed on complex platforms like vehicles, aircraft, or ships.
  • Computes monostatic and bistatic radar cross sections for various targets and polarizations.
  • Provides guidance on selecting and configuring electromagnetic solvers for accurate simulation.
  • Supports mesh control and GPU acceleration to optimize analysis of large-scale structures.

When to use it

  • When designing dish or reflector antennas for satellite or terrestrial communication.
  • When developing reflectarray antennas or RIS with specific phase requirements.
  • When evaluating the performance of an antenna mounted on a large conducting platform.
  • When calculating the radar cross section of a target for electromagnetic signature analysis.

Advantages

  • Enables trade studies for reflector antennas using analytical calculators.
  • Supports complex platform integration via STL, STEP, and IGES file imports.
  • Offers multiple solver options to balance computational speed and simulation accuracy.
  • Provides tools for both far-field pattern analysis and near-field RCS computation.

Usage examples

“Design a prime-focus parabolic reflector antenna operating at 10 GHz.”
The agent will guide the creation of a reflectorParabolic object, set the exciter, and use the design method to calculate dimensions based on the specified frequency.
“How do I analyze the RCS of a metal plate at 5 GHz?”
The agent will provide a script using the platform object to load the plate geometry and the rcs function to compute the monostatic RCS using the PO solver.
“Set up an installed antenna analysis for a dipole on a vehicle model.”
The agent will provide instructions to define the platform from an STL file, configure the installedAntenna object, and specify the appropriate solver for the platform geometry.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/matlab/matlab-analyze-antenna-structures/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip matlab-analyze-antenna-structures.zip -d .agents/skills

Documentation by MathWorks

Antenna Structure Design and Analysis

Design, analyze, and visualize electrically large antenna structures — reflector antennas, reflectarrays/RIS, platform-installed antennas, and radar cross section — using MATLAB Antenna Toolbox with appropriate EM solvers for each problem class.

When to Use

Reflector antennas

  • Design a parabolic dish, satellite dish, or prime-focus reflector

  • Design a Cassegrain or Gregorian dual-reflector system

  • Design an offset-fed reflector (no blockage)

  • Design a corner reflector, cylindrical or spherical reflector

  • Use reflectorCalculator for trade studies

  • Import custom reflector geometry from STL files

Reflectarrays and RIS

  • Design a reflectarray antenna with unit cell phase control

  • Design a reconfigurable intelligent surface (RIS) with quantized phases

  • Characterize unit cell reflection phase (S-curve)

  • Synthesize an aperture phase distribution for beam steering

  • Verify pattern via pattern multiplication

Installed antennas on platforms

  • Mount an antenna on a vehicle, aircraft, ship, satellite, or large structure

  • Analyze installed antenna patterns, coupling, or efficiency

  • Load platform geometry from STL/STEP/IGES files

  • Generate platform geometry programmatically

Radar cross section

  • Compute monostatic or bistatic RCS

  • Analyze RCS of a platform, antenna, or array

  • Compare RCS across polarizations (HH, VV, HV, VH)

  • Compute RCS of a dielectric target

When NOT to Use

  • Designing standalone antenna elements or arrays (no platform) — use matlab-design-antenna

  • Optimizing antenna dimensions with SADEA/TR-SADEA — use matlab-design-antenna

  • Impedance matching, measured antenna objects, RF propagation, or SAR — use matlab-integrate-antenna

  • A flat reflector backing a dipole — use matlab-design-antenna (catalog element)

Must-Follow Rules

Reflectors
  • Set Exciter BEFORE design() — design(obj, freq) takes two arguments only for reflectors

  • cavity is NOT a valid exciter — it will error

  • reflectorCorner and reflectorCylindrical have no SolverType property — always MoM

  • Array as exciter: design the array first, assign to Exciter, do NOT call design() on reflector afterward

Reflectarrays
  • infiniteArray only supports pcbStack with exactly 3 layers (metal-dielectric-metal)

  • Set BoardThickness before Layers on pcbStack — order matters

  • Feed offset: Use [Lp/4, 0, 1, 3] — not [0 0 1 3]

  • Always unwrap phase with unwrap() and normalize magnitude (peak = 1)

  • Pattern multiplication adds dB — element pattern (dB) + array factor (dB), NOT linear multiplication

Installed Antennas
  • installedAntenna only supports pure metal antennas — no dielectric substrates

  • Platform Units must be explicit — defaults to "mm" but ElementPosition is always in meters

  • Set ElementPosition before Element for multi-element setups

  • Always mesh explicitly before analysis — uncontrolled density causes inaccurate results

RCS
  • One of azimuth or elevation must be scalar for monostatic sweeps

  • Dielectric targets require FMM solver — PO and MoM will error

  • UseFileAsMesh = true required for dielectric .mat files

  • PO fails at grazing incidence — returns artificially low values (~-250 dBsm)

Solver Selection (All Workflows)
  • Default: MoM-PO for installed/reflectors, PO for RCS

  • Use FMM for: closed bodies, concave features, dielectric targets

  • Verify FMM convergence with solver() then convergence() after analysis

  • Mesh density: lambda/10 for MoM/FMM, lambda/6 for MoM-PO, default for PO

Workflow

1. Reflector Antenna Design
  1. Parse — Identify reflector type, frequency, exciter, f/D ratio, constraints

  2. Create — Set exciter first (if non-default), then call design(obj, freq)

  3. Customize — Adjust Radius, FocalLength, FeedOffset for custom f/D

  4. Analyze — Pattern, gain, beamwidth, impedance

  5. Report — Key metrics with units, f/D ratio, aperture in wavelengths

For trade studies, use reflectorCalculator first (instant), then createAntenna for full-wave.

2. Reflectarray / RIS Design
  1. Design unit cell — Parameterized pcbStack (3 layers) with variable patch size

  2. Characterize S-curve — Sweep patch size via planeWaveExcitation + infiniteArray + EHfields

  3. Synthesize aperture phase — Compute required phase (path delay + beam steering gradient)

  4. Map phase to geometry — Invert S-curve via interpolation; quantize for RIS

  5. Build geometry — conformalArray with unique elements at each position

  6. Verify pattern — Element pattern + array factor via patternCustom

3. Installed Antenna Analysis
  1. Create platform — Load from STL/STEP/IGES or generate programmatically

  2. Install element(s) — Set Platform, ElementPosition, Element, SolverType

  3. Mesh — mesh(ant, MaxEdgeLength=lambda/N) per solver guidelines

  4. Analyze — Pattern, impedance, S-parameters (coupling), efficiency

  5. Report — Metrics with units; verify FMM convergence if used

4. RCS Analysis
  1. Create target — Load platform from file or use antenna/array object directly

  2. Select solver — PO (default, fast), MoM (small, accurate), FMM (dielectric/concave)

  3. Compute — rcs(obj, freq, az, el, Polarization=..., Solver=...)

  4. Report — Peak RCS (dBsm), angular location, polarization

Key Classes

ClassPurpose
reflectorParabolicPrime-focus parabolic dish
cassegrain / gregorianSymmetric dual-reflector systems
cassegrainOffset / gregorianOffsetOffset dual-reflector (no blockage)
reflectorCornerCorner reflector (90/60/45 deg)
reflectorCylindrical / reflectorSphericalFan-beam / wide-scan reflectors
customDualReflectorsCustom STL reflector surfaces
reflectorCalculatorGaussian-beam analytical design (R2026a)
installedAntennaAntenna mounted on conducting platform
platform3D geometry loader (STL/STEP/IGES)
infiniteArrayPeriodic boundary conditions for unit cells
planeWaveExcitationPlane wave illumination for S-curve/RCS
conformalArrayArbitrary element positions (reflectarray geometry)
pcbStackUnit cell structure (3-layer for reflectarrays)
rcsRadar cross section function

Conventions

Coding Standards
  • 4-space indentation, lowerCamelCase variables, UpperCamelCase Name-Value args

  • "double quotes" for strings, fprintf for formatted output

  • Do not add titles to Antenna Toolbox plots (show, pattern, rcs auto-plot)

  • Do add titles to manual plot, imagesc, subplot, and TitleTop to polarpattern

  • Show all plots in separate figures. Include units in all output.

Script-First Workflow

For design, analysis, or sweep tasks — write code to .m files, run via run_matlab_file, iterate by editing and re-running. Use inline evaluate_matlab_code for quick one-off checks.

References
Load when...Reference
Designing any reflector antenna (parabolic, dual, corner, custom STL)references/reflector-antennas.md
Designing a reflectarray or RIS (unit cells, S-curve, phase synthesis)references/reflectarrays.md
Installing antennas on platforms (STL loading, multi-element, conformalArray workaround)references/installed-antennas.md
Computing monostatic/bistatic RCS (polarization, dielectric targets, GPU)references/rcs-analysis.md
Choosing between MoM-PO, PO, MoM, FMM for any applicationreferences/solver-selection.md

Copyright 2026 The MathWorks, Inc.

Files

references/reflectarrays.md

Reflectarray and RIS Design

Unit Cell Design with pcbStack

A reflectarray unit cell is a pcbStack with three layers: patch (metal) + substrate (dielectric) + ground (metal).

f0 = 5.8e9;
c0 = physconst("LightSpeed");
lambda = c0 / f0;
cellSize = 0.5 * lambda;
Lp = 8e-3;
subHeight = 1.524e-3;

sub = dielectric(Name="RO4003C", EpsilonR=3.55, LossTangent=0.0027, Thickness=subHeight);
boardGnd = antenna.Rectangle(Length=cellSize, Width=cellSize);
patch = antenna.Rectangle(Length=Lp, Width=Lp);

uc = pcbStack;
uc.BoardShape     = boardGnd;
uc.BoardThickness = subHeight;
uc.Layers         = {patch, sub, boardGnd};
uc.FeedLocations  = [Lp/4, 0, 1, 3];    % offset feed for proper excitation
Critical Constraints
  • infiniteArray only supports pcbStack with exactly 3 layers (metal-dielectric-metal). Multi-layer stacks throw: "Multilayer Substrate is not supported for Infinite arrays."

  • Set BoardThickness before Layers -- setting Layers first causes MATLAB to silently overwrite dielectric thickness.

  • Feed offset: Use [Lp/4, 0, 1, 3] for proper patch excitation -- not [0 0 1 3].

  • BoardShape must match the ground plane -- this defines the unit cell boundary.

Shape Objects for Metal Patterns

All shapes are in the antenna namespace:

% Cross-shaped patch
crossPatch = antenna.Rectangle(Length=armLen, Width=armWid) + ...
             antenna.Rectangle(Length=armWid, Width=armLen);

% Ring patch
ring = antenna.Circle(Radius=Ro) - antenna.Circle(Radius=Ri);

% Slotted patch
slotted = antenna.Rectangle(Length=Lp, Width=Wp) - antenna.Rectangle(Length=Ls, Width=Ws);
Substrate Selection
MaterialEpsilonRLossTangentUse Case
Custom "RO4003C"3.550.0027Recommended for reflectarrays
"Teflon"2.10.0002Low-loss, moderate phase range
"TMM3"3.450.002Higher permittivity, wider phase range
"FR4"4.80.026Prototyping only (high loss)

Phase Characterization (S-Curve)

Use planeWaveExcitation + infiniteArray + EHfields to extract reflection phase vs. geometry parameter.

Important: EHfields returns only the field scattered by the patch currents. The magnitude peaks at resonance (maximum patch re-radiation). The relative phase variation across patch sizes is correct for reflectarray design because the ground plane contribution is spatially constant and cancels when computing inter-element phase differences.

f0 = 5.8e9;
c0 = physconst("LightSpeed");
lambda = c0 / f0;
k0 = 2*pi / lambda;
cellSize = 0.5 * lambda;
subHeight = 1.524e-3;
epsR = 3.55;
tanD = 0.0027;

sub = dielectric(Name="RO4003C", EpsilonR=epsR, LossTangent=tanD, Thickness=subHeight);
boardGnd = antenna.Rectangle(Length=cellSize, Width=cellSize);

patchSize0 = lambda / (2*sqrt(epsR));
patchSizes = linspace(0.3*patchSize0, 1.4*patchSize0, 20);

AF = 4*pi*cellSize^2 / lambda^2;
obsRadius = 100 * lambda;

reflMag   = zeros(size(patchSizes));
reflPhase = zeros(size(patchSizes));

for idx = 1:numel(patchSizes)
    ps = patchSizes(idx);
    patch = antenna.Rectangle(Length=ps, Width=ps);

    uc = pcbStack;
    uc.BoardShape     = boardGnd;
    uc.BoardThickness = subHeight;
    uc.Layers         = {patch, sub, boardGnd};
    uc.FeedLocations  = [ps/4, 0, 1, 3];

    ia = infiniteArray(Element=uc);
    ia.ScanAzimuth   = 0;
    ia.ScanElevation = 90;
    numSummationTerms(ia, 15);

    pw = planeWaveExcitation;
    pw.Element      = ia;
    pw.Direction    = [0 0 -1];
    pw.Polarization = [1 0 0];

    obsLoc = [0; 0; obsRadius];
    [Eo, ~] = EHfields(pw, f0, obsLoc);
    Eo = Eo * AF;
    Eco = dot(Eo, [1; 0; 0]);

    reflMag(idx)   = abs(Eco);
    reflPhase(idx) = angle(Eco);
end

reflMag = reflMag / max(reflMag);
reflPhaseUnwrap = unwrap(reflPhase);

figure;
subplot(2,1,1);
plot(patchSizes*1e3, reflMag, "b-o", LineWidth=1.5, MarkerSize=4);
ylabel("Reflection Magnitude |R|");
title(sprintf("Unit Cell S-Curve (%.1f GHz)", f0/1e9));
grid on;

subplot(2,1,2);
plot(patchSizes*1e3, rad2deg(reflPhaseUnwrap), "r-o", LineWidth=1.5, MarkerSize=4);
xlabel("Patch Side Length (mm)");
ylabel("Reflection Phase (deg)");
grid on;

phaseRange = max(reflPhaseUnwrap) - min(reflPhaseUnwrap);
fprintf("Phase range: %.0f degrees\n", rad2deg(phaseRange));
S-Curve Quality Criteria
  • Phase range >= 300 degrees (ideally 360). If less, increase substrate thickness or permittivity.

  • Smooth, monotonic variation -- no abrupt jumps or flat regions.

  • Normalized magnitude near unity across most sizes.

Sweep Range

Start with 0.3 * patchSize0 to 1.4 * patchSize0 where patchSize0 = lambda / (2*sqrt(epsR)).

Aperture Phase Synthesis

Required Phase Formula
% Element positions (centered grid)
xIdx = (-(Nx-1)/2 : (Nx-1)/2);
yIdx = (-(Ny-1)/2 : (Ny-1)/2);
[Xgrid, Ygrid] = meshgrid(xIdx * cellSize, yIdx * cellSize);

% Feed-to-element distances
dx = elemX - feedPos(1);
dy = elemY - feedPos(2);
dz = 0 - feedPos(3);
Rmn = sqrt(dx.^2 + dy.^2 + dz.^2);
phiPath = k0 * Rmn;

% Beam steering phase
u0 = sin(deg2rad(theta0)) * cos(deg2rad(phi0));
v0 = sin(deg2rad(theta0)) * sin(deg2rad(phi0));
phiBeam = k0 * (elemX * u0 + elemY * v0);

% Required reflection phase
phiReq = mod(phiPath - phiBeam, 2*pi);
S-Curve Inversion (Phase to Patch Size)
[phaseSorted, sortIdx] = sort(scurve.reflPhase);
patchSorted = scurve.patchSizes(sortIdx);
[phaseSorted, uniqIdx] = unique(phaseSorted);
patchSorted = patchSorted(uniqIdx);

phaseMin = min(phaseSorted);
phaseMax = max(phaseSorted);
phaseRange = phaseMax - phaseMin;
phiReqWrap = phaseMin + mod(phiReq - phaseMin, phaseRange);

elemPatchSize = interp1(phaseSorted, patchSorted, phiReqWrap, "pchip", "extrap");
elemPatchSize = max(min(elemPatchSize, max(scurve.patchSizes)), min(scurve.patchSizes));

Feed Illumination Model

thetaFeed = atan2(sqrt(dx.^2 + dy.^2), abs(dz));
feedIllum = (cos(thetaFeed).^qFeed) ./ Rmn;
elemAmp   = feedIllum .* elemReflMag;
elemAmp   = elemAmp / max(elemAmp);
elemTotalPhase = elemReflPhase - phiPath;

Geometry Visualization with conformalArray

elements = cell(1, nElem);
for ii = 1:nElem
    ps = elemPatchSize(ii);
    patch = antenna.Rectangle(Length=ps, Width=ps);
    uc = pcbStack;
    uc.BoardShape     = boardGnd;
    uc.BoardThickness = subHeight;
    uc.Layers         = {patch, sub, boardGnd};
    uc.FeedLocations  = [ps/4, 0, 1, 3];
    elements{ii} = uc;
end

elemPositions = [elemX, elemY, zeros(nElem, 1)];
raGeom = conformalArray(Element=elements, ElementPosition=elemPositions, Reference="origin");
figure; show(raGeom);
figure; layout(raGeom);

Pattern Verification (Pattern Multiplication)

Angle convention: Use theta (0:180, from z-axis). patternCustom expects theta convention.

Element Pattern
thetaGrid = 0:1:180;
phiGrid   = 0:1:360;
elGrid    = 90 - thetaGrid;
dElem = pattern(unitCell, f0, phiGrid, elGrid);
dElem = dElem.';
Array Factor
[THG, PHG] = meshgrid(deg2rad(thetaGrid), deg2rad(phiGrid));
AF = zeros(size(THG));
for ii = 1:numel(THG)
    u = sin(THG(ii)) * cos(PHG(ii));
    v = sin(THG(ii)) * sin(PHG(ii));
    phaseProg = k0 * (elemX * u + elemY * v);
    AF(ii) = abs(sum(elemAmp .* exp(1j * (elemTotalPhase + phaseProg))));
end
AF_dB = 20*log10(AF / max(AF(:)));
AF_dB(AF_dB < -60) = -60;
Pattern Multiplication and Display
dElemNorm = dElem - max(dElem(:));
totalPattern_dB = dElemNorm + AF_dB;
totalPattern_dB = totalPattern_dB - max(totalPattern_dB(:));

figure;
patternCustom(totalPattern_dB, thetaGrid, phiGrid);

RIS Phase Quantization

Nbits = 2;
Nstates = 2^Nbits;
phaseStep = 2*pi / Nstates;
phiQuantized = round(phiReq / phaseStep) * phaseStep;

sincVal = sin(pi/Nstates) / (pi/Nstates);
quantEff = sincVal^2;
fprintf("Quantization loss: %.1f dB\n", 10*log10(quantEff));
BitsStatesEfficiencyLoss
120.405-3.9 dB
240.811-0.9 dB
380.950-0.2 dB

Design Parameters

  • Unit cell size: lambda/2 (default). Grating lobe limit: cellSize < lambda/(1 + sin(theta_max)).

  • f/D ratio: 0.8 (default). Range: 0.5-1.5.

  • Feed exponent q: q = -10 / (20*log10(cos(atan(D/(2*F))))) for -10 dB edge taper.

  • Patch sweep range: 0.3*patchSize0 to 1.4*patchSize0 where patchSize0 = lambda/(2*sqrt(epsR)).


Copyright 2026 The MathWorks, Inc.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
MathWorks
Publisher
MathWorks (Official)
Source
matlab/matlab-agentic-toolkit · skills-catalog/rf-and-mixed-signal/matlab-analyze-antenna-structures · commit 2a7f215
Licence
BSD 2-Clause License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE.md)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by MathWorks or MathWorks.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-analyze-antenna-structures.zip