Struct acq_state_t¶

ClassList > acq_state_t

Streaming acquisition-engine state. More...

• #include <acq_core.h>

Public Attributes¶

Detailed Description¶

Allocate with acq_create_burst() or acq_create_continuous(); never stack-allocate.

Public Attributes Documentation¶

variable band_mask¶

uint8_t* acq_state_t::band_mask;

n_surf; 1 = outside the searched band

variable blk¶

float _Complex* acq_state_t::blk;

window_bins * coherent_bins * code_bins: the block's per-tile epoch correlations; NULL unless both exceed 1.

variable blk_epoch¶

size_t acq_state_t::blk_epoch;

Epochs gathered in the current block (0 … coherent_bins-1).

variable carrier_freq_hz¶

double acq_state_t::carrier_freq_hz;

RF carrier the Doppler is physically coupled to, Hz (acq_set_carrier_freq_hz()); 0 = uncoupled: no code-rate hypothesis per tile, no dwell advance in the hand-off.

variable chip_rate¶

double acq_state_t::chip_rate;

Chip rate (Hz).

variable cn0_dbhz¶

double acq_state_t::cn0_dbhz;

Design C/N0 the search is sized for (dB-Hz); 0 on a burst engine means none was given.

variable code_bins¶

size_t acq_state_t::code_bins;

One segment in samples = sf*spc.

variable code_only_epochs¶

size_t acq_state_t::code_only_epochs;

Whole code-only epochs a waveform's code-only window holds at any chip phase (§2.1); 1 = no window, D = 1.

variable coherent_bins¶

size_t acq_state_t::coherent_bins;

Coherent depth = slow-time FFT length (<= reps on a burst engine). In wideband mode the block depth D inside every tile (file doc); 1 = one epoch, the continuous engine's default.

variable colbuf¶

float _Complex* acq_state_t::colbuf;

Gathered column scratch (coherent_bins).

variable colout¶

float _Complex* acq_state_t::colout;

FFT'd column scratch (coherent_bins).

variable corr¶

corr2d_state_t* acq_state_t::corr;

Single-row-ref correlator (dwell=1).

variable doppler_rate¶

double acq_state_t::doppler_rate;

Doppler rate the depth is bounded against (Hz/s); 0 = no bound from the rate.

variable doppler_res_hz¶

double acq_state_t::doppler_res_hz;

Doppler bin width = chip_rate/(sf*coherent_bins).

variable doppler_span_hz¶

double acq_state_t::doppler_span_hz;

Native Doppler half-range = chip_rate/(2*sf).

variable doppler_uncertainty¶

double acq_state_t::doppler_uncertainty;

One-sided Doppler search half-range (Hz); 0 = full native span.

variable dwells¶

uint64_t acq_state_t::dwells;

dwells decided since create/reset

variable epochs_per_symbol¶

double acq_state_t::epochs_per_symbol;

(chip_rate/sf)/symbol_rate; 0 when symbol_rate <= 0.

variable eta¶

float acq_state_t::eta;

Raw per-cell Rayleigh amplitude threshold.

variable eta_nc¶

float acq_state_t::eta_nc;

Non-coherent CFAR threshold (order-N_nc Marcum).

variable frame_n¶

size_t acq_state_t::frame_n;

Raw samples consumed from the ring per iteration: == n natively; == code_bins in wideband mode (one epoch's worth — window_bins hypotheses come from ONE shared epoch, not from consuming more input).

variable fs¶

double acq_state_t::fs;

Sample rate (Hz) = chip_rate * spc.

variable interp¶

size_t acq_state_t::interp;

Doppler-axis interpolation factor of the inverse (1 = none). Zero-padding the product in frequency is exact band-limited interpolation, so a peak landing between two slow-time bins is no longer attenuated by the scalloping loss that made a half-bin burst invisible at any SNR (gh-1002). It adds resolution to the SURFACE only: the reported bin is mapped back to the native grid, so no consumer's arithmetic changes.

variable keep_surface¶

int acq_state_t::keep_surface;

1 = normalise every decided dwell into stat_surface for acq_surface(); set by a caller or by acq_set_surface_sink()

variable mag_buf¶

float* acq_state_t::mag_buf;

|out_buf| (n).

variable max_peaks¶

size_t acq_state_t::max_peaks;

list capacity per dwell (1 = the maximum)

variable n¶

size_t acq_state_t::n;

NATIVE grid size in samples: coherent_bins * window_bins * code_bins (both may exceed 1: D rows inside each tile). This is the INPUT frame and the count of statistically independent cells it is what the threshold ladder is sized from, and it is what doppler_bin is reported on.

variable n_held¶

size_t acq_state_t::n_held;

the last dwell's picks held as twins (§7.1)

variable n_noncoh¶

size_t acq_state_t::n_noncoh;

Non-coherent looks per detection (1 = coherent).

variable n_peaks¶

size_t acq_state_t::n_peaks;

picks in the last dwell, held ones too

variable n_surf¶

size_t acq_state_t::n_surf;

Cells in the correlation SURFACE = interp * n. The inverse transform is evaluated on a finer Doppler grid, so the buffers, the peak search and the CFAR reference span this and not n.

variable n_twins¶

size_t acq_state_t::n_twins;

picks carried over from the last dwell

variable nc_count¶

size_t acq_state_t::nc_count;

Coherent dumps in the current look (0…n_noncoh-1).

variable nc_surface¶

float* acq_state_t::nc_surface;

Non-coherent |·|² accumulator (n); NULL unless n_noncoh > 1.

variable noise_est¶

float acq_state_t::noise_est;

variable noise_hi¶

size_t acq_state_t::noise_hi;

Last CFAR reference bin (inclusive).

variable noise_lo¶

size_t acq_state_t::noise_lo;

First CFAR reference bin (inclusive).

variable noise_mode¶

det_noise_mode_t acq_state_t::noise_mode;

CFAR aggregation mode.

variable noise_scratch¶

float* acq_state_t::noise_scratch;

Scratch for the median sort (n).

variable out_buf¶

float _Complex* acq_state_t::out_buf;

corr2d dump output (n) — also the wideband mode's (window_bins, code_bins) grid.

variable parts¶

acq_part_t* acq_state_t::parts;

window_bins partial slots of the decided surface's per-tile passes

variable pd¶

double acq_state_t::pd;

Target detection probability.

variable pd_predicted¶

double acq_state_t::pd_predicted;

Predicted Pd at cn0_dbhz and the chosen grid: the AVERAGE Pd over the straddle priors (slow-time scalloping over the INTERPOLATED bin the peak search samples, intra-segment rotation, code sample offset — quadrature over uniform priors), not the on-grid best case, and not Pd at the mean amplitude (which Jensen makes optimistic). Conservative by construction: the engine takes the maximum over an interpolated surface, which the Marcum form does not credit (doppler#1183, #1064). NAN when no design C/N0 was given.

variable peak_col¶

size_t acq_state_t::peak_col;

variable peak_conc¶

float acq_state_t::peak_conc;

the strongest pick's column concentration

variable peak_mag¶

float acq_state_t::peak_mag;

variable peak_mask¶

uint8_t* acq_state_t::peak_mask;

n_surf; the working mask

variable peak_row¶

size_t acq_state_t::peak_row;

variable peaks¶

det_peak_t* acq_state_t::peaks;

max_peaks: the last dwell's picks

variable pfa¶

double acq_state_t::pfa;

Target system false-alarm probability (stored for configure_search_raw's threshold re-derivation).

variable pfa_cell¶

double acq_state_t::pfa_cell;

Bonferroni per-cell false-alarm probability.

variable pool¶

dp_pool_t* acq_state_t::pool;

NULL or one thread = serial

variable ref¶

float _Complex* acq_state_t::ref;

Single-row reference (n), owned.

variable reps¶

size_t acq_state_t::reps;

Max coherent code repetitions (the ceiling); always 1 for an engine built via acq_create_continuous().

variable ring¶

dp_f32_t* acq_state_t::ring;

Raw cf32 input ring (the only ring).

variable ring_cap¶

size_t acq_state_t::ring_cap;

Ring capacity in complex samples.

variable samples_consumed¶

uint64_t acq_state_t::samples_consumed;

Total framed samples (the state's offset).

variable searched_bins¶

size_t acq_state_t::searched_bins;

Doppler bins scanned (<= coherent_bins; du prior).

variable sf¶

size_t acq_state_t::sf;

Chips per PN segment (= len(code)).

variable sink¶

acq_surface_sink_fn acq_state_t::sink;

NULL = none

variable sink_ctx¶

void* acq_state_t::sink_ctx;

variable sink_decim¶

uint32_t acq_state_t::sink_decim;

the sink sees every sink_decim-th dwell

variable slow_fft¶

fft_state_t* acq_state_t::slow_fft;

Length-coherent_bins forward FFT (slow time).

variable spc¶

size_t acq_state_t::spc;

Samples per chip (chip-rate oversample factor).

variable stat_surface¶

float* acq_state_t::stat_surface;

n_surf: the last decided dwell in the gate's units; allocated on the first dwell decided with keep_surface set

variable straddle_loss¶

double acq_state_t::straddle_loss;

Mean AMPLITUDE derating from grid straddle — a diagnostic summary (~20*log10 of it in dB); sizing and pd_predicted average Pd itself over the priors. Derived config, recomputed by create().

variable surface_at¶

uint64_t acq_state_t::surface_at;

samples_consumed of that dwell; 0 = none

variable symbol_rate¶

double acq_state_t::symbol_rate;

Continuous data-symbol rate (Hz); 0 = no known data-modulation clock. Diagnostic only on an engine built via acq_create_continuous() (which always forces coherent_bins=1 regardless) — informational, doesn't feed sizing.

variable test_stat¶

float acq_state_t::test_stat;

variable threads¶

int acq_state_t::threads;

workers the pool runs on, the caller included; 1 without a pool

variable threshold¶

float acq_state_t::threshold;

CFAR gate on test_stat (theta); coherent path.

variable tile_col¶

float _Complex** acq_state_t::tile_col;

window_bins column scratch: a chunk of ACQ_COL_CHUNK columns of D*interp (zero tails) in, then out; NULL at D == 1

variable tile_inv¶

fft_state_t** acq_state_t::tile_inv;

window_bins inverse plans (code_bins)

variable tile_prod¶

float _Complex** acq_state_t::tile_prod;

window_bins product buffers

variable tile_rows¶

size_t** acq_state_t::tile_rows;

window_bins tables of D*interp: the surface row of each slow-time row of the tile (acq_block_row), once per grid rather than per cell; NULL at D == 1

variable tile_slow¶

fft_state_t** acq_state_t::tile_slow;

window_bins slow-time plans (D*interp), NULL at D == 1

variable tlm¶

acq_tlm_t acq_state_t::tlm;

telemetry attachment; ctx NULL = detached

variable twin_col¶

uint32_t* acq_state_t::twin_col;

max_peaks: last dwell's picks, code phases

variable twin_row¶

uint32_t* acq_state_t::twin_row;

max_peaks: last dwell's picks, native rows

variable underpowered¶

uint8_t acq_state_t::underpowered;

1 when pd_predicted < pd; never without a design C/N0 there is no target to be under.

variable wide_fwd¶

fft_state_t* acq_state_t::wide_fwd;

Forward FFT, length code_bins.

variable wide_inv¶

fft_state_t* acq_state_t::wide_inv;

Inverse FFT, length code_bins.

variable wide_prod¶

float _Complex* acq_state_t::wide_prod;

Rolled-spectrum * wide_ref_spec product, length code_bins; reused per hypothesis.

variable wide_ref_spec¶

float _Complex* acq_state_t::wide_ref_spec;

conj(FFT(replica row)), length code_bins.

variable wide_spec¶

float _Complex* acq_state_t::wide_spec;

FFT(raw epoch), length code_bins; once/epoch.

variable window_bins¶

size_t acq_state_t::window_bins;

Wideband frequency-window hypotheses (1 = disabled/native — see the file doc comment).

variable yframe¶

float _Complex* acq_state_t::yframe;

Slow-time-FFT'd frame (n) fed to corr.

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