PhasedArrays

CircularArray

Circular aperture array with support for various lattice types.

Fields

• plane::String: The Cartesian plane in which the circular aperture lies ("xy", "xz", or "yz").
• R::Float64: Radius of the circular aperture in meters.
• N_elements::Int64: Number of antenna elements in the array.
• lattice::LatticeType: Lattice geometry used for placing elements (e.g., Rectangular).
• coordinates::Matrix{Float64}: A 3×N matrix of element coordinates in 3D space.
• weights::Vector{ComplexF64}: Excitation weights applied to each element.
• element_pattern::ElementPattern: Radiation pattern model of each element.

Description

The CircularArray type represents a 2D array of antenna elements placed within a circular aperture of radius R, lying in the specified Cartesian plane. The layout of elements is controlled by the chosen lattice geometry (currently, only Rectangular is supported). This array type supports arbitrary excitation weights and element radiation patterns.

CircularArray(plane::String, R::Float64, lattice::LatticeType, args...; kwargs...)

Construct a circular array of elements within a radius R in the specified Cartesian plane using the specified lattice type.

Arguments

• plane: Plane in which the array lies ("xy", "xz", or "yz").
• R: Radius of the circular aperture (in meters).
• lattice: Lattice type used for element placement (currently only Rectangular is supported).
• args..., kwargs...: Passed to the specific lattice constructor (e.g., inter-element spacing, weights, element pattern).

Returns

A CircularArray with coordinates generated based on the chosen lattice type.

Example

f = 3e9
λ = 3e8 / f
array = CircularArray("xy", 5λ, Rectangular, 0.5λ, 0.5λ)

RingArray(plane::String, radius, N_elements; weights=nothing, pattern=IsotropicPattern('θ'))

Construct a circular antenna array with N_elements elements equally spaced on a ring of radius radius in the specified plane.

Arguments

• plane: The Cartesian plane in which the ring lies ("xy", "xz", or "yz").
• radius: Radius of the ring in meters.
• N_elements: Number of antenna elements placed uniformly on the ring.
• weights (optional): Excitation weights for each element; defaults to uniform weights (1/N).
• pattern (optional): Element radiation pattern; defaults to an isotropic θ-directed pattern.

Returns

A RingArray instance with 3D element coordinates arranged around the origin.

Example

using PhasedArrays
f = 5e9
λ = 3e8/f
ra = RingArray("xy", λ, 8)

RingArray

Circular (ring) array of antenna elements in a specified Cartesian plane.

Fields

• plane::String: The plane in which the ring lies. Must be "xy", "xz", or "yz".
• radius::Float64: Radius of the ring in meters.
• N_elements::Int64: Number of equally spaced elements along the ring.
• coordinates::Matrix{Float64}: A 3×N matrix of element coordinates in 3D space.
• weights: Complex excitation weights for each element (e.g., a vector of ComplexF64 values).
• element_pattern::ElementPattern: Radiation pattern model for the array elements (e.g., isotropic or directional).

Description

The RingArray type defines a circular array with N_elements evenly spaced antennas placed on a ring of radius radius in the specified plane. It supports arbitrary excitation weights and customizable element radiation patterns.

ULA(axis::Char, N::Int, dist::Float64; weights=nothing, pattern=IsotropicPattern('θ'))

Construct a Uniform Linear Array along the given axis ('x', 'y', or 'z') with N elements spaced dist meters apart.

Weights and element pattern are optional; defaults are uniform weighting and an isotropic θ-directed pattern.

ULA

Uniform Linear Array (ULA) of antenna elements.

Fields

• axis::Char: The axis along which the array is aligned ('x', 'y', or 'z').
• N_elements::Int64: Number of antenna elements in the array.
• dist::Float64: Inter-element spacing in meters.
• coordinates::Matrix{Float64}: A 3×N matrix of element coordinates in 3D space.
• weights: Complex excitation weights for each element (e.g., a vector of ComplexF64 values).
• element_pattern::ElementPattern: Radiation pattern model for the array elements (e.g., isotropic or custom pattern).

Description

The ULA type defines a uniform linear antenna array with equally spaced elements aligned along a specified Cartesian axis. The array supports arbitrary excitation weights and element radiation patterns.

Example use:

using PhasedArrays
f = 3e9
λ = 3e8/f
d = 0.5*λ
N = 5
ula = ULA('x',N,d)

URA(plane::String, N1, N2, d1, d2; weights=nothing, pattern=IsotropicPattern('θ'))

Construct a Uniform Rectangular Array (URA) with N1 × N2 elements spaced by d1 and d2 meters along the specified plane.

Arguments

• plane: The plane in which the array is placed. Must be "xy", "xz", or "yz".
• N1: Number of elements along the first axis of the chosen plane.
• N2: Number of elements along the second axis of the chosen plane.
• d1: Spacing along the first axis (in meters).
• d2: Spacing along the second axis (in meters).
• weights (optional): Excitation weights; defaults to uniform weights (1/N).
• pattern (optional): Element radiation pattern; defaults to isotropic pattern in the θ-direction.

Returns

A URA instance with 3D element coordinates centered around the origin.

Example

using PhasedArrays
f = 10e9
λ = 3e8/f
ura = URA("xy", 4, 4, 0.5λ, 0.5λ)

URA

Uniform Rectangular Array (URA) of antenna elements.

Fields

• plane::String: The Cartesian plane in which the array lies. Must be "xy", "xz", or "yz".
• N1::Int64: Number of elements along the first axis of the plane.
• N2::Int64: Number of elements along the second axis of the plane.
• d1::Float64: Element spacing along the first axis (in meters).
• d2::Float64: Element spacing along the second axis (in meters).
• weights: Complex excitation weights for each element (e.g., a vector of ComplexF64 values).
• element_pattern::ElementPattern: Radiation pattern of the element.

Description

The URA type represents a uniform rectangular antenna array, constructed in one of the three primary Cartesian planes. It supports arbitrary element weights and customizable radiation patterns.

Example use:

using PhasedArrays
f = 3e9
λ = 3e8/f
dx = 0.5*λ
dy = 0.25*λ
N = 5
ura = URA("xy",N,N,dx,dy)

HansenWoodyardArray(axis::Char, N::Int, freq::Float64) -> ULA

Constructs a Hansen-Woodyard endfire linear array along the specified axis.

Arguments

• axis: Array orientation; must be one of 'x', 'y', or 'z'.
• N: Number of antenna elements.
• freq: Operating frequency in Hz.

Returns

A ULA object with Hansen-Woodyard spacing and weights that steer the beam toward the endfire direction.

Notes

• Spacing is set to λ/2 * (1 - 1/N) for enhanced endfire directivity.
• The beam is steered to:
  • θ=90°, ϕ=0° for 'x'-axis
  • θ=90°, ϕ=90° for 'y'-axis
  • θ=0° for 'z'-axis

Example

array = HansenWoodyardArray('y', 10, 3e9)

Radial_bartlett_hann_window(r::Float64)

Returns Bartlett-Hann window evaluated at normalized radius r.

Hybrid taper with smoother roll-off and moderate sidelobe control.

apply_radial_taper!(array::URA, taper_fun::Function, n::Int)

Applies a radial taper to the weights of a URA array in-place.

Arguments

• array: A URA (Uniform Rectangular Array) whose weights will be modified.
• taper_fun: A function mapping normalized radius ∈ [0, 1] to a taper value.
• n: Number of outer radial rings (based on unique distance levels) to suppress fully (i.e., taper to zero).

Behavior

• Computes distance of each element from array center.
• Applies taper based on normalized radius r/r_max, where r_max is the distance to the n-th inner ring.
• Weights are multiplied by the taper and normalized.

Example

apply_radial_taper!(ura, radial_hann_window, 1)

apply_taper_2D!(array::URA, taper::Function, axis::Symbol)

Applies a 2D tapering function (with separable kernels) to the weights of a uniform rectangular array (URA).

Arguments

• array: A URA instance whose weights will be modified in-place.
• taper: A function that takes an integer N and returns a vector of length N representing the taper weights along one dimension.
• axis: Specifies which dimensions to apply the taper on.
  • :dim1 applies taper along the first axis.
  • :dim2 applies taper along the second axis.
  • :both applies same taper on both axes.

Behavior

The function constructs a 2D taper weight matrix by taking the outer product of the taper vectors along each dimension. It multiplies the existing weights element-wise by this taper matrix and then normalizes the resulting weights so that the sum of their absolute values is 1.

Notes

• The weights field of array is updated in-place.
• The function assumes the weights vector can be reshaped into (N1, N2), where N1 and N2 are the array dimensions.

Example

tukey = N -> linear_tukey_window(N, 0.5)  # Example taper function
apply_taper_2D!(ura, tukey, :both)

flattop(HalfWidth)

Returns a function u -> 1 or 0, representing a flat-top beam pattern of given half-width (in degrees).

Arguments

• HalfWidth: Angular half-width of the flat region in degrees.

Returns

Function defined on directional cosine u = cos(θ), with 1 inside the main lobe and 0 outside.

gaussian_pattern(σ)

Returns a Gaussian-shaped pattern in the directional cosine domain.

Arguments

• σ: Standard deviation controlling the width of the main lobe.

Returns

A function u -> exp(-u^2 / (2σ^2)) for smooth, bell-shaped beam shaping.

least_squares_synthesis(N, d, λ, Bd; θrange=0.0:0.1:180.0) -> Vector{ComplexF64}

Computes array weights using least-squares pattern synthesis.

Arguments

• N: Number of elements.
• d: Element spacing.
• λ: Wavelength.
• Bd: Desired pattern as a function of u = cos(θ).
• θrange: Angle range in degrees over which the pattern is matched (default: 0.0:0.1:180.0).

Returns

Weight vector that minimizes the squared error between the desired and actual beam pattern.

linear_bartlett_hann_window(N)

Returns a normalized Bartlett-Hann window of length N. Normalized to peak 1.

linear_blackman_harris_window(N)

Returns a normalized Blackman-Harris window of length N.

High sidelobe suppression, typically better than standard Blackman. Normalized to 1.

linear_blackman_window(N)

Returns a normalized Blackman window of length N.

Provides good sidelobe suppression at the cost of wider mainlobe. Normalized to peak 1.

linear_dolph_cheb_window(N, R, d, λ)

Computes Dolph-Chebyshev window of length N for a ULA with element spacing d and wavelength λ.

Arguments

• R: Desired sidelobe level in dB (e.g. -20).
• d: Element spacing in meters.
• λ: Wavelength in meters.

Returns a real-valued weight vector normalized to unit gain in the endfire direction.

linear_gaussian_window(N, σ)

Returns a normalized Gaussian window of length N with spread parameter σ.

smaller σ results in wider mainlobe and lower sidelobes. Normalized to peak 1.

linear_hamming_window(N)

Returns a normalized Hamming window of length N.

Used to taper array weights to reduce sidelobe levels. The window is normalized to have maximum value 1.

linear_hann_window(N)

Returns a normalized Hann window of length N.

A cosine-based taper that reduces sidelobes. Maximum value is normalized to 1.

linear_kaiser_window(N, β)

Returns a normalized Kaiser window of length N with shape parameter β.

Useful for controlling sidelobe levels via β. Normalized to peak 1.

linear_taylor_window(N, R, n̄, d, λ)

Generates a Taylor window with N elements, sidelobe level R (dB), and n̄ equal-level sidelobes.

Arguments

• R: Desired sidelobe level in dB (for example -20).
• n̄: Number of equal sidelobes + 1. Must be between 1 and N–1.
• d: Element spacing in meters.
• λ: Wavelength in meters.

Returns a real-valued taper optimized for sidelobe control in antenna arrays.

linear_tukey_window(N, α)

Returns a normalized Tukey (tapered cosine) window of length N with tapering parameter α ∈ [0, 1].

• α = 0 → rectangular window
• α = 1 → Hann window

Normalized to maximum value 1.

radial_blackman_harris_window(r::Float64)

Returns Blackman-Harris window at normalized radius r.

radial_blackman_window(r::Float64)

Blackman window evaluated at normalized radius r.

Provides stronger sidelobe suppression than Hann or Hamming.

radial_hamming_window(r::Float64)

Returns the value of a Hamming window at normalized radius r.

Commonly used for moderate sidelobe suppression in array tapering.

radial_hann_window(r::Float64)

Returns the value of a Hann window evaluated at normalized radius r ∈ [0, 1].

Used in radial tapers for circular or rectangular arrays.

radial_kaiser_window(r::Float64, β::Float64)

Returns Kaiser window value at normalized radius r, with shape parameter β.

radial_tukey_window(r::Float64, α::Float64)

Returns Tukey (tapered cosine) window value at normalized radius r, with tapering parameter α ∈ [0, 1].

• α = 0 gives rectangular window
• α = 1 gives Hann window

raised_cosine(HalfWidth, rolloff)

Returns a function representing a raised-cosine-shaped beam pattern in the directional cosine domain.

Arguments

• HalfWidth: Half-width of the main lobe (in degrees).
• rolloff: Transition width (in directional cosine units).

Returns

A smooth beam pattern tapering from 1 to 0 around the edge of the flat region.

sinc_pattern(scale)

Returns a sinc-based beam shaping function.

Arguments

• scale: Controls the lobe spacing and width in the directional cosine domain.

Returns

A function u -> sinc(scale * u), centered at broadside.

woodward_sampling(N, d, λ, goalPattern) -> Vector{ComplexF64}

Computes array weights using Woodward (spatial) sampling method.

Arguments

• N: Number of elements.
• d: Element spacing (in meters).
• λ: Wavelength (in meters).
• goalPattern: A function u -> desired pattern, where u = cos(θ) is the directional cosine.

Returns

Complex weight vector that approximates the desired pattern over sampled points.