Internals

local_backend(backend) -> AbstractExecutionBackend

The per-process compute backend: the wrapped inner for a distribution wrapper, else the backend itself.

is_distributed(backend) — true if backend splits work across processes/ranks.

resolve_backend(backend) -> AbstractExecutionBackend

Resolve AutoBackend to a concrete local backend instance; all other backends are returned as-is. The AutoBackend method is defined in the parent FlowFieldSpectra module so it can detect a loaded threading extension via Base.get_extension.

physical_wavenumbers(grid::AbstractCartesianGrid, ms) -> NTuple{D,<:AbstractRange}

Physical wavenumber ranges for a Cartesian grid at spectral resolution ms.

spatial_dims(grid) -> Int

Number of physical/spatial (transformed) dimensions D. For a scattered grid this is the ambient dimension (number of coordinate axes), which can exceed ndims_spatial.

ndims_spatial(grid) -> Int

Number of leading array dimensions a field on this grid consumes: D for a tensor-product Cartesian grid or a structured spherical grid, and 1 for any scattered/point-cloud grid (the single point axis). Every array dimension after these is a batch dimension.

spatial_size(grid) -> NTuple

Sizes of the leading spatial array dimensions: (N_1, …, N_D) for a tensor-product Cartesian grid, (Nθ, Nφ) for a structured spherical grid, and (N,) for a scattered grid.

npoints(grid) -> Int

Total number of spatial sample points: prod(spatial_size(grid)) (∏ N_d for a tensor grid, N for a scattered grid).

spatial_shape(prob) — the leading spatial array sizes (N_1, …).

batch_shape(prob) — the trailing batch sizes (() if none).

n_batch(prob) — number of trailing batch dims.

batch_length(prob) — total batch slices, prod(batch) (1 if no batch axes).

coeff_output_size(spectral::Tuple, prob) -> NTuple

Shape of the coefficient array: (spectral…, batch…).

coeff_eltype(grid) -> Type

Complex coefficient element type for a grid (Complex{FT}).

stack_fields(fields::Tuple) -> AbstractArray

Convenience for the multi-field call form: stack equal-shaped field arrays along a new trailing batch axis ((spatial…, batch…, NU)). This materializes a combined array — pass a single (spatial…, batch…) array to avoid the copy.

window_function(win::AbstractWindow, n::Integer, ::Type{T}=Float64) -> Vector{T}

Allocate and return the length-n taper win.

window_function!(w::AbstractVector, win::AbstractWindow) -> w

Fill w (length n) in place with the taper win.

window_correction(w::AbstractVector) -> (S1, S2)

Coherent-gain factor S1 = (Σ w)/n and power factor S2 = (Σ w²)/n. Amplitude spectra divide by S1; power/energy spectra divide by S2 to preserve variance.

detrend!(x::AbstractVector, d::AbstractDetrend) -> x

Detrend x in place according to d.

sided_factor(s::AbstractSidedness, k, kmax) -> Real

Folding multiplier. TwoSided → 1 everywhere. OneSided → 2 for interior wavenumbers, 1 at DC (k≈0) and Nyquist (k≈kmax) which have no negative-frequency partner.

LegendreTables{FT}

Precomputed, point-independent recurrence coefficients for the normalized associated Legendre functions $\bar P_\ell^m$ up to degree lmax. Built once per transform via legendre_tables; the per-point table is then filled in O(lmax²) with no sqrt calls by fill_legendre!.

legendre_tables(::Type{FT}, lmax::Int) -> LegendreTables{FT}

Precompute the recurrence coefficients up to degree lmax.

fill_legendre!(Plm::AbstractMatrix, t::LegendreTables, x, s, lmax)

Fill Plm[l+1, m+1] = \bar P_\ell^m(x) for m = 0:lmax, l = m:lmax at a single point with x = cosθ, s = sinθ, reusing the precomputed coefficients in t. Entries with l < m are left untouched (the projection never reads them).

normalized_legendre(l, m, x, s) -> FT

Single normalized associated Legendre value $\bar P_\ell^m(x)$ (m ≥ 0) computed by on-the-fly recurrence. Reference implementation used for validation; the hot path uses fill_legendre!.