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, ndim_state: int = 2)[source]

Bases: stonesoup.sensor.sensor.Sensor

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 targets state space and the sensors measurement capability

  • noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follow 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.

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

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 targets state space and the sensors measurement capability

noise_covar: stonesoup.types.array.CovarianceMatrix

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

measure(ground_truths: Set[GroundTruthState], noise: Union[numpy.ndarray, bool] = True, **kwargs)Set[stonesoup.types.detection.TrueDetection][source]

Generate a measurement for a given state

Parameters
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.RadarRotatingBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, dwell_center: State, rpm: float, max_range: float, fov_angle: float, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, ndim_state: int = 2)[source]

Bases: stonesoup.sensor.radar.radar.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 targets state space and the sensors measurement capability

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

  • dwell_center (State) – A state object, whose state_vector property describes the rotation angle of the center of the sensor’s current FOV (i.e. the dwell center) 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)

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

  • 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.

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

dwell_center: stonesoup.types.state.State

A state object, whose state_vector property describes the rotation angle of the center of the sensor’s current FOV (i.e. the dwell center) 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)

max_range: float

The maximum detection range of the radar (in meters)

fov_angle: float

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

measure(ground_truths: Set[GroundTruthState], noise: Union[numpy.ndarray, bool] = True, **kwargs)Set[stonesoup.types.detection.TrueDetection][source]

Generate a measurement for a given state

Parameters
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]

rotate(timestamp)[source]

Rotate the sensor’s antenna

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

Parameters

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

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, ndim_state: int = 3)[source]

Bases: stonesoup.sensor.radar.radar.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 targets state space and the sensors measurement capability

  • noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follow 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.

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

ndim_state: int

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

noise_covar: stonesoup.types.array.CovarianceMatrix

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

measure(ground_truths: Set[GroundTruthState], noise: Union[numpy.ndarray, bool] = True, **kwargs)Set[stonesoup.types.detection.TrueDetection][source]

Generate a measurement for a given state

Parameters
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.RadarBearingRangeRate(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, ndim_state: int = 3, velocity_mapping: Tuple[int, int, int] = (1, 3, 5))[source]

Bases: stonesoup.sensor.radar.radar.RadarBearingRange

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

Note

This class implementation assuming at 3D cartesian space, it therefore expects a 6D state space.

Parameters
  • position_mapping (Tuple[int, int]) – Mapping between the targets state space and the sensors measurement capability

  • noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follow 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.

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

  • 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: stonesoup.types.array.CovarianceMatrix

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

measure(ground_truths: Set[GroundTruthState], noise: Union[numpy.ndarray, bool] = True, **kwargs)Set[stonesoup.types.detection.TrueDetection][source]

Generate a measurement for a given state

Parameters
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.RadarElevationBearingRangeRate(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, ndim_state: int = 6, velocity_mapping: Tuple[int, int, int] = (1, 3, 5))[source]

Bases: stonesoup.sensor.radar.radar.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 targets state space and the sensors measurement capability

  • noise_covar (CovarianceMatrix) – The sensor noise covariance matrix. This is utilised by (and follow 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.

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

  • 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: stonesoup.types.array.CovarianceMatrix

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

measure(ground_truths: Set[GroundTruthState], noise: Union[numpy.ndarray, bool] = True, **kwargs)Set[stonesoup.types.detection.TrueDetection][source]

Generate a measurement for a given state

Parameters
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.RadarRasterScanBearingRange(position_mapping: Tuple[int, int], noise_covar: CovarianceMatrix, dwell_center: State, rpm: float, max_range: float, fov_angle: float, for_angle: float, rotation_offset: StateVector = None, mounting_offset: StateVector = None, movement_controller: Movable = None, ndim_state: int = 2)[source]

Bases: stonesoup.sensor.radar.radar.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-center 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 assuming at 3D cartesian space, it therefore expects a 6D state space.

Parameters
  • position_mapping (Tuple[int, int]) – Mapping between the targets state space and the sensors measurement capability

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

  • dwell_center (State) – A state object, whose state_vector property describes the rotation angle of the center of the sensor’s current FOV (i.e. the dwell center) 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)

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

  • 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.

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

for_angle: float

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

rotate(timestamp)[source]

Rotate the sensor’s antenna

This method computes and updates the sensor’s dwell_center 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)[source]

Bases: stonesoup.sensor.sensor.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 it 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]

measurement_model: stonesoup.models.measurement.base.MeasurementModel

The Measurement model used to generate measurements.

beam_shape: stonesoup.sensor.radar.beam_shape.BeamShape

Object describing the shape of the beam.

beam_transition_model: stonesoup.sensor.radar.beam_pattern.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 it 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: stonesoup.types.numeric.Probability

Probability of false alarm used in the North’s approximation

rotation_offset: stonesoup.types.array.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])

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: Union[numpy.ndarray, bool] = True, **kwargs)Set[stonesoup.types.detection.TrueDetection][source]

Generate a measurement for a given state

Parameters
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: stonesoup.base.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)[source]

Gives position of beam at given time

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

Bases: stonesoup.sensor.radar.beam_pattern.BeamTransitionModel

Stationary beam that points in the direction of centre

Parameters

centre (Sequence) – Centre of the beam pattern

move_beam(*args, **kwargs)[source]

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.datetime = None)[source]

Bases: stonesoup.sensor.radar.beam_pattern.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.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)[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: stonesoup.base.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)[source]

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)[source]

Bases: stonesoup.sensor.radar.beam_shape.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