phased-array-systems

Phased array antenna system design, optimization, and performance visualization for wireless communications and radar applications.

Documentation | Live Demo | Getting Started | API Reference

Why phased-array-systems?

• Model-Based Workflow: MBSE/MDAO approach from requirements through optimized designs
• Requirements-Driven: Every evaluation produces pass/fail with margins and traceability
• Trade-Space Exploration: DOE generation and Pareto analysis for systematic design exploration
• Design Optimization: Scipy-based solvers (DE, dual annealing, L-BFGS-B) with constraint support
• Comprehensive Models: Comms link budget, radar detection, RF cascade, digital beamformer, reliability
• Dual Application: Supports both communications link budgets and radar detection scenarios
• Reproducible: Config-driven workflow with seed control and version stamping

Workflow

Config (YAML/JSON) → Architecture + Scenario → DOE Generation → Batch Evaluation
       ↓                                                              ↓
  Requirements ───────────────────────────────────────────→ Verification
                                                                   ↓
                                                           Pareto Extraction
                                                                   ↓
              Reports ← Visualization ← Optimization ←────────────┘

Features

• Requirements as first-class objects: Every run produces pass/fail + margins with traceability
• Trade-space exploration: DOE + Pareto optimization over single-point designs
• Design optimization: Scipy solvers with weighted multi-objective scalarization and constraint penalties
• Communications & Radar: Link budget analysis and radar detection modeling
• RF cascade analysis: Friis noise figure, IIP3, SFDR, MDS for cascaded receiver chains
• Digital beamformer models: ADC/DAC characterization, bandwidth budgets, scheduling
• TRM reliability: MTBF, availability, graceful degradation with failed elements
• Flat metrics dictionary: All models return consistent dict[str, float] for interchange
• Config-driven reproducibility: Stable case IDs, seed control, version stamping
• CLI and Python API: Use from command line or integrate into scripts

Installation

pip install phased-array-systems

# Development dependencies
pip install phased-array-systems[dev]

# Visualization extras
pip install phased-array-systems[plotting]

Quick Start

Single Case Evaluation

from phased_array_systems import Architecture, ArrayConfig, RFChainConfig
from phased_array_systems import CommsLinkScenario, evaluate_case

# Define architecture
arch = Architecture(
    array=ArrayConfig(nx=8, ny=8, dx_lambda=0.5, dy_lambda=0.5),
    rf=RFChainConfig(tx_power_w_per_elem=1.0, pa_efficiency=0.3),
)

# Define scenario
scenario = CommsLinkScenario(
    freq_hz=10e9,
    bandwidth_hz=10e6,
    range_m=100e3,
    required_snr_db=10.0,
)

# Evaluate
metrics = evaluate_case(arch, scenario)
print(f"EIRP: {metrics['eirp_dbw']:.1f} dBW")
print(f"Link Margin: {metrics['link_margin_db']:.1f} dB")

DOE Trade Study

from phased_array_systems import DesignSpace, generate_doe, BatchRunner, extract_pareto

# Define design space
space = (
    DesignSpace()
    .add_variable("array.nx", "int", low=4, high=16)
    .add_variable("array.ny", "int", low=4, high=16)
    .add_variable("rf.tx_power_w_per_elem", "float", low=0.5, high=3.0)
)

# Generate DOE
doe = generate_doe(space, method="lhs", n_samples=100, seed=42)

# Run batch evaluation
runner = BatchRunner(scenario)
results = runner.run(doe)

# Extract Pareto frontier
pareto = extract_pareto(results, [
    ("cost_usd", "minimize"),
    ("eirp_dbw", "maximize"),
])

Design Optimization

from phased_array_systems import optimize_design, DesignSpace, CommsLinkScenario

scenario = CommsLinkScenario(
    freq_hz=10e9, bandwidth_hz=10e6, range_m=100e3, required_snr_db=10.0,
)
space = (
    DesignSpace()
    .add_variable("array.nx", "categorical", values=[4, 8, 16])
    .add_variable("array.ny", "categorical", values=[4, 8, 16])
    .add_variable("rf.tx_power_w_per_elem", "float", low=0.5, high=3.0)
)

result = optimize_design(
    space=space, scenario=scenario,
    objective="eirp_dbw", sense="maximize", method="de", seed=42,
)
print(f"Best EIRP: {result.best_metrics['eirp_dbw']:.1f} dBW")

Examples

See the examples/ directory:

• 01_comms_single_case.py - Single case evaluation
• 02_comms_doe_trade.py - Full DOE trade study workflow
• 03_radar_detection_trade.py - Radar detection analysis and trade study
• 05_optimization.py - Design optimization with constraint handling

Tutorial Notebook

Try the interactive tutorial in Google Colab!

Package Structure

phased_array_systems/
├── architecture/     # Array, RF chain, cost configurations
├── scenarios/        # CommsLinkScenario, RadarDetectionScenario
├── requirements/     # Requirement definitions and verification
├── models/
│   ├── antenna/      # Phased array adapter and metrics
│   ├── comms/        # Link budget, propagation models
│   ├── radar/        # Radar equation, detection, integration
│   ├── rf/           # Cascaded RF chain analysis (NF, IIP3, SFDR)
│   ├── digital/      # ADC/DAC, bandwidth, scheduling models
│   └── swapc/        # Power and cost models
├── trades/           # DOE, batch runner, Pareto analysis
├── viz/              # Plotting utilities
└── io/               # Config loading, results export

Development

# Clone the repository
git clone https://github.com/jman4162/phased-array-systems.git
cd phased-array-systems

# Install in development mode
pip install -e ".[dev]"

# Run tests
pytest tests/ -v

# Run linting
ruff check .

CLI

# Single case evaluation
pasys run config.yaml

# DOE batch study
pasys doe config.yaml -n 100 --method lhs

# Design optimization
pasys optimize config.yaml --objective eirp_dbw --sense maximize

# Extract Pareto frontier
pasys pareto results.parquet -x cost_usd -y eirp_dbw --plot

# Generate report
pasys report results.parquet --format html

Documentation

Full documentation is available at jman4162.github.io/phased-array-systems:

• Getting Started - Installation and quickstart
• User Guide - Detailed usage guides
• Tutorials - Step-by-step walkthroughs
• API Reference - Complete API documentation
• Theory - Background equations and theory

Interactive Demo

Try the interactive Streamlit demo app featuring:

• Single Case Calculator: Evaluate array configurations with real-time metrics
• Trade Study: DOE generation with Pareto optimization
• RF Cascade Analyzer: Cascaded noise figure, gain, and linearity analysis
• Radar Detection: SNR calculation and detection probability curves

Run locally:

cd app
pip install -r requirements.txt
streamlit run streamlit_app.py

Citation

If you use phased-array-systems in academic work, please cite:

@software{phased_array_systems,
  title = {phased-array-systems: Phased Array Antenna System Design and Optimization},
  author = {John Hodge},
  year = {2026},
  url = {https://github.com/jman4162/phased-array-systems}
}

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

MIT License - see LICENSE for details.