Radars

class stonesoup.sensor.radar.radar.RadarBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)

Bases: SimpleSensor

A simple radar sensor that generates measurements of targets, using a CartesianToBearingRange model, relative to its position.

Note

The current implementation of this class assumes a 3D Cartesian plane.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

ndim_state: int

Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

position_mapping: Tuple[int, int]

Mapping between the target’s state space and the sensor’s measurement capability

noise_covar: CovarianceMatrix

The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

max_range: float

The maximum detection range of the radar (in meters)

property measurement_model

Measurement model of the sensor, describing general sensor model properties

class stonesoup.sensor.radar.radar.RadarBearing(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)

Bases: SimpleSensor

A simple radar sensor that generates measurements of targets, using a Cartesian2DToBearing model, relative to its position.

Note

The current implementation of this class assumes a 2D Cartesian plane.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying Cartesian2DToBearing model

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying Cartesian2DToBearing model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

ndim_state: int

Number of state dimensions. This is utilised by (and follows in format) the underlying Cartesian2DToBearing model

position_mapping: Tuple[int, int]

Mapping between the target’s state space and the sensor’s measurement capability

noise_covar: CovarianceMatrix

The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying Cartesian2DToBearing model

max_range: float

The maximum detection range of the radar (in meters)

property measurement_model

Measurement model of the sensor, describing general sensor model properties

class stonesoup.sensor.radar.radar.RadarRotatingBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, dwell_centre: StateVector, rpm: float, fov_angle: float, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf, resolution: Angle = Angle(0.017453292519943295))

Bases: RadarBearingRange

A simple rotating radar, with set field-of-view (FOV) angle, range and rotations per minute (RPM), that generates measurements of targets, using a CartesianToBearingRange model, relative to its position.

Note

• The current implementation of this class assumes a 3D Cartesian plane.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• dwell_centre (StateVector) – A state_vector property that describes the rotation angle of the centre of the sensor’s current FOV (i.e. the dwell centre) relative to the positive x-axis of the sensor frame/orientation. The angle is positive if the rotation is in the counter-clockwise direction when viewed by an observer looking down the z-axis of the sensor frame, towards the origin. Angle units are in radians

• rpm (float) – The number of antenna rotations per minute (RPM)

• fov_angle (float) – The radar field of view (FOV) angle (in radians).

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

• resolution (Angle, optional) – Resolution of the dwell_centre. Used by the DwellActionsGenerator during sensor management.

dwell_centre: StateVector

A state_vector property that describes the rotation angle of the centre of the sensor’s current FOV (i.e. the dwell centre) relative to the positive x-axis of the sensor frame/orientation. The angle is positive if the rotation is in the counter-clockwise direction when viewed by an observer looking down the z-axis of the sensor frame, towards the origin. Angle units are in radians

rpm: float

The number of antenna rotations per minute (RPM)

resolution: Angle

Resolution of the dwell_centre. Used by the DwellActionsGenerator during sensor management.

max_range: float

The maximum detection range of the radar (in meters)

fov_angle: float

The radar field of view (FOV) angle (in radians).

property measurement_model

Measurement model of the sensor, describing general sensor model properties

measure(ground_truths: Set[GroundTruthState], noise: ndarray | bool = True, **kwargs) → Set[TrueDetection]

Generate a measurement for a given state

Parameters:

• ground_truths (Set[GroundTruthState]) – A set of GroundTruthState

• noise (numpy.ndarray or bool) – An externally generated random process noise sample (the default is True, in which case rvs() is used; if False, no noise will be added)

Returns:

A set of measurements generated from the given states. The timestamps of the measurements are set equal to that of the corresponding states that they were calculated from. Each measurement stores the ground truth path that it was produced from.

Return type:

Set[TrueDetection]

class stonesoup.sensor.radar.radar.RadarRotatingBearing(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, dwell_centre: StateVector, rpm: float, fov_angle: float, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf, resolution: Angle = Angle(0.017453292519943295))

Bases: RadarBearing

A simple rotating radar, with set field-of-view (FOV) angle, range and rotations per minute (RPM), that generates measurements of targets, using a Cartesian2DToBearing model, relative to its position.

Note

• The current implementation of this class assumes a 2D Cartesian plane.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying Cartesian2DToBearing model

• dwell_centre (StateVector) – A state_vector property that describes the rotation angle of the centre of the sensor’s current FOV (i.e. the dwell centre) relative to the positive x-axis of the sensor frame/orientation. The angle is positive if the rotation is in the counter-clockwise direction when viewed by an observer looking down the z-axis of the sensor frame, towards the origin. Angle units are in radians

• rpm (float) – The number of antenna rotations per minute (RPM)

• fov_angle (float) – The radar field of view (FOV) angle (in radians).

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying Cartesian2DToBearing model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

• resolution (Angle, optional) – Resolution of the dwell_centre. Used by the DwellActionsGenerator during sensor management.

dwell_centre: StateVector

A state_vector property that describes the rotation angle of the centre of the sensor’s current FOV (i.e. the dwell centre) relative to the positive x-axis of the sensor frame/orientation. The angle is positive if the rotation is in the counter-clockwise direction when viewed by an observer looking down the z-axis of the sensor frame, towards the origin. Angle units are in radians

rpm: float

The number of antenna rotations per minute (RPM)

resolution: Angle

Resolution of the dwell_centre. Used by the DwellActionsGenerator during sensor management.

max_range: float

The maximum detection range of the radar (in meters)

fov_angle: float

The radar field of view (FOV) angle (in radians).

property measurement_model

Measurement model of the sensor, describing general sensor model properties

measure(ground_truths: Set[GroundTruthState], noise: ndarray | bool = True, **kwargs) → Set[TrueDetection]

Generate a measurement for a given state

Parameters:

• ground_truths (Set[GroundTruthState]) – A set of GroundTruthState

• noise (numpy.ndarray or bool) – An externally generated random process noise sample (the default is True, in which case rvs() is used; if False, no noise will be added)

Returns:

A set of measurements generated from the given states. The timestamps of the measurements are set equal to that of the corresponding states that they were calculated from. Each measurement stores the ground truth path that it was produced from.

Return type:

Set[TrueDetection]

class stonesoup.sensor.radar.radar.RadarElevationBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 3, max_range: float = inf)

Bases: RadarBearingRange

A radar sensor that generates measurements of targets, using a CartesianToElevationBearingRange model, relative to its position.

Note

This implementation of this class assumes a 3D Cartesian space.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToElevationBearingRange model

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

ndim_state: int

Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

noise_covar: CovarianceMatrix

The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToElevationBearingRange model

max_range: float

The maximum detection range of the radar (in meters)

property measurement_model

Measurement model of the sensor, describing general sensor model properties

class stonesoup.sensor.radar.radar.RadarBearingRangeRate(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 3, max_range: float = inf, velocity_mapping: Tuple[int, int, int] = (1, 3, 5))

Bases: RadarBearingRange

A radar sensor that generates measurements of targets, using a CartesianToBearingRangeRate model, relative to its position and velocity.

Note

This class implementation assumes a 3D cartesian space and therefore expects a 6D state space.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToBearingRangeRate model

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRangeRate model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

• velocity_mapping (Tuple[int, int, int], optional) – Mapping to the target’s velocity information within its state space

velocity_mapping: Tuple[int, int, int]

Mapping to the target’s velocity information within its state space

ndim_state: int

Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRangeRate model

noise_covar: CovarianceMatrix

The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToBearingRangeRate model

property measurement_model

Measurement model of the sensor, describing general sensor model properties

class stonesoup.sensor.radar.radar.RadarElevationBearingRangeRate(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 6, max_range: float = inf, velocity_mapping: Tuple[int, int, int] = (1, 3, 5))

Bases: RadarBearingRangeRate

A radar sensor that generates measurements of targets, using a CartesianToElevationBearingRangeRate model, relative to its position and velocity.

Note

The current implementation of this class assumes a 3D Cartesian plane.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToElevationBearingRangeRate model

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToElevationBearingRangeRate model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

• velocity_mapping (Tuple[int, int, int], optional) – Mapping to the target’s velocity information within its state space

velocity_mapping: Tuple[int, int, int]

Mapping to the target’s velocity information within its state space

ndim_state: int

Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToElevationBearingRangeRate model

noise_covar: CovarianceMatrix

The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToElevationBearingRangeRate model

property measurement_model

Measurement model of the sensor, describing general sensor model properties

class stonesoup.sensor.radar.radar.RadarRasterScanBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, dwell_centre: StateVector, rpm: float, fov_angle: float, for_angle: float, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf, resolution: Angle = Angle(0.017453292519943295))

Bases: RadarRotatingBearingRange

A simple raster scan radar, with set field-of-regard (FoR) angle, field-of-view (FoV) angle, range and rotations per minute (RPM), that generates measurements of targets, using a CartesianToBearingRange model, relative to its position

This is a simple extension of the RadarRotatingBearingRange class with the rotate function changed to restrict the dwell-centre to within the field of regard. It’s important to note that this only works (has been tested) in an 2D environment

Note

This class implementation assumes a 3D cartesian space and therefore expects a 6D state space.

Parameters:

• position_mapping (Tuple[int, int]) – Mapping between the target’s state space and the sensor’s measurement capability

• noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• dwell_centre (StateVector) – A state object, whose state_vector property describes the rotation angle of the centre of the sensor’s current FOV (i.e. the dwell centre) relative to the positive x-axis of the sensor frame/orientation. The angle is positive if the rotation is in the counter-clockwise direction when viewed by an observer looking down the z-axis of the sensor frame, towards the origin. Angle units are in radians

• rpm (float) – The number of antenna rotations per minute (RPM)

• fov_angle (float) – The radar field of view (FOV) angle (in radians).

• for_angle (float) – The radar field of regard (FoR) angle (in radians).

• rotation_offset (StateVector, optional) – A StateVector containing the sensor rotation offsets from the platform’s primary axis (defined as the direction of motion). Defaults to a zero vector with the same length as the Platform’s velocity_mapping

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• clutter_model (ClutterModel, optional) – An optional clutter generator that adds a set of simulated Clutter objects to the measurements at each time step. The clutter is simulated according to the provided distribution.

• ndim_state (int, optional) – Number of state dimensions. This is utilised by (and follows in format) the underlying CartesianToBearingRange model

• max_range (float, optional) – The maximum detection range of the radar (in meters)

• resolution (Angle, optional) – Resolution of the dwell_centre. Used by the DwellActionsGenerator during sensor management.

dwell_centre: StateVector

A state object, whose state_vector property describes the rotation angle of the centre of the sensor’s current FOV (i.e. the dwell centre) relative to the positive x-axis of the sensor frame/orientation. The angle is positive if the rotation is in the counter-clockwise direction when viewed by an observer looking down the z-axis of the sensor frame, towards the origin. Angle units are in radians

for_angle: float

The radar field of regard (FoR) angle (in radians).

act(timestamp)

Rotate the sensor’s antenna

This method computes and updates the sensor’s dwell_centre property.

Parameters:

timestamp (datetime.datetime) – A timestamp signifying when the rotation completes

class stonesoup.sensor.radar.radar.AESARadar(measurement_model: MeasurementModel, beam_shape: BeamShape, beam_transition_model: BeamTransitionModel, duty_cycle: float, band_width: float, receiver_noise: float, frequency: float, antenna_gain: float, beam_width: float, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, position_mapping: Tuple[int, int, int] = (0, 1, 2), number_pulses: int = 1, loss: float = 0, swerling_on: bool = False, rcs: float = None, probability_false_alarm: Probability = 1e-06)

Bases: Sensor

An AESA (Active electronically scanned array) radar model that calculates the signal to noise ratio (SNR) of a target and the subsequent probability of detection (PD). The SNR is calculated using:

\[\mathit{SNR} = \dfrac{c^2\, n_p \,\beta}{64\,\pi^3 \,kT_0 \,B \,F \,f^2 \,L} \times\dfrac{\sigma\, G_a^2\, P_t}{R^4}\]

where \(c\) is the speed of light \(n_p\) is the number of pulses in a burst \(\beta\) is the duty cycle which is unitless \(k\) is the boltzmann constant \(T_0\) is system temperature in kelvin \(B\) is the bandwidth in hertz \(F\) is the noise figure unitless \(f\) is the frequency in hertz \(L\) is the loss which is unitless The probability of detection (\(P_{d}\)) is calculated using the North’s approximation,

\[P_{d} = 0.5\, erfc\left(\sqrt{-\ln{P_{fa}}}-\sqrt{ \mathit{SNR} +0.5} \right)\]

where \(P_{fa}\) is the probability of false alarm. In this model the AESA scan angle effects the gain by:

\[G_a = G_a \cos{\left(\theta\right)} \cos{\left(\phi\right)}\]

where \(\theta\) and \(\phi\) are respectively the azimuth and elevation angles in respects to the boresight of the antenna. The effect of beam spoiling on the beam width is :

\[\Delta\theta = \dfrac{\Delta\theta}{\cos{\left(\theta\right)} \cos{\left(\phi\right)}}\]

Note

The current implementation of this class assumes a 3D Cartesian plane. This model does not generate false alarms.

Parameters:

• measurement_model (MeasurementModel) – The measurement model used to generate measurements.

• beam_shape (BeamShape) – Object describing the shape of the beam.

• beam_transition_model (BeamTransitionModel) – Object describing the movement of the beam in azimuth and elevation from the perspective of the radar.

• duty_cycle (float) – Duty cycle is the fraction of the time the radar is transmitting.

• band_width (float) – Bandwidth of the receiver in hertz.

• receiver_noise (float) – Noise figure of the radar in decibels.

• frequency (float) – Transmitted frequency in hertz.

• antenna_gain (float) – Total antenna gain in decibels.

• beam_width (float) – Radar beam width in radians.

• rotation_offset (StateVector, optional) – A 3x1 array of angles (rad), specifying the radar orientation in terms of the counter-clockwise rotation around the \(x,y,z\) axis. i.e Roll, Pitch and Yaw. Default is StateVector([0, 0, 0])

• mounting_offset (StateVector, optional) – A StateVector containing the sensor translation offsets from the platform’s reference point. Defaults to a zero vector with length 3

• movement_controller (Movable, optional) – The `Movable object that controls the movement of this sensor. Will be set by the platform if the sensor is assigned to a platform.

• position_mapping (Tuple[int, int, int], optional) – Mapping between or positions and state dimensions. [x,y,z]

• number_pulses (int, optional) – The number of pulses in the radar burst.

• loss (float, optional) – Loss in decibels.

• swerling_on (bool, optional) – Is the Swerling 1 case used. If True the RCS of the target will change for each timestep. The random RCS follows the probability distribution of the Swerling 1 case.

• rcs (float, optional) – The radar cross section of targets in meters squared. Used if RCS not present on truth. Default None, where ‘rcs’ must be present on truth.

• probability_false_alarm (Probability, optional) – Probability of false alarm used in the North’s approximation

position_mapping: Tuple[int, int, int]

Mapping between or positions and state dimensions. [x,y,z]

beam_shape: BeamShape

Object describing the shape of the beam.

beam_transition_model: BeamTransitionModel

Object describing the movement of the beam in azimuth and elevation from the perspective of the radar.

number_pulses: int

The number of pulses in the radar burst.

duty_cycle: float

Duty cycle is the fraction of the time the radar is transmitting.

band_width: float

Bandwidth of the receiver in hertz.

receiver_noise: float

Noise figure of the radar in decibels.

frequency: float

Transmitted frequency in hertz.

antenna_gain: float

Total antenna gain in decibels.

beam_width: float

Radar beam width in radians.

loss: float

Loss in decibels.

swerling_on: bool

Is the Swerling 1 case used. If True the RCS of the target will change for each timestep. The random RCS follows the probability distribution of the Swerling 1 case.

rcs: float

The radar cross section of targets in meters squared. Used if RCS not present on truth. Default None, where ‘rcs’ must be present on truth.

probability_false_alarm: Probability

Probability of false alarm used in the North’s approximation

rotation_offset: StateVector

A 3x1 array of angles (rad), specifying the radar orientation in terms of the counter-clockwise rotation around the \(x,y,z\) axis. i.e Roll, Pitch and Yaw. Default is StateVector([0, 0, 0])

measurement_model: MeasurementModel

The measurement model used to generate measurements.

gen_probability(truth)

Generates probability of detection of a given State.

Parameters:

truth (The target state.)

Returns:

• det_prob (float) – Probability of detection.

• snr (float) – Signal to noise ratio.

• rcs (float) – RCS after the Swerling 1 case is applied.

• directed_power (float) – Power in the direction of the target.

• spoiled_gain (float) – Gain in decibels with beam spoiling applied.

• spoiled_width (float) – Beam width with beam spoiling applied.

measure(ground_truths: Set[GroundTruthState], noise: ndarray | bool = True, **kwargs) → Set[TrueDetection]

Generate a measurement for a given state

Parameters:

• ground_truths (Set[GroundTruthState]) – A set of GroundTruthState

• noise (numpy.ndarray or bool) – An externally generated random process noise sample (the default is True, in which case rvs() is used; if False, no noise will be added)

Returns:

A set of measurements generated from the given states. The timestamps of the measurements are set equal to that of the corresponding states that they were calculated from. Each measurement stores the ground truth path that it was produced from.

Return type:

Set[TrueDetection]

Beam Patterns

class stonesoup.sensor.radar.beam_pattern.BeamTransitionModel(centre: Sequence)

Bases: Base

Base class for Beam Transition Model

Parameters:

centre (Sequence) – Centre of the beam pattern

centre: Sequence

Centre of the beam pattern

abstract move_beam(timestamp, **kwargs)

Gives position of beam at given time

class stonesoup.sensor.radar.beam_pattern.StationaryBeam(centre: Sequence)

Bases: BeamTransitionModel

Stationary beam that points in the direction of centre

Parameters:

centre (Sequence) – Centre of the beam pattern

move_beam(*args, **kwargs)

generates a beam position based on the centre

Returns:

• azimuth (float) – azimuth from the perspective of the radar at given timestamp

• elevation (float) – elevation from the perspective of the radar at given timestamp

class stonesoup.sensor.radar.beam_pattern.BeamSweep(angle_per_s: float, frame: Tuple[float, float], separation: float, centre: Tuple[float, float] = (0, 0), init_time: datetime = None)

Bases: BeamTransitionModel

This describes a beam moving in a raster pattern

Parameters:

• angle_per_s (float) – The speed that the beam scans at

• frame (Tuple[float, float]) – Dimensions of search frame as [azimuth,elevation]

• separation (float) – Separation of lines in elevation

• centre (Tuple[float, float], optional) – Centre of the search frame in [azimuth,elevation]. Defaults to (0, 0)

• init_time (datetime.datetime, optional) – The time the frame is started

init_time: datetime

The time the frame is started

angle_per_s: float

The speed that the beam scans at

frame: Tuple[float, float]

Dimensions of search frame as [azimuth,elevation]

separation: float

Separation of lines in elevation

centre: Tuple[float, float]

Centre of the search frame in [azimuth,elevation]. Defaults to (0, 0)

move_beam(timestamp, **kwargs)

Returns the position of the beam at given timestamp

Parameters:

timestamp (datetime.datetime) – current timestep

Returns:

• azimuth (float) – azimuth from the perspective of the radar at given timestamp

• elevation (float) – elevation from the perspective of the radar at given timestamp

Beam Shapes

class stonesoup.sensor.radar.beam_shape.BeamShape(peak_power: float)

Bases: Base

Base class for beam shape

Parameters:

peak_power (float) – peak power of the main lobe in Watts

peak_power: float

peak power of the main lobe in Watts

abstract beam_power(azimuth, elevation, beam_width, **kwargs)

beam power sent in the direction of the target. azimuth = elevation = 0 for center of beam

class stonesoup.sensor.radar.beam_shape.Beam2DGaussian(peak_power: float)

Bases: BeamShape

The beam is in the shape of a 2D gaussian in the azimuth and elevation. The width at half the maxima is the beam width. It is described by:

\[P = P_p\exp \left( 0.5 \times \left(\left(\frac{2.35\,az}{B_w}\right) ^2 +\left(\frac{2.35\,el}{B_w}\right)^2 \right) \right)\]

where \(az\) and \(el\) are the azimuth and elevation angles away from the centre. \(B_w\) is the beam width and \(P_p\) is the peak power.

Parameters:

peak_power (float) – peak power of the main lobe in Watts

beam_power(azimuth, elevation, beam_width, **kwargs)

Parameters:

• azimuth (float) – The angle of the target away from the boresight of the radar in azimuth

• elevation (float) – The angle of the target away from the boresight of the radar in elevation

• beam_width (float) – The width of the radar beam

Returns:

the power directed towards the target

Return type:

float