RadarCoherentIntegration#

Functions#

NVCVStatus pvaCoherentIntegrationComputeSteeringVectors(NVCVTensorHandle rxPositions, NVCVTensorHandle azimuthBins, NVCVTensorHandle elevationBins, NVCVTensorHandle steeringVectors)

Computes steering vectors for Coherent Integration.

NVCVStatus pvaCoherentIntegrationCreate(NVCVOperatorHandle *handle, NVCVTensorRequirements const *const rangeDopplerMapTensorRequirements, NVCVTensorRequirements const *const coherentIntegrationRxTensorRequirements, NVCVTensorRequirements const *const coherentIntegrationFinalTensorRequirements, PVARadarCoherentIntegrationParams const *const params)

Constructs a Coherent Integration operator.

NVCVStatus pvaCoherentIntegrationSubmit(NVCVOperatorHandle handle, cudaStream_t stream, NVCVTensorHandle const rangeDopplerMap, NVCVTensorHandle const steeringVectors, NVCVTensorHandle coherentIntegrationRx, NVCVTensorHandle coherentIntegrationFinal)

Submits the Coherent Integration operator to a CUDA stream.

NVCVStatus pvaCoherentIntegrationSubmit(NVCVOperatorHandle handle, cupvaStream_t stream, NVCVTensorHandle const rangeDopplerMap, NVCVTensorHandle const steeringVectors, NVCVTensorHandle coherentIntegrationRx, NVCVTensorHandle coherentIntegrationFinal)

Submits the Coherent Integration operator to a cuPVA stream.

Functions#

NVCVStatus pvaCoherentIntegrationComputeSteeringVectors(
NVCVTensorHandle rxPositions,
NVCVTensorHandle azimuthBins,
NVCVTensorHandle elevationBins,
NVCVTensorHandle steeringVectors,
)#

Computes steering vectors for Coherent Integration.

This utility computes steering vectors from Rx positions and angle bins and writes them to a caller-owned tensor. The resulting tensor can be reused across submissions while the Rx positions and angle bins remain unchanged. A caller may instead provide steering vectors directly from the sensor.

Steering vectors are computed as:

phase[k,az,el] =
    rxPositions[k].x * cos(el) * sin(az)
    + rxPositions[k].y * sin(el)

steering[az,el,k] = exp(-j * 2 * pi * phase[k,az,el])

Angle-bin values are converted from degrees to radians for the trigonometric operations.

All four tensors must use host-mappable PVA memory.

Parameters:
  • rxPositions – [in] Wavelength-normalized Rx positions.

    • Type: NVCV_DATA_TYPE_2F32.

    • Layout/rank: W, rank 1.

    • Shape: [numRx], where numRx is 4, 8, 12, or 16.

    • Component 0 is the horizontal position and component 1 is the vertical position.

    • All components must be finite.

  • azimuthBins – [in] Azimuth angle bins in degrees.

    • Type: NVCV_DATA_TYPE_F32.

    • Layout/rank: W, rank 1.

    • Shape: [numAzimuthBins], where numAzimuthBins > 0.

    • All values must be finite.

  • elevationBins – [in] Elevation angle bins in degrees.

    • Type: NVCV_DATA_TYPE_F32.

    • Layout/rank: W, rank 1.

    • Shape: [numElevationBins], where numElevationBins > 0.

    • All values must be finite.

  • steeringVectors – [out] Steering-vector output.

    • Type: NVCV_DATA_TYPE_2S16 (complex Q15).

    • Layout/rank: CHW, rank 3.

    • Shape: [numAzimuthBins, numElevationBins, numRx].

    • C, H, and W correspond to azimuth, elevation, and Rx, respectively.

    • C * H * W must not exceed 12,288 elements.

    • Must be fully packed in [Azimuth][Elevation][Rx] order.

Return values:
  • NVCV_ERROR_INVALID_ARGUMENT – A tensor is NULL or does not satisfy the documented requirements.

  • NVCV_ERROR_INTERNAL – Internal computation failure.

  • NVCV_SUCCESS – Steering vectors computed successfully.

NVCVStatus pvaCoherentIntegrationCreate(
NVCVOperatorHandle *handle,
NVCVTensorRequirements const *const rangeDopplerMapTensorRequirements,
NVCVTensorRequirements const *const coherentIntegrationRxTensorRequirements,
NVCVTensorRequirements const *const coherentIntegrationFinalTensorRequirements,
PVARadarCoherentIntegrationParams const *const params,
)#

Constructs a Coherent Integration operator.

For complex range-Doppler input X[r,k,d] and steering-vector input S[az,el,k], the operator computes:

beam[r,d,az,el] =
    sum_k X[r,k,d] * S[az,el,k]

C[r,d] = max_(az,el) abs(beam[r,d,az,el])

Each supplied Q15 steering value is used directly as the complex multiplication factor; no implicit conjugation is applied. Steering vectors may be provided by the sensor or computed using pvaCoherentIntegrationComputeSteeringVectors. C is true magnitude (amplitude), not squared magnitude or power. The internal angle-bin traversal order is unspecified, and no selected-angle index is produced.

The folded map is:

F[r,q] = sum_(m=0..repeatFold-1)
             C[r, q + m * (numDopplerBins / repeatFold)]

The U32 outputs store C / 2^rxShift and F / 2^finalShift, truncated toward zero and saturated to INT32_MAX, where:

rxShift    = ceil(log2(numRx)) + 1
finalShift = rxShift + ceil(log2(repeatFold))

The sum over k coherently integrates the complex inputs across the Rx dimension. Because C contains magnitudes, the subsequent accumulation across Tx-related Doppler folds to form F is non-coherent.

All components in the range-Doppler input must use one common upstream fixed-point exponent.

Limitations (all constraints apply):

  • Dimensions: 4 <= numRangeBins <= 4096, 128 <= numDopplerBins <= 4096, and numRx is 4, 8, 12, or 16.

  • repeatFold is a multiple of 4 in [4, 128] and evenly divides numDopplerBins.

  • numDopplerBins / repeatFold is a multiple of 32.

  • Input layout is [Range][Doppler][Rx] or [Range][Rx][Doppler].

  • Every Range, Doppler, and Rx input byte stride and every output byte stride is positive and fits in a 32-bit unsigned value.

  • [Range][Doppler][Rx]: Rx stride is 8 bytes, Doppler stride is in [numRx * 8, 65535] bytes, and Range rows do not overlap.

  • [Range][Rx][Doppler]: Doppler stride is 8 bytes, Rx stride is in [numDopplerBins * 8, 65535] bytes, and Range rows do not overlap.

  • Both U32 outputs have a 4-byte W stride and non-overlapping Range rows.

  • Steering vectors are packed in [Azimuth][Elevation][Rx] order with byte strides [Elevation * Rx * 4, Rx * 4, 4].

Note

If the input or either output Range stride exceeds 2^23 - 1 bytes, the operator remains correct but processes one Range row per tile, which may reduce throughput.

Parameters:
  • handle – [out] Pointer to the created operator handle. Must not be NULL. Destroy a successfully created handle with nvcvOperatorDestroy after all submitted work has completed.

  • rangeDopplerMapTensorRequirements – [in] Input tensor requirements. Must not be NULL.

    • Type: NVCV_DATA_TYPE_2S32.

    • Layout/rank: HCW, or NHCW with N = 1.

    • For PVA_FFT_LAYOUT_RANGE_RX_DOPPLER: H = numRangeBins, C = numRx, W = numDopplerBins.

    • For PVA_FFT_LAYOUT_RANGE_DOPPLER_RX: H = numRangeBins, C = numDopplerBins, W = numRx.

  • coherentIntegrationRxTensorRequirements – [in] Rx-coherently-integrated detection-map output requirements. Must not be NULL.

    • Type: NVCV_DATA_TYPE_U32.

    • Layout/rank: HW, rank 2.

    • Shape: [numRangeBins, numDopplerBins].

  • coherentIntegrationFinalTensorRequirements – [in] Final detection-map output requirements after non-coherent accumulation across Tx-related Doppler folds. Must not be NULL.

    • Type: NVCV_DATA_TYPE_U32.

    • Layout/rank: HW, rank 2.

    • Shape: [numRangeBins, numDopplerBins / repeatFold].

  • params – [in] Operator parameters. Must not be NULL. The parameter structure and tensor requirements are copied before this function returns, so the caller may release or modify them after a successful call.

Return values:
  • NVCV_ERROR_INVALID_ARGUMENT – A pointer is NULL or a parameter, shape relationship, or enum value is invalid.

  • NVCV_ERROR_INVALID_IMAGE_FORMAT – A tensor type, rank, or layout is unsupported.

  • NVCV_ERROR_OUT_OF_MEMORY – Insufficient memory to create the operator.

  • NVCV_SUCCESS – Operator created successfully.

NVCVStatus pvaCoherentIntegrationSubmit(
NVCVOperatorHandle handle,
cudaStream_t stream,
NVCVTensorHandle const rangeDopplerMap,
NVCVTensorHandle const steeringVectors,
NVCVTensorHandle coherentIntegrationRx,
NVCVTensorHandle coherentIntegrationFinal,
)#

Submits the Coherent Integration operator to a CUDA stream.

The range-Doppler and output tensors must match the complete requirements supplied at creation, including type, shape, layout, strides, alignment, and memory accessibility. The steering-vector tensor must satisfy the documented runtime requirements and be PVA-accessible. No two submitted tensors may overlap; in-place operation is unsupported.

Note

CUDA stream support requirements:

  • PVA SDK 2.7.0 or later

  • Jetpack 7 or later

  • DriveOS 7 or later

  • x86 Emulator is not supported

Parameters:
  • handle – [in] Valid operator handle. Must not be NULL.

  • stream – [in] Valid CUDA stream.

  • rangeDopplerMap – [in] Input range-Doppler tensor. Must not be NULL.

  • steeringVectors – [in] Precomputed steering vectors. Must not be NULL. The tensor may be populated by the sensor or by pvaCoherentIntegrationComputeSteeringVectors.

    • Type: NVCV_DATA_TYPE_2S16 (complex Q15).

    • Layout/rank: CHW, rank 3.

    • Shape: [numAzimuthBins, numElevationBins, numRx], where all dimensions are positive and numRx matches the input range-Doppler tensor.

    • C, H, and W correspond to azimuth, elevation, and Rx, respectively.

    • C * H * W must not exceed 12,288 elements.

  • coherentIntegrationRx – [out] Rx-coherently-integrated detection map before Doppler folding. Must not be NULL.

  • coherentIntegrationFinal – [out] Final detection map after non-coherent accumulation across Tx-related Doppler folds. Must not be NULL.

Return values:
  • NVCV_ERROR_INVALID_ARGUMENT – An argument is invalid or a tensor does not match the configured requirements.

  • NVCV_ERROR_INTERNAL – Internal execution failure.

  • NVCV_ERROR_NOT_IMPLEMENTED – CUDA stream support is unavailable.

  • NVCV_SUCCESS – Operation submitted successfully.

NVCVStatus pvaCoherentIntegrationSubmit(
NVCVOperatorHandle handle,
cupvaStream_t stream,
NVCVTensorHandle const rangeDopplerMap,
NVCVTensorHandle const steeringVectors,
NVCVTensorHandle coherentIntegrationRx,
NVCVTensorHandle coherentIntegrationFinal,
)#

Submits the Coherent Integration operator to a cuPVA stream.

The range-Doppler and output tensors must match the complete requirements supplied at creation, including type, shape, layout, strides, alignment, and memory accessibility. The steering-vector tensor must satisfy the documented runtime requirements and be PVA-accessible. No two submitted tensors may overlap; in-place operation is unsupported.

Parameters:
  • handle – [in] Valid operator handle. Must not be NULL.

  • stream – [in] Valid cuPVA stream.

  • rangeDopplerMap – [in] Input range-Doppler tensor. Must not be NULL.

  • steeringVectors – [in] Precomputed steering vectors. Must not be NULL. The tensor may be populated by the sensor or by pvaCoherentIntegrationComputeSteeringVectors.

    • Type: NVCV_DATA_TYPE_2S16 (complex Q15).

    • Layout/rank: CHW, rank 3.

    • Shape: [numAzimuthBins, numElevationBins, numRx], where all dimensions are positive and numRx matches the input range-Doppler tensor.

    • C, H, and W correspond to azimuth, elevation, and Rx, respectively.

    • C * H * W must not exceed 12,288 elements.

  • coherentIntegrationRx – [out] Rx-coherently-integrated detection map before Doppler folding. Must not be NULL.

  • coherentIntegrationFinal – [out] Final detection map after non-coherent accumulation across Tx-related Doppler folds. Must not be NULL.

Return values:
  • NVCV_ERROR_INVALID_ARGUMENT – An argument is invalid or a tensor does not match the configured requirements.

  • NVCV_ERROR_INTERNAL – Internal execution failure.

  • NVCV_SUCCESS – Operation submitted successfully.