imap-processing 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

imap_processing/tests/ena_maps/test_spatial_utils.py

@@ -0,0 +1,161 @@
+"""Test creation of solid angle map and other spatial utils."""
+
+import numpy as np
+import numpy.testing as npt
+import pytest
+
+from imap_processing.ena_maps.utils import spatial_utils
+
+# Parameterize with spacings (degrees here):
+valid_spacings = [0.25, 0.5, 1, 5, 10, 20]
+invalid_spacings = [0, -1, 11]
+invalid_spacings_match_str = [
+    "Spacing must be positive valued, non-zero.",
+    "Spacing must be positive valued, non-zero.",
+    "Spacing must divide evenly into pi radians.",
+]
+
+
+def test_build_spatial_bins():
+    """Tests build_spatial_bins function."""
+    az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
+        spatial_utils.build_spatial_bins(
+            az_spacing_deg=0.5,
+            el_spacing_deg=0.5,
+        )
+    )
+
+    assert az_bin_edges[0] == 0
+    assert az_bin_edges[-1] == 2 * np.pi
+    assert len(az_bin_edges) == 721
+
+    assert el_bin_edges[0] == -np.pi / 2
+    assert el_bin_edges[-1] == np.pi / 2
+    assert len(el_bin_edges) == 361
+
+    assert len(az_bin_midpoints) == 720
+    np.testing.assert_allclose(az_bin_midpoints[0], np.deg2rad(0.25), atol=1e-4)
+    np.testing.assert_allclose(az_bin_midpoints[-1], np.deg2rad(359.75), atol=1e-4)
+
+    assert len(el_bin_midpoints) == 360
+    np.testing.assert_allclose(el_bin_midpoints[0], np.deg2rad(-89.75), atol=1e-4)
+    np.testing.assert_allclose(el_bin_midpoints[-1], np.deg2rad(89.75), atol=1e-4)
+
+
+@pytest.mark.parametrize("spacing", valid_spacings)
+def test_build_solid_angle_map_integration(spacing):
+    """Test build_solid_angle_map function integrates to 4 pi steradians."""
+    solid_angle_map_steradians = spatial_utils.build_solid_angle_map(
+        spacing_deg=spacing
+    )
+    np.testing.assert_allclose(
+        np.sum(solid_angle_map_steradians), 4 * np.pi, atol=0, rtol=1e-9
+    )
+
+
+@pytest.mark.parametrize("spacing", valid_spacings)
+def test_build_solid_angle_map_equal_at_equal_el(spacing):
+    """Test build_solid_angle_map function produces equal solid angle at equal el."""
+    solid_angle_map = spatial_utils.build_solid_angle_map(
+        spacing_deg=spacing,
+    )
+    el_grid = spatial_utils.AzElSkyGrid(
+        spacing_deg=spacing,
+        reversed_elevation=False,
+    ).el_grid
+    for unique_el in np.unique(el_grid):
+        solid_angles = solid_angle_map[el_grid == unique_el]
+        np.testing.assert_allclose(solid_angles, solid_angles[0])
+
+
+@pytest.mark.parametrize(
+    "spacing, match_str", zip(invalid_spacings, invalid_spacings_match_str)
+)
+def test_build_solid_angle_map_invalid_spacing(spacing, match_str):
+    """Test build_solid_angle_map function raises error for invalid spacing."""
+    with pytest.raises(ValueError, match=match_str):
+        _ = spatial_utils.build_solid_angle_map(
+            spacing_deg=spacing,
+        )
+
+
+@pytest.mark.parametrize("order", ["C", "F"])
+def test_rewrap_even_spaced_az_el_grid_1d(order):
+    """Test rewrap_even_spaced_az_el_grid function, without extra axis."""
+    orig_shape = (360 * 12, 180 * 12)
+    orig_grid = np.fromfunction(lambda i, j: i**2 + j, orig_shape, dtype=int)
+    raveled_values = orig_grid.ravel(order=order)
+    rewrapped_grid_infer_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
+        raveled_values,
+        order=order,
+    )
+    rewrapped_grid_known_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
+        raveled_values,
+        shape=orig_shape,
+        order=order,
+    )
+
+    assert np.array_equal(rewrapped_grid_infer_shape, orig_grid)
+    assert np.array_equal(rewrapped_grid_known_shape, orig_grid)
+
+
+@pytest.mark.parametrize("order", ["C", "F"])
+def test_rewrap_even_spaced_az_el_grid_2d(order):
+    """Test rewrap_even_spaced_az_el_grid function, with extra axis."""
+    orig_shape = (360 * 12, 180 * 12, 5)
+    orig_grid = np.fromfunction(lambda i, j, k: i**2 + j + k, orig_shape, dtype=int)
+    raveled_values = orig_grid.reshape(-1, 5, order=order)
+    rewrapped_grid_infer_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
+        raveled_values,
+        order=order,
+    )
+    rewrapped_grid_known_shape = spatial_utils.rewrap_even_spaced_az_el_grid(
+        raveled_values,
+        shape=orig_shape,
+        order=order,
+    )
+    assert raveled_values.shape == (360 * 12 * 180 * 12, 5)
+    assert np.array_equal(rewrapped_grid_infer_shape, orig_grid)
+    assert np.array_equal(rewrapped_grid_known_shape, orig_grid)
+
+
+class TestAzElSkyGrid:
+    @pytest.mark.parametrize("spacing", valid_spacings)
+    def test_instantiate_and_values(self, spacing):
+        grid = spatial_utils.AzElSkyGrid(
+            spacing_deg=spacing,
+            reversed_elevation=False,
+        )
+
+        # Size checks
+        assert grid.az_bin_midpoints.size == int(360 / spacing) == grid.grid_shape[0]
+        assert grid.el_bin_midpoints.size == int(180 / spacing) == grid.grid_shape[1]
+        assert grid.az_grid.shape == grid.el_grid.shape == grid.grid_shape
+
+        # Check grid values in radians
+        expected_azimuth_bin_midpoints_deg = np.arange(
+            (spacing / 2), 360 + (spacing / 2), spacing
+        )
+        expected_elevation_bin_midpoints_deg = np.arange(
+            -90 + (spacing / 2), 90 + (spacing / 2), spacing
+        )
+        npt.assert_allclose(
+            grid.az_bin_midpoints,
+            np.deg2rad(expected_azimuth_bin_midpoints_deg),
+            atol=1e-11,
+        )
+        npt.assert_allclose(
+            grid.el_bin_midpoints,
+            np.deg2rad(expected_elevation_bin_midpoints_deg),
+            atol=1e-11,
+        )
+
+        # Check bin edges in degrees, radians
+        expected_az_bin_edges_deg = np.arange(0, 360 + spacing, spacing)
+        expected_el_bin_edges_deg = np.arange(-90, 90 + spacing, spacing)
+        npt.assert_allclose(
+            grid.az_bin_edges, np.deg2rad(expected_az_bin_edges_deg), atol=1e-11
+        )
+        npt.assert_allclose(
+            grid.el_bin_edges, np.deg2rad(expected_el_bin_edges_deg), atol=1e-11
+        )

imap_processing/tests/glows/conftest.py

@@ -7,6 +7,7 @@ from imap_processing.glows.l0 import decom_glows
 from imap_processing.glows.l1a.glows_l1a import glows_l1a, process_de_l0
 from imap_processing.glows.l1a.glows_l1a_data import HistogramL1A
 from imap_processing.glows.l1b.glows_l1b import glows_l1b
+from imap_processing.glows.l2.glows_l2 import glows_l2
 
 
 @pytest.fixture()
@@ -45,4 +46,9 @@ def l1a_dataset(packet_path):
 
 @pytest.fixture()
 def l1b_hist_dataset(l1a_dataset):
-    return glows_l1b(l1a_dataset[0], "v001")
+    return glows_l1b(l1a_dataset[1], "v001")
+
+
+@pytest.fixture()
+def l2_hist_dataset(l1b_datasets):
+    return glows_l2(l1b_datasets, "v001")

imap_processing/tests/glows/test_glows_l1a_cdf.py

@@ -1,6 +1,5 @@
 import dataclasses
 from functools import reduce
-from pathlib import Path
 
 import numpy as np
 import pytest
@@ -16,13 +15,10 @@ from imap_processing.glows.l1a.glows_l1a_data import HistogramL1A
 from imap_processing.glows.utils.constants import TimeTuple
 
 
-@pytest.fixture(scope="module")
-def l1a_data():
+@pytest.fixture()
+def l1a_data(packet_path):
     """Read test data from file"""
-    current_directory = Path(__file__).parent
-    packet_path = (
-        current_directory / "validation_data" / "glows_test_packet_20110921_v01.pkts"
-    )
+
     histogram_l0, de_l0 = decom_glows.decom_packets(packet_path)
 
     histogram_l1a = [HistogramL1A(hist) for hist in histogram_l0]

imap_processing/tests/glows/test_glows_l1a_data.py

@@ -8,12 +8,14 @@ import pandas as pd
 import pytest
 
 from imap_processing.glows import __version__
+from imap_processing.glows.l1a.glows_l1a import glows_l1a
 from imap_processing.glows.l1a.glows_l1a_data import (
     DirectEventL1A,
     HistogramL1A,
     StatusData,
 )
 from imap_processing.glows.utils.constants import DirectEvent, GlowsConstants, TimeTuple
+from imap_processing.spice.time import met_to_ttj2000ns
 
 
 @pytest.fixture()
@@ -38,6 +40,22 @@ def test_histogram_list(histogram_test_data, decom_test_data):
     assert sum(histogram_test_data.histogram) == histl0.EVENTS
 
 
+def test_histogram_obs_day(packet_path):
+    l1a = glows_l1a(packet_path, "v001")
+
+    assert len(l1a) == 3
+
+    assert "hist" in l1a[0].attrs["Logical_source"]
+    assert "hist" in l1a[1].attrs["Logical_source"]
+
+    # Numbers pulled from the validation data.
+    # this test assumes that the "is_night" flag switching from true to false is the
+    # start of the observation day.
+
+    assert np.array_equal(l1a[0]["imap_start_time"].data[0], 54232215.0)
+    assert np.array_equal(l1a[1]["imap_start_time"].data[0], 54232455.0)
+
+
 def test_histogram_attributes(histogram_test_data):
     """Test other data in histogram packet"""
 
@@ -488,7 +506,8 @@ def test_expected_de_results(l1a_test_data):
 
 
 def test_expected_hist_results(l1a_dataset):
-    hist = l1a_dataset[0]
+    end_time = l1a_dataset[0]["epoch"].data[-1]
+
     validation_data = (
         Path(__file__).parent / "validation_data" / "glows_l1a_hist_validation.json"
     )
@@ -521,15 +540,24 @@ def test_expected_hist_results(l1a_dataset):
         "pulse_length_variance",
     ]
 
-    for index, data in enumerate(out["output"]):
+    for data in out["output"]:
+        epoch_val = met_to_ttj2000ns(
+            TimeTuple(
+                data["imap_start_time"]["seconds"],
+                data["imap_start_time"]["subseconds"],
+            ).to_seconds()
+        )
+
+        # Validation data spans the two obs days, so this selects the correct output
+        dataset_index = 1 if epoch_val > end_time else 0
+        datapoint = l1a_dataset[dataset_index].sel(epoch=epoch_val)
+
         for field in time_fields.keys():
             expected_time = (
                 data[field]["seconds"]
                 + data[field]["subseconds"] / GlowsConstants.SUBSECOND_LIMIT
             )
-            assert np.array_equal(
-                expected_time, hist.isel(epoch=index)[time_fields[field]].data
-            )
+            assert np.array_equal(expected_time, datapoint[time_fields[field]].data)
 
         for field in compare_fields:
-            assert np.array_equal(data[field], hist.isel(epoch=index)[field].data)
+            assert np.array_equal(data[field], datapoint[field].data)

imap_processing/tests/glows/test_glows_l1b_data.py

@@ -5,7 +5,12 @@ import numpy as np
 import pytest
 
 from imap_processing.glows.l1b.glows_l1b import glows_l1b
-from imap_processing.glows.l1b.glows_l1b_data import AncillaryParameters, DirectEventL1B
+from imap_processing.glows.l1b.glows_l1b_data import (
+    AncillaryParameters,
+    DirectEventL1B,
+    HistogramL1B,
+)
+from imap_processing.spice.time import met_to_ttj2000ns
 
 
 def test_glows_l1b_ancillary_file():
@@ -75,11 +80,8 @@ def test_glows_l1b_de():
 
 
 def test_validation_data_histogram(l1a_dataset):
-    hist_day_one = l1a_dataset[0]
-    hist_day_two = l1a_dataset[1]
-
-    l1b_day_one = glows_l1b(hist_day_one, "v001")
-    l1b_day_two = glows_l1b(hist_day_two, "v001")
+    l1b = [glows_l1b(l1a_dataset[0], "v001"), glows_l1b(l1a_dataset[1], "v001")]
+    end_time = l1b[0]["epoch"].data[-1]
 
     validation_data = (
         Path(__file__).parent
@@ -122,26 +124,23 @@ def test_validation_data_histogram(l1a_dataset):
         # "spacecraft_velocity_std_dev": "spacecraft_velocity_std_dev",
     }
 
-    for index, validation_output in enumerate(out["output"]):
-        if validation_output["imap_start_time"] < 54259215:
-            # day of 2011-09-20
-            l1b = l1b_day_one
-            l1b_index = index
-        else:
-            l1b_index = index - l1b_day_one.epoch.size
-            l1b = l1b_day_two
+    for validation_output in out["output"]:
+        epoch_val = met_to_ttj2000ns(validation_output["imap_start_time"])
+
+        # Validation data spans the two obs days, so this selects the correct output
+        dataset_index = 1 if epoch_val > end_time else 0
+        datapoint = l1b[dataset_index].sel(epoch=epoch_val)
 
         assert np.equal(
             validation_output["imap_start_time"],
-            l1b.isel(epoch=l1b_index).imap_start_time.data,
+            datapoint.imap_start_time.data,
         )
 
         for key in validation_output:
             if key not in expected_matching_columns.keys():
                 continue
-
             np.testing.assert_array_almost_equal(
-                l1b[expected_matching_columns[key]].isel(epoch=l1b_index).data,
+                datapoint[expected_matching_columns[key]].data,
                 validation_output[key],
                 decimal=1,
             )
@@ -185,3 +184,16 @@ def test_validation_data_de(l1a_dataset):
                 np.testing.assert_array_almost_equal(
                     l1b[key].isel(epoch=index).data, validation_output[key], decimal=1
                 )
+
+
+@pytest.mark.parametrize(
+    "flags, expected",
+    [
+        (0, np.zeros(10)),
+        (64, np.array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0])),
+        (65, np.array([1, 0, 0, 0, 0, 0, 1, 0, 0, 0])),
+    ],
+)
+def test_deserialize_flags(flags, expected):
+    output = HistogramL1B.deserialize_flags(flags)
+    assert np.array_equal(output, expected)

imap_processing/tests/glows/test_glows_l2.py

@@ -0,0 +1,101 @@
+import numpy as np
+import pytest
+import xarray as xr
+
+from imap_processing.glows.l2.glows_l2 import (
+    generate_l2,
+    glows_l2,
+    return_good_times,
+)
+from imap_processing.glows.l2.glows_l2_data import DailyLightcurve
+
+
+@pytest.fixture()
+def l1b_hists():
+    epoch = xr.DataArray(np.arange(4), name="epoch", dims=["epoch"])
+    bins = xr.DataArray(np.arange(5), name="bins", dims=["bins"])
+    hist = xr.DataArray(
+        np.ones((4, 5)), dims=["epoch", "bins"], coords={"epoch": epoch, "bins": bins}
+    )
+    hist[1, 0] = -1
+    hist[2, 0] = -1
+    hist[1, 1] = -1
+    hist[2, 3] = -1
+
+    input = xr.Dataset(coords={"epoch": epoch, "bins": bins})
+    input["histogram"] = hist
+
+    return input
+
+
+def test_glows_l2(l1b_hist_dataset):
+    l2 = glows_l2(l1b_hist_dataset, "v001")[0]
+    assert l2.attrs["Logical_source"] == "imap_glows_l2_hist"
+
+    assert np.allclose(l2["filter_temperature_average"].values, [57.6], rtol=0.1)
+
+
+@pytest.mark.skip(reason="Spin table not yet complete")
+def test_split_by_observational_day(l1b_hist_dataset):
+    # TODO: Complete test when spin table is complete
+    raise NotImplementedError
+
+
+def test_filter_good_times():
+    active_flags = np.ones((17,))
+    active_flags[16] = 0
+    test_flags = np.ones((4, 17))
+    test_flags[1, 0] = 0
+    test_flags[3, 16] = 0
+    flags = xr.DataArray(test_flags, dims=["epoch", "flags"])
+
+    good_times = return_good_times(flags, active_flags)
+    expected_good_times = [0, 2, 3]
+
+    assert np.array_equal(good_times, expected_good_times)
+
+
+def test_generate_l2(l1b_hist_dataset):
+    l2 = generate_l2(l1b_hist_dataset)
+
+    expected_values = {
+        "filter_temperature_average": [57.59],
+        "filter_temperature_std_dev": [0.21],
+        "hv_voltage_average": [1715.4],
+        "hv_voltage_std_dev": [0.0],
+    }
+
+    assert np.isclose(
+        l2.filter_temperature_average,
+        expected_values["filter_temperature_average"],
+        0.01,
+    )
+    assert np.isclose(
+        l2.filter_temperature_std_dev,
+        expected_values["filter_temperature_std_dev"],
+        0.01,
+    )
+    assert np.isclose(
+        l2.hv_voltage_average, expected_values["hv_voltage_average"], 0.01
+    )
+    assert np.isclose(
+        l2.hv_voltage_std_dev, expected_values["hv_voltage_std_dev"], 0.01
+    )
+
+
+def test_exposure_times(l1b_hists):
+    exposure_time = xr.DataArray([10, 10, 20, 10])
+    expected_times = np.array([20, 40, 50, 30, 50])
+
+    times = DailyLightcurve.calculate_exposure_times(l1b_hists, exposure_time)
+
+    assert np.array_equal(times, expected_times)
+
+
+def test_bin_exclusions(l1b_hists):
+    # TODO test excluding bins as well
+
+    raw_hists = DailyLightcurve.calculate_histogram_sums(l1b_hists["histogram"].data)
+    expected_values = [2, 3, 4, 3, 4]
+
+    assert np.array_equal(raw_hists, expected_values)

imap_processing/tests/hi/conftest.py

@@ -5,7 +5,7 @@ import pytest
 
 @pytest.fixture(scope="session")
 def hi_test_data_path(imap_tests_path):
-    return imap_tests_path / "hi" / "test_data"
+    return imap_tests_path / "hi" / "data"
 
 
 @pytest.fixture(scope="session")
@@ -14,8 +14,8 @@ def hi_l0_test_data_path(hi_test_data_path):
 
 
 @pytest.fixture(scope="session")
-def hi_l1a_test_data_path(hi_test_data_path):
-    return hi_test_data_path / "l1a"
+def hi_l1_test_data_path(hi_test_data_path):
+    return hi_test_data_path / "l1"
 
 
 def create_metaevent(esa_step, met_subseconds, met_seconds):

imap_processing/tests/hi/data/l1/imap_his_pset-calibration-prod-config_20240101_v001.csv

@@ -0,0 +1,31 @@
+# Calibration Product DE Filter Configuration File
+# Valid start date: 2024-01-01 (from filename)
+# This file will be used in processing until a new calibration file is uploaded
+# to the SDC with either a higher version number or new date in the filename.
+# For details on how the SDC selects ancillary files for processing, see:
+# https://imap-processing.readthedocs.io/en/latest/data-access/calibration-files.html
+#
+# When creating PSET products, the following table will be used to filter the list
+# of DEs into the into calibration product categories at each ESA energy step. Only
+# DEs with coincidence type contained in the `coincidence_type_list` and time-of-flight
+# values that are in the inclusive range specified by the low and high entries for each
+# energy step are included in the angular pset bins.
+cal_prod_num,esa_energy_step,coincidence_type_list,tof_ab_low,tof_ab_high,tof_ac1_low,tof_ac1_high,tof_bc1_low,tof_bc1_high,tof_c1c2_low,tof_c1c2_high
+0,1,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,2,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,3,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,4,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,5,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,6,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,7,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,8,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+0,9,ABC1C2|ABC1|AC1C2,15,55,0,70,-50,10,5,25
+1,1,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,2,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,3,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,4,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,5,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,6,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,7,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,8,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25
+1,9,BC1C2|AB|AC1,15,55,0,70,-50,10,5,25

imap_processing/tests/hi/test_hi_l1b.py

@@ -32,17 +32,18 @@ def test_hi_l1b_hk(hi_l0_test_data_path):
     assert l1b_dataset.attrs["Logical_source"] == "imap_hi_l1b_90sensor-hk"
 
 
+@pytest.mark.external_test_data()
 @pytest.mark.external_kernel()
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_hi_l1b_de(
-    hi_l1a_test_data_path, spice_test_data_path, use_fake_spin_data_for_time
+    hi_l1_test_data_path, spice_test_data_path, use_fake_spin_data_for_time
 ):
     """Test coverage for imap_processing.hi.hi_l1b.hi_l1b() with
     direct events L1A as input"""
     # Start MET time of spin for simulated input data is 482372988
-    use_fake_spin_data_for_time(482372988)
+    use_fake_spin_data_for_time(482372987.999)
     l1a_test_file_path = (
-        hi_l1a_test_data_path / "imap_hi_l1a_45sensor-de_20250415_v000.cdf"
+        hi_l1_test_data_path / "imap_hi_l1a_45sensor-de_20250415_v999.cdf"
     )
     # Process using test data
     data_version = "001"
@@ -50,7 +51,7 @@ def test_hi_l1b_de(
 
     l1b_dataset = hi_l1b(l1a_dataset, data_version=data_version)
     assert l1b_dataset.attrs["Logical_source"] == "imap_hi_l1b_45sensor-de"
-    assert len(l1b_dataset.data_vars) == 14
+    assert len(l1b_dataset.data_vars) == 15
 
 
 @pytest.fixture()
@@ -95,11 +96,11 @@ def synthetic_trigger_id_and_tof_data():
     )
     data = [arr[good_inds] for arr in data]
     data_vars = {
-        n: xr.DataArray(arr, dims=["epoch"]) for n, arr in zip(var_names, data)
+        n: xr.DataArray(arr, dims=["event_met"]) for n, arr in zip(var_names, data)
     }
     synthetic_l1a_ds = xr.Dataset(
         coords={
-            "epoch": xr.DataArray(
+            "event_met": xr.DataArray(
                 np.arange(data_vars["trigger_id"].size), name="epoch", dims=["epoch"]
             )
         },
@@ -226,15 +227,19 @@ def test_compute_hae_coordinates(mock_instrument_pointing, sensor_number):
     # Make a fake dataset with epoch and Logical_source
     fake_dataset = xr.Dataset(
         attrs={"Logical_source": f"imap_hi_l1a_{sensor_number}sensor-de"},
-        coords={"epoch": xr.DataArray(np.arange(200), name="epoch", dims=["epoch"])},
+        coords={
+            "event_met": xr.DataArray(
+                np.arange(200), name="event_met", dims=["event_met"]
+            )
+        },
     )
 
     new_vars = compute_hae_coordinates(fake_dataset)
     assert "hae_latitude" in new_vars
-    assert new_vars["hae_latitude"].shape == fake_dataset.epoch.shape
+    assert new_vars["hae_latitude"].shape == fake_dataset.event_met.shape
     np.testing.assert_allclose(new_vars["hae_latitude"].values, sensor_number)
     assert "hae_longitude" in new_vars
-    assert new_vars["hae_longitude"].shape == fake_dataset.epoch.shape
+    assert new_vars["hae_longitude"].shape == fake_dataset.event_met.shape
     np.testing.assert_allclose(new_vars["hae_longitude"].values, sensor_number)