imap-processing 0.11.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", "l0", ""),
-        ("foo", "l0", "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

@@ -11,20 +11,29 @@ from imap_processing import imap_module_directory, utils
 def test_convert_raw_to_eu(tmp_path):
     """Test coverage for utils.convert_raw_to_eu()"""
     # Generate a csv for testing
+    # Include segmented and unsegmented polyvals
+    dn_cutoff = 2
     test_df = pd.DataFrame(
         data={
-            "packetName": ["PACKET_0", "PACKET_0", "PACKET_1"],
-            "mnemonic": ["FIELD_0", "FIELD_1", "FIELD_0"],
-            "convertAs": ["UNSEGMENTED_POLY", "UNSEGMENTED_POLY", "FOO_METHOD"],
-            "c0": [0, 1, 2],
-            "c1": [0, 1, 2],
-            "c2": [0, 0, 2],
-            "c3": [0, 0, 2],
-            "c4": [0, 0, 2],
-            "c5": [0, 1, 2],
-            "c6": [0, 0, 2],
-            "c7": [0, 0, 2],
-            "unit": ["a", "b", "c"],
+            "packetName": ["PACKET_0", "PACKET_0", "PACKET_2", "PACKET_2", "PACKET_1"],
+            "mnemonic": ["FIELD_0", "FIELD_1", "FIELD_2", "FIELD_2", "FIELD_0"],
+            "convertAs": [
+                "UNSEGMENTED_POLY",
+                "UNSEGMENTED_POLY",
+                "SEGMENTED_POLY",
+                "SEGMENTED_POLY",
+                "FOO_METHOD",
+            ],
+            "dn_range_start": [0, 0, 1, dn_cutoff + 1, 0],
+            "dn_range_stop": [0, 0, dn_cutoff, 4, 0],
+            "c0": [0, 1, 3, 4, 2],
+            "c1": [0, 1, 3, 4, 2],
+            "c2": [0, 0, 3, 4, 2],
+            "c3": [0, 0, 3, 4, 2],
+            "c5": [0, 1, 3, 4, 2],
+            "c6": [0, 0, 3, 4, 2],
+            "c7": [0, 0, 3, 4, 2],
+            "unit": ["a", "b", "d", "d", "c"],
         }
     )
     test_csv = tmp_path / "test_convert_table.csv"
@@ -36,11 +45,13 @@ def test_convert_raw_to_eu(tmp_path):
     n_packets = 3
     field_0 = np.arange(n_packets)
     field_1 = np.arange(n_packets) + 10
+    field_2 = np.arange(n_packets) + 1
     time = np.arange(n_packets) + 1000
     dn_dataset = xr.Dataset(
         data_vars=dict(
             FIELD_0=(["time"], field_0),
             FIELD_1=(["time"], field_1),
+            FIELD_2=(["time"], field_2),
         ),
         coords=dict(
             time=time,
@@ -53,7 +64,7 @@ def test_convert_raw_to_eu(tmp_path):
 
     # Check the converted values by manually doing the polynomial math
     np.testing.assert_array_equal(eu_dataset["FIELD_0"].data, np.zeros(n_packets))
-    assert eu_dataset["FIELD_0"].attrs["units"] == test_df["unit"].iloc[0]
+    assert eu_dataset["FIELD_0"].attrs["UNITS"] == test_df["unit"].iloc[0]
 
     field_1_coeffs = (
         test_df[test_df["mnemonic"] == "FIELD_1"].filter(regex=r"c\d").values[0]
@@ -63,14 +74,125 @@ def test_convert_raw_to_eu(tmp_path):
         field_1_compare += coeff * np.power(field_1, p)
     np.testing.assert_array_equal(eu_dataset["FIELD_1"].data, field_1_compare)
 
+    eu_dataset = utils.convert_raw_to_eu(
+        dn_dataset.copy(), test_csv.absolute(), "PACKET_2", comment="#"
+    )
+    # Test the segmented polynomials
+    field_2_coeffs = (
+        test_df[test_df["mnemonic"] == "FIELD_2"].filter(regex=r"c\d").values
+    )
+    field_2_compare_seg_1 = np.zeros(len(field_2[field_2 <= dn_cutoff]))
+    field_2_compare_seg_2 = np.zeros(len(field_2[field_2 > dn_cutoff]))
+    for p, coeff in enumerate(field_2_coeffs[0]):
+        field_2_compare_seg_1 += coeff * np.power(field_2[field_2 <= dn_cutoff], p)
+    for p, coeff in enumerate(field_2_coeffs[1]):
+        field_2_compare_seg_2 += coeff * np.power(field_2[field_2 > dn_cutoff], p)
+
+    field_2_compare = np.concatenate([field_2_compare_seg_1, field_2_compare_seg_2])
+    np.testing.assert_array_equal(eu_dataset["FIELD_2"].data, field_2_compare)
+
+    assert eu_dataset["FIELD_2"].attrs["UNITS"] == test_df["unit"].iloc[2]
     # Check that a ValueError is raised for unexpected conversion specified in
     # conversion table "convertAs" column
-    with pytest.raises(ValueError, match=r"Unexpected conversion type: .*"):
-        eu_dataset = utils.convert_raw_to_eu(
+    with pytest.raises(
+        ValueError,
+        match="Column 'convertAs' must all be UNSEGMENTED_POLY or "
+        "SEGMENTED_POLY for a packet name and mnemonic",
+    ):
+        utils.convert_raw_to_eu(
             dn_dataset.copy(), test_csv.absolute(), "PACKET_1", comment="#"
         )
 
 
+def test_segmented_poly_out_of_range(tmp_path):
+    """Test that a value error is thrown if a raw DN value is out of range"""
+    # Generate a csv for testing
+    test_df = pd.DataFrame(
+        data={
+            "packetName": ["PACKET_0", "PACKET_0"],
+            "mnemonic": ["FIELD_0", "FIELD_0"],
+            "convertAs": ["SEGMENTED_POLY", "SEGMENTED_POLY"],
+            # Make ranges higher than DNs
+            "dn_range_start": [100, 201],
+            "dn_range_stop": [200, 400],
+            "c0": [0, 1],
+            "c1": [0, 1],
+            "c2": [0, 1],
+            "c3": [0, 1],
+            "c5": [0, 1],
+            "c6": [0, 1],
+            "c7": [0, 1],
+            "unit": ["a", "b"],
+        }
+    )
+    test_csv = tmp_path / "test_convert_table.csv"
+    with open(test_csv, "w") as f:
+        f.write("# Comment on first line of file\n")
+        test_df.to_csv(f, index=False)
+
+    # Generate a fake dataset for testing
+    n_packets = 3
+    field_0 = np.arange(n_packets)
+    time = np.arange(n_packets) + 1000
+    dn_dataset = xr.Dataset(
+        data_vars=dict(
+            FIELD_0=(["time"], field_0),
+        ),
+        coords=dict(
+            time=time,
+        ),
+    )
+    # Check that a ValueError is raised for DNs not in any ranges
+    with pytest.raises(
+        ValueError, match="Raw DN values found outside of the expected range"
+    ):
+        utils.convert_raw_to_eu(
+            dn_dataset.copy(), test_csv.absolute(), "PACKET_0", comment="#"
+        )
+
+
+def test_unsegmented_poly_multiple_rows(tmp_path):
+    """Test that a value error is thrown if there are multiple rows with the same
+    mnemonic and packet name and convertAs is UNSEGMENTED_POLY"""
+    # Generate a csv for testing
+    test_df = pd.DataFrame(
+        data={
+            "packetName": ["PACKET_0", "PACKET_0"],
+            "mnemonic": ["FIELD_0", "FIELD_0"],
+            "convertAs": ["UNSEGMENTED_POLY", "UNSEGMENTED_POLY"],
+            "c0": [0, 1],
+            "c1": [0, 1],
+            "c2": [0, 1],
+            "c3": [0, 1],
+            "c5": [0, 1],
+            "c6": [0, 1],
+            "c7": [0, 1],
+            "unit": ["a", "a"],
+        }
+    )
+    test_csv = tmp_path / "test_convert_table.csv"
+    with open(test_csv, "w") as f:
+        f.write("# Comment on first line of file\n")
+        test_df.to_csv(f, index=False)
+
+    # Generate a fake dataset for testing
+    field_0 = np.arange(3)
+    dn_dataset = xr.Dataset(
+        data_vars=dict(
+            FIELD_0=(["time"], field_0),
+        )
+    )
+    # Check that a ValueError is raised for DNs not in any ranges
+    with pytest.raises(
+        ValueError,
+        match="For unsegmented polynomial conversions, there should "
+        "only be one row per mnemonic and packet name",
+    ):
+        utils.convert_raw_to_eu(
+            dn_dataset.copy(), test_csv.absolute(), "PACKET_0", comment="#"
+        )
+
+
 @pytest.mark.parametrize(
     "use_derived_value, expected_mode",
     [(True, np.array(["HVENG", "HVSCI"])), (False, np.array([2, 3]))],
@@ -100,10 +222,11 @@ def test_packet_file_to_datasets(use_derived_value, expected_mode):
 
 
 def test_packet_file_to_datasets_flat_definition():
-    test_file = "tests/idex/test_data/imap_idex_l0_raw_20231214_v001.pkts"
+    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)