Radar Channels¶

Hermes’ radar channels can be used to simulate basic propagation characteristics of sensing signals. They can be thought of as stripped down raytracing channels which consider only a single reflection in between the transmitting and receiving device, with the reflection being generated by target objects specified by the user.

        classDiagram

   class RadarChannelBase {

      <<Abstract>>

      +realize()
      +propagate()
   }

   class SingleTargetRadarChannel {

      +propagate()
   }

   class MultiTargetRadarChannel {

      +propagate()
   }

   class RadarChannelRealization {

      <<Abstract>>

      +propagate()
   }

   class SingleTargetRadarChannelRealization {

      +propagate()
   }

   class MultiTargetRadarChannelRealization {

      +propagate()
   }

   class RadarPathRealization {

      <<Abstract>>

      +propagation_delay()
      +relative_velocity()
      +propagation_response()
   }

   class RadarInterferenceRealization {

      +propagation_delay()
      +relative_velocity()
      +propagation_response()
   }

   class RadarTargetRealization {

      <<Abstract>>

      +propagation_delay()
      +relative_velocity()
      +propagation_response()
   }

   class RadarTarget {

      <<Abstract>>

      +get_cross_section() : RadarCrossSectionModel
      +get_velocity()
      +get_forwards_transformation()
      +get_backwards_transformation()
   }

   class VirtualRadarTarget {

      +get_cross_section() : RadarCrossSectionModel
      +get_velocity()
      +get_forwards_transformation()
      +get_backwards_transformation()
   }

   class PhysicalRadarTarget {

      +RadarCrossSectionModel cross_section
      +Moveable moveable

      +get_cross_section() : RadarCrossSectionModel
      +get_velocity()
      +get_forwards_transformation()
      +get_backwards_transformation()
   }

   RadarChannelBase o-- RadarChannelRealization : realize()
   SingleTargetRadarChannel o-- SingleTargetRadarChannelRealization : realize()
   MultiTargetRadarChannel o-- MultiTargetRadarChannelRealization : realize()
   RadarChannelRealization *-- RadarPathRealization
   MultiTargetRadarChannel *-- RadarTarget

   SingleTargetRadarChannel --|> RadarChannelBase
   MultiTargetRadarChannel --|> RadarChannelBase

   SingleTargetRadarChannelRealization --|> RadarChannelRealization
   MultiTargetRadarChannelRealization --|> RadarChannelRealization
   RadarInterferenceRealization --|> RadarPathRealization
   RadarTargetRealization --|> RadarPathRealization
   PhysicalRadarTarget --|> RadarTarget
   VirtualRadarTarget --|> RadarTarget

   click RadarChannelBase href "channel.radar.RadarChannelBase.html"
   click SingleTargetRadarChannel href "channel.radar.SingleTargetRadarChannel.html"
   click MultiTargetRadarChannel href "channel.radar.MultiTargetRadarChannel.html"
   click RadarChannelRealization href "channel.radar.RadarChannelRealization.html"
   click SingleTargetRadarChannelRealization href "channel.radar.SingleTargetRadarChannelRealization.html"
   click MultiTargetRadarChannelRealization href "channel.radar.MultiTargetRadarChannelRealization.html"
   click RadarPathRealization href "channel.radar.RadarPathRealization.html"
   click RadarInterferenceRealization href "channel.radar.RadarInterferenceRealization.html"
   click RadarTargetRealization href "channel.radar.RadarTargetRealization.html"
   click RadarTarget href "channel.radar.RadarTarget.html"
   click VirtualRadarTarget href "channel.radar.VirtualRadarTarget.html"
   click PhysicalRadarTarget href "channel.radar.PhysicalRadarTarget.html"

There are currently two types of Radar Channels, namely the easy-to-use SingleTargetRadarChannel, considering only a single reflector between its two linked devices, and the more complex MultiTargetRadarChannel, which allows for the specification of multiple reflectors with individual Cross Sections, that may represent Virtual Targets or existing Physical Targets.

A radar channel linking two devices indexed by \(\alpha\) and \(\beta\) and located at cartesian coordinates \(\mathbf{p}_{\mathrm{Device}}^{(\alpha)}\) and \(\mathbf{p}_{\mathrm{Device}}^{(\beta)}\) while moving with a global velocity of \(\mathbf{v}_{\mathrm{Device}}^{(\alpha)}\) and \(\mathbf{v}_{\mathrm{Device}}^{(\beta)}\) respectively, is modeled by the impulse response

\[\mathbf{H}^{(\alpha,\beta)}(t, \tau) = \mathbf{H}_{\mathrm{LOS}}^{(\alpha, \beta)}(t) \delta(\tau - \tau_{\mathrm{Device}}^{(\alpha,\beta)}) + \sum_{\ell=1}^{L} \mathbf{H}_{\mathrm{Target}}^{(\alpha, \beta, \ell)}(t) \delta(\tau - \tau_{\mathrm{Target}}^{(\alpha,\beta,\ell)})\]

considering a line-of-sight (LOS) interference component between both devices and a sum of \(L\) first-order reflection components generated by the \(L\) targets. The LOS component

\[\mathbf{H}_{\mathrm{LOS}}^{(\alpha, \beta)}(t) = \frac{ c_0 }{ 4 \pi f_{\mathrm{c}}^{(\alpha)} d_{\mathrm{Device}}^{(\alpha,\beta)} } \mathbf{A}_{\mathrm{Device}}^{(\alpha,\beta)} \exp\left( 2\mathrm{j}\pi f_{\mathrm{c}}^{(\alpha)} (\tau_{\mathrm{Device}}^{(\alpha,\beta)} + \frac{ \overline{v}_{\mathrm{Device}}^{(\alpha,\beta)}}{ c_0 } t ) \right)\]

depends on the distance and resulting time-of-flight delay between the devices

\[\begin{split}d_{\mathrm{Device}}^{(\alpha,\beta)} &= \| \mathbf{p}_{\mathrm{Device}}^{(\alpha)} - \mathbf{p}_{\mathrm{Device}}^{(\beta)} \|_2 \\ \tau_{\mathrm{Device}}^{(\alpha,\beta)} &= \frac{ d_{\mathrm{Device}}^{(\alpha,\beta)} }{ c_0 } \\\end{split}\]

as well as the relative velocity between the devices

\[\overline{v}_{\mathrm{Device}}^{(\alpha,\beta)} = \frac{ (\mathbf{v}_{\mathrm{Device}}^{(\alpha)} - \mathbf{v}_{\mathrm{Device}}^{(\beta)})^\mathsf{T} (\mathbf{p}_{\mathrm{Device}}^{(\alpha)} - \mathbf{p}_{\mathrm{Device}}^{(\beta)} ) }{ d_{\mathrm{Device}}^{(\alpha,\beta)} } \ \text{.}\]

Note that if a mono-static radar configuration is considered, i.e. \(\alpha = \beta\), the LOS component is not considered, since it is equivalent to Leakage between transmit and receive chains. The reflection components generated by the \(L\) targets are modeled by

\[\mathbf{H}_{\mathrm{Target}}^{(\alpha, \beta, \ell)}(t) = \frac{ c_0 \sigma_{\ell}^{\frac{1}{2}} }{ (4 \pi)^{\frac{3}{2}} f_{\mathrm{c}}^{(\alpha)} d_{\mathrm{Target}}^{(\alpha,\ell)} d_{\mathrm{Target}}^{(\beta,\ell)} } \exp\left( 2\mathrm{j}\pi f_{\mathrm{c}}^{(\alpha)} (\tau_{\mathrm{Target}}^{(\alpha,\beta,\ell)} + \frac{ \overline{v}_{\mathrm{Target}}^{(\alpha,\ell)} + \overline{v}_{\mathrm{Target}}^{(\beta,\ell)}}{ c_0 } t ) +\mathrm{j} \phi_{\mathrm{Target}}^{(\ell)} \right)\]

where the distance and resulting time-of-flight delay between the device and the \(\ell\)-th target are given by

\[\begin{split}d_{\mathrm{Target}}^{(\alpha,\ell)} &= \| \mathbf{p}_{\mathrm{Device}}^{(\alpha)} - \mathbf{p}_{\mathrm{Target}}^{(\ell)} \|_2 \\ \tau_{\mathrm{Target}}^{(\alpha,\beta,\ell)} &= \frac{ d_{\mathrm{Target}}^{(\alpha,\ell)} + d_{\mathrm{Target}}^{(\beta,\ell)} }{ c_0 } \ \text{.}\end{split}\]

The doppler shift perceived by the receiving device depends on the velocities on both devices and the target, which results in an overall relative velocity of

\[\overline{v}_{\mathrm{Target}}^{(\alpha,\ell)} = \frac{ (\mathbf{v}_{\mathrm{Target}}^{(\ell)} - \mathbf{v}_{\mathrm{Device}}^{(\alpha)})^\mathsf{T} (\mathbf{p}_{\mathrm{Target}}^{(\ell)} - \mathbf{p}_{\mathrm{Device}}^{(\alpha)} ) }{ d_{\mathrm{Target}}^{(\alpha,\ell)} } \ \text{.}\]

class RadarChannelBase(attenuate=True, *args, **kwargs)[source]¶

Bases: Generic[RCRT], Channel[RCRT, RadarChannelSample]

Base class of all radar channel implementations.

Parameters:: attenuate (bool, optional) – Radar channel attenuation flag, see also RadarChannelBase.attenuate(). Enabled by default.

property attenuate: bool¶

Radar channel attenuation flag.

If enabled, losses such as free-space propagation and radar cross sections will be considered.

class RadarChannelRealization(sample_hooks, gain)[source]¶

Bases: ChannelRealization[RadarChannelSample]

Realization of a radar channel.

_summary_

Parameters:

sample_hooks (Set[ChannelSampleHook[CST]], optional) – Hooks to be called after the channel is sampled.
gain (float) – Linear power gain factor a signal experiences when being propagated over this realization.

class RCRT¶

Type of radar channel realization.

alias of TypeVar(‘RCRT’, bound=RadarChannelRealization)

class RadarChannelSample(paths, gain, state)[source]¶

Bases: ChannelSample

Realization of a radar channel.

Generated by RadarChannelBase.realize() and RadarChannelBase.realize_interference().

Parameters:

paths (Sequence[RadarPath]) – Sequence of realized radar propagation paths.
gain (float) – Channel gain in linear scale.
state (ChannelState) – State of the channel at the time of sampling.

null_hypothesis()[source]¶

Generate a null hypothesis channel sample rom a given channel sample.

Null hypothesis sample will remove non-static propagation components from the channel model. This function is, for example, accessed to evaluate a radar link’s receiver operating characteristics.

Returns: The null hypothesis radar channel realization.

Return type:: RadarChannelSample

state(num_samples, max_num_taps, interpolation_mode=InterpolationMode.NEAREST)[source]¶

Generate the discrete channel state information from this channel realization.

Denoted by

\[\mathbf{H}^{(m, \tau)} \in \mathbb{C}^{N_{\mathrm{Rx}} \times N_{\mathrm{Tx}}}\]

within the respective equations.

Parameters:

num_samples (int) – Number of discrete time-domain samples of the chanel state information.
max_num_taps (int) – Maximum number of delay taps considered per discrete time-domain sample.
interpolation_mode (InterpolationMode, optional) – Interpolation behaviour of the channel realization’s delay components with respect to the proagated signal’s sampling rate. If not specified, an integer rounding to the nearest sampling instance will be assumed.

Return type:

ChannelStateInformation

Returns: The channel state information representing this channel realization.

property expected_energy_scale: float¶

Expected linear scaling of a propagated signal’s energy at each receiving antenna.

Required to compute the expected energy of a signal after propagation, and therfore signal-to-noise ratios (SNRs) and signal-to-interference-plus-noise ratios (SINRs).

property gain: float¶: Channel gain in linear scale.

property paths: Sequence[RadarPath]¶: Sequence of realized radar propagation paths.

class RCST¶

Type of radar channel sample.

alias of TypeVar(‘RCST’, bound=RadarChannelSample)

class RadarPath(attenuate=True, static=False)[source]¶

Bases: HDFSerializable

Realization of a radar propagation path between transmitter and receiver

Parameters:

attenuate (bool, optional) – Should the propagated signal be attenuated during propagation modeling? Enabled by default.
static (bool, optional) – Is the path considered static? Static paths will remain during null hypothesis testing. Disabled by default.

add_propagation(transmitter_state, receiver_state, signal, bandwidth, carrier_frequency, propagated_samples, propagation_delay=None, relative_velocity=None)[source]¶

Add propagation of a signal over this path realization to a given sample buffer.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.
signal (numpy.ndarray) – Signal samples to be propagated.
bandwidth (float) – Sampling rate of the the propagated signal model in Hz.
carrier_frequency (float) – Central carrier frequency of the propagated signal in Hz.
propagated_samples (numpy.ndarray) – Sample buffer to be written to.
propagation_delay (float, optional) – Propagation delay of the wave from transmitter over target to receiver. If not specified, the delay will be queried from propagation_delay().
relative_velocity (float, optional) – Relative velocity between transmitter and receiver. If not specified, the velocity will be queried from relative_velocity().

Return type:

None

add_state(transmitter, receiver, bandwidth, carrier_frequency, delay, state)[source]¶

Add propagation of a signal over this path realization to a given channel state information sample buffer.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.
bandwidth (float) – Sampling rate of the the propagated signal model in Hz.
carrier_frequency (float) – Central carrier frequency of the propagated signal in Hz.
delay (float) – Delay of the channel state information in seconds.
state (numpy.ndarray) – Sample buffer to be written to.

Return type:

None

abstract propagation_delay(transmitter, receiver)[source]¶

Propagation delay of the wave from transmitter over target to receiver.

Denoted by \(\tau_{\ast}\) within the respective equations.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (Device) – Receiving device.

Return type:

float

Returns: Propagation delay in seconds.

abstract propagation_response(transmitter, receiver, carrier_frequency)[source]¶

Multipath sensor array response matrix from transmitter to receiver.

Includes polarization losses.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.
carrier_frequency (float) – Carrier frequency of the propagated signal in Hz. Denoted by \(f_{\mathrm{c}}^{(\alpha)}\) within the respective equations.

Return type:

ndarray

Returns: Numpy matrix of antenna response weights.

abstract relative_velocity(transmitter, receiver)[source]¶

Relative velocity between transmitter and receiver.

Denoted by \(v_{\ast}\) within the respective equations.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.

Return type:

float

Returns: Relative velocity in m/s.

property attenuate: bool¶: Should a propagated signal be attenuated during propagation modeling?

abstract property ground_truth: Tuple[ndarray, ndarray] | None¶

Consolidate the true target information represented by this path.

Either a tuple of the target’s position and velocity or None if the path represents only interference / clutter.

property static: bool¶: Is the path considered static?

class RadarTargetPath(position, velocity, cross_section, reflection_phase, attenuate=True, static=False)[source]¶

Bases: RadarPath

Realization of a radar propagation path resulting from a target scattering

Parameters:

position (numpy.ndarray) – Global position of the path’s target.
velocity (numpy.ndarray) – Global velocity of the path’s target.
cross_section (float) – Radar cross section of the path’s target in \(\mathrm{m}^2\).
reflection_phase (float) – Reflection phase of the path’s target in radians.
attenuate (bool, optional) – Should the propagated signal be attenuated during propagation modeling? Enabled by default.
static (bool, optional) – Is the path considered static? Static paths will remain during null hypothesis testing. Disabled by default.

propagation_delay(transmitter, receiver)[source]¶

Propagation delay of the wave from transmitter over target to receiver.

Denoted by \(\tau_{\ast}\) within the respective equations.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (Device) – Receiving device.

Return type:

float

Returns: Propagation delay in seconds.

propagation_response(transmitter, receiver, carrier_frequency)[source]¶

Multipath sensor array response matrix from transmitter to receiver.

Includes polarization losses.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.
carrier_frequency (float) – Carrier frequency of the propagated signal in Hz. Denoted by \(f_{\mathrm{c}}^{(\alpha)}\) within the respective equations.

Return type:

ndarray

Returns: Numpy matrix of antenna response weights.

relative_velocity(transmitter, receiver)[source]¶

Relative velocity between transmitter and receiver.

Denoted by \(v_{\ast}\) within the respective equations.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.

Return type:

float

Returns: Relative velocity in m/s.

property cross_section: float¶

Radar cross section of the path’s target in \(\mathrm{m}^2\).

Denoted by \(\sigma_{\ell}\) within the respective equations.

property ground_truth: Tuple[ndarray, ndarray]¶

Consolidate the true target information represented by this path.

Either a tuple of the target’s position and velocity or None if the path represents only interference / clutter.

property position: ndarray¶

Global position of the path’s target.

Denoted by \(\mathbf{p}^{(\ell)}\) within the respective equations.

property reflection_phase: float¶

Reflection phase of the path’s target in radians.

Represented by \(\phi_{\mathrm{Target}}^{(\ell)}\) within the respective equations.

property velocity: ndarray¶

Global velocity of the path’s target in m/s as a cartesian vector.

Denoted by \(\mathbf{v}^{(\ell)}\) within the respective equations.

class RadarInterferencePath(attenuate=True, static=False)[source]¶

Bases: RadarPath

Realization of a line of sight interference propgation path between a radar transmitter and receiver

Parameters:

attenuate (bool, optional) – Should the propagated signal be attenuated during propagation modeling? Enabled by default.
static (bool, optional) – Is the path considered static? Static paths will remain during null hypothesis testing. Disabled by default.

propagation_delay(transmitter, receiver)[source]¶

Propagation delay of the wave from transmitter over target to receiver.

Denoted by \(\tau_{\ast}\) within the respective equations.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (Device) – Receiving device.

Return type:

float

Returns: Propagation delay in seconds.

propagation_response(transmitter, receiver, carrier_frequency)[source]¶

Multipath sensor array response matrix from transmitter to receiver.

Includes polarization losses.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.
carrier_frequency (float) – Carrier frequency of the propagated signal in Hz. Denoted by \(f_{\mathrm{c}}^{(\alpha)}\) within the respective equations.

Return type:

ndarray

Returns: Numpy matrix of antenna response weights.

relative_velocity(transmitter, receiver)[source]¶

Relative velocity between transmitter and receiver.

Denoted by \(v_{\ast}\) within the respective equations.

Parameters:

transmitter (DeviceState) – Transmitting device.
receiver (DeviceState) – Receiving device.

Return type:

float

Returns: Relative velocity in m/s.

property ground_truth: None¶

Consolidate the true target information represented by this path.

Either a tuple of the target’s position and velocity or None if the path represents only interference / clutter.