Range Equation

Radar and one-way link range equations.

Implements the two-way radar range equation (received signal power and SNR) and the one-way Friis transmission equation used for jammer link budgets.

min_target_detection_range(Pt, Gt, Gr, sigma, wavelength, SNR_thresh, B, F, L, T)

Calculate the maximum detectable range for a single uncoded pulse given an SNR threshold. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
SNR_thresh	float	Minimum SNR required for detection [unitless]	required
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required

Returns:

Name	Type	Description
float	float	Maximum detection range [m]

Source code in src/rad_lab/range_equation.py

def min_target_detection_range(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    SNR_thresh: float,
    B: float,
    F: float,
    L: float,
    T: float,
) -> float:
    """
    Calculate the maximum detectable range for a single uncoded pulse given an SNR threshold.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        SNR_thresh (float): Minimum SNR required for detection [unitless]
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]

    Returns:
        float: Maximum detection range [m]
    """
    return (
        (Pt * Gt * Gr * sigma * wavelength**2)
        / (((4 * c.PI) ** 3) * (SNR_thresh) * c.K_BOLTZ * T * B * F * L)
    ) ** (1 / 4)

min_target_detection_range_bpsk_cp(Pt, Gt, Gr, sigma, wavelength, SNR_thresh, B, F, L, T, n_p, n_c)

Calculate the maximum detectable range for coherently processed BPSK pulses. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
SNR_thresh	float	Minimum SNR required for detection [unitless]	required
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required
n_p	float	Number of pulses coherently processed [unitless]	required
n_c	float	Number of binary chips per pulse [unitless]	required

Returns:

Name	Type	Description
float	float	Maximum detection range [m]

Source code in src/rad_lab/range_equation.py

def min_target_detection_range_bpsk_cp(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    SNR_thresh: float,
    B: float,
    F: float,
    L: float,
    T: float,
    n_p: float,
    n_c: float,
) -> float:
    """
    Calculate the maximum detectable range for coherently processed BPSK pulses.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        SNR_thresh (float): Minimum SNR required for detection [unitless]
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]
        n_p (float): Number of pulses coherently processed [unitless]
        n_c (float): Number of binary chips per pulse [unitless]

    Returns:
        float: Maximum detection range [m]
    """
    one_pulse = min_target_detection_range(Pt, Gt, Gr, sigma, wavelength, SNR_thresh, B, F, L, T)
    return one_pulse * (n_p * n_c) ** (1 / 4)

min_target_detection_range_dutyfactor_cp(Pt, Gt, Gr, sigma, wavelength, SNR_thresh, F, L, T, Tcpi, tau_df)

Calculate the maximum detectable range for coherently processed pulses using duty factor parameters. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Peak transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
SNR_thresh	float	Minimum SNR required for detection [unitless]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required
Tcpi	float	Total coherent processing interval duration [s]	required
tau_df	float	Radar duty factor [0 to 1]	required

Returns:

Name	Type	Description
float	float	Maximum detection range [m]

Source code in src/rad_lab/range_equation.py

def min_target_detection_range_dutyfactor_cp(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    SNR_thresh: float,
    F: float,
    L: float,
    T: float,
    Tcpi: float,
    tau_df: float,
) -> float:
    """
    Calculate the maximum detectable range for coherently processed pulses using duty factor parameters.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Peak transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        SNR_thresh (float): Minimum SNR required for detection [unitless]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]
        Tcpi (float): Total coherent processing interval duration [s]
        tau_df (float): Radar duty factor [0 to 1]

    Returns:
        float: Maximum detection range [m]
    """
    one_pulse = min_target_detection_range(Pt, Gt, Gr, sigma, wavelength, SNR_thresh, 1, F, L, T)
    return one_pulse * (Tcpi * tau_df) ** (1 / 4)

noise_power(B, F, T)

Calculate the thermal noise power of the receiver.

Parameters:

Name	Type	Description	Default
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
T	float	System noise temperature [Kelvin]	required

Returns:

Name	Type	Description
float	float	Noise power [W]

Source code in src/rad_lab/range_equation.py

def noise_power(B: float, F: float, T: float) -> float:
    """
    Calculate the thermal noise power of the receiver.

    Args:
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        T (float): System noise temperature [Kelvin]

    Returns:
        float: Noise power [W]
    """
    return c.K_BOLTZ * T * B * F

signal_range_eqn(Pt, Gt, Gr, sigma, wavelength, R, L)

Calculate the received signal power for a radar system.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range to the target [m]	required
L	float	System losses [unitless]	required

Returns:

Name	Type	Description
float	float	Received signal power [W]

Source code in src/rad_lab/range_equation.py

def signal_range_eqn(
    Pt: float, Gt: float, Gr: float, sigma: float, wavelength: float, R: float, L: float
) -> float:
    """
    Calculate the received signal power for a radar system.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range to the target [m]
        L (float): System losses [unitless]

    Returns:
        float: Received signal power [W]
    """
    return (Pt * Gt * Gr * sigma * wavelength**2) / (((4 * c.PI) ** 3) * (R**4) * L)

signal_range_eqn_one_way(Pt, Gt, Gr, wavelength, R, L)

Calculate the received power for a one-way communication link (Friis equation).

Models a transmitter and receiver with no target reflection — e.g. an EA platform retransmitting a stored pulse directly to the radar receiver.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range between transmitter and receiver [m]	required
L	float	System losses [unitless]	required

Returns:

Name	Type	Description
float	float	Received power [W]

Source code in src/rad_lab/range_equation.py

def signal_range_eqn_one_way(
    Pt: float, Gt: float, Gr: float, wavelength: float, R: float, L: float
) -> float:
    """
    Calculate the received power for a one-way communication link (Friis equation).

    Models a transmitter and receiver with no target reflection — e.g. an EA
    platform retransmitting a stored pulse directly to the radar receiver.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range between transmitter and receiver [m]
        L (float): System losses [unitless]

    Returns:
        float: Received power [W]
    """
    return (Pt * Gt * Gr * wavelength**2) / ((4 * c.PI) ** 2 * R**2 * L)

snr_range_eqn(Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T, time_bandwidth_prod)

Calculate the single-pulse Signal-to-Noise Ratio (SNR) for a pulse with pulse compression. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range to the target [m]	required
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required
time_bandwidth_prod	float	Pulse compression ratio (time-bandwidth product) [unitless]	required

Returns:

Name	Type	Description
float	float	Signal-to-Noise Ratio [unitless]

Source code in src/rad_lab/range_equation.py

def snr_range_eqn(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    R: float,
    B: float,
    F: float,
    L: float,
    T: float,
    time_bandwidth_prod: float,
) -> float:
    """
    Calculate the single-pulse Signal-to-Noise Ratio (SNR) for a pulse with pulse compression.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range to the target [m]
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]
        time_bandwidth_prod (float): Pulse compression ratio (time-bandwidth product) [unitless]

    Returns:
        float: Signal-to-Noise Ratio [unitless]
    """
    return (
        snr_range_eqn_uncoded(Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T) * time_bandwidth_prod
    )

snr_range_eqn_bpsk_cp(Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T, n_p, n_c)

Calculate the Signal-to-Noise Ratio (SNR) for Binary Phase Shift Keying (BPSK) pulses after coherent processing. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range to the target [m]	required
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required
n_p	float	Number of pulses coherently integrated [unitless]	required
n_c	float	Number of binary chips per pulse [unitless]	required

Returns:

Name	Type	Description
float	float	Integrated Signal-to-Noise Ratio [unitless]

Source code in src/rad_lab/range_equation.py

def snr_range_eqn_bpsk_cp(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    R: float,
    B: float,
    F: float,
    L: float,
    T: float,
    n_p: float,
    n_c: float,
) -> float:
    """
    Calculate the Signal-to-Noise Ratio (SNR) for Binary Phase Shift Keying (BPSK) pulses after coherent processing.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range to the target [m]
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]
        n_p (float): Number of pulses coherently integrated [unitless]
        n_c (float): Number of binary chips per pulse [unitless]

    Returns:
        float: Integrated Signal-to-Noise Ratio [unitless]
    """
    return snr_range_eqn_cp(Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T, n_p, n_c)

snr_range_eqn_cp(Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T, n_p, time_bandwidth_prod)

Calculate the Signal-to-Noise Ratio (SNR) after coherent processing of multiple pulses. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range to the target [m]	required
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required
n_p	float	Number of pulses coherently integrated [unitless]	required
time_bandwidth_prod	float	Pulse compression ratio [unitless]	required

Returns:

Name	Type	Description
float	float	Integrated Signal-to-Noise Ratio [unitless]

Source code in src/rad_lab/range_equation.py

def snr_range_eqn_cp(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    R: float,
    B: float,
    F: float,
    L: float,
    T: float,
    n_p: float,
    time_bandwidth_prod: float,
) -> float:
    """
    Calculate the Signal-to-Noise Ratio (SNR) after coherent processing of multiple pulses.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range to the target [m]
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]
        n_p (float): Number of pulses coherently integrated [unitless]
        time_bandwidth_prod (float): Pulse compression ratio [unitless]

    Returns:
        float: Integrated Signal-to-Noise Ratio [unitless]
    """
    single_pulse_snr = snr_range_eqn(
        Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T, time_bandwidth_prod
    )
    return single_pulse_snr * n_p

snr_range_eqn_duty_factor_pulses(Pt, Gt, Gr, sigma, wavelength, R, F, L, T, Tcpi, tau_df)

Calculate the Signal-to-Noise Ratio (SNR) using the duty factor and coherent processing interval. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Peak transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range to the target [m]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required
Tcpi	float	Total coherent processing interval (CPI) duration [s]	required
tau_df	float	Radar duty factor [0 to 1]	required

Returns:

Name	Type	Description
float	float	Integrated Signal-to-Noise Ratio [unitless]

Source code in src/rad_lab/range_equation.py

def snr_range_eqn_duty_factor_pulses(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    R: float,
    F: float,
    L: float,
    T: float,
    Tcpi: float,
    tau_df: float,
) -> float:
    """
    Calculate the Signal-to-Noise Ratio (SNR) using the duty factor and coherent processing interval.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Peak transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range to the target [m]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]
        Tcpi (float): Total coherent processing interval (CPI) duration [s]
        tau_df (float): Radar duty factor [0 to 1]

    Returns:
        float: Integrated Signal-to-Noise Ratio [unitless]
    """
    assert 0 <= tau_df <= 1, "duty factor must be in [0,1]."

    single_pulse_snr = snr_range_eqn_uncoded(Pt, Gt, Gr, sigma, wavelength, R, 1, F, L, T)
    return single_pulse_snr * Tcpi * tau_df

snr_range_eqn_uncoded(Pt, Gt, Gr, sigma, wavelength, R, B, F, L, T)

Calculate the single-pulse Signal-to-Noise Ratio (SNR) for an uncoded pulse. All gain and loss factors must be in linear (unitless) form.

Parameters:

Name	Type	Description	Default
Pt	float	Transmit power [W]	required
Gt	float	Transmit antenna gain [unitless]	required
Gr	float	Receive antenna gain [unitless]	required
sigma	float	Radar cross section [m^2]	required
wavelength	float	Wavelength of the carrier signal [m]	required
R	float	Range to the target [m]	required
B	float	Receiver bandwidth [Hz]	required
F	float	Receiver noise factor [unitless]	required
L	float	System losses [unitless]	required
T	float	System noise temperature [Kelvin]	required

Returns:

Name	Type	Description
float	float	Signal-to-Noise Ratio [unitless]

Source code in src/rad_lab/range_equation.py

def snr_range_eqn_uncoded(
    Pt: float,
    Gt: float,
    Gr: float,
    sigma: float,
    wavelength: float,
    R: float,
    B: float,
    F: float,
    L: float,
    T: float,
) -> float:
    """
    Calculate the single-pulse Signal-to-Noise Ratio (SNR) for an uncoded pulse.
    All gain and loss factors must be in linear (unitless) form.

    Args:
        Pt (float): Transmit power [W]
        Gt (float): Transmit antenna gain [unitless]
        Gr (float): Receive antenna gain [unitless]
        sigma (float): Radar cross section [m^2]
        wavelength (float): Wavelength of the carrier signal [m]
        R (float): Range to the target [m]
        B (float): Receiver bandwidth [Hz]
        F (float): Receiver noise factor [unitless]
        L (float): System losses [unitless]
        T (float): System noise temperature [Kelvin]

    Returns:
        float: Signal-to-Noise Ratio [unitless]
    """
    return (Pt * Gt * Gr * sigma * wavelength**2) / (
        ((4 * c.PI) ** 3) * (R**4) * c.K_BOLTZ * T * B * F * L
    )