---

name: matlab-design-antenna description: > Design antennas, arrays, and PCB antennas using MATLAB Antenna Toolbox. Covers catalog antenna design and pattern analysis, custom antenna construction (customAntenna + shape.), PCB antenna design (pcbStack + antenna.), finite and infinite array design, AI-accelerated design exploration (AIAntenna, patternFromAI), and optimization (SADEA/TR-SADEA). Use when the user wants to design, create, model, analyze, optimize, or fabricate an antenna or array. license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md metadata: author: MathWorks version: "2.0"

Antenna and Array Design

Design, analyze, and optimize antennas and arrays using MATLAB Antenna Toolbox — from catalog elements to custom shapes, PCB fabrication, AI-accelerated exploration, and surrogate-assisted optimization.

When to Use

Catalog antenna design

• Design a standard antenna at a frequency (dipole, patch, horn, helix, Yagi, etc.)
• Analyze radiation pattern (3D, 2D cuts, polarization, beamwidth, sidelobes)
• Compute impedance, S-parameters, or return loss
• Set substrate material before design
• Compare patterns across antennas or frequencies

Custom antenna design

• Build non-catalog antennas from geometric primitives (shape.*)
• Construct 3D structures (waveguides, horns, cavities) via extrusion
• Import STL/CAD geometry and add feeds
• Configure delta-gap or probe feeds on custom structures

PCB antenna design

• Build multi-layer PCB antenna stackups (pcbStack)
• Create custom metal patterns with boolean operations (antenna.*)
• Configure probe, edge, or aperture-coupled feeds
• Export Gerber files for fabrication
• Convert catalog antennas to pcbStack

Array design

• Design linear, rectangular, circular, or conformal arrays
• Beam steering, amplitude tapering, grating lobe analysis
• Infinite array analysis (scan impedance, scan blindness, Floquet BC)
• MIMO/handset multi-antenna isolation and ECC
• Mutual coupling analysis

AI-accelerated design

• Rapid parametric sweeps with AIAntenna surrogate models
• Reconstruct 3D patterns from 2D slices (patternFromAI)
• Full-factorial design space exploration
• Export AI-tuned designs for full-wave validation

Optimization

• Optimize antenna dimensions for gain, bandwidth, SLL, or F/B ratio
• Built-in optimize() for catalog antennas with string objectives
• SADEA/TR-SADEA with custom evaluation functions for pcbStack/customAntenna
• Geometric constraints (linear and nonlinear)

When NOT to Use

• Reflector antennas, reflectarrays, installed antennas, or RCS — use matlab-analyze-antenna-structures
• Impedance matching networks, measuredAntenna, RF propagation, or SAR — use matlab-integrate-antenna

Must-Follow Rules

Catalog Antennas

• Prefer catalog antennas over customAntenna — use customAntenna only when no catalog antenna or system antenna matches the requested geometry
• Always use design() unless user provides explicit dimensions or antenna lacks design() support
• Set substrate BEFORE design() — design() adapts dimensions to the substrate
• Mesh at lambda/8 for substrate antennas after design() and before analysis
• Use SweepOption="interp" only with sparameters (not impedance) on substrate antennas

Custom Antennas (customAntenna)

• Use shape.* namespace (NOT antenna.*) with customAntenna
• All dimensions in meters — not mm or cm
• Always define a feed — customAntenna without createFeed cannot be analyzed
• Feed must be at a geometric discontinuity — not middle of flat plate
• Extrude first, rotate second — extrudeLinear requires XY-plane shapes
• Shapes are handle objects — use copy() to preserve before transforming

PCB Antennas (pcbStack)

• Set BoardThickness BEFORE Layers — otherwise dielectric gets wrong thickness
• Use antenna.* namespace (NOT shape.*) for pcbStack metal patterns
• Layer indices are cell array positions — in {M,D,M}, ground is index 3
• design() does not work on pcbStack — design catalog antenna first, then convert
• Gerber Filename must be char ('single quotes'), not "string"

Arrays

• Always pass element as 3rd argument to design(arr, freq, element) — omitting resets to dipole
• AmplitudeTaper for rectangularArray is column-major order
• Infinite arrays have no NumElements/ElementSpacing — unit cell = ground plane size
• Use phaseShift() for finite steering, ScanAzimuth/ScanElevation for infinite

AI Workflows

• Use design(..., ForAI=true) — direct em.ai.AIAntenna() constructor not supported
• Only 12 antenna types have pretrained AI models
• Input slices for patternFromAI must be row vectors with 1-degree integer spacing
• Always validate AI predictions with exportAntenna + full-wave simulation

Optimization

• Start from design() to get physically reasonable initial dimensions
• Tier 1 bounds: cell array {lb1,lb2; ub1,ub2}, Tier 2 bounds: numeric matrix [lb;ub]
• Negate metrics for maximization in custom evaluation functions (SADEA minimizes)
• Wrap custom eval in try/catch — return 1e6 penalty for invalid geometry
• Set FrequencyRange explicitly for bandwidth optimization (default +/-5% may not match target)

Workflow

1. Catalog Antenna Design

1. Parse — Identify antenna type, frequency, substrate, constraints
2. Create — Set substrate (if any), call design(ant, freq)
3. Mesh — mesh(ant, MaxEdgeLength=lambda/8) for substrate antennas
4. Analyze — Impedance, S-parameters, 3D pattern, 2D cuts with polarpattern
5. Report — Key metrics with units (Z, BW, gain, beamwidth)

2. Custom Antenna Design

1. Build shapes — shape.* primitives (Rectangle, Box, Cylinder, Polygon)
2. Transform — translate, rotate, scale (handle objects — copy first)
3. Combine — Boolean: + (union), - (subtract), & (intersect)
4. Extrude — extrudeLinear (taper) or extrudeRotate (revolution)
5. Assemble — customAntenna(Shape=...), createFeed(ant, loc, numEdges)
6. Mesh & analyze — mesh(ant, MaxEdgeLength=lambda/6), impedance, pattern

3. PCB Antenna Design

1. Define stackup — pcbStack, set BoardThickness FIRST, then Layers
2. Create patterns — antenna.* shapes with boolean operations
3. Configure feed — FeedLocations = [x, y, sigLayer, gndLayer]
4. Analyze — S-parameters (with SweepOption="interp"), pattern
5. Export — gerberWrite with PCBWriter, PCBServices, PCBConnectors

4. Array Design

1. Build array — Set type, size/elements, then design(arr, freq, element)
2. Steer — phaseShift() finite, ScanAzimuth/ScanElevation infinite
3. Taper — AmplitudeTaper (column-major for rectangular)
4. Analyze — arrayFactor (fast) → patternMultiply → pattern (accurate)
5. Coupling — sparameters, correlation, isolation metrics

5. AI-Accelerated Design

1. Create — design(ant, freq, ForAI=true) for supported types
2. Explore — tunableRanges, parametric sweep, resonantFrequency, bandwidth
3. Validate — exportAntenna + full-wave impedance/pattern
4. Reconstruct — patternFromAI from 2D slices (row vectors, 1-deg spacing)

6. Optimization

1. Formulate — Choose objective, design variables, bounds, constraints
2. Select tier — Catalog + built-in objective → Tier 1; else → Tier 2
3. Run — optimize() or OptimizerSADEA/OptimizerTRSADEA
4. Extract — getBestMemberData, showConvergenceTrend, isConverged
5. Validate — Full analysis sweep on optimized design

Key Classes

| Class | Purpose | |-------|---------| | design() | Scale catalog antennas to frequency | | customAntenna | Arbitrary geometry from shape.* primitives | | pcbStack | Multi-layer PCB antenna with antenna.* shapes | | linearArray / rectangularArray / circularArray | Finite arrays | | conformalArray | Arbitrary element positions (MIMO, custom) | | infiniteArray | Unit cell with Floquet BC | | em.ai.AIAntenna | Pretrained surrogate for instant prediction | | patternFromAI | 3D pattern from 2D slices | | optimize() | Built-in SADEA for catalog antennas | | OptimizerSADEA / OptimizerTRSADEA | Custom optimization |

Conventions

Coding Standards

• 4-space indentation, lowerCamelCase variables, UpperCamelCase Name-Value args
• "double quotes" for strings (except Gerber Filename which requires 'char')
• fprintf for formatted output
• Do not add titles to Antenna Toolbox plots (pattern, show, rfplot, impedance)
• Do add titles to manual plot figures and TitleTop to polarpattern
• Show all plots in separate figures. Include units in all output.
• Use physconst("LightSpeed") — never hardcode 3e8

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 catalog antennas (types, design(), substrate, patterns) | references/catalog-antennas.md | | Building custom antennas (shape.*, extrusion, feeds, substrate) | references/custom-antennas.md | | Designing PCB antennas (pcbStack, layers, boolean, Gerber) | references/pcb-antennas.md | | Designing arrays (finite, infinite, steering, taper, MIMO) | references/arrays.md | | AI design exploration (AIAntenna, patternFromAI, surrogates) | references/ai-antenna-workflows.md | | Optimizing antennas (SADEA, bounds, constraints, custom eval) | references/optimization.md |

---

Copyright 2026 The MathWorks, Inc.