matlab-design-reflector-antenna

name: matlab-design-reflector-antenna description: Design and analyze curved reflector antennas using MATLAB Antenna Toolbox. Covers parabolic dishes (prime-focus, Cassegrain, Gregorian), offset dual-reflector configurations, corner reflectors, cylindrical and spherical reflectors, and custom dual-reflector surfaces. Includes exciter selection, f/D ratio design, solver selection (MoM-PO, PO, MoM, FMM), feed offset, and pattern analysis. Use when the user wants to design a dish antenna, parabolic reflector, Cassegrain, Gregorian, corner reflector, or any curved reflector structure. license: MathWorks BSD-3-Clause allowed-tools: mcp__matlab__evaluate_matlab_code mcp__matlab__check_matlab_code mcp__matlab__detect_matlab_toolboxes ReadMcpResourceTool argument-hint: [exciter-type] metadata: author: MathWorks version: "1.0"

Reflector Antenna Design Skill

You are an expert RF and antenna engineer assisting a professional engineer with reflector antenna design. Use MATLAB Antenna Toolbox to design, analyze, and visualize curved reflector antennas including parabolic dishes, dual-reflector systems, corner reflectors, and custom reflector geometries.

Scope: This skill covers curved/shaped reflector structures. The flat reflector (backing structure for dipoles) is a catalog element covered by the general antenna design skill.

When to Use

• User wants to design a parabolic dish, satellite dish, or prime-focus reflector
• User wants a Cassegrain or Gregorian dual-reflector system
• User wants an offset-fed reflector (no blockage)
• User wants a corner reflector antenna
• User wants to use reflectorCalculator for trade studies
• User asks about f/D ratio, aperture efficiency, or feed illumination taper

When NOT to Use

• User wants a flat reflector backing a dipole — use matlab-design-antenna (catalog reflector)
• User wants a reflectarray with unit cells — use matlab-design-reflectarray
• User wants a PCB antenna — use matlab-design-pcb-antenna
• User wants to optimize reflector dimensions — use matlab-optimize-antenna

Core Workflow

1. Parse the request -- Identify reflector type, operating frequency, exciter type, aperture size, f/D ratio, and constraints (offset feed, scan angle, polarization).
2. Create the reflector -- Set exciter first (if non-default), then call design().
3. Analyze -- Pattern, gain, beamwidth, impedance, sidelobe level.
4. Solver selection -- Choose MoM-PO (default), PO, MoM, or FMM based on electrical size.
5. Present results -- Summarize key metrics with units.

Reflector Types

Name mapping:

• "dish antenna" / "parabolic dish" / "satellite dish" --> reflectorParabolic
• "Cassegrain" / "dual reflector" --> cassegrain or cassegrainOffset
• "Gregorian" --> gregorian or gregorianOffset
• "corner reflector" --> reflectorCorner
• "offset feed" / "no blockage" --> cassegrainOffset or gregorianOffset
• "shaped reflector" / "custom surface" --> customDualReflectors

Creating Reflector Antennas

design() for Reflectors

Reflector antennas use design(obj, freq) with two arguments only. Set the exciter on the object before calling design():

freq = 10e9;

% Default exciter (dipole for parabolic)
rp = design(reflectorParabolic, freq);

% Custom exciter -- set BEFORE design
rp = reflectorParabolic;
rp.Exciter = hornConical;
rp = design(rp, freq);

Important: Unlike finite arrays, design() for reflectors does NOT accept a third element argument. Always set Exciter property first.

Supported Exciters

For dual-reflector systems (Cassegrain/Gregorian), hornConical is the standard choice -- it provides symmetric illumination with controlled beamwidth.

Workflow 1: Prime-Focus Parabolic Dish

The most common reflector antenna. Key parameter is the f/D ratio.

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

% Design with default dipole exciter
rp = design(reflectorParabolic, freq);
figure; show(rp);
figure; pattern(rp, freq);

% Key dimensions
fprintf("Radius: %.4f m (%.1f lambda)\n", rp.Radius, rp.Radius/lambda);
fprintf("Focal length: %.4f m\n", rp.FocalLength);
fprintf("f/D ratio: %.2f\n", rp.FocalLength / (2*rp.Radius));
fprintf("Aperture diameter: %.4f m (%.1f lambda)\n", 2*rp.Radius, 2*rp.Radius/lambda);

With Horn Exciter (Higher Gain)

freq = 10e9;

rp = reflectorParabolic;
rp.Exciter = hornConical;
rp = design(rp, freq);

figure; show(rp);
figure; pattern(rp, freq);

% Beamwidth
[bw, angles] = beamwidth(rp, freq, 0, 1:360);
fprintf("3-dB beamwidth: %.1f deg\n", bw);

Custom f/D Ratio

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

rp = reflectorParabolic;
rp.Exciter = hornConical;
rp.Radius = 10 * lambda;           % 10-lambda aperture radius
rp.FocalLength = 10 * lambda;      % f/D = 0.5
rp.FeedOffset = [0 0 0];

figure; show(rp);
figure; pattern(rp, freq);

Workflow 2: Cassegrain and Gregorian (Symmetric Dual-Reflector)

freq = 10e9;

% Cassegrain (hyperbolic subreflector) -- shorter, common for large dishes
cass = design(cassegrain, freq);
figure; show(cass);
figure; pattern(cass, freq);
fprintf("Main radius: %.4f m, Sub radius: %.4f m\n", cass.Radius(1), cass.Radius(2));

% Gregorian (ellipsoidal subreflector) -- lower cross-pol, slightly longer
greg = design(gregorian, freq);
figure; show(greg);
figure; pattern(greg, freq);

Both use hornConical as default exciter. Properties: Radius (1-by-2), FocalLength (1-by-2).

Workflow 3: Offset Dual-Reflector (No Feed Blockage)

Offset configurations eliminate aperture blockage, improving efficiency and reducing sidelobes.

freq = 10e9;

co = design(cassegrainOffset, freq);
figure; show(co);
figure; pattern(co, freq);
fprintf("Offset: %.4f m, InterAxialAngle: %.1f deg\n", co.MainReflectorOffset, co.InterAxialAngle);

% Offset Gregorian
go = design(gregorianOffset, freq);
figure; show(go);

Offset-specific properties: MainReflectorOffset, InterAxialAngle, DualReflectorSpacing, ReflectorTilt ([main, sub] angles).

Workflow 4: Corner Reflector

Two conducting planes at an angle. Corner angle determines gain.

freq = 1e9;
rc = design(reflectorCorner, freq);
rc.CornerAngle = 90;
figure; show(rc);
figure; pattern(rc, freq);
fprintf("Corner angle: %d deg, Spacing: %.4f m\n", rc.CornerAngle, rc.Spacing);

Workflow 5: Cylindrical and Spherical Reflectors

freq = 1e9;

% Cylindrical -- fan beam (narrow in one plane, wide in other)
% Properties: GroundPlaneLength, GroundPlaneWidth, Spacing, Depth, EnableProbeFeed, Conductor
rcyl = design(reflectorCylindrical, freq);
figure; show(rcyl);
figure; pattern(rcyl, freq);

% Spherical -- wide-angle scanning by moving the feed
% Properties: Radius, Depth, FeedOffset ([0 0 0.075] default), SolverType
rs = design(reflectorSpherical, freq);
figure; show(rs);
figure; pattern(rs, freq);
fprintf("Radius: %.4f m, Depth: %.4f m\n", rs.Radius, rs.Depth);

Using an Array as Exciter

Any array object (linearArray, circularArray, etc.) can be assigned as the Exciter for a reflector. Design the array first, then assign it -- do NOT call design() on the reflector afterward.

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

% Design the array exciter first
arr = circularArray;
arr.NumElements = 4;
arr.Element = spiralArchimedean;
arr = design(arr, freq);

% Assign to reflector (set dimensions manually -- no design() on reflector)
rp = reflectorParabolic;
rp.Exciter = arr;
rp.Radius = 5*lambda;
rp.FocalLength = 5*lambda;   % f/D = 0.5

figure; show(rp);
figure; pattern(rp, freq);

Works with all reflector types:

% Corner reflector with linear array of invertedF
rc = reflectorCorner;
rc.Exciter = design(linearArray, freq, invertedF);
rc.GroundPlaneWidth = 2*lambda;
rc.Spacing = 0.25*lambda;
figure; show(rc);

EnableProbeFeed (Cylindrical Reflector)

reflectorCylindrical has an EnableProbeFeed property that changes the feed mechanism from a standalone exciter to a probe feed through the reflector surface:

rcyl = design(reflectorCylindrical, freq);
rcyl.EnableProbeFeed = true;
figure; show(rcyl);
figure; pattern(rcyl, freq);

Workflow 6: Custom Reflector Surfaces from STL Files

Import arbitrary reflector geometry from STL files using stlread and assign to customDualReflectors. This works for single-reflector setups (only MainReflector needed) or dual-reflector configurations.

Single Custom Reflector from STL

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

% Load STL as triangulation object
tri = stlread("MyCustomReflector.stl");

% Create reflector with custom surface
cdr = customDualReflectors;
cdr.MainReflector = tri;
cdr.Exciter = dipole(Length=0.15, Width=0.015, Tilt=90, TiltAxis=[0 1 0]);
cdr.FeedOffset = [0 0 0.05];          % exciter position relative to reflector
cdr.RemeshReflectors = true;           % re-mesh imported surface for solver

figure; show(cdr);
figure; pattern(cdr, freq);

Dual Custom Reflectors from STL

freq = 10e9;

mainTri = stlread("main_reflector.stl");
subTri = stlread("sub_reflector.stl");

cdr = customDualReflectors;
cdr.MainReflector = mainTri;
cdr.SubReflector = subTri;
cdr.Exciter = hornConical;
cdr.ReflectorOffset = [0 0 0; 0 0 0.1];
cdr.FeedOffset = [0 0 0.15];

figure; show(cdr);
figure; pattern(cdr, freq);

Optimizing Exciter Position on Custom Reflector

To optimize the exciter location on a custom STL reflector without moving the reflector itself, vary FeedOffset using SADEA optimization (see matlab-optimize-antenna):

freq = 2e9;
tri = stlread("MyCustomReflector.stl");

% Define evaluation function that sweeps FeedOffset
evalFcn = @(params) evaluateReflector(params, tri, freq);

% Use SADEA to optimize exciter position
% Optimization variables: FeedOffset [x, y, z]
% See matlab-optimize-antenna skill for full SADEA setup

Properties:

• MainReflector: N-by-3 matrix or triangulation object (from stlread)
• SubReflector: N-by-3 matrix or triangulation object (optional for single-reflector)
• ReflectorOffset: 2-by-3 matrix [main offset; sub offset] — additive translation applied on top of existing coordinates
• FeedOffset: 1-by-3 vector — controls exciter position independently of reflector
• ReflectorTilt: [main, sub] tilt angles
• RemeshReflectors: true/false (re-mesh imported surfaces for better solver accuracy)

Coordinate System Behavior

customDualReflectors preserves the coordinate system of the data you assign. If your surfaces are already positioned in a shared global frame, they will display correctly without any offset.

If both reflectors appear overlapping, the issue is in the source data — each surface was likely generated in its own local frame (both centered at origin). In that case, use ReflectorOffset to apply the correct relative positioning:

% Surfaces generated independently (both at local origin)
cdr = customDualReflectors;
cdr.MainReflector = mainPoints;
cdr.SubReflector = subPoints;

% ReflectorOffset is ADDITIVE — shifts each surface from its current position
cdr.ReflectorOffset = [0 0 0; 0 0 0.3];   % shift sub 0.3m above main

If surfaces are already in global coordinates (correct relative positions), do NOT apply ReflectorOffset — coordinates are used as-is.

Alternative: installedAntenna (Non-Reflector Structures)

If your custom geometry is an electrically large scattering structure (e.g., vehicle body, aircraft fuselage) rather than a traditional reflector, use installedAntenna instead (see matlab-analyze-installed-antenna):

ant = installedAntenna;
ant.Platform = platform(FileName="vehicle_body.stl", Units="m");
ant.Element = dipole(Length=0.15, Width=0.015);
ant.ElementPosition = [x y z];    % meters — controls antenna placement
figure; show(ant);
figure; pattern(ant, freq);

Use installedAntenna when:

• The structure is not shaped to focus energy (not a dish/reflector)
• You need to study antenna placement on a large platform
• You want MoM-PO or FMM solvers for installed performance

Workflow 7: Reflector Calculator (Gaussian-Beam Analysis)

reflectorCalculator (R2026a) provides fast analytical design using Gaussian-beam methods -- no full-wave solve required. Computes efficiency, gain, beamwidth, and sidelobe level instantly.

See references/reflectorCalculator.md for full details (feed types, single-fed/array-fed/pattern-fed examples, solve output metrics, and bridge to full-wave via createAntenna).

Quick usage:

freq = 12e9;
rc = reflectorCalculator;
rc.Diameter = 1;
rc.FocalLength = 0.9;
rc.ClearanceHeight = 0.1;
rc.FeedType = "singlefed";
rc.RadiatingElement = "horn";
s = solve(rc, freq);           % returns 18-metric table instantly
ant = createAntenna(rc, freq); % bridge to customDualReflectors for full-wave

When to use: Trade studies, sizing, feed selection. Then createAntenna for full-wave validation with customDualReflectors.

Solver Selection

rp.SolverType = "MoM-PO";      % Hybrid (default for parabolic)
rp.SolverType = "PO";          % Physical optics only (fastest)
rp.SolverType = "FMM";         % Fast multipole method

Note: reflectorCorner and reflectorCylindrical do NOT have a SolverType property -- they always use MoM.

f/D Ratio Design Guide

The focal-length-to-diameter ratio controls the tradeoff between spillover and illumination efficiency.

Optimal f/D: Match feed -10 dB beamwidth to dish subtended angle. Use thetaEdge = 2*atand(1/(4*fOverD)).

Feed Offset and Tilt

% Beam squint via feed offset (small offsets only -- large offsets cause coma)
rp.FeedOffset = [0.02 0 0];   % 20mm lateral offset
figure; pattern(rp, freq);

% Mechanical steering via tilt
rp.Tilt = 30;
rp.TiltAxis = [0 1 0];   % 30 deg about Y-axis
figure; pattern(rp, freq);

For significant beam steering, use offset reflector configurations (cassegrainOffset/gregorianOffset) rather than feed offset.

Analysis Functions

All standard Antenna Toolbox analysis functions work on reflector objects: pattern, patternAzimuth, patternElevation, beamwidth, impedance, sparameters, axialRatio, rfplot. Use memoryEstimate(rp, freq) before running large analyses.

Mesh coarsening for substrate-backed exciters: After design(), apply explicit mesh before analysis:

mesh(ant, MaxEdgeLength=lambda/8);

Interpolation sweep for faster frequency sweeps: When RF Toolbox is available and the exciter has a substrate, use:

try
    spar = sparameters(rp, freqRange, SweepOption="interp");
catch
    spar = sparameters(rp, freqRange);
end

Memory and Performance

• < 5 lambda:** MoM feasible. **5-50 lambda:** MoM-PO (default). **> 50 lambda: PO or FMM.
• Dual-reflector systems require more memory than single-dish.

Design Rules of Thumb

MATLAB Coding Standards

• Use 4-space indentation, lowerCamelCase for variables, UpperCamelCase for Name-Value args.
• Use "double quotes" for strings. Use fprintf for formatted numerical output.
• Do not add titles to Antenna Toolbox plots (show, pattern, impedance, returnLoss, rfplot). Do add titles to manual plot() figures.
• Show all plots in separate figures. Include units in all output.

Guidelines

• Always set Exciter before design() -- design() only takes two arguments for reflectors.
• Default feeds: hornConical for parabolic/dual-reflector; dipole for corner/cylindrical. cavity is NOT valid -- it will error.
• Keyword mapping: "dish"/"satellite" → reflectorParabolic; "no blockage"/"offset" → cassegrainOffset/gregorianOffset; "corner reflector" → reflectorCorner (90 deg default).
• Use MoM-PO as default solver for parabolic/spherical. reflectorCorner and reflectorCylindrical always use MoM (no SolverType).
• Report f/D ratio and aperture size in wavelengths. Warn about memory for dishes > 50 lambda.
• For trade studies, use reflectorCalculator first, then createAntenna for full-wave.
• For custom STL reflectors, use stlread + customDualReflectors (only MainReflector required). To optimize feed position, vary FeedOffset with SADEA. If the STL is a scattering platform, use installedAntenna instead.

Copyright 2026 The MathWorks, Inc.