Wideband Module#

The wideband module provides functions for analyzing and compensating beam squint effects in wideband phased arrays using true time delay (TTD) and hybrid phase/TTD architectures.

Beam Squint Analysis#

phased_array.compute_beam_squint(x, y, theta0_deg, phi0_deg, center_frequency, frequencies, steering_mode='phase', architecture=None, n_points=361)[source]#

Compute beam squint (pointing error) vs frequency.

Parameters:

  • x (ndarray) – Element x-positions in meters

  • y (ndarray) – Element y-positions in meters

  • theta0_deg (float) – Intended steering angle in degrees

  • phi0_deg (float) – Intended azimuth angle in degrees

  • center_frequency (float) – Center frequency in Hz (where weights are computed)

  • frequencies (ndarray) – Frequencies to evaluate in Hz

  • steering_mode (str) – ‘phase’ - phase-only steering (maximum squint) ‘ttd’ - true-time delay (no squint) ‘hybrid’ - TTD at subarray + phase at element

  • architecture (SubarrayArchitecture, optional) – Required for ‘hybrid’ mode

  • n_points (int) – Number of angle points for pattern computation

Returns:

results – ‘frequencies’ : Frequency values (Hz) ‘beam_angles’ : Actual beam pointing angle at each frequency (deg) ‘squint’ : Pointing error (deg), positive = beam moved towards broadside ‘relative_gain’ : Gain relative to center frequency (dB)

Return type:

dict

Examples

Analyze beam squint for a phase-steered array:

>>> import numpy as np
>>> import phased_array as pa
>>> wavelength = 0.03  # 10 GHz center frequency
>>> geom = pa.create_rectangular_array(16, 16, dx=0.5, dy=0.5, wavelength=wavelength)
>>> freqs = np.linspace(9e9, 11e9, 11)  # 9-11 GHz
>>> results = pa.compute_beam_squint(
...     geom.x, geom.y,
...     theta0_deg=30, phi0_deg=0,
...     center_frequency=10e9,
...     frequencies=freqs,
...     steering_mode='phase'
... )
>>> results['squint'].shape
(11,)

Compare steering modes:

>>> # Phase steering: beam squint increases with bandwidth
>>> # TTD steering: no beam squint (squint ~ 0)
>>> results_ttd = pa.compute_beam_squint(
...     geom.x, geom.y, 30, 0, 10e9, freqs, steering_mode='ttd'
... )
phased_array.analyze_instantaneous_bandwidth(x, y, theta0_deg, phi0_deg, center_frequency, squint_tolerance_deg=0.5, steering_mode='phase', architecture=None)[source]#

Analyze instantaneous bandwidth for given squint tolerance.

Parameters:

  • x (ndarray) – Element x-positions in meters

  • y (ndarray) – Element y-positions in meters

  • theta0_deg (float) – Steering angle in degrees

  • phi0_deg (float) – Azimuth angle in degrees

  • center_frequency (float) – Center frequency in Hz

  • squint_tolerance_deg (float) – Maximum acceptable beam squint in degrees

  • steering_mode (str) – ‘phase’, ‘ttd’, or ‘hybrid’

  • architecture (SubarrayArchitecture, optional) – Required for ‘hybrid’ mode

Returns:

results – ‘ibw_hz’ : Instantaneous bandwidth in Hz ‘ibw_percent’ : Bandwidth as percentage of center frequency ‘ibw_ratio’ : Bandwidth ratio (f_high / f_low)

Return type:

dict

phased_array.compute_pattern_vs_frequency(x, y, theta0_deg, phi0_deg, center_frequency, frequencies, steering_mode='phase', architecture=None, n_points=181, phi_cut_deg=None)[source]#

Compute radiation pattern at multiple frequencies.

Parameters:

  • x (ndarray) – Element x-positions in meters

  • y (ndarray) – Element y-positions in meters

  • theta0_deg (float) – Steering angle in degrees

  • phi0_deg (float) – Azimuth angle in degrees

  • center_frequency (float) – Center frequency in Hz

  • frequencies (ndarray) – Frequencies to compute patterns at

  • steering_mode (str) – ‘phase’, ‘ttd’, or ‘hybrid’

  • architecture (SubarrayArchitecture, optional) – Required for ‘hybrid’ mode

  • n_points (int) – Number of angle points

  • phi_cut_deg (float, optional) – Phi angle for cut (default: phi0_deg)

Returns:

results – ‘angles’ : Theta angles in degrees ‘frequencies’ : Frequency values ‘patterns’ : 2D array of patterns (n_freq x n_angles) in dB

Return type:

dict

True Time Delay Steering#

phased_array.steering_vector_ttd(x, y, theta0_deg, phi0_deg, frequency, c=299792458.0)[source]#

Compute true-time delay (TTD) steering vector.

TTD provides frequency-independent beam pointing by applying actual time delays rather than phase shifts.

Parameters:

  • x (ndarray) – Element x-positions in meters

  • y (ndarray) – Element y-positions in meters

  • theta0_deg (float) – Steering elevation angle in degrees (from broadside)

  • phi0_deg (float) – Steering azimuth angle in degrees

  • frequency (float) – Operating frequency in Hz

  • c (float, optional) – Speed of light in m/s (default: 299792458)

Returns:

weights – Complex steering weights with TTD phases

Return type:

ndarray

Notes

The time delay for each element is:

tau_n = (x_n * sin(theta) * cos(phi) + y_n * sin(theta) * sin(phi)) / c

The phase is: phi_n = -2 * pi * f * tau_n

This is equivalent to phase steering at the given frequency, but the key difference is that the TIME DELAY is what’s physically implemented, so the beam points correctly at all frequencies.

Examples

TTD steering for a 10 GHz array with physical positions:

>>> import numpy as np
>>> import phased_array as pa
>>> # Array positions in meters (e.g., 16x16 at half-wavelength for 10 GHz)
>>> wavelength = 0.03  # 10 GHz
>>> geom = pa.create_rectangular_array(16, 16, dx=0.5, dy=0.5, wavelength=wavelength)
>>> weights_ttd = pa.steering_vector_ttd(
...     geom.x, geom.y,
...     theta0_deg=30, phi0_deg=0,
...     frequency=10e9
... )
>>> weights_ttd.shape
(256,)

Compare TTD vs phase steering beam squint:

>>> # TTD maintains beam direction across bandwidth
>>> # Phase steering causes beam squint at off-center frequencies
>>> squint = pa.compute_beam_squint(
...     geom.x, geom.y, theta0_deg=30, phi0_deg=0,
...     center_freq=10e9, bandwidth=2e9, n_freqs=11
... )
phased_array.steering_delays_ttd(x, y, theta0_deg, phi0_deg, c=299792458.0)[source]#

Compute true-time delays for steering (frequency-independent).

Parameters:

  • x (ndarray) – Element x-positions in meters

  • y (ndarray) – Element y-positions in meters

  • theta0_deg (float) – Steering elevation angle in degrees

  • phi0_deg (float) – Steering azimuth angle in degrees

  • c (float, optional) – Speed of light in m/s

Returns:

delays – Time delays in seconds for each element

Return type:

ndarray

Hybrid Phase/TTD Steering#

phased_array.steering_vector_hybrid(geometry, architecture, theta0_deg, phi0_deg, frequency, c=299792458.0)[source]#

Compute hybrid TTD + phase steering vector.

True-time delay is applied at the subarray level (coarse steering), and phase shifters provide fine adjustment within each subarray. This is the most common architecture for wideband phased arrays.

Parameters:

  • geometry (ArrayGeometry) – Array geometry with element positions

  • architecture (SubarrayArchitecture) – Subarray partitioning

  • theta0_deg (float) – Steering elevation angle in degrees

  • phi0_deg (float) – Steering azimuth angle in degrees

  • frequency (float) – Operating frequency in Hz

  • c (float, optional) – Speed of light in m/s

Returns:

weights – Complex steering weights

Return type:

ndarray

Notes

For each element: 1. TTD is computed based on subarray center position 2. Phase shift compensates for element offset from subarray center

This reduces beam squint compared to phase-only steering, with squint now determined by subarray size rather than array size.

phased_array.compute_subarray_delays_ttd(architecture, theta0_deg, phi0_deg, c=299792458.0)[source]#

Compute TTD values for each subarray.

Parameters:

  • architecture (SubarrayArchitecture) – Subarray partitioning with center positions

  • theta0_deg (float) – Steering elevation angle in degrees

  • phi0_deg (float) – Steering azimuth angle in degrees

  • c (float, optional) – Speed of light in m/s

Returns:

delays – Time delay for each subarray in seconds (shape: n_subarrays,)

Return type:

ndarray

phased_array.compute_subarray_weights_hybrid(geometry, architecture, theta0_deg, phi0_deg, frequency, amplitude_taper=None, ttd_quantization_bits=None, phase_quantization_bits=None, c=299792458.0)[source]#

Compute hybrid TTD + phase weights with optional quantization.

Parameters:

  • geometry (ArrayGeometry) – Array geometry

  • architecture (SubarrayArchitecture) – Subarray partitioning

  • theta0_deg (float) – Steering elevation angle in degrees

  • phi0_deg (float) – Steering azimuth angle in degrees

  • frequency (float) – Operating frequency in Hz

  • amplitude_taper (ndarray, optional) – Amplitude weights for each element

  • ttd_quantization_bits (int, optional) – Bits for TTD quantization (e.g., 6 bits = 64 delay steps)

  • phase_quantization_bits (int, optional) – Bits for phase shifter quantization

  • c (float, optional) – Speed of light

Returns:

results – ‘weights’ : Complex element weights ‘subarray_delays’ : TTD value for each subarray (seconds) ‘element_phases’ : Phase shift for each element (radians)

Return type:

dict

Comparison#

phased_array.compare_steering_modes(geometry, architecture, theta0_deg, phi0_deg, center_frequency, bandwidth_percent=20.0, n_freq_points=11)[source]#

Compare beam squint for different steering modes.

Parameters:

  • geometry (ArrayGeometry) – Array geometry

  • architecture (SubarrayArchitecture) – Subarray partitioning

  • theta0_deg (float) – Steering angle in degrees

  • phi0_deg (float) – Azimuth angle in degrees

  • center_frequency (float) – Center frequency in Hz

  • bandwidth_percent (float) – Total bandwidth as percentage of center frequency

  • n_freq_points (int) – Number of frequency points to evaluate

Returns:

results – Results for each steering mode (‘phase’, ‘hybrid’, ‘ttd’)

Return type:

dict