RadarCaponROIPreprocess (Beamspace Projection)#
Overview#
This operator prepares the inputs of the Capon (MVDR) DoA-on-ROI stage (RadarCaponROIDOA). Capon beamforming over the full virtual array is too expensive for real-time use, so each detection is first reduced to a small angular region of interest (ROI) in beamspace:
a coarse DoA estimate over the full beamspace selects the ROI,
the detection’s per-Doppler snapshots are projected onto the
svDimbeamspace bins of that ROI, andthe matching block of precomputed, ROI-projected steering vectors is copied out next to them.
For every detection the operator writes numDopplerBinsCovMat (H) ROI
beamspace snapshots of dimension svDim and the svDim x numElBins
x numAzBins steering vectors for that ROI. Both are complex 2S32 fixed
point and feed the Capon operator directly.
Every per-detection stage runs on the PVA VPU; pvaCaponROIPreprocessSubmit
only reads the detection count (and converts custom twiddle tables) on the CPU.
Only the LOCAL Doppler mode (a window centered on the detected Doppler bin) is
supported.
Algorithm Description#
Notation#
numAzVirtxnumElVirtis the virtual array used by the projection; virtual channelvc = rx*numTx + txsits at azimuth indexvc % numAzVirtand elevation indexvc / numAzVirt.beamAzxbeamElis the beamspace (DFT size per axis). Beamspace bins are reported in shifted order: DFT binkof an axis of sizebeamis output bin(k + beam/2) % beam(integer division), so the broadside beam is near the center.An ROI is
roiAzxroiElconsecutive shifted bins starting at(roiAzStart, roiElStart);svDim = roiAz*roiEland ROI channelc = eLoc*roiAz + aLocis the bin(roiAzStart + aLoc, roiElStart + eLoc).The beamspace value of an element-space vector \(x\) at DFT bin \((k_a, k_e)\) is
\[X(k_a, k_e) = \sum_{e}\sum_{a} W_{el}[k_e][e]\, W_{az}[k_a][a]\, \overline{x[a, e]},\]with the default tables \(W_{az}[k][a] = e^{-j 2\pi k a / \text{beamAz}}\) and \(W_{el}[k][e] = e^{-j 2\pi k e / \text{beamEl}}\).
Processing flow#
For each detection d in [0, detectionCount) the operator runs the following
stages, all on the VPU.
Doppler window. Select the
N = 2*floor(dopplerNeighborhood/2)Doppler bins(detDopplers[d] + i - N/2) mod numChirps,i = 0 .. N-1, from the detection’s range-Doppler plane.DDM decode. For each transmitter, read the plane at the selected bin shifted by
relDopplerOffset[tx](modulonumChirps) and multiply by the decode weightddmaWeightRe[tx] + j*ddmaWeightIm[tx]. This gives the virtual-array snapshotx[vc][i]for everyvc = rx*numTx + tx.Forward-backward averaging (when
enableFBA). AppendNbackward snapshots,x_b[vc][i] = conj(x[nvc-1-vc][i]). Snapshot rows are ordered forward0 .. N-1, then backwardN .. 2N-1; any remaining rows up to H are zero.Block-float quantization. Convert the detection’s snapshots to 32-bit fixed point with one shared exponent chosen from their peak magnitude, so the VPU projection cannot overflow. The decoded real and imaginary parts must be finite and below 2^24 in magnitude; this is not checked, and other values give that detection unspecified (saturated) snapshots.
Coarse DoA. Compute the beamspace power spectrum of
elementSnapshots[d]and find its peak bin inside the coarse-DoA field of view (coarseAzBinLo..coarseAzBinHixcoarseElBinLo..coarseElBinHi). The spectrum is evaluated with 16-bit twiddles; for an azimuth-only array the four strongest candidates are re-evaluated in FP32 and the strongest one wins. The spectrum is computed either by a direct DFT or, whencoarseDoAUseFftis set and the geometry allows, by a batched FFT-64 that processes 16 detections per run.ROI selection. The ROI is centered on the peak bin (start
peak - (roiSize-1)/2per axis), clamped to[0, beamAz-roiAz]x[0, beamEl-roiEl]so it stays inside the beamspace.Azimuth projection. Apply the
roiAzazimuth DFT rows of the ROI to every snapshot (stage 3 output), givingroiAzxnumElVirtpartial sums per snapshot.Elevation projection. Apply the
roiElelevation DFT rows of the ROI to the partial sums, giving thesvDimROI beamspace values per snapshot. WhennumElVirt == 1this stage is folded into stage 7.Output quantization. Write the projected snapshots to
snapshotsROIin Q(inputQBits), as H rows ofsvDimcomplex values. Rows past the FBA-expanded snapshot count are zero. Values are not saturated, so the projected snapshots must stay below 2^(31-inputQBits) in magnitude.Steering-block gather. Copy the steering LUT block for this ROI, row
roiElStart*(beamAz-roiAz+1) + roiAzStartofsteeringLut, tosteeringVectorsROI[d]unchanged.
Device kernels#
The operator embeds three VPU programs. They differ in stage 5 (coarse DoA)
and in how stages 7 and 8 project the snapshots; the other stages are shared.
pvaCaponROIPreprocessCreate picks one per operator instance from its
parameters, and the choice does not change at Submit:
FFT kernel — selected when
coarseDoAUseFftis true. It computes the azimuth spectrum with a fixed-point FFT-64 run over 16 detections at a time (a short final group is handled automatically) and uses the dot-product projection. It requiresnumElVirt == 1,beamAz == 64,numAzVirt == 64, the generated twiddle tables, no coarse-DoA grid and the full coarse-DoA field of view; otherwise Create returnsNVCV_ERROR_INVALID_ARGUMENT.Direct-DFT kernel — selected when
coarseDoAUseFftis false,numElVirt == 1and the dot-product projection applies (below). It computes the coarse-DoA spectrum with a direct DFT and uses the dot-product projection.General direct-DFT kernel — selected for every other configuration with
coarseDoAUseFftfalse: an elevation array (numElVirt > 1), an oddnumAzVirt, or custom tables with FBA and a Doppler window that is not a multiple of 8 rows. It also computes the coarse DoA with a direct DFT. It uses the dot-product projection where it applies, and per-element multiply-accumulate projection paths otherwise.
The dot-product projection applies when numAzVirt is even and
numElVirt is 1, or 2 with roiAz*numElVirt*B <= 1024. B is
2*ceil(W/8)*8 when FBA runs with the generated tables and
numDopplerBinsCovMat otherwise, where W = 2*floor(dopplerNeighborhood/2)
is the Doppler window. With custom tables and FBA it also needs
the Doppler window to be a multiple of 8 rows.
Together, the two direct-DFT kernels support every geometry listed under Limitations, including 2D arrays, a coarse-DoA grid and a narrowed field of view.
Twiddle tables#
By default (useCustomTwiddles == false) Create generates the DFT tables
\(W_{az}\) and \(W_{el}\) shown above, and the waz / wel
tensors are ignored (their requirements and handles may be NULL).
Set useCustomTwiddles to supply your own tables, for example calibrated or
non-uniform beam directions:
wazis HW[1, beamAz*numAzVirt]2F32, row-majorwaz[k][a](rowk, elementa);welis HW[1, beamEl*coarseElVirt]2F32, row-majorwel[k][e].Row
kof a table is shifted output bin(k + beam/2) % beam(beamisbeamAzorbeamEl). The ROI start, the coarse-DoA field of view and the steering LUT row all use output bins, so build the steering LUT with this same convention.Entries are converted to Q15 (16-bit) for the VPU and must be finite with a complex magnitude of at most 1 (a part of 1 saturates to 32767/32768); Submit rejects other values. Larger entries would lower the elementSnapshots bound below (to about 128 at a magnitude of sqrt(2)).
The tables are read and converted on the CPU at every Submit.
Custom tables cannot be combined with
coarseDoAUseFft.
Steering LUT#
steeringLut holds one block per possible ROI start, numRoiPos =
(beamAz-roiAz+1)*(beamEl-roiEl+1) blocks in total. The block for ROI start
(roiAzStart, roiElStart) is row roiElStart*(beamAz-roiAz+1) +
roiAzStart and contains the steering vectors of the numAzBins x
numElBins search directions inside that ROI, projected onto the ROI’s
svDim beamspace bins with the same beamspace transform and tables as the
snapshots, laid out [svDim][numElBins][numAzBins] and quantized to
Q(steeringQBits). The LUT is constant across frames; build it once. The
sample reference caponROIPreprocessSteeringLut() builds it for a uniform
array with the default tables.
Parameters#
PVACaponROIPreprocessParams:
Field |
Description |
|---|---|
|
Transmit and receive channels. |
|
Doppler size of the range-Doppler planes. |
|
Virtual array used by the projection. |
|
Beamspace DFT sizes, independent of |
|
ROI size in beamspace bins; |
|
Steering search directions per ROI. |
|
Snapshot rows H per detection. |
|
Doppler window, at least 2; |
|
true = forward-backward averaging (doubles the snapshot rows). |
|
Fractional bits of |
|
Row count of the per-detection tensors: the most detections one Submit
can process ( |
|
DDM Doppler shift per TX in bins, typically
|
|
DDM decode weight per TX, typically |
|
true = batched FFT-64 coarse DoA (FFT kernel); false (default) = direct DFT. |
|
Height of an optional coarse-DoA position grid onto which a sparse
array is zero-filled; 0 (default) = |
|
Inclusive coarse-DoA field of view in output bins; all zero (default) = full beamspace. Narrowing requires the direct-DFT kernel. |
|
false (default) = generated DFT tables; true = caller’s |
Limitations#
numTx and numRx in [1, 8], and numTx*numRx <= numAzVirt*numElVirt.
ddmaWeightRe and ddmaWeightIm finite for every TX in [0, numTx).
numAzVirt in [1, 69], numElVirt in [1, 35], and numAzVirt*numElVirt <= 69.
beamAz in [1, 128], beamEl in [1, 64]; beamAz*numAzVirt <= 4096 unless a coarse-DoA grid is used.
coarseElVirt (when nonzero) in [numElVirt, 35]; a grid (coarseElVirt != numElVirt) requires numElVirt == 1 and the direct-DFT coarse DoA.
roiAz in [1, beamAz], roiEl in [1, beamEl], and svDim == roiAz*roiEl <= 16.
roiAz*numElVirt*numDopplerBinsCovMat <= 1024.
numAzBins in [1, 16], numElBins in [1, 8].
numDopplerBinsCovMat (H) a multiple of 8 in [8, 64]; dopplerNeighborhood >= 2, and 2*floor(dopplerNeighborhood/2), doubled when enableFBA, must not exceed H (the remaining snapshot rows are zero).
rangeDopplerPlanes: every value a detection reads (its row among the first detectionCount, at the chirps of its Doppler window shifted by each TX’s relDopplerOffset) must decode to real and imaginary parts that are finite and below 2^24 in magnitude. Not checked: other values give that detection unspecified (saturated) snapshots.
elementSnapshots (first detectionCount rows): real and imaginary parts below 4 in magnitude, since coarse DoA converts them to 16-bit Q13. For numElVirt == 1 the azimuth beamspace power is also kept in 32 bits, which needs the sum of
|elementSnapshots|over a row below 180 (about 181 less a rounding margin, for twiddles of complex magnitude at most 1; for example below 2.8 per element at numAzVirt == 64). Not checked; larger values saturate or wrap and can select the wrong ROI. Scaling a row by a common factor does not change its ROI.Custom waz/wel entries (useCustomTwiddles) finite with complex magnitude at most 1; Submit rejects others.
For numElVirt > 1 the coarse DoA ranks the 2D beamspace on fixed-point power, with no floating-point refine (numElVirt == 1 re-scores its strongest candidates in FP32): when two peaks are within about 1e-3 in relative power, it can select another ROI than a double-precision reference.
inputQBits and steeringQBits in [0, 30]. snapshotsROI values are not saturated: a projected snapshot of magnitude 2^(31-inputQBits) or more wraps.
numChirps in [1, 512].
maxDet in [1, 1024]; above 256 it is tiled tileCols detections per DMA line, where tileCols is its smallest divisor >= ceil(maxDet/256) (there must be one <= 256), and tileCols times the larger of 2*numAzVirt*coarseElVirt and 2*numChirps*numRx must not exceed 65535.
coarseDoAUseFft requires useCustomTwiddles == false, numElVirt == 1, beamAz == 64, numAzVirt == 64, no coarse-DoA grid and the full coarse-DoA field of view.
The coarse-DoA field of view must be an ordered bin range inside [0, beamAz) x [0, beamEl).
In addition:
Every tensor must have the layout, data type and shape listed in
OpCaponROIPreprocess.hand be densely packed (no row padding).The tensors passed to Submit must match the requirements given to Create.
Only the LOCAL Doppler mode is supported.
Performance#
Execution Time is the average time required to execute the operator on a single VPU core.
Note that each PVA contains two VPU cores, which can operate in parallel to process two streams simultaneously, or reduce execution time by approximately half by splitting the workload between the two cores.
Total Power represents the average total power consumed by the module when the operator is executed concurrently on both VPU cores.
Idle power is approximately 7.6 W on Jetson AGX Orin and 11.8 W on Jetson AGX Thor when the PVA is not processing data.
For detailed information on interpreting the performance table below and understanding the benchmarking setup, see Performance Benchmark.
Max Detections |
Snapshot Height |
Elevation Elements |
Coarse DoA |
Execution Time |
Submit Latency |
Total Power |
|---|---|---|---|---|---|---|
100 |
16 |
1 |
DFT |
0.562ms |
0.005ms |
11.211W |
100 |
16 |
1 |
FFT |
0.587ms |
0.006ms |
10.712W |
100 |
32 |
1 |
DFT |
0.659ms |
0.005ms |
11.111W |
100 |
32 |
1 |
FFT |
0.684ms |
0.006ms |
11.01W |
100 |
64 |
1 |
DFT |
0.852ms |
0.005ms |
11.308W |
100 |
64 |
1 |
FFT |
0.881ms |
0.006ms |
10.909W |
100 |
64 |
2 |
DFT |
1.602ms |
0.005ms |
10.209W |
500 |
16 |
1 |
DFT |
2.467ms |
0.006ms |
11.711W |
500 |
16 |
1 |
FFT |
2.558ms |
0.006ms |
11.61W |
500 |
32 |
1 |
DFT |
2.948ms |
0.006ms |
11.211W |
500 |
32 |
1 |
FFT |
3.041ms |
0.006ms |
11.111W |
500 |
64 |
1 |
DFT |
3.914ms |
0.006ms |
11.409W |
500 |
64 |
1 |
FFT |
4.009ms |
0.006ms |
11.01W |
500 |
64 |
2 |
DFT |
7.618ms |
0.006ms |
10.31W |
1024 |
16 |
1 |
DFT |
4.952ms |
0.006ms |
11.711W |
1024 |
16 |
1 |
FFT |
5.138ms |
0.007ms |
11.61W |
1024 |
16 |
2 |
DFT |
10.420ms |
0.007ms |
10.41W |
1024 |
32 |
1 |
DFT |
5.942ms |
0.006ms |
11.61W |
1024 |
32 |
1 |
FFT |
6.125ms |
0.007ms |
11.211W |
1024 |
32 |
2 |
DFT |
12.115ms |
0.007ms |
10.31W |
1024 |
64 |
1 |
DFT |
7.918ms |
0.006ms |
11.409W |
1024 |
64 |
1 |
FFT |
8.104ms |
0.007ms |
11.409W |
1024 |
64 |
2 |
DFT |
15.498ms |
0.007ms |
10.608W |
Max Detections |
Snapshot Height |
Elevation Elements |
Coarse DoA |
Execution Time |
Submit Latency |
Total Power |
|---|---|---|---|---|---|---|
100 |
16 |
1 |
DFT |
0.594ms |
0.003ms |
14.763W |
100 |
16 |
1 |
FFT |
0.608ms |
0.004ms |
14.369W |
100 |
32 |
1 |
DFT |
0.703ms |
0.004ms |
14.258W |
100 |
32 |
1 |
FFT |
0.718ms |
0.004ms |
14.157W |
100 |
64 |
1 |
DFT |
0.922ms |
0.004ms |
14.157W |
100 |
64 |
1 |
FFT |
0.936ms |
0.004ms |
14.157W |
100 |
64 |
2 |
DFT |
1.767ms |
0.004ms |
13.459W |
500 |
16 |
1 |
DFT |
2.735ms |
0.004ms |
14.865W |
500 |
16 |
1 |
FFT |
2.740ms |
0.004ms |
14.369W |
500 |
32 |
1 |
DFT |
3.279ms |
0.004ms |
14.763W |
500 |
32 |
1 |
FFT |
3.285ms |
0.004ms |
14.763W |
500 |
64 |
1 |
DFT |
4.367ms |
0.004ms |
14.157W |
500 |
64 |
1 |
FFT |
4.373ms |
0.004ms |
14.258W |
500 |
64 |
2 |
DFT |
8.546ms |
0.004ms |
13.357W |
1024 |
16 |
1 |
DFT |
5.539ms |
0.004ms |
14.865W |
1024 |
16 |
1 |
FFT |
5.532ms |
0.004ms |
14.966W |
1024 |
16 |
2 |
DFT |
11.705ms |
0.004ms |
13.56W |
1024 |
32 |
1 |
DFT |
6.653ms |
0.004ms |
14.763W |
1024 |
32 |
1 |
FFT |
6.641ms |
0.004ms |
14.763W |
1024 |
32 |
2 |
DFT |
13.613ms |
0.004ms |
14.349W |
1024 |
64 |
1 |
DFT |
8.882ms |
0.004ms |
14.157W |
1024 |
64 |
1 |
FFT |
8.876ms |
0.004ms |
14.157W |
1024 |
64 |
2 |
DFT |
17.428ms |
0.004ms |
14.248W |
Sample Validation#
The capon_roi_preprocess sample builds the steering LUT with the CPU
reference caponROIPreprocessSteeringLut(), runs the operator, and compares
both outputs with the double-precision CPU reference caponROIPreprocess()
(public/samples/radar_processing/capon_roi_preprocess/ref):
snapshotsROImust match within a few LSB (the device projection is fixed point);steeringVectorsROIis a verbatim LUT copy and must match exactly.