Radars
- class stonesoup.sensor.radar.radar.RadarBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, resolutions: dict = None, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesianToBearingRange
modelresolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesianToBearingRange
modelmax_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
- 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, resolutions: dict = None, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesian2DToBearing
modelresolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesian2DToBearing
modelmax_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
- 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, resolutions: dict = None, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesianToBearingRange
modeldwell_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 radiansrpm (
float
) – The number of antenna rotations per minute (RPM)fov_angle (
float
) – The radar field of view (FOV) angle (in radians).resolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesianToBearingRange
modelmax_range (
float
, optional) – The maximum detection range of the radar (in meters)
- 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
- 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] [source]
Generate a measurement for a given state
- Parameters:
ground_truths (Set[
GroundTruthState
]) – A set ofGroundTruthState
noise (
numpy.ndarray
or bool) – An externally generated random process noise sample (the default is True, in which caservs()
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, resolutions: dict = None, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesian2DToBearing
modeldwell_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 radiansrpm (
float
) – The number of antenna rotations per minute (RPM)fov_angle (
float
) – The radar field of view (FOV) angle (in radians).resolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesian2DToBearing
modelmax_range (
float
, optional) – The maximum detection range of the radar (in meters)
- 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
- 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] [source]
Generate a measurement for a given state
- Parameters:
ground_truths (Set[
GroundTruthState
]) – A set ofGroundTruthState
noise (
numpy.ndarray
or bool) – An externally generated random process noise sample (the default is True, in which caservs()
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, resolutions: dict = None, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 3, max_range: float = inf)[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesianToElevationBearingRange
modelresolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesianToBearingRange
modelmax_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
- 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, resolutions: dict = None, 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))[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesianToBearingRangeRate
modelresolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesianToBearingRangeRate
modelmax_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, resolutions: dict = None, 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))[source]
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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesianToElevationBearingRangeRate
modelresolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesianToElevationBearingRangeRate
modelmax_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, resolutions: dict = None, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, clutter_model: ClutterModel = None, ndim_state: int = 2, max_range: float = inf)[source]
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 positionThis 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 capabilitynoise_covar (
CovarianceMatrix
) – The sensor noise covariance matrix. This is utilised by (and follows in format) the underlyingCartesianToBearingRange
modeldwell_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 radiansrpm (
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).resolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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’svelocity_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 3movement_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 simulatedClutter
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 underlyingCartesianToBearingRange
modelmax_range (
float
, optional) – The maximum detection range of the radar (in meters)
- 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
- act(timestamp)[source]
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, resolutions: dict = None, 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)[source]
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.resolutions (
dict
, optional) – Mapping of eachActionableProperty
of the sensor and corresponding resolutions at which the sensor is able to be tasked.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 isStateVector([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 3movement_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
- beam_transition_model: BeamTransitionModel
Object describing the movement of the beam in azimuth and elevation from the perspective of the radar.
- 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)[source]
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] [source]
Generate a measurement for a given state
- Parameters:
ground_truths (Set[
GroundTruthState
]) – A set ofGroundTruthState
noise (
numpy.ndarray
or bool) – An externally generated random process noise sample (the default is True, in which caservs()
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)[source]
Bases:
Base
Base class for Beam Transition Model
- Parameters:
centre (
Sequence
) – Centre of the beam pattern
- class stonesoup.sensor.radar.beam_pattern.StationaryBeam(centre: Sequence)[source]
Bases:
BeamTransitionModel
Stationary beam that points in the direction of centre
- Parameters:
centre (
Sequence
) – Centre of the beam pattern
- 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)[source]
Bases:
BeamTransitionModel
This describes a beam moving in a raster pattern
- Parameters:
angle_per_s (
float
) – The speed that the beam scans atframe (
Tuple[float, float]
) – Dimensions of search frame as [azimuth,elevation]separation (
float
) – Separation of lines in elevationcentre (
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
- move_beam(timestamp, **kwargs)[source]
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)[source]
Bases:
Base
Base class for beam shape
- Parameters:
peak_power (
float
) – peak power of the main lobe in Watts
- class stonesoup.sensor.radar.beam_shape.Beam2DGaussian(peak_power: float)[source]
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)[source]
- 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