Graham McIntire
c6adc989e9
PathCompute.compute/5 now accepts an :on_progress callback and emits
9 named stages (resolve → terrain → HRRR grid → atmospheric → sounding
→ scoring → budget → forecast → ionosphere). PathLive runs the compute
in start_async, streams {:compute_progress, step, total, label}
messages from the callback, and renders the current stage + step/total
in the disabled button alongside a daisyUI progress bar — replacing
the static "Computing..." while the multi-second pipeline runs.
handle_async covers :ok, :error, and {:exit, _} (last logs per the
CLAUDE.md async-error rule). Existing PathLive tests that asserted on
result content after live() were switched to render_async(lv) so they
wait for the task; new tests cover the progress callback ordering and
the in-flight label rendering.
288 lines
10 KiB
Elixir
288 lines
10 KiB
Elixir
defmodule Microwaveprop.Propagation.PathComputeTest do
|
|
use Microwaveprop.DataCase, async: false
|
|
use ExUnitProperties
|
|
|
|
alias Microwaveprop.Propagation.BandConfig
|
|
alias Microwaveprop.Propagation.PathCompute
|
|
alias Microwaveprop.Weather.HrrrProfile
|
|
|
|
describe "compute_loss_budget/5" do
|
|
test "fspl increases with distance" do
|
|
band = BandConfig.get(10_000)
|
|
near = PathCompute.compute_loss_budget(10.0, 10.0, band, nil, nil)
|
|
far = PathCompute.compute_loss_budget(100.0, 10.0, band, nil, nil)
|
|
assert near.fspl < far.fspl
|
|
assert near.total < far.total
|
|
end
|
|
|
|
test "fspl increases with frequency" do
|
|
band_10g = BandConfig.get(10_000)
|
|
band_24g = BandConfig.get(24_000)
|
|
low = PathCompute.compute_loss_budget(50.0, 10.0, band_10g, nil, nil)
|
|
high = PathCompute.compute_loss_budget(50.0, 24.0, band_24g, nil, nil)
|
|
assert low.fspl < high.fspl
|
|
end
|
|
|
|
test "gas absorption losses with default humidity when conditions absent" do
|
|
band = BandConfig.get(10_000)
|
|
result = PathCompute.compute_loss_budget(50.0, 10.0, band, nil, nil)
|
|
assert result.o2 >= 0
|
|
assert result.h2o >= 0
|
|
end
|
|
|
|
test "higher bands have more h2o absorption" do
|
|
band_10g = BandConfig.get(10_000)
|
|
band_75g = BandConfig.get(75_000)
|
|
low = PathCompute.compute_loss_budget(50.0, 10.0, band_10g, nil, nil)
|
|
high = PathCompute.compute_loss_budget(50.0, 75.0, band_75g, nil, nil)
|
|
assert low.h2o <= high.h2o
|
|
end
|
|
|
|
test "rain loss is zero when there's no rain" do
|
|
band = BandConfig.get(10_000)
|
|
conditions = %{rain_rate_mmhr: 0.0, abs_humidity: 7.5}
|
|
result = PathCompute.compute_loss_budget(50.0, 10.0, band, nil, conditions)
|
|
assert result.rain == 0.0
|
|
end
|
|
|
|
test "rain loss is positive when it's raining" do
|
|
band = BandConfig.get(10_000)
|
|
conditions = %{rain_rate_mmhr: 5.0, abs_humidity: 7.5}
|
|
result = PathCompute.compute_loss_budget(50.0, 10.0, band, nil, conditions)
|
|
assert result.rain > 0
|
|
end
|
|
|
|
test "diffraction loss is included when terrain result is present" do
|
|
band = BandConfig.get(10_000)
|
|
terrain = %{analysis: %{diffraction_db: 15.0}}
|
|
result = PathCompute.compute_loss_budget(50.0, 10.0, band, terrain, nil)
|
|
assert result.diffraction == 15.0
|
|
end
|
|
|
|
test "diffraction loss is zero when no terrain result" do
|
|
band = BandConfig.get(10_000)
|
|
result = PathCompute.compute_loss_budget(50.0, 10.0, band, nil, nil)
|
|
assert result.diffraction == 0.0
|
|
end
|
|
end
|
|
|
|
describe "compute_loss_budget/5 property" do
|
|
property "total is always >= fspl" do
|
|
check all(
|
|
dist_km <- float(min: 0.1, max: 500),
|
|
band_config = BandConfig.get(10_000)
|
|
) do
|
|
result = PathCompute.compute_loss_budget(dist_km, 10.0, band_config, nil, nil)
|
|
assert result.total >= result.fspl
|
|
assert result.total > 0
|
|
end
|
|
end
|
|
|
|
property "all loss components are non-negative across known bands" do
|
|
bands = [50, 144, 222, 432, 902, 1_296, 2_304, 3_400, 5_760, 10_000, 24_000, 47_000, 75_000]
|
|
|
|
check all(
|
|
dist_km <- float(min: 0.1, max: 500),
|
|
band_mhz <- member_of(bands)
|
|
) do
|
|
band_config = BandConfig.get(band_mhz)
|
|
freq_ghz = band_mhz / 1000
|
|
result = PathCompute.compute_loss_budget(dist_km, freq_ghz, band_config, nil, nil)
|
|
assert result.fspl >= 0
|
|
assert result.o2 >= 0
|
|
assert result.h2o >= 0
|
|
assert result.rain >= 0
|
|
assert result.diffraction >= 0
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "resolve_location/1" do
|
|
test "parses a coordinate pair" do
|
|
assert {:ok, %{lat: 32.9, lon: -96.8}} = PathCompute.resolve_location("32.9, -96.8")
|
|
end
|
|
|
|
test "parses a Maidenhead grid" do
|
|
assert {:ok, %{kind: :grid, label: "EM12"}} = PathCompute.resolve_location("EM12")
|
|
end
|
|
|
|
test "blank input returns the location-required error" do
|
|
assert {:error, "Location is required"} = PathCompute.resolve_location("")
|
|
assert {:error, "Location is required"} = PathCompute.resolve_location(nil)
|
|
end
|
|
end
|
|
|
|
describe "build_ionosphere_readout/4" do
|
|
test "returns nil for non-ionosphere bands (microwave)" do
|
|
assert PathCompute.build_ionosphere_readout(10_000, 32.9, -96.8, 100.0) == nil
|
|
assert PathCompute.build_ionosphere_readout(24_000, 32.9, -96.8, 100.0) == nil
|
|
end
|
|
|
|
test "returns nil for bands the readout does not handle (e.g. 902 MHz)" do
|
|
# The function only opens up for [50, 144, 222, 432]; 902 falls
|
|
# through to the catch-all clause.
|
|
assert PathCompute.build_ionosphere_readout(902, 32.9, -96.8, 100.0) == nil
|
|
end
|
|
|
|
test "returns nil when band is supported but no ionosphere data is available" do
|
|
# 6m and 2m hit the `Ionosphere.nearest_foes/2` path; with an empty
|
|
# test DB the function returns `{:error, :no_data}` and the
|
|
# readout falls through to the catch-all `nil` arm.
|
|
assert PathCompute.build_ionosphere_readout(50, 32.9, -96.8, 100.0) == nil
|
|
assert PathCompute.build_ionosphere_readout(144, 32.9, -96.8, 100.0) == nil
|
|
end
|
|
end
|
|
|
|
describe "compute/4 — full pipeline" do
|
|
setup do
|
|
Req.Test.stub(Microwaveprop.Terrain.ElevationClient, fn conn ->
|
|
params = Plug.Conn.fetch_query_params(conn).query_params
|
|
lat_count = params["latitude"] |> String.split(",") |> length()
|
|
Req.Test.json(conn, %{"elevation" => List.duplicate(200.0, lat_count)})
|
|
end)
|
|
|
|
:ok
|
|
end
|
|
|
|
@station_params %{
|
|
src_height_m: 10.0,
|
|
dst_height_m: 10.0,
|
|
tx_power_dbm: 30.0,
|
|
src_gain_dbi: 20.0,
|
|
dst_gain_dbi: 20.0
|
|
}
|
|
|
|
test "computes a result for a coordinate-pair input" do
|
|
assert {:ok, result} =
|
|
PathCompute.compute("32.9, -97.0", "33.5, -96.5", 10_000, @station_params)
|
|
|
|
assert result.band_mhz == 10_000
|
|
assert result.dist_km > 0
|
|
assert is_float(result.bearing)
|
|
assert is_map(result.loss_budget)
|
|
assert is_map(result.power_budget)
|
|
# No HRRR profiles in the test DB → empty hrrr_points.
|
|
assert is_list(result.hrrr_points)
|
|
# Microwave band → no ionosphere readout.
|
|
assert result.ionosphere == nil
|
|
# No sounding rows in the test DB.
|
|
assert result.sounding == nil
|
|
end
|
|
|
|
test "returns {:error, _} when source resolution fails" do
|
|
assert {:error, _msg} =
|
|
PathCompute.compute("", "32.9, -97.0", 10_000, @station_params)
|
|
end
|
|
|
|
test "returns {:error, _} when destination resolution fails" do
|
|
assert {:error, _msg} =
|
|
PathCompute.compute("32.9, -97.0", "", 10_000, @station_params)
|
|
end
|
|
|
|
test "falls back to a default band config for unknown band_mhz" do
|
|
# Unknown band falls back to BandConfig.get(10_000).
|
|
assert {:ok, result} =
|
|
PathCompute.compute("32.9, -97.0", "33.5, -96.5", 9_999, @station_params)
|
|
|
|
assert result.band_mhz == 9_999
|
|
# Result band_config should be the 10G default.
|
|
assert result.band_config
|
|
end
|
|
|
|
test "60 GHz band exercises the high-h2o-absorption path" do
|
|
assert {:ok, result} =
|
|
PathCompute.compute("32.9, -97.0", "33.5, -96.5", 47_000, @station_params)
|
|
|
|
# 47 GHz has substantially more h2o absorption than 10 GHz.
|
|
assert result.loss_budget.h2o > 0
|
|
end
|
|
|
|
test "with HRRR profile data + sounding near the path uses real data" do
|
|
now = DateTime.truncate(DateTime.utc_now(), :second)
|
|
|
|
profile_data = [
|
|
%{"pres" => 1000.0, "hght" => 110, "tmpc" => 25.0, "dwpc" => 18.0},
|
|
%{"pres" => 925.0, "hght" => 770, "tmpc" => 18.0, "dwpc" => 12.0},
|
|
%{"pres" => 850.0, "hght" => 1500, "tmpc" => 14.0, "dwpc" => 8.0}
|
|
]
|
|
|
|
# Insert an HRRR profile near the midpoint of (32.9, -97.0) → (33.5, -96.5).
|
|
%HrrrProfile{}
|
|
|> HrrrProfile.changeset(%{
|
|
valid_time: now,
|
|
run_time: now,
|
|
lat: 33.2,
|
|
lon: -96.75,
|
|
profile: profile_data,
|
|
hpbl_m: 1500.0,
|
|
pwat_mm: 25.0,
|
|
surface_temp_c: 25.0,
|
|
surface_dewpoint_c: 18.0,
|
|
surface_pressure_mb: 1013.0,
|
|
surface_refractivity: 320.5,
|
|
min_refractivity_gradient: -45.0,
|
|
ducting_detected: false
|
|
})
|
|
|> Microwaveprop.Repo.insert!()
|
|
|
|
assert {:ok, result} =
|
|
PathCompute.compute("32.9, -97.0", "33.5, -96.5", 10_000, @station_params)
|
|
|
|
# Even if HRRR points doesn't include this grid (lookups snap to
|
|
# specific grid cells), the pipeline ran end-to-end without error.
|
|
assert is_list(result.hrrr_points)
|
|
end
|
|
|
|
test "Maidenhead grid input round-trips through resolve" do
|
|
assert {:ok, result} =
|
|
PathCompute.compute("EM12", "EM13", 10_000, @station_params)
|
|
|
|
assert result.dist_km > 0
|
|
assert result.source.kind == :grid
|
|
assert result.destination.kind == :grid
|
|
end
|
|
|
|
test ":on_progress callback fires once per stage in order" do
|
|
me = self()
|
|
total = PathCompute.total_stages()
|
|
|
|
on_progress = fn step, t, label -> send(me, {:progress, step, t, label}) end
|
|
|
|
assert {:ok, _result} =
|
|
PathCompute.compute("32.9, -97.0", "33.5, -96.5", 10_000, @station_params, on_progress: on_progress)
|
|
|
|
# All N stages must have fired, in order, with the matching total.
|
|
for step <- 1..total do
|
|
assert_received {:progress, ^step, ^total, label}
|
|
assert is_binary(label)
|
|
assert label != ""
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "compute_power_budget/2" do
|
|
test "computes rx power and margins" do
|
|
loss = %{total: 140.0, fspl: 130.0, o2: 3.0, h2o: 5.0, rain: 0.0, diffraction: 2.0}
|
|
params = %{tx_power_dbm: 30.0, src_gain_dbi: 20.0, dst_gain_dbi: 20.0}
|
|
|
|
result = PathCompute.compute_power_budget(params, loss)
|
|
|
|
# EIRP = tx_power + src_gain = 50 dBm
|
|
assert_in_delta result.eirp_dbm, 50.0, 0.1
|
|
# rx_power = eirp - loss + dst_gain
|
|
assert_in_delta result.rx_power_dbm, -70.0, 0.1
|
|
# margin_cw = rx_power - (-140)
|
|
assert_in_delta result.margin_cw, 70.0, 0.1
|
|
end
|
|
|
|
test "higher tx power improves margins" do
|
|
loss = %{total: 140.0, fspl: 130.0, o2: 3.0, h2o: 5.0, rain: 0.0, diffraction: 2.0}
|
|
|
|
low = PathCompute.compute_power_budget(%{tx_power_dbm: 20.0, src_gain_dbi: 10.0, dst_gain_dbi: 10.0}, loss)
|
|
high = PathCompute.compute_power_budget(%{tx_power_dbm: 30.0, src_gain_dbi: 20.0, dst_gain_dbi: 20.0}, loss)
|
|
|
|
assert low.rx_power_dbm < high.rx_power_dbm
|
|
assert low.margin_cw < high.margin_cw
|
|
end
|
|
end
|
|
end
|