bmd-sim-jamming electronic warfare module to quantify the effects of noise jamming (barrage), deception jamming (DRFM), and counterelectronic measures (ECCM) on radar performance. Burnthrough range calculations, jammer-to-noise ratio (JNR) degradation curves, and track quality collapse thresholds are derived from first-principles radar equations and validated against open-source parametric data. The simulation framework is implemented in Go, outputs JSON via Kafka streaming, and integrates with the broader FORGE command-and-control (C2) architecture for real-time kill-chain exercise support.
The Ballistic Missile Defense System (BMDS) employs a layered sensor network spanning space-based infrared satellites (SBIRS, DSP, STSS) and ground-based phased-array radars to detect, track, discriminate, and engage ballistic missile threats across boost, midcourse, and terminal flight phases. The radars—operating at frequencies from 420 MHz (UHF) to 10 GHz (X-band)—provide the essential fire-control quality data that enables interceptor commit decisions.
Modeling these radars with sufficient physical fidelity to support operational analysis, wargaming, and kill-chain timing studies requires careful attention to the radar range equation, atmospheric propagation losses, detection probability thresholds, track initiation logic, and—critically—the effects of electronic warfare (EW). Adversary jamming, whether barrage noise or sophisticated DRFM-based deception, can degrade or deny radar detection, corrupt track data, and collapse the kill chain. Understanding these effects quantitatively is essential for both defensive planning and ECCM investment decisions.
The FORGE simulation suite provides a family of 57 interoperable binaries covering the full BMDS kill chain. This paper draws on two primary components:
bmd-sim-uewr, bmd-sim-tpy2, bmd-sim-gbr, bmd-sim-lrdr) implementing physically grounded detection, tracking, and discrimination models.bmd-sim-jamming, bmd-sim-electronic-attack) implementing noise jamming, DRFM deception, JNR calculation, burnthrough range, and ECCM effectiveness.The paper is organized as follows: Section 2 reviews radar fundamentals and the range equation. Section 3 details each BMDS radar type with parametric tables. Section 4 covers detection and tracking. Sections 5–7 address electronic attack, JNR/burnthrough analysis, and ECCM techniques. Section 8 describes the Kafka-based integration architecture. Section 9 presents validation, and Section 10 concludes.
The foundational model for all radar detection calculations in the FORGE suite is the monostatic radar range equation, expressed in its energy-on-target form:
$$ \text{SNR} = \frac{P_t \cdot \tau \cdot N \cdot G^2 \cdot \lambda^2 \cdot \sigma}{(4\pi)^3 \cdot R^4 \cdot k \cdot T \cdot L_s} $$where $P_t$ is peak transmit power, $\tau$ is pulse width, $N$ is the number of integrated pulses, $G$ is antenna gain, $\lambda$ is wavelength, $\sigma$ is target radar cross-section (RCS), $R$ is range, $k$ is Boltzmann's constant, $T$ is system noise temperature, and $L_s$ represents aggregate system losses (atmospheric, beamshape, scanning, receiver).
This formulation is preferred over the average-power/bandwidth form because it correctly accounts for energy on target through peak power $\times$ pulse width $\times$ pulse count, rather than assuming uniform spectral occupancy. The FORGE implementation in bmd-sim-uewr computes:
numerator = AvgPower * gainLinear^2 * wavelength^2 * rcs
denominator = (4*pi)^3 * range^4 * k * T * bandwidth * nfLinear
snr = numerator / denominator
where gainLinear = 10^(G/10) and nfLinear = 10^(NF/10). This matches Equation (1) when average power is substituted for $P_t \cdot \tau \cdot N / T_{\text{pri}}$ and bandwidth absorbs the processing gain.
The SNR at the radar receiver determines whether a target is detectable. For a phased-array radar with known parameters, the SNR can be computed directly from Equation (1). In the FORGE models, each radar type has calibrated parameters:
| Parameter | Symbol | Typical Range | Notes |
|---|---|---|---|
| Peak Power | $P_t$ | 100 kW – 1 MW | Per-array-face; UEWR up to 582.4 kW |
| Antenna Gain | G | 38–50 dBi | Phased array; frequency-dependent |
| System Losses | $L_s$ | 10–14 dB | Atmospheric + beamshape + scanning + receiver |
| Noise Figure | NF | 2–3 dB | Receiver noise figure |
| Bandwidth | B | 100 kHz – 10 MHz | Narrowband tracking to wideband discrimination |
The detection threshold is typically set at SNR $\geq$ 13 dB for a single-pulse $P_d = 0.9$ in the FORGE models, though UEWR uses a lower 6 dB threshold appropriate for its UHF early-warning mission with high integration gain.
Detection probability is computed from the SNR using a threshold-based model. The FORGE implementation in bmd-sim-core/pkg/physics provides:
where the threshold is radar-specific (6 dB for UEWR, 13 dB for TPY-2) and $f()$ maps the margin to a probability using a sigmoidal or linear approximation. The implementation properly clamps the result to $[0, 1]$ to avoid numerical artifacts.
For the UEWR model, confidence is computed as:
confidence = min(1.0 - (threshold - snrDB)/20, 1.0)
This gives a linear confidence ramp from threshold (confidence = 0) to threshold + 20 dB (confidence = 1.0), providing a reasonable approximation to the detection probability curve without requiring lookup tables.
The RCS simulator (bmd-sim-rcs) implements four Swerling fluctuation models across 13 threat profiles and 8 frequency bands (VHF through Ka-band). Aspect-dependent RCS is provided for nose, broadside, and tail aspects:
| Threat Type | Nose RCS (m²) | Broadside RCS (m²) | Typical Swerling |
|---|---|---|---|
| ICBM RV | 0.01 – 0.1 | 0.1 – 1.0 | I (slow) / III (fast) |
| MRBM RV | 0.05 – 0.25 | 0.25 – 2.5 | I |
| HGV | 0.001 – 0.01 | 0.01 – 0.1 | I/IV |
| Decoy | 0.001 – 10 | 0.01 – 50 | I or II |
Table 1. Representative RCS values by threat type and aspect.
The FORGE radar suite models five primary ground-based radars spanning three frequency bands. Each has distinct capabilities, roles, and vulnerabilities to electronic warfare.
Figure 1. BMDS radar coverage architecture — five radar types feed detections and tracks into the Track Manager, which correlates and fuses data before passing to C2BMC for engagement decisions. Electronic warfare effects feed into the Track Manager to adjust quality metrics.
The Upgraded Early Warning Radar is a UHF-band (420–450 MHz) phased-array system originally developed from PAVE PAWS and BMEWS sites. Its primary mission is strategic early warning and midcourse tracking of ICBM-class threats at very long range.
| Parameter | Value | Source |
|---|---|---|
| Frequency | 435 MHz (center) | FORGE model |
| Wavelength | 0.69 m | Calculated |
| Peak Power | 1 MW | FORGE model |
| Average Power | 150 kW | FORGE model |
| Antenna Gain | 42 dBi | FORGE model |
| Effective Aperture | ~8,000 m² | FORGE model |
| Noise Figure | 2.0 dB | FORGE model |
| Bandwidth | 100 kHz | Narrowband tracking |
| Detection Range (1 m²) | ~5,500 km | FORGE model |
| Tracking Range | ~3,000 km | FORGE model |
| Track Capacity | 500 simultaneous | FORGE model |
| Min Elevation | 3° | FORGE model |
| System Losses | 12 dB | Atmospheric + beamshape + scanning |
| Sites | Beale AFB, RAF Fylingdales, Clear AFS, Cape Cod AFS | FORGE model |
Table 2. UEWR radar parameters.
The UEWR model implements four-site correlation: a SiteManager maintains active site locations and computes line-of-sight visibility using spherical-Earth geometry. For a site at height $h_s$ and target at altitude $h_t$, the maximum radar horizon is:
where $R_E = 6,371$ km. Multiple sites can simultaneously observe a target, enabling track correlation and handover. The atmospheric loss model at UHF frequencies is minimal (0.5–1 dB two-way for near-horizon paths), which is one of UHF's key advantages.
The AN/TPY-2 is an X-band (8.55–10 GHz) transportable phased-array radar serving both forward-based detection and THAAD fire-control roles. It provides the highest resolution of any BMDS radar, enabling discrimination of closely spaced objects.
| Parameter | Value | Notes |
|---|---|---|
| Frequency | 9.5 GHz | X-band center |
| Peak Power | 100 kW per element | FORGE model |
| Antenna Gain | 45–50+ dBi | High-gain phased array |
| Noise Figure | 3.0 dB | FORGE model |
| Pulse Width | 100 μs | FORGE model |
| PRI Frequency | 300 kHz | FORGE model |
| Bandwidth | 10 MHz | Wideband discrimination |
| Detection Range | ~2,000 km | FORGE model |
| Tracking Range | ~600 km | FORGE model |
| Track Capacity | 1,000 simultaneous | FORGE model |
| System Losses | 10 dB | Including X-band rain/fog attenuation |
Table 3. AN/TPY-2 radar parameters.
The TPY-2 model implements sector-based search management with task scheduling. The radar operates in four modes: Search, Track, Cued Search, and Tasked. A SectorManager divides the surveillance volume into azimuth/elevation sectors and calculates coverage percentage. Track initiation uses M-of-N confirmation logic (default: 3 detections out of 5 opportunities, with SNR threshold of 13 dB).
The Ground-Based Radar (XBR/SBX) is an X-band (10 GHz) phased array designed for midcourse discrimination and GMD fire-control support. It provides the highest resolution discrimination capability in the BMDS inventory.
| Parameter | Value | Notes |
|---|---|---|
| Frequency | 10 GHz | X-band |
| Antenna Gain | 50 dBi | FORGE model |
| System Losses | 10 dB | FORGE model |
| ISLR | −30 dB | Integrated sidelobe ratio for discrimination |
| Detection Range (0.01 m²) | ~328 km | FORGE model |
| Detection Range (1 m²) | ~1,860 km | FORGE model |
Table 4. XBR/SBX radar parameters.
The GBR model implements a discrimination pipeline that classifies objects as Warhead, Decoy, Uncertain, or Unknown based on:
The LRDR at Clear, Alaska is an S-band (~2–4 GHz) radar designed for midcourse discrimination and tracking of ballistic threats approaching North America from the Pacific.
| Parameter | Value | Notes |
|---|---|---|
| Frequency | ~3 GHz | S-band center |
| Peak Power | 280 kW | FORGE model |
| Detection Range (RV) | ~4,871 km | FORGE model |
| Track Capacity | 1,000 simultaneous | FORGE model |
| System Losses | 10 dB | FORGE model |
| ISLR | −30 dB | Discrimination quality |
Table 5. LRDR radar parameters.
LRDR operates in S-band, providing a compromise between UEWR's long-range UHF detection and TPY-2/XBR's X-band discrimination resolution. Its mid-band frequency offers better weather penetration than X-band while providing finer resolution than UHF for discrimination tasks.
The COBRA DANE radar (AN/FPS-108) is an L-band (~1.2–1.4 GHz) phased-array radar on Shemya Island, Alaska. Its primary BMDS role is strategic data collection and tracking of ballistic missiles in the northern Pacific.
| Parameter | Value | Notes |
|---|---|---|
| Frequency | ~1.3 GHz | L-band |
| Detection Range | ~3,000 km | Open-source estimate |
| Primary Role | Data collection, signature measurement | Not fire-control |
| System Losses | 10–12 dB | Estimated |
Table 6. COBRA DANE radar parameters.
Raw detections are insufficient for weapon release. The FORGE track managers implement M-of-N confirmation logic to establish valid tracks. The TPY-2 track initiator uses a default configuration of M=3 detections out of N=5 opportunities:
type MofNConfig struct {
M int // required confirmations
N int // detection opportunities
}
func DefaultMofNConfig() *MofNConfig {
return &MofNConfig{M: 3, N: 5}
}
Figure 2. Track formation state machine — detections progress from pending through M-of-N confirmation (3 of 5) to active track. Tracks are dropped if N opportunities expire without M confirmations.
The track initiation state machine progresses through four states:
Detections are associated with pending tracks using a 5,000-meter spatial gating window. When a new detection falls within this gate of an existing pending track, it is associated; otherwise, a new pending track is created.
Once a track is established, the FORGE track state machine computes a composite quality score from four sub-metrics:
$$ Q_{\text{composite}} = 0.3 \cdot Q_{\text{geometric}} + 0.3 \cdot Q_{\text{signal}} + 0.2 \cdot Q_{\text{temporal}} + 0.2 \cdot Q_{\text{discrimination}} $$where:
Track state transitions are governed by composite quality thresholds:
The UEWR track model maintains full state vectors including latitude, longitude, altitude, speed, heading, and RCS. The phase classification logic determines flight phase from kinematic state:
| Phase | Altitude | Speed | Threat Level |
|---|---|---|---|
| Boost | > 80 km | > 3,000 m/s | — |
| Midcourse | > 60 km | Any | — |
| Reentry | ≤ 60 km | > 1,000 m/s | — |
| Threat Assessment | |||
| CRITICAL | > 100 km | > 5,000 m/s | ICBM-class |
| HIGH | > 50 km | > 2,000 m/s | IRBM/MRBM-class |
| MEDIUM | Any | > 500 m/s | SRBM-class |
| LOW | Below thresholds | Benign | |
Table 7. Track phase and threat classification.
The UEWR SiteManager implements multi-site track correlation. Given four active sites (Beale, Fylingdales, Clear, Cape Cod), a target at altitude h can be observed by all sites within line-of-sight. The CorrelateTrack() function returns the list of sites that can see a given target, enabling:
For typical midcourse targets at 200–400 km altitude, all four UEWR sites with overlapping coverage can observe simultaneously, providing geometric diversity that significantly improves track accuracy and resilience.
Electronic warfare against BMDS radars takes two primary forms: noise jamming (denial) and deception jamming (manipulation). The bmd-sim-jamming package implements both, along with the bmd-sim-electronic-attack binary which provides a broader ECM simulation including DRFM techniques and chaff.
Barrage noise jamming raises the noise floor across a wide bandwidth, reducing the radar's effective SNR and thus its detection range. The NewNoiseJammer constructor creates a jammer with specified power, frequency, bandwidth, and standoff distance:
func NewNoiseJammer(power, freq, bw, distance float64) *Jammer {
return &Jammer{
Type: JamNoise, Power: power, Frequency: freq,
Bandwidth: bw, Distance: distance, Active: true,
}
}
Typical parameters for a standoff noise jammer targeting X-band radars:
The noise jammer's effect is computed through the JNR (Jammer-to-Noise Ratio), which directly degrades the radar's ability to detect targets within the jammed sector.
Digital Radio Frequency Memory (DRFM) jamming is modeled through NewDeceptionJammer, which creates coherent false targets that appear identical to real returns:
func NewDeceptionJammer(power, freq, distance float64) *Jammer {
return &Jammer{
Type: JamDeception, Power: power, Frequency: freq,
Bandwidth: 1e6, Distance: distance, Active: true,
}
}
DRFM techniques modeled in the broader bmd-sim-electronic-attack include:
The bmd-sim-electronic-attack reports both jsr_db (J/S ratio in dB) and jammer_effective (boolean), indicating whether the jamming is sufficient to deny the target radar. For the default AN/TPY-2 scenario with a 10 kW noise barrage at 200 km range, the J/S ratio is strongly negative (−125 dB), indicating the radar easily burns through at operational ranges. However, higher-power jammers at closer range can achieve effective denial.
The bmd-sim-electronic-attack supports additional ECM types beyond noise and DRFM:
| ECM Type | Code | Effect |
|---|---|---|
| Noise Barrage | NOISE_BARRAGE | Broadband noise raising floor |
| Noise Spot | NOISE_SPOT | Narrowband noise focused on radar frequency |
| DRFM | DRFM | Coherent false target generation |
| RGPO | RGPO | Range gate pull-off |
| VGPO | VGPO | Velocity gate pull-off |
| Cross-Pol | CROSSPOL | Cross-polarization angle deception |
| Chaff | CHAFF | Frequency-dependent volumetric scattering |
Table 8. ECM types supported by bmd-sim-electronic-attack.
Figure 5. JNR vs range degradation curves — the 1 MW ERP standoff jammer denies detection at close range (JNR $\geq$ 20 dB), with effect diminishing as $1/R^2$. A 10 kW jammer produces only degraded effects. Sidelobe blanking (SLB) ECCM at +30 dB pushes the entire curve below the noise floor, effectively neutralizing the jammer.
The JNR quantifies how much the jammer raises the noise floor at the radar receiver. The FORGE implementation computes:
$$ \text{JNR}_{\text{dB}} = 10 \cdot \log_{10}\!\left(\frac{P_J \cdot G_R}{4\pi \cdot R_J^2 \cdot k \cdot T_0 \cdot B_R}\right) $$where $P_J$ is jammer ERP, $G_R$ is radar receive gain (linear), $R_J$ is jammer-to-radar distance, $k$ is Boltzmann's constant, $T_0 = 290$ K is reference temperature, and $B_R$ is radar receiver bandwidth.
In the code:
func (j *Jammer) JNR(radarGain, radarBandwidth float64) float64 {
if !j.Active || j.Distance <= 0 || j.Power <= 0 {
return 0
}
gainLinear := math.Pow(10, radarGain/10)
jPowerDensity := j.Power * gainLinear / (4 * math.Pi * j.Distance * j.Distance)
noisePower := 1.38e-23 * 290 * radarBandwidth
jsr := jPowerDensity / noisePower
if jsr <= 0 { return 0 }
return 10 * math.Log10(jsr)
}
The JNR calculation uses the jammer's power density at the radar (accounting for the one-way propagation loss $1/(4\pi R^2)$) divided by the radar's internal noise power. This is the correct formulation for a standoff jammer whose energy arrives through the radar's sidelobes or main beam.
Burnthrough range is the range at which the radar's signal energy exceeds the jammer energy by a specified margin, allowing target detection even in the presence of jamming. The FORGE implementation:
func (j *Jammer) BurnthroughRange(radarPower, radarGain,
targetRCS, marginDB float64) float64 {
if j.Power <= 0 || j.Distance <= 0 { return 1e9 }
gainLinear := math.Pow(10, radarGain/10)
marginLinear := math.Pow(10, marginDB/10)
burnRange := math.Sqrt(
radarPower * gainLinear * targetRCS * j.Distance * j.Distance /
(4 * math.Pi * j.Power * marginLinear))
return burnRange
}
This derives from equating the radar's two-way signal power at range $R_{\text{BT}}$ with the jammer's one-way interference power, including a required margin $M$. The result is:
$$ R_{\text{BT}} = \sqrt{\frac{P_R \cdot G \cdot \sigma \cdot R_J^2}{4\pi \cdot P_J \cdot M}} $$Note that burnthrough range scales as the square root of the ratio of radar power $\times$ gain $\times$ RCS to jammer power. This means that doubling the radar power or target RCS only increases burnthrough range by a factor of $\sqrt{2}$, while halving the jammer power has the same effect. This fundamental scaling underscores why ECCM techniques that reduce effective jammer power (like sidelobe blanking at $-30$ dB) are more impactful than increasing radar power.
The JammingEffect function maps JNR to operational impact categories:
func JammingEffect(jnrDB float64) string {
switch {
case jnrDB < 0: return "NONE"
case jnrDB < 10: return "DEGRADED"
case jnrDB < 20: return "SIGNIFICANT"
default: return "DENIED"
}
}
| JNR (dB) | Effect | Operational Impact |
|---|---|---|
| < 0 | NONE | Jammer below noise floor; no effect on radar |
| 0 – 10 | DEGRADED | Partial reduction in detection range; track quality reduced |
| 10 – 20 | SIGNIFICANT | Major detection range reduction; some tracks lost |
| ≥ 20 | DENIED | Radar sector denied; no reliable detection possible |
Table 9. JNR thresholds and operational effects.
The bmd-sim-electronic-attack extends this with scenario-specific degradation metrics. For example, the default AN/TPY-2 scenario with noise barrage jamming reports:
burnthrough_km: Range at which radar can track through jammingdetection_range_km: Effective detection range under jammingradar_only_range_km: Unjammed detection rangeeccm_suppression_db: How much ECCM reduces jamming (dB)eccm_range_recovery_pct: Percentage of range recovered by ECCMjammer_effective: Whether jamming denies the radarElectronic Counter-Countermeasures (ECCM) are techniques employed by radars to mitigate the effects of jamming. The bmd-sim-jamming package models four primary ECCM techniques with their effectiveness in dB of jamming reduction:
func ECCMEffectiveness(technique ECCMTechnique) float64 {
switch technique {
case ECCMFreqAgility: return 20 // dB
case ECCMSidelobeBlanking: return 30 // dB
case ECCMHomeOnJam: return 15 // dB
case ECCMPulseCompression: return 10 // dB
default: return 0
}
}
Frequency agility (frequency hopping) forces the jammer to spread its power across a wider bandwidth, reducing spectral power density at any single frequency. If the radar hops across $N_f$ frequencies and the jammer must cover all of them, the effective jammer power at each frequency is reduced by a factor of $N_f$. The 20 dB figure corresponds to a 100:1 frequency hopping ratio, meaning the jammer's effective power at any single radar frequency is reduced by a factor of 100.
For X-band radars like TPY-2, which can hop across 1.45 GHz of bandwidth, frequency agility is particularly effective against narrowband spot jammers but less effective against wideband barrage jammers that cover the full hopping range.
Sidelobe blanking (SLB) is the most effective ECCM in the model at +30 dB. It works by using an auxiliary antenna to detect jammer energy arriving through the radar's sidelobes and blanking the receiver during those periods. Since most standoff jamming enters through sidelobes (which are 30–40 dB below the main beam), blanking the sidelobes effectively rejects the jammer energy while preserving main-beam detection.
The 30 dB figure is consistent with typical phased-array sidelobe levels. UEWR's 42 dBi main beam gain versus ~10 dBi sidelobes gives approximately 32 dB of sidelobe rejection, making SLB highly effective for this class of radar.
Home-on-Jam (HOJ) is an intercept technique rather than a detection ECCM. When a radar-guided interceptor detects a jammer, it can use the jammer's energy as a beacon for terminal guidance. The +15 dB figure represents the operational advantage: rather than being denied by jamming, the interceptor uses the jammer's radiation as a targeting source. This transforms a jammer from a defensive asset (denying radar detection) into an offensive liability (providing a guidance source).
HOJ is modeled as a 15 dB improvement in the kill chain because it effectively eliminates the need for the radar to maintain track quality through jamming—the interceptor homes directly on the jammer. This is particularly effective against standoff noise jammers whose position is known.
Pulse compression (chirp or phase coding) provides processing gain by transmitting a long pulse with internal modulation and compressing it upon reception. This increases the effective SNR without increasing peak power. The +10 dB figure corresponds to a compression ratio of 10:1 (approximately 10 dB), which is conservative for modern BMDS radars that may achieve 20–30 dB of compression gain.
Pulse compression is effective against noise jamming because the jammer's energy is spread across the uncompressed bandwidth, while the radar's matched filter concentrates the signal energy. However, DRFM jammers can replicate the pulse compression code, negating this advantage.
Figure 3. ECCM pipeline — jamming is detected and classified as noise or deception, then the appropriate countermeasures are selected. Noise jamming is countered by frequency agility, sidelobe blanking, and pulse compression; deception jamming is countered by Home-on-Jam. ECCM techniques can be stacked for up to 50+ dB of combined rejection.
bmd-sim-electronic-attack models ECCM stacking with the eccm_suppression_db and eccm_net_gain_db fields.
Figure 4. Kafka integration flow — radar and EW simulators produce JSON events to Kafka topics, consumed by the track correlator for multi-source fusion and C2BMC for engagement decisions. EW analytics consume jamming/ECCM topics for real-time threat assessment.
All FORGE simulators produce JSON output that can be streamed via Apache Kafka for real-time integration. The C2 framework (forge-c2) implements a Kafka consumer/producer pattern:
type SensorEvent struct {
EventID string `json:"event_id"`
Timestamp time.Time `json:"timestamp"`
SensorID string `json:"sensor_id"`
SensorType string `json:"sensor_type"` // OPIR, RADAR, SEISMIC, ACOUSTIC
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
Altitude float64 `json:"altitude"`
Azimuth float64 `json:"azimuth"`
Elevation float64 `json:"elevation"`
SignalType string `json:"signal_type"` // IR, RF, SEISMIC, ACOUSTIC
Intensity float64 `json:"intensity"`
Frequency float64 `json:"frequency"`
SNR float64 `json:"snr"`
Confidence float64 `json:"confidence"`
}
Kafka topics are organized by sensor type and data class:
forge.radar.detection — Raw detection events from all radarsforge.radar.track — Confirmed track updatesforge.ew.jamming — Jamming events and JNR measurementsforge.ew.eccm — ECCM activation and effectiveness reportsforge.c2.engage — Engagement orders from C2BMCThe consumer uses configurable group IDs (forge-c2-<topic>) with last-offset start for real-time scenarios, ensuring each C2 instance processes all events without duplication.
The radar and EW simulators integrate into the broader FORGE C2 ecosystem through the forge-c2 framework, which provides:
The kill chain flows through these components: radar detections enter via Kafka, are correlated by forge-track-correlator, prioritized by bmd-sim-c2bmc with ROE enforcement, and assigned to interceptors by bmd-sim-wta (Weapon-Target Assignment). The bmd-sim-kill-chain-rt orchestrates real-time kill chain timing with an -ew flag that injects EW scenarios, providing direct measurement of how jamming affects the end-to-end kill chain.
All simulators produce standardized JSON output via the sim-cli shared library:
result := cli.NewSimResult("jamging")
result.Parameters["power_w"] = j.Power
result.Parameters["freq_ghz"] = j.Frequency / 1e9
result.Parameters["jnr_db"] = j.JNR(30, 1e6)
result.Parameters["effect"] = jamming.JammingEffect(j.JNR(30, 1e6))
result.Parameters["burnthrough_range_km"] = 45
result.Parameters["eccm_available"] = "FREQUENCY_AGILITY"
result.Parameters["detection_degradation_pct"] = 35
result.Parameters["track_degradation_pct"] = 25
cli.WriteJSON(result)
This schema enables machine-readable consumption by AI planners, visualization systems, and higher-level wargaming frameworks. The -json flag produces one-shot results; -i enables interactive mode with live streaming; and -duration and -seed flags support reproducible scenario runs.
The FORGE radar models are validated against open-source parametric data for each radar type. Key validation results:
The UEWR model computes a maximum detection range of ~5,500 km against a 1 m$^2$ RCS target, consistent with published PAVE PAWS performance estimates of 4,800–5,500 km. The 6 dB detection threshold (lower than fire-control radars) reflects UEWR's early-warning mission where high integration gain compensates for lower per-pulse SNR.
The TPY-2 model computes a search volume range of ~6,304 km (for a large RCS) and ~630 km against a 0.1 m$^2$ RV-class target, consistent with published AN/TPY-2 performance data of 600–2,000 km depending on mode and RCS.
The GBR/XBR model achieves detection at ~328 km against a 0.01 m$^2$ target and ~1,860 km against a 1 m$^2$ target, matching published X-band radar performance for midcourse discrimination.
The JNR implementation is validated against analytical predictions. For the default noise jammer (1 MW ERP, 3 GHz, 100 MHz bandwidth, 500 km range) against a 30 dBi radar with 1 MHz bandwidth, the model reports JNR = 109 dB, confirming that this particular jamming configuration far exceeds the denial threshold. The JammingEffect function correctly classifies this as "DENIED."
For a 5 MW radar with 50 dBi gain tracking a 1.0 m$^2$ target through 10 dB of jamming margin, the burnthrough model produces a positive range consistent with the radar equation scaling. Unit tests confirm that inactive jammers and zero-distance jammers return appropriate boundary values.
The four ECCM techniques (frequency agility 20 dB, sidelobe blanking 30 dB, HOJ 15 dB, pulse compression 10 dB) are consistent with published effectiveness values in Adamy (2001) and Schleher (1999). Sidelobe blanking at 30 dB matches the typical sidelobe rejection ratio of phased arrays.
about/ directory for each simulator.
This paper has presented the FORGE BMDS radar simulation suite, integrating detection probability modeling, track quality metrics, and electronic warfare effects into a unified framework. The key findings are:
The FORGE simulation suite provides a physically grounded, composable framework for exploring these dynamics. All models are open-source, JSON-native, and integrate via Kafka for real-time wargaming. Future work includes adding atmospheric refraction models for UHF, ISAR imaging for XBR, cognitive jamming patterns, and multi-radar cross-jamming scenarios.
forge-sims repository.bmd-sim-jamming repository.bmd-sim-uewr repository.bmd-sim-tpy2 repository.bmd-sim-gbr repository.bmd-sim-lrdr repository.