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

imap_processing/tests/swe/test_swe_l1a.py

@@ -10,3 +10,21 @@ def test_cdf_creation():
     cem_raw_cdf_filepath = write_cdf(processed_data[0])
 
     assert cem_raw_cdf_filepath.name == "imap_swe_l1a_sci_20240510_v001.cdf"
+
+
+def test_cdf_creation_hk():
+    test_data_path = "tests/swe/l0_data/2024051010_SWE_HK_packet.bin"
+    processed_data = swe_l1a(imap_module_directory / test_data_path, "001")
+
+    hk_cdf_filepath = write_cdf(processed_data[0])
+
+    assert hk_cdf_filepath.name == "imap_swe_l1a_hk_20240510_v001.cdf"
+
+
+def test_cdf_creation_cem_raw():
+    test_data_path = "tests/swe/l0_data/2024051011_SWE_CEM_RAW_packet.bin"
+    processed_data = swe_l1a(imap_module_directory / test_data_path, "001")
+
+    cem_raw_cdf_filepath = write_cdf(processed_data[0])
+
+    assert cem_raw_cdf_filepath.name == "imap_swe_l1a_cem-raw_20240510_v001.cdf"

imap_processing/tests/swe/test_swe_l1a_cem_raw.py

@@ -0,0 +1,52 @@
+from dataclasses import fields
+
+import pandas as pd
+import pytest
+
+from imap_processing import imap_module_directory
+from imap_processing.ccsds.ccsds_data import CcsdsData
+from imap_processing.swe.utils.swe_utils import SWEAPID
+from imap_processing.utils import packet_file_to_datasets
+
+
+@pytest.fixture(scope="session")
+def decom_raw_cem_data():
+    """Read test data from file"""
+    test_folder_path = imap_module_directory / "tests/swe/l0_data"
+    packet_file = test_folder_path / "2024051011_SWE_CEM_RAW_packet.bin"
+    xtce_document = (
+        imap_module_directory / "swe/packet_definitions/swe_packet_definition.xml"
+    )
+    datasets_by_apid = packet_file_to_datasets(
+        packet_file, xtce_document, use_derived_value=False
+    )
+    return datasets_by_apid[SWEAPID.SWE_CEM_RAW]
+
+
+def test_number_of_packets(decom_raw_cem_data):
+    """This test and validate number of packets."""
+    expected_number_of_packets = 25
+    assert len(decom_raw_cem_data) == expected_number_of_packets
+
+
+def test_swe_raw_cem_data(decom_raw_cem_data):
+    """This test and validate raw data of SWE raw CEM data."""
+    # read validation data
+    test_data_path = imap_module_directory / "tests/swe/l0_validation_data"
+    raw_validation_data = pd.read_csv(
+        test_data_path / "idle_export_eu.SWE_CEM_RAW_20240510_092742.csv",
+        index_col="SHCOARSE",
+    )
+
+    first_data = decom_raw_cem_data.isel(epoch=0)
+    validation_data = raw_validation_data.loc[first_data["shcoarse"].values]
+
+    ccsds_header_keys = [field.name for field in fields(CcsdsData)]
+    ccsds_header_keys += ["SHCOARSE"]
+
+    # compare unpacked data to validation data
+    for key in first_data.keys():
+        if key.upper() in ccsds_header_keys:
+            continue
+        # check if the data is the same.
+        assert first_data[key] == validation_data[key.upper()]

imap_processing/tests/swe/test_swe_l1a_hk.py

@@ -0,0 +1,68 @@
+from dataclasses import fields
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from imap_processing import imap_module_directory
+from imap_processing.ccsds.ccsds_data import CcsdsData
+from imap_processing.swe.utils.swe_utils import SWEAPID
+from imap_processing.utils import packet_file_to_datasets
+
+
+@pytest.fixture(scope="session")
+def decom_hk_data():
+    """Read test data from file"""
+    test_folder_path = imap_module_directory / "tests/swe/l0_data"
+    packet_file = test_folder_path / "2024051010_SWE_HK_packet.bin"
+    xtce_document = (
+        imap_module_directory / "swe/packet_definitions/swe_packet_definition.xml"
+    )
+    datasets_by_apid = packet_file_to_datasets(
+        packet_file,
+        xtce_document,
+        use_derived_value=True,
+    )
+    return datasets_by_apid[SWEAPID.SWE_APP_HK]
+
+
+def test_swe_hk_data(decom_hk_data):
+    """This test and validate raw data of SWAPI raw housekeeping data."""
+    # read validation data
+    test_data_path = imap_module_directory / "tests/swe/l0_validation_data"
+
+    raw_validation_data = pd.read_csv(
+        test_data_path / "idle_export_eu.SWE_APP_HK_20240510_092742.csv",
+        index_col="SHCOARSE",
+    )
+
+    first_data = decom_hk_data.isel(epoch=0)
+    validation_data = raw_validation_data.loc[first_data["shcoarse"].values]
+
+    # TODO: check with SWE team
+    mismatched_keys = [
+        "HVPS_ESA_DAC",
+    ]
+
+    ccsds_header_keys = [field.name for field in fields(CcsdsData)]
+    ccsds_header_keys += ["SHCOARSE"]
+    # compare raw values of validation data
+    for key in first_data.keys():
+        data_key = key.upper()
+        if data_key in ccsds_header_keys:
+            continue
+
+        if data_key in mismatched_keys:
+            continue
+
+        # Compare derived string values to validation data
+        if str(first_data[key].dtype).startswith("<U"):
+            assert first_data[key].values == validation_data[data_key]
+        # Compare derived float values to validation data
+        elif first_data[key].dtype == "float64":
+            np.testing.assert_almost_equal(
+                first_data[key].values, validation_data[data_key], decimal=6
+            )
+        # Compare derived integer values to validation data
+        else:
+            assert first_data[key].values == validation_data[data_key]

imap_processing/tests/swe/test_swe_l1b_science.py

@@ -9,6 +9,7 @@ from imap_processing.swe.l1b.swe_l1b_science import (
     apply_in_flight_calibration,
     get_indices_of_full_cycles,
 )
+from imap_processing.swe.utils import swe_constants
 
 
 @pytest.fixture(scope="session")
@@ -57,8 +58,17 @@ def test_in_flight_calibration_factor(mock_read_in_flight_cal_data, l1a_test_dat
 
     input_time = 453051355.0
     input_count = 19967
-    one_full_cycle_data = np.full((24, 30, 7), input_count)
-    acquisition_time = np.full((24, 30), input_time)
+    one_full_cycle_data = np.full(
+        (
+            swe_constants.N_ESA_STEPS,
+            swe_constants.N_ANGLE_SECTORS,
+            swe_constants.N_CEMS,
+        ),
+        input_count,
+    )
+    acquisition_time = np.full(
+        (swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS), input_time
+    )
 
     # Test that calibration factor is within correct range given test data
     expected_cal_factor = 1 + ((2 - 1) / (453051900 - 453051300)) * (
@@ -72,13 +82,22 @@ def test_in_flight_calibration_factor(mock_read_in_flight_cal_data, l1a_test_dat
 
     np.testing.assert_allclose(
         calibrated_count,
-        np.full((24, 30, 7), input_count * expected_cal_factor),
+        np.full(
+            (
+                swe_constants.N_ESA_STEPS,
+                swe_constants.N_ANGLE_SECTORS,
+                swe_constants.N_CEMS,
+            ),
+            input_count * expected_cal_factor,
+        ),
         rtol=1e-9,
     )
 
     # Check for value outside of calibration time range
     input_time = 1.0
-    acquisition_time = np.full((24, 30), input_time)
+    acquisition_time = np.full(
+        (swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS), input_time
+    )
 
     with pytest.raises(ValueError, match="Acquisition min/max times: "):
         apply_in_flight_calibration(one_full_cycle_data, acquisition_time)

imap_processing/tests/swe/test_swe_l2.py

@@ -10,8 +10,6 @@ from imap_processing.cdf.utils import write_cdf
 from imap_processing.swe.l1a.swe_l1a import swe_l1a
 from imap_processing.swe.l1b.swe_l1b import swe_l1b
 from imap_processing.swe.l2.swe_l2 import (
-    ENERGY_CONVERSION_FACTOR,
-    VELOCITY_CONVERSION_FACTOR,
     calculate_flux,
     calculate_phase_space_density,
     find_angle_bin_indices,
@@ -19,17 +17,25 @@ from imap_processing.swe.l2.swe_l2 import (
     put_data_into_angle_bins,
     swe_l2,
 )
-from imap_processing.swe.utils.swe_utils import read_lookup_table
+from imap_processing.swe.utils import swe_constants
+from imap_processing.swe.utils.swe_utils import (
+    read_lookup_table,
+)
 
 
 def test_get_particle_energy():
     """Test get_particle_energy function."""
     all_energy = get_particle_energy()
-    expected_energy = read_lookup_table()["esa_v"].values * ENERGY_CONVERSION_FACTOR
+    expected_energy = (
+        read_lookup_table()["esa_v"].values * swe_constants.ENERGY_CONVERSION_FACTOR
+    )
     np.testing.assert_array_equal(all_energy["energy"], expected_energy)
 
 
-@patch("imap_processing.swe.l2.swe_l2.GEOMETRIC_FACTORS", new=np.full(7, 1))
+@patch(
+    "imap_processing.swe.utils.swe_constants.GEOMETRIC_FACTORS",
+    new=np.full(swe_constants.N_CEMS, 1),
+)
 @patch(
     "imap_processing.swe.l2.swe_l2.get_particle_energy",
     return_value=pd.DataFrame(
@@ -50,21 +56,34 @@ def test_calculate_phase_space_density(patch_get_particle_energy):
         {
             "science_data": (
                 ["epoch", "energy", "angle", "cem"],
-                np.full((total_sweeps, 24, 30, 7), 1),
+                np.full(
+                    (
+                        total_sweeps,
+                        swe_constants.N_ESA_STEPS,
+                        swe_constants.N_ANGLE_SECTORS,
+                        swe_constants.N_CEMS,
+                    ),
+                    1,
+                ),
+            ),
+            "acq_duration": (
+                ["epoch", "cycle"],
+                np.full((total_sweeps, swe_constants.N_QUARTER_CYCLES), 80.0),
             ),
-            "acq_duration": (["epoch", "cycle"], np.full((total_sweeps, 4), 80.0)),
             "esa_table_num": (
                 ["epoch", "cycle"],
-                np.repeat([0, 1], 4).reshape(total_sweeps, 4),
+                np.repeat([0, 1], swe_constants.N_QUARTER_CYCLES).reshape(
+                    total_sweeps, swe_constants.N_QUARTER_CYCLES
+                ),
             ),
         }
     )
     phase_space_density_ds = calculate_phase_space_density(l1b_dataset)
     assert phase_space_density_ds["phase_space_density"].shape == (
         total_sweeps,
-        24,
-        30,
-        7,
+        swe_constants.N_ESA_STEPS,
+        swe_constants.N_ANGLE_SECTORS,
+        swe_constants.N_CEMS,
     )
 
     # Test that first sweep has correct values. In patch,
@@ -72,16 +91,34 @@ def test_calculate_phase_space_density(patch_get_particle_energy):
     #   2. we have set energy to 1.
     #   3. we have set science_data to 1.
     # Using this in the formula, we calculate expected density value.
-    expected_calculated_density = (2 * 1) / (1 * VELOCITY_CONVERSION_FACTOR * 1**2)
-    expected_density = np.full((24, 30, 7), expected_calculated_density)
+    expected_calculated_density = (2 * 1) / (
+        1 * swe_constants.VELOCITY_CONVERSION_FACTOR * 1**2
+    )
+    expected_density = np.full(
+        (
+            swe_constants.N_ESA_STEPS,
+            swe_constants.N_ANGLE_SECTORS,
+            swe_constants.N_CEMS,
+        ),
+        expected_calculated_density,
+    )
     np.testing.assert_array_equal(
         phase_space_density_ds["phase_space_density"][0].data, expected_density
     )
 
     # Test that second sweep has correct values, similar to first sweep,
     # but with energy 2.
-    expected_calculated_density = (2 * 1) / (1 * VELOCITY_CONVERSION_FACTOR * 2**2)
-    expected_density = np.full((24, 30, 7), expected_calculated_density)
+    expected_calculated_density = (2 * 1) / (
+        1 * swe_constants.VELOCITY_CONVERSION_FACTOR * 2**2
+    )
+    expected_density = np.full(
+        (
+            swe_constants.N_ESA_STEPS,
+            swe_constants.N_ANGLE_SECTORS,
+            swe_constants.N_CEMS,
+        ),
+        expected_calculated_density,
+    )
     np.testing.assert_array_equal(
         phase_space_density_ds["phase_space_density"][1].data, expected_density
     )
@@ -96,18 +133,36 @@ def test_calculate_flux():
         {
             "science_data": (
                 ["epoch", "energy", "angle", "cem"],
-                np.full((total_sweeps, 24, 30, 7), 1),
+                np.full(
+                    (
+                        total_sweeps,
+                        swe_constants.N_ESA_STEPS,
+                        swe_constants.N_ANGLE_SECTORS,
+                        swe_constants.N_CEMS,
+                    ),
+                    1,
+                ),
+            ),
+            "acq_duration": (
+                ["epoch", "cycle"],
+                np.full((total_sweeps, swe_constants.N_QUARTER_CYCLES), 80.0),
             ),
-            "acq_duration": (["epoch", "cycle"], np.full((total_sweeps, 4), 80.0)),
             "esa_table_num": (
                 ["epoch", "cycle"],
-                np.repeat([0, 1], 4).reshape(total_sweeps, 4),
+                np.repeat([0, 1], swe_constants.N_QUARTER_CYCLES).reshape(
+                    total_sweeps, swe_constants.N_QUARTER_CYCLES
+                ),
             ),
         }
     )
 
     flux = calculate_flux(l1b_dataset)
-    assert flux.shape == (total_sweeps, 24, 30, 7)
+    assert flux.shape == (
+        total_sweeps,
+        swe_constants.N_ESA_STEPS,
+        swe_constants.N_ANGLE_SECTORS,
+        swe_constants.N_CEMS,
+    )
     assert type(flux) == np.ndarray
 
 
@@ -142,18 +197,19 @@ def test_find_angle_bin_indices():
 def test_put_data_into_angle_bins():
     """Test put_data_into_angle_bins function."""
     num_cycles = 1
-    num_esa_step = 24
-    num_angle_bins = 30
-    num_cems = 7
     # Create test counts data to test
     # Find all even numbers in the range 0 to 30
     even_numbers = np.arange(0, 30, 2)
     # repeat it twice now to get:
     # [0, 0, 2, 2, ...., 28, 28]
     example_data = np.repeat(even_numbers, 2)
-    energy_angle_test_data = np.tile(example_data, (num_cycles, num_esa_step, 1))
+    energy_angle_test_data = np.tile(
+        example_data, (num_cycles, swe_constants.N_ESA_STEPS, 1)
+    )
     # Expand to include 7 CEMs by repeating across last dimension
-    test_data = np.repeat(energy_angle_test_data[..., np.newaxis], num_cems, axis=-1)
+    test_data = np.repeat(
+        energy_angle_test_data[..., np.newaxis], swe_constants.N_CEMS, axis=-1
+    )
 
     # Took this example from intermediate output from actual data
     angle_bins_example = [
@@ -190,16 +246,28 @@ def test_put_data_into_angle_bins():
     ]
     # Now data with every row to be same as angle_bins_example
     test_angle_bin_indices_data = np.full(
-        (num_cycles, num_esa_step, num_angle_bins), angle_bins_example
+        (num_cycles, swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS),
+        angle_bins_example,
     )
 
     binned_data = put_data_into_angle_bins(test_data, test_angle_bin_indices_data)
-    assert binned_data.shape == (num_cycles, num_esa_step, num_angle_bins, num_cems)
+    assert binned_data.shape == (
+        num_cycles,
+        swe_constants.N_ESA_STEPS,
+        swe_constants.N_ANGLE_BINS,
+        swe_constants.N_CEMS,
+    )
 
     # Test that the binned data has correct values in correct bins by
     # checking that odd number columns are filled with nan
     expected_binned_data = np.full(
-        (num_cycles, num_esa_step, num_angle_bins, num_cems), np.nan
+        (
+            num_cycles,
+            swe_constants.N_ESA_STEPS,
+            swe_constants.N_ANGLE_BINS,
+            swe_constants.N_CEMS,
+        ),
+        np.nan,
     )
     np.testing.assert_array_equal(
         binned_data[0, 0, 1::2, 0], expected_binned_data[0, 0, 1::2, 0]
@@ -259,9 +327,23 @@ def test_swe_l2(mock_read_in_flight_cal_data, use_fake_spin_data_for_time):
     l2_dataset = swe_l2(l1b_dataset[0], "002")
 
     assert type(l2_dataset) == xr.Dataset
-    assert l2_dataset["phase_space_density_spin_sector"].shape == (6, 24, 30, 7)
-    assert l2_dataset["flux_spin_sector"].shape == (6, 24, 30, 7)
-    assert l2_dataset["acquisition_time"].shape == (6, 24, 30)
+    assert l2_dataset["phase_space_density_spin_sector"].shape == (
+        6,
+        swe_constants.N_ESA_STEPS,
+        swe_constants.N_ANGLE_SECTORS,
+        swe_constants.N_CEMS,
+    )
+    assert l2_dataset["flux_spin_sector"].shape == (
+        6,
+        swe_constants.N_ESA_STEPS,
+        swe_constants.N_ANGLE_SECTORS,
+        swe_constants.N_CEMS,
+    )
+    assert l2_dataset["acquisition_time"].shape == (
+        6,
+        swe_constants.N_ESA_STEPS,
+        swe_constants.N_ANGLE_SECTORS,
+    )
 
     # Write L2 to CDF
     l2_cdf_filepath = write_cdf(l2_dataset)

imap_processing/tests/test_cli.py

@@ -62,8 +62,8 @@ def test_main(mock_instrument):
 @pytest.mark.parametrize(
     "instrument, data_level, raises_value_error",
     [
-        ("mag", "l0", ""),
-        ("foo", "l0", "foo is not in the supported .*"),
+        ("mag", "l1a", ""),
+        ("foo", "l1a", "foo is not in the supported .*"),
         ("codice", "l1z", "l1z is not a supported .*"),
     ],
 )

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,7 +222,7 @@ 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"