Struct acq_result_t¶

ClassList > acq_result_t

One acquisition detection event.

• #include <acq_core.h>

Public Attributes¶

Public Attributes Documentation¶

variable chip_phase¶

double acq_result_t::chip_phase;

The code's own instantaneous phase at the hand-off instant, in chips, Dll's convention the seed a code loop wants for this hit. The same value dp_acq_build_handoff() reports as acq_handoff_t::chip_phase: the inverted lag advanced by the dwell's dilation when a carrier is set (dp_acq_set_carrier_freq_hz()). For an engine built by dp_acq_create_burst(), one chip is one template sample, so chip_phase is in template samples over code_bins: a caller at s samples per chip divides by s. The dp_burst_acq_create() wrapper forwards no carrier setter, so its hits carry no dwell advance. Appended last so positional initialisers do not shift.

variable cn0_dbhz_est¶

float acq_result_t::cn0_dbhz_est;

Estimated carrier-to-noise density (dB-Hz), backed out of test_stat via the same C/N0 <-> per-sample-amplitude-SNR relationship used to size the engine (see dp_acq_create_burst()/ dp_acq_create_continuous()). Tracks the true C/N0 while receiver AWGN dominates the CFAR noise estimate; saturates at the code's own autocorrelation-sidelobe floor once the true C/N0 exceeds what this code/geometry can resolve — a real ceiling, not a fault.

variable code_phase¶

size_t acq_result_t::code_phase;

Peak col: code phase (0 … code_bins-1).

variable doppler_bin¶

size_t acq_result_t::doppler_bin;

Peak row: Doppler bin (0 … coherent_bins-1), or, in wideband mode, a bin of the uniform grid of window_bins*coherent_bins bins (window_bins tiles of coherent_bins each) — see acq_core.h's file doc comment.

variable doppler_rate_hz_s¶

double acq_result_t::doppler_rate_hz_s;

The Doppler rate, Hz/s, of the rate hypothesis that won this hit's dwell (dp_acq_create_burst()'s rate_hypotheses); 0 without hypotheses, and 0 when the dwell's block is one or two epochs, which cannot see a rate (every hypothesis is then the same surface). A hypothesis, not a fit, and a reliable one only from a block WHOLLY inside the preamble and well above the design point. Then it names the hypothesis nearest the carrier's rate within half a spacing, doppler_rate/(n - 1) every time (validate_acq_rate_pd's reported-rate rows, N = 9, D = 10, design -13 dB, 23 dB over it: 119/119 at true rate 0, 121/121 at +R). Below that it is not: at the design point only 30% (rate 0) and 66% (+R) of the full-block hits name it, adjacent hypotheses differing by at most pi/4 of phase at the block's edges so that noise picks among neighbours; and about three hits in four come from dwells STRADDLING the preamble's edges, which often name +-R (39% of all hits at +10 dB-Hz name the nearest at true rate 0, 51% at +R). DETECTION is unaffected the surface that wins is a good one whichever neighbour it is. Treat the value as a seed, not a measurement, at the C/N0 the engine was sized for. With max_peaks > 1 one hypothesis's surface serves the whole dwell's list, so every hit of a dwell wears the winner's rate. The Doppler the hit reports is the carrier's at the middle of the dwell's block. Appended last so positional initialisers do not shift.

variable noise_est¶

float acq_result_t::noise_est;

CFAR noise estimate over [noise_lo, noise_hi].

variable peak_mag¶

float acq_result_t::peak_mag;

max |R[i,j]| over the surface (linear).

variable samples_consumed¶

uint64_t acq_result_t::samples_consumed;

st->samples_consumed at the exact moment this hit was appended — the raw sample offset (since this engine's own stream start) this detection's epoch ended at. The per-hit anchor a caller needs to derive a precise timestamp (dp_sample_clock_stamp_at(), timing/timing_core.h) instead of reusing one message-level timestamp for every hit — a single push() call spanning multiple epochs can emit several hits at different sample offsets. Acquisition itself stays wall-clock-agnostic; this is the raw material a caller with a real clock converts.

variable test_stat¶

float acq_result_t::test_stat;

The gating CFAR statistic: peak_mag / noise_est under coherent-only detection (n_noncoh == 1); scaled by sqrt(2*n_noncoh) once non-coherent looks are combined. 0 if noise_est == 0.

The documentation for this class was generated from the following file native/inc/doppler/acq/acq_core.h