imap-processing 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/tests/test_cli.py

@@ -5,11 +5,25 @@ from unittest import mock
 
 import pytest
 import xarray as xr
+from imap_data_access.processing_input import (
+    ProcessingInputCollection,
+    ScienceInput,
+)
 
-from imap_processing.cli import Codice, Hi, Hit, Swe, Ultra, _validate_args, main
+from imap_processing.cli import (
+    Codice,
+    Glows,
+    Hi,
+    Hit,
+    Spacecraft,
+    Swe,
+    Ultra,
+    _validate_args,
+    main,
+)
 
 
-@pytest.fixture()
+@pytest.fixture
 def mock_instrument_dependencies():
     with (
         mock.patch("imap_processing.cli.imap_data_access.query") as mock_query,
@@ -17,6 +31,9 @@ def mock_instrument_dependencies():
         mock.patch("imap_processing.cli.imap_data_access.upload") as mock_upload,
         mock.patch("imap_processing.cli.write_cdf") as mock_write_cdf,
         mock.patch("imap_processing.cli.load_cdf") as mock_load_cdf,
+        mock.patch(
+            "imap_processing.cli.ProcessInstrument.pre_processing"
+        ) as mock_pre_processing,
     ):
         mocks = {
             "mock_query": mock_query,
@@ -24,6 +41,7 @@ def mock_instrument_dependencies():
             "mock_upload": mock_upload,
             "mock_write_cdf": mock_write_cdf,
             "mock_load_cdf": mock_load_cdf,
+            "mock_pre_processing": mock_pre_processing,
         }
         yield mocks
 
@@ -37,18 +55,28 @@ def test_main(mock_instrument):
         "mag",
         "--dependency",
         (
-            '[{"instrument": "mag", '
-            '"data_level": "l0", '
-            '"descriptor": "sci", '
-            '"version": "v001", '
-            '"start_date": "20240430"}]'
+            "["
+            "{"
+            '"type": "ancillary",'
+            '"files": ['
+            '"imap_mag_l1b-cal_20250101_v001.cdf",'
+            '"imap_mag_l1b-cal_20250103-20250104_v002.cdf"'
+            "]"
+            "},"
+            "{"
+            '"type": "science",'
+            '"files": ['
+            '"imap_mag_l0_raw_20240430_v001.cdf",'
+            "]"
+            "}"
+            "]"
         ),
         "--data-level",
         "l1a",
         "--start-date",
         "20240430",
-        "--end-date",
-        "20240501",
+        "--repointing",
+        "repoint12345",
         "--version",
         "v001",
         "--upload-to-sdc",
@@ -60,18 +88,25 @@ def test_main(mock_instrument):
 
 
 @pytest.mark.parametrize(
-    "instrument, data_level, raises_value_error",
+    "instrument, data_level, start_date, repointing, raises_value_error",
     [
-        ("mag", "l1a", ""),
-        ("foo", "l1a", "foo is not in the supported .*"),
-        ("codice", "l1z", "l1z is not a supported .*"),
+        ("mag", "l1a", "20250101", None, ""),
+        ("foo", "l1a", None, None, "foo is not in the supported .*"),
+        ("codice", "l1z", None, None, "l1z is not a supported .*"),
+        ("glows", "l1a", None, "repoint12345", ""),
+        ("glows", "l1a", None, "12345", ".* not a valid repointing.*"),
+        ("glows", "l1a", "2000001", None, ".* not a valid date.*"),
     ],
 )
-def test_validate_args(instrument, data_level, raises_value_error):
+def test_validate_args(
+    instrument, data_level, start_date, repointing, raises_value_error
+):
     """Test coverage for imap_processing.cli._validate_args()"""
     args = mock.Mock
     args.instrument = instrument
     args.data_level = data_level
+    args.start_date = start_date
+    args.repointing = repointing
 
     if raises_value_error:
         with pytest.raises(ValueError, match=raises_value_error):
@@ -85,90 +120,139 @@ def test_codice(mock_codice_l1a, mock_instrument_dependencies):
     """Test coverage for cli.CoDICE class"""
 
     test_dataset = xr.Dataset({}, attrs={"cdf_filename": "file0"})
-
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_codice_l0_raw_20230822_v001.pkts")
+    )
     mocks = mock_instrument_dependencies
     mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
     mocks["mock_download"].return_value = "file0"
-    mock_codice_l1a.return_value = test_dataset
+    mock_codice_l1a.return_value = [test_dataset]
     mocks["mock_write_cdf"].side_effect = ["/path/to/file0"]
+    mocks["mock_pre_processing"].return_value = input_collection
 
     dependency_str = (
-        "[{"
-        "'instrument': 'codice',"
-        "'data_level': 'l0',"
-        "'descriptor': 'hskp',"
-        "'version': 'v001',"
-        "'start_date': '20230822'"
-        "}]"
-    )
-    instrument = Codice(
-        "l1a", "hskp", dependency_str, "20230822", "20230822", "v001", True
+        '[{"type": "science","files": ["imap_codice_l0_raw_20230822_v001.pkts"]}]'
     )
+
+    instrument = Codice("l1a", "hskp", dependency_str, "20230822", None, "v001", True)
+
     instrument.process()
-    assert mocks["mock_query"].call_count == 1
-    assert mocks["mock_download"].call_count == 1
     assert mock_codice_l1a.call_count == 1
     assert mocks["mock_upload"].call_count == 1
 
 
-@pytest.mark.parametrize("data_level, n_prods", [("l1a", 2), ("l1b", 1), ("l1c", 1)])
-def test_hi_l1(mock_instrument_dependencies, data_level, n_prods):
+def test_repointing_file_creation(mock_instrument_dependencies):
+    test_datasets = [xr.Dataset({}, attrs={"cdf_filename": "file0"})]
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_glows_l0_raw_20230822-repoint00001_v001.pkts")
+    )
+    dependency_str = (
+        '[{"type": "science","files": '
+        '["imap_glows_l0_raw_20230822-repoint00001_v001.pkts"]}]'
+    )
+    instrument = Glows(
+        "l1a", "hist", dependency_str, None, "repoint00002", "v001", False
+    )
+
+    mock_instrument_dependencies["mock_write_cdf"].side_effect = ["/path/to/file0"]
+
+    # Call the method that uses write_cdf
+    instrument.post_processing(test_datasets, input_collection)
+
+    # Assert that write_cdf was called with the expected arguments
+    assert mock_instrument_dependencies["mock_write_cdf"].call_count == 1
+    assert (
+        mock_instrument_dependencies["mock_write_cdf"]
+        .call_args[0][0]
+        .attrs.get("Repointing", None)
+        == "repoint00002"
+    )
+
+
+@pytest.mark.parametrize(
+    "data_level, science_input, n_prods",
+    [
+        ("l1a", ["imap_hi_l0_raw_20231212_v001.pkts"], 2),
+        ("l1b", ["imap_hi_l1a_90sensor-de_20241105_v001.cdf"], 1),
+        ("l1b", ["imap_hi_l0_raw_20231212_v001.pkts"], 2),
+        ("l1c", ["imap_hi_l1b_45sensor-de_20250415_v001.cdf"], 1),
+    ],
+)
+def test_hi_l1(mock_instrument_dependencies, data_level, science_input, n_prods):
     """Test coverage for cli.Hi class"""
     mocks = mock_instrument_dependencies
-    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
-    mocks["mock_download"].return_value = "file0"
-    mocks["mock_write_cdf"].side_effect = ["/path/to/file0", "/path/to/file1"]
+    mocks["mock_write_cdf"].side_effect = ["/path/to/file0"] * n_prods
     mocks["mock_load_cdf"].return_value = xr.Dataset()
+    input_collection = ProcessingInputCollection(
+        *[ScienceInput(file) for file in science_input]
+    )
+    mocks["mock_pre_processing"].return_value = input_collection
 
     # patch autospec=True makes this test confirm that the function call in cli.py
     # matches the mocked function signature.
     with mock.patch(
         f"imap_processing.cli.hi_{data_level}.hi_{data_level}", autospec=True
     ) as mock_hi:
-        mock_hi.return_value = [f"{data_level}_file{n}" for n in range(n_prods)]
+        mock_hi.return_value = [xr.Dataset()] * n_prods
         dependency_str = (
-            "[{"
-            "'instrument': 'lo',"
-            "'data_level': 'l0',"
-            "'descriptor': 'sci',"
-            "'version': 'v00-01',"
-            "'start_date': '20231212'"
-            "}]"
+            '[{"type": "science","files": ["imap_hi_l0_raw_20231212_v001.pkts"]}]'
         )
         instrument = Hi(
             data_level, "sci", dependency_str, "20231212", "20231213", "v005", True
         )
+
         instrument.process()
-        assert mocks["mock_query"].call_count == 1
-        assert mocks["mock_download"].call_count == 1
         assert mock_hi.call_count == 1
         assert mocks["mock_upload"].call_count == n_prods
 
 
+@mock.patch("imap_processing.cli.quaternions.process_quaternions", autospec=True)
+def test_spacecraft(mock_spacecraft_l1a, mock_instrument_dependencies):
+    """Test coverage for cli.Spacecraft class"""
+
+    test_dataset = xr.Dataset({}, attrs={"cdf_filename": "file0"})
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_spacecraft_l0_raw_20230822_v001.pkts")
+    )
+    mocks = mock_instrument_dependencies
+    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
+    mocks["mock_download"].return_value = "file0"
+    mock_spacecraft_l1a.return_value = [test_dataset]
+    mocks["mock_write_cdf"].side_effect = ["/path/to/file0"]
+    mocks["mock_pre_processing"].return_value = input_collection
+
+    dependency_str = (
+        '[{"type": "science","files": ["imap_spacecraft_l0_raw_20230822_v001.pkts"]}]'
+    )
+
+    instrument = Spacecraft(
+        "l1a", "quaternions", dependency_str, "20230822", "20230822", "v001", True
+    )
+
+    instrument.process()
+    assert mock_spacecraft_l1a.call_count == 1
+    assert mocks["mock_upload"].call_count == 1
+
+
 @mock.patch("imap_processing.cli.ultra_l1a.ultra_l1a")
 def test_ultra_l1a(mock_ultra_l1a, mock_instrument_dependencies):
     """Test coverage for cli.Ultra class with l1a data level"""
     mocks = mock_instrument_dependencies
-    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
-    mocks["mock_download"].return_value = "dependency0"
-    mock_ultra_l1a.return_value = ["l1a_dataset0", "l1a_dataset1"]
+    mock_ultra_l1a.return_value = [xr.Dataset(), xr.Dataset()]
     mocks["mock_write_cdf"].side_effect = ["/path/to/product0", "/path/to/product1"]
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_ultra_l0_raw_20240207_v001.pkts")
+    )
+    mocks["mock_pre_processing"].return_value = input_collection
 
     dependency_str = (
-        "[{"
-        "'instrument': 'ultra',"
-        "'data_level': 'l0',"
-        "'descriptor': 'raw',"
-        "'version': 'v001',"
-        "'start_date': '20240207'"
-        "}]"
+        '[{"type": "science","files": ["imap_ultra_l0_raw_20240207_v001.pkts"]}]'
     )
     instrument = Ultra(
         "l1a", "raw", dependency_str, "20240207", "20240208", "v001", True
     )
+
     instrument.process()
-    assert mocks["mock_query"].call_count == 1
-    assert mocks["mock_download"].call_count == 1
     assert mock_ultra_l1a.call_count == 1
     assert mocks["mock_upload"].call_count == 2
 
@@ -177,14 +261,17 @@ def test_ultra_l1a(mock_ultra_l1a, mock_instrument_dependencies):
 def test_ultra_l1b(mock_ultra_l1b, mock_instrument_dependencies):
     """Test coverage for cli.Ultra class with l1b data level"""
     mocks = mock_instrument_dependencies
-    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
     mocks["mock_download"].return_value = "dependency0"
-    mock_ultra_l1b.return_value = ["l1b_dataset0", "l1b_dataset1"]
+    mock_ultra_l1b.return_value = [xr.Dataset(), xr.Dataset()]
     mocks["mock_write_cdf"].side_effect = ["/path/to/product0", "/path/to/product1"]
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_ultra_l1a_de_20240207_v001.cdf")
+    )
+    mocks["mock_pre_processing"].return_value = input_collection
 
     instrument = Ultra("l1b", "de", "[]", "20240207", "20240208", "v001", True)
+
     instrument.process()
-    assert mocks["mock_query"].call_count == 0
     assert mocks["mock_download"].call_count == 0
     assert mock_ultra_l1b.call_count == 1
     assert mocks["mock_upload"].call_count == 2
@@ -194,15 +281,16 @@ def test_ultra_l1b(mock_ultra_l1b, mock_instrument_dependencies):
 def test_ultra_l1c(mock_ultra_l1c, mock_instrument_dependencies):
     """Test coverage for cli.Ultra class with l1c data level"""
     mocks = mock_instrument_dependencies
-    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
-    mocks["mock_download"].return_value = "dependency0"
-    mock_ultra_l1c.return_value = ["l1c_dataset0", "l1c_dataset1"]
+    mock_ultra_l1c.return_value = [xr.Dataset(), xr.Dataset()]
     mocks["mock_write_cdf"].side_effect = ["/path/to/product0", "/path/to/product1"]
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_ultra_l1b_de_20240207_v001.cdf")
+    )
+    mocks["mock_pre_processing"].return_value = input_collection
 
     instrument = Ultra("l1c", "pset", "[]", "20240207", "20240208", "v001", True)
+
     instrument.process()
-    assert mocks["mock_query"].call_count == 0
-    assert mocks["mock_download"].call_count == 0
     assert mock_ultra_l1c.call_count == 1
     assert mocks["mock_upload"].call_count == 2
 
@@ -211,24 +299,19 @@ def test_ultra_l1c(mock_ultra_l1c, mock_instrument_dependencies):
 def test_hit_l1a(mock_hit_l1a, mock_instrument_dependencies):
     """Test coverage for cli.Hit class with l1a data level"""
     mocks = mock_instrument_dependencies
-    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
-    mocks["mock_download"].return_value = "dependency0"
-    mock_hit_l1a.return_value = ["l1a_dataset0", "l1a_dataset1"]
+    mock_hit_l1a.return_value = [xr.Dataset(), xr.Dataset()]
     mocks["mock_write_cdf"].side_effect = ["/path/to/product0", "/path/to/product1"]
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_hit_l0_raw_20100105_v001.pkts")
+    )
+    mocks["mock_pre_processing"].return_value = input_collection
 
     dependency_str = (
-        "[{"
-        "'instrument': 'hit',"
-        "'data_level': 'l0',"
-        "'descriptor': 'raw',"
-        "'version': 'v001',"
-        "'start_date': '20100105'"
-        "}]"
+        '[{"type": "science","files": ["imap_hit_l0_raw_20100105_v001.pkts"]}]'
     )
     instrument = Hit("l1a", "raw", dependency_str, "20100105", "20100101", "v001", True)
+
     instrument.process()
-    assert mocks["mock_query"].call_count == 1
-    assert mocks["mock_download"].call_count == 1
     assert mock_hit_l1a.call_count == 1
     assert mocks["mock_upload"].call_count == 2
 
@@ -237,25 +320,25 @@ def test_hit_l1a(mock_hit_l1a, mock_instrument_dependencies):
 def test_post_processing(mock_swe_l1a, mock_instrument_dependencies):
     """Test coverage for post processing"""
     mocks = mock_instrument_dependencies
-    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
     mocks["mock_download"].return_value = "dependency0"
-    # Return empty list to simulate no data to write
-    mock_swe_l1a.return_value = []
+    test_ds = xr.Dataset()
+    mock_swe_l1a.return_value = [test_ds]
+    input_collection = ProcessingInputCollection(
+        ScienceInput("imap_swe_l0_raw_20100105_v001.pkts")
+    )
+    mocks["mock_pre_processing"].return_value = input_collection
 
     dependency_str = (
-        "[{"
-        "'instrument': 'hit',"
-        "'data_level': 'l0',"
-        "'descriptor': 'raw',"
-        "'version': 'v001',"
-        "'start_date': '20100105'"
-        "}]"
+        '[{"type": "science","files": ["imap_swe_l0_raw_20100105_v001.pkts"]}]'
     )
-    instrument = Swe("l1a", "raw", dependency_str, "20100105", "20100101", "v001", True)
+    instrument = Swe("l1a", "raw", dependency_str, "20100105", None, "v001", True)
 
     # This function calls both the instrument.do_processing() and
     # instrument.post_processing()
     instrument.process()
     assert mock_swe_l1a.call_count == 1
-    # This test is testing that no upload happened
-    assert mocks["mock_upload"].call_count == 0
+    # This test is testing that one file was uploaded
+    assert mocks["mock_upload"].call_count == 1
+
+    # Test parent injection
+    assert test_ds.attrs["Parents"] == ["imap_swe_l0_raw_20100105_v001.pkts"]

imap_processing/tests/test_utils.py

@@ -225,7 +225,8 @@ def test_packet_file_to_datasets_flat_definition():
     test_file = "tests/idex/test_data/imap_idex_l0_raw_20231218_v001.pkts"
     packet_files = imap_module_directory / test_file
     packet_definition = (
-        imap_module_directory / "idex/packet_definitions/idex_packet_definition.xml"
+        imap_module_directory
+        / "idex/packet_definitions/idex_science_packet_definition.xml"
     )
     with pytest.raises(ValueError, match="Packet fields do not match"):
         utils.packet_file_to_datasets(packet_files, packet_definition)

imap_processing/tests/ultra/data/mock_data.py

@@ -14,7 +14,7 @@ DEFAULT_RECT_SPACING_DEG_L1C = 0.5
 DEFAULT_HEALPIX_NSIDE_L1C = 128
 
 
-def mock_l1c_pset_product_rectangular(  # noqa: PLR0913
+def mock_l1c_pset_product_rectangular(
     spacing_deg: float = DEFAULT_RECT_SPACING_DEG_L1C,
     stripe_center_lat: int = 0,
     width_scale: float = 10.0,
@@ -136,18 +136,23 @@ def mock_l1c_pset_product_rectangular(  # noqa: PLR0913
         ensure_spice(spice.unitim, time_kernels_only=True)(tdb_et, "ET", "TT") * 1e9
     )
 
+    logical_source = f"imap_ultra_l1c_{head}sensor-spacecraftpset"
+    logical_file_id = (
+        f"{logical_source}_{timestr[:4]}{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
+    )
+
     pset_product = xr.Dataset(
         {
             "counts": (
                 [
                     CoordNames.TIME.value,
-                    CoordNames.ENERGY.value,
+                    CoordNames.ENERGY_ULTRA.value,
                     CoordNames.AZIMUTH_L1C.value,
                     CoordNames.ELEVATION_L1C.value,
                 ],
                 counts,
             ),
-            "exposure_time": (
+            "exposure_factor": (
                 [
                     CoordNames.TIME.value,
                     CoordNames.AZIMUTH_L1C.value,
@@ -158,7 +163,7 @@ def mock_l1c_pset_product_rectangular(  # noqa: PLR0913
             "sensitivity": (
                 [
                     CoordNames.TIME.value,
-                    CoordNames.ENERGY.value,
+                    CoordNames.ENERGY_ULTRA.value,
                     CoordNames.AZIMUTH_L1C.value,
                     CoordNames.ELEVATION_L1C.value,
                 ],
@@ -169,7 +174,7 @@ def mock_l1c_pset_product_rectangular(  # noqa: PLR0913
             CoordNames.TIME.value: [
                 tt_j2000ns,
             ],
-            CoordNames.ENERGY.value: energy_bin_midpoints,
+            CoordNames.ENERGY_ULTRA.value: energy_bin_midpoints,
             CoordNames.AZIMUTH_L1C.value: np.arange(
                 0 + spacing_deg / 2, 360, spacing_deg
             ),
@@ -178,17 +183,16 @@ def mock_l1c_pset_product_rectangular(  # noqa: PLR0913
             ),
         },
         attrs={
-            "Logical_file_id": (
-                f"imap_ultra_l1c_{head}sensor-pset_{timestr[:4]}"
-                f"{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
-            )
+            "Logical_file_id": logical_file_id,
+            "Logical_source": logical_source,
+            "Data_version": "001",
         },
     )
 
     return pset_product
 
 
-def mock_l1c_pset_product_healpix(  # noqa: PLR0913
+def mock_l1c_pset_product_healpix(
     nside: int = DEFAULT_HEALPIX_NSIDE_L1C,
     stripe_center_lat: int = 0,
     width_scale: float = 10.0,
@@ -251,7 +255,8 @@ def mock_l1c_pset_product_healpix(  # noqa: PLR0913
     head : str, optional
         The sensor head (either '45' or '90') (default is '45').
     """
-    _, energy_bin_midpoints, _ = build_energy_bins()
+    energy_intervals, energy_bin_midpoints, _ = build_energy_bins()
+    energy_bin_delta = np.diff(energy_intervals, axis=1).squeeze()
     num_energy_bins = len(energy_bin_midpoints)
     npix = hp.nside2npix(nside)
     counts = np.zeros(npix)
@@ -277,8 +282,13 @@ def mock_l1c_pset_product_healpix(  # noqa: PLR0913
         ]
     )
 
-    # Generate exposure times using gaussian distribution
-    exposure_time = peak_exposure * (prob_scaling_factor / prob_scaling_factor.max())
+    # Generate exposure times using gaussian distribution, but wider
+    prob_scaling_factor_exptime = counts_scaling_params[1] * np.exp(
+        -(lat_diff**2) / (2 * (3 * width_scale) ** 2)
+    )
+    exposure_time = peak_exposure * (
+        prob_scaling_factor_exptime / prob_scaling_factor_exptime.max()
+    )
 
     # Ensure counts are integers
     counts = counts.astype(int)
@@ -292,24 +302,37 @@ def mock_l1c_pset_product_healpix(  # noqa: PLR0913
         ensure_spice(spice.unitim, time_kernels_only=True)(tdb_et, "ET", "TT") * 1e9
     )
 
+    logical_source = f"imap_ultra_l1c_{head}sensor-spacecraftpset"
+    logical_file_id = (
+        f"{logical_source}_{timestr[:4]}{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
+    )
+
     pset_product = xr.Dataset(
         {
             "counts": (
                 [
                     CoordNames.TIME.value,
-                    CoordNames.ENERGY.value,
+                    CoordNames.ENERGY_ULTRA.value,
                     CoordNames.HEALPIX_INDEX.value,
                 ],
                 counts,
             ),
-            "exposure_time": (
+            "background_rates": (
+                [
+                    CoordNames.TIME.value,
+                    CoordNames.ENERGY_ULTRA.value,
+                    CoordNames.HEALPIX_INDEX.value,
+                ],
+                np.full_like(counts, 0.05, dtype=float),
+            ),
+            "exposure_factor": (
                 [CoordNames.HEALPIX_INDEX.value],
                 exposure_time,
             ),
             "sensitivity": (
                 [
                     CoordNames.TIME.value,
-                    CoordNames.ENERGY.value,
+                    CoordNames.ENERGY_ULTRA.value,
                     CoordNames.HEALPIX_INDEX.value,
                 ],
                 sensitivity,
@@ -322,19 +345,24 @@ def mock_l1c_pset_product_healpix(  # noqa: PLR0913
                 [CoordNames.HEALPIX_INDEX.value],
                 lat_pix,
             ),
+            "energy_bin_delta": (
+                [CoordNames.ENERGY_ULTRA.value],
+                energy_bin_delta,
+            ),
         },
         coords={
             CoordNames.TIME.value: [
                 tt_j2000ns,
             ],
-            CoordNames.ENERGY.value: energy_bin_midpoints,
+            CoordNames.ENERGY_ULTRA.value: xr.DataArray(
+                energy_bin_midpoints, dims=(CoordNames.ENERGY_ULTRA.value,)
+            ),
             CoordNames.HEALPIX_INDEX.value: pix_indices,
         },
         attrs={
-            "Logical_file_id": (
-                f"imap_ultra_l1c_{head}sensor-pset_{timestr[:4]}"
-                f"{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
-            )
+            "Logical_file_id": logical_file_id,
+            "Logical_source": logical_source,
+            "Data_version": "v001",
         },
     )