EW SYSTEMS CALCULATOR

import numpy as np

def radar_range(Pt, Gt, Gr, sigma, freq_GHz, S_min):
    """Radar range equation — returns max range in km"""
    lam = 3e8 / (freq_GHz * 1e9)          # wavelength
    numerator   = Pt * Gt * Gr * sigma * lam**2
    denominator = (4 * np.pi)**3 * S_min
    R_max = (numerator / denominator)**(1/4)    # metres
    return R_max / 1e3                           # km

import numpy as np

def compute_js_ratio(Pj, Gj, Pt, Gt, sigma, Rt_km, Rj_km):
    """Jamming-to-Signal ratio for self-protection or escort jamming.
    Returns J/S in dB. Positive means jamming dominates."""
    Rt = Rt_km * 1e3
    Rj = Rj_km * 1e3
    # Power ratio (linear)
    js_linear = (Pj * Gj * 4 * np.pi * Rt**2) / (Pt * Gt * sigma * Rj**2)
    js_dB = 10 * np.log10(js_linear)
    return js_dB

# Operational note: J/S > 0 dB masks target; typical ERP requirement: 6–20 dB

import numpy as np

def friis(Pt_W, Gt, Gr, freq_GHz, R_km):
    """Friis transmission — returns received power in dBm"""
    lam = 3e8 / (freq_GHz * 1e9)
    R   = R_km * 1e3
    Pr  = Pt_W * Gt * Gr * (lam / (4 * np.pi * R))**2
    return 10 * np.log10(Pr * 1e3)   # dBm

import numpy as np

def required_jammer_eirp(js_req_dB, Pt, Gt, sigma, Rt_km, Rj_km):
    """Compute required jammer EIRP (dBW) to achieve specified J/S.
    Follows Listing 5.9 from the book."""
    js_req = 10**(js_req_dB / 10)         # dB → linear
    Rt = Rt_km * 1e3
    Rj = Rj_km * 1e3
    # Required EIRP = J/S * (Pt*Gt*sigma) / (4*pi) * (Rj/Rt)^2
    eirp_linear = js_req * Pt * Gt * sigma * (Rj / Rt)**2 / (4 * np.pi)
    eirp_dBW    = 10 * np.log10(eirp_linear)
    return eirp_dBW, eirp_linear

eirp_dBW, eirp_W = required_jammer_eirp(6, 50e3, 3162, 1, 100, 110)
print(f"Required EIRP: {eirp_dBW:.1f} dBW ({eirp_W/1e3:.2f} kW)")

import numpy as np

def escort_js(Pj, Gj, Pt, Gt, sigma, Rj_km, Rt_km, freq_GHz):
    """Escort Jammer J/S ratio.
    Uses full bistatic radar equation vs one-way jammer path."""
    lam = 3e8 / (freq_GHz * 1e9)
    Rj, Rt = Rj_km*1e3, Rt_km*1e3
    # Jammer signal at radar receiver (one-way)
    Sj = (Pj * Gj * lam**2) / (4 * np.pi * Rj)**2
    # Target echo at radar receiver (two-way)
    Se = (Pt * Gt * sigma * lam**2) / ((4*np.pi)**3 * Rt**4)
    js = 10 * np.log10(Sj / Se)
    return js

# G_r cancels (same receive antenna sees both jammer and target)

import numpy as np

def es_intercept_range(Pt, Gt, Ges, S_es_dBm, freq_GHz):
    """ES receiver intercept range — returns km"""
    lam    = 3e8 / (freq_GHz * 1e9)
    S_es   = 10**(S_es_dBm/10) * 1e-3     # dBm → W
    EIRP   = Pt * Gt
    R = (lam / (4 * np.pi)) * np.sqrt(EIRP * Ges / S_es)
    return R / 1e3

# ES typically intercepts 2–5× radar's own detection range

import numpy as np

def tdoa_crlb(BW_MHz, snr_dB, N_obs):
    """Cramér-Rao Lower Bound for TDOA position accuracy."""
    B    = BW_MHz * 1e6
    snr  = 10**(snr_dB / 10)
    c    = 3e8
    # Timing noise standard deviation (CRLB)
    sigma_t = 1 / (2 * np.pi * B * np.sqrt(2 * snr))
    # Position error
    sigma_pos = c * sigma_t / np.sqrt(N_obs)
    return sigma_pos   # metres (1σ)

# Example: 10 MHz BW, 20 dB SNR, 3 pairs → sub-10m accuracy

import numpy as np

def gps_jam_range(Pj_W, Gj, js_req_dB, Gr=2.0):
    """GPS L1 C/A jamming radius (km).
    For the legacy C/A code, R_c = 1/(23 × 10^-3), G_c = 0, J/S ≥ 10 dB,
    maintaining lock: J/S ≥ 10-25 dB, acquisition: J/S ≥ 25-35 dB."""
    f_L1    = 1575.42e6   # L1 frequency Hz
    lam     = 3e8 / f_L1
    S_gps   = 10**(-130/10) * 1e-3   # −130 dBm → W
    js_req  = 10**(js_req_dB/10)
    R = (lam / (4*np.pi)) * np.sqrt(Pj_W * Gj * Gr / (js_req * S_gps))
    return R / 1e3

print(f"10W omni jammer @ J/S=20dB: {gps_jam_range(10,1,20):.1f} km")

import numpy as np

h = 6.626e-34; c = 3e8; k = 1.381e-23

def planck_radiance(lam_um, T):
    """Spectral radiance of blackbody (W/m²/sr/m).
    lam_um: wavelength in micrometres, T: temperature in Kelvin"""
    lam = lam_um * 1e-6                          # μm → m
    B = (2*h*c**2 / lam**5) / (np.exp(h*c/(lam*k*T)) - 1)
    return B * 1e-6                               # → W/m²/sr/μm

# Wien's Law peak wavelength
wien_peak = 2898 / T   # μm

import numpy as np

def ir_detection_snr(phi_s, phi_b, eta, N):
    """IR detector SNR — background-limited detection model.
    Returns SNR in dB and detection regime label."""
    signal  = eta * phi_s * np.sqrt(N)
    noise   = np.sqrt(eta * (phi_s + phi_b))
    snr     = signal / noise
    blip    = phi_b / phi_s          # background-to-signal ratio
    regime  = "BLIP" if blip > 10 else "Shot-noise limited"
    return 10*np.log10(snr), regime

# Detection threshold: SNR > 5–15 dB depending on P_fa requirement

import numpy as np

def receiver_sensitivity(NF_dB, B_MHz, SNR_min_dB):
    """Minimum detectable signal power (dBm).
    kT0 = −174 dBm/Hz at 290 K standard temperature."""
    kT0_dBm_Hz = -174.0
    S_min = kT0_dBm_Hz + NF_dB + 10*np.log10(B_MHz*1e6) + SNR_min_dB
    return S_min

# Typical superheterodyne EW receiver: NF=6dB, B=10MHz → −108dBm sensitivity
# Wide-open receiver: NF=12dB, B=1GHz → −72dBm (much lower sensitivity)

import numpy as np

def iq_image_rejection(alpha, phi_deg):
    """Image Rejection Ratio for IQ imbalance.
    alpha: amplitude imbalance (linear), phi: phase imbalance (degrees)."""
    phi = np.radians(phi_deg)
    num = (1 + alpha*np.cos(phi))**2 + (alpha*np.sin(phi))**2
    den = (1 - alpha*np.cos(phi))**2 + (alpha*np.sin(phi))**2
    irr = 10 * np.log10(num / den)
    return irr

def correct_iq(y, alpha, phi_deg):
    """Estimate IQ correction using least-squares ."""
    phi = np.radians(phi_deg)
    # Correction matrix
    A = np.array([[1, 0],
                  [-np.sin(phi)/alpha, np.cos(phi)/alpha]])
    iq = np.vstack([y.real, y.imag])
    corrected = A @ iq
    return corrected[0] + 1j*corrected[1]