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

imap_processing/idex/idex_l0.py

@@ -2,14 +2,19 @@
 
 import logging
 from pathlib import Path
-from typing import Union
+from typing import Any, Union
+
+from xarray import Dataset
 
 from imap_processing import decom, imap_module_directory
+from imap_processing.utils import packet_file_to_datasets
 
 logger = logging.getLogger(__name__)
 
 
-def decom_packets(packet_file: Union[str, Path]) -> list:
+def decom_packets(
+    packet_file: Union[str, Path],
+) -> tuple[list[Any], dict[int, Dataset]]:
     """
     Decom IDEX data packets using IDEX packet definition.
 
@@ -20,12 +25,21 @@ def decom_packets(packet_file: Union[str, Path]) -> list:
 
     Returns
     -------
-    list
-        All the unpacked data.
+    Tuple[list, dict]
+        Returns a list of all unpacked science data and a dictionary of datasets
+        indexed by their APIDs.
+
+    Notes
+    -----
+    The function 'packet_file_to_dataset' does not work with IDEX science packets due to
+    branching logic within the science xml file. The science data and housekeeping data
+    will be decommed separately and both returned from this function.
     """
-    xtce_filename = "idex_packet_definition.xml"
-    xtce_file = f"{imap_module_directory}/idex/packet_definitions/{xtce_filename}"
+    xtce_base_path = f"{imap_module_directory}/idex/packet_definitions"
+    science_xtce_file = f"{xtce_base_path}/idex_science_packet_definition.xml"
+    hk_xtce_file = f"{xtce_base_path}/idex_housekeeping_packet_definition.xml"
 
-    decom_packet_list = decom.decom_packets(packet_file, xtce_file)
+    science_decom_packet_list = decom.decom_packets(packet_file, science_xtce_file)
+    datasets_by_apid = packet_file_to_datasets(packet_file, hk_xtce_file)
 
-    return list(decom_packet_list)
+    return list(science_decom_packet_list), datasets_by_apid

imap_processing/idex/idex_l1a.py

@@ -10,7 +10,7 @@ Examples
     from imap_processing.idex.idex_l1a import PacketParser
 
     l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20231214_v001.pkts"
-    l1a_data = PacketParser(l0_file, data_version)
+    l1a_data = PacketParser(l0_file)
     l1a_data.write_l1a_cdf()
 """
 
@@ -26,6 +26,7 @@ import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.idex.decode import rice_decode
+from imap_processing.idex.idex_constants import IDEXAPID
 from imap_processing.idex.idex_l0 import decom_packets
 from imap_processing.spice.time import met_to_ttj2000ns
 from imap_processing.utils import convert_to_binary_string
@@ -57,11 +58,9 @@ class PacketParser:
     ----------
     packet_file : str
         The path and filename to the L0 file to read.
-    data_version : str
-        The version of the data product being created.
     """
 
-    def __init__(self, packet_file: Union[str, Path], data_version: str) -> None:
+    def __init__(self, packet_file: Union[str, Path]) -> None:
         """
         Read a L0 pkts file and perform all of the decom work.
 
@@ -69,23 +68,62 @@ class PacketParser:
         ----------
         packet_file : pathlib.Path | str
           The path and filename to the L0 file to read.
-        data_version : str
-            The version of the data product being created.
 
         Notes
         -----
             Currently assumes one L0 file will generate exactly one L1a file.
         """
-        decom_packet_list = decom_packets(packet_file)
+        self.data = []
+        self.idex_attrs = get_idex_attrs()
+        epoch_attrs = self.idex_attrs.get_variable_attributes(
+            "epoch", check_schema=False
+        )
+
+        science_packets, datset_by_apid = decom_packets(packet_file)
+
+        if science_packets:
+            logger.info("Processing IDEX L1A Science data.")
+            self.data.append(self._create_science_dataset(science_packets))
+
+        if IDEXAPID.IDEX_EVT in datset_by_apid:
+            logger.info("Processing IDEX L1A Event Message data.")
+            data = datset_by_apid[IDEXAPID.IDEX_EVT]
+            data.attrs = self.idex_attrs.get_global_attributes("imap_idex_l1a_evt")
+            data["epoch"].attrs = epoch_attrs
+            self.data.append(data)
+
+        if IDEXAPID.IDEX_CATLST in datset_by_apid:
+            logger.info("Processing IDEX L1A Catalog List Summary data.")
+            data = datset_by_apid[IDEXAPID.IDEX_CATLST]
+            data.attrs = self.idex_attrs.get_global_attributes("imap_idex_l1a_catlst")
+            data["epoch"].attrs = epoch_attrs
+            self.data.append(data)
+
+        logger.info("IDEX L1A data processing completed.")
+
+    def _create_science_dataset(self, science_decom_packet_list: list) -> xr.Dataset:
+        """
+        Process IDEX science packets into an xarray Dataset.
+
+        Parameters
+        ----------
+        science_decom_packet_list : list
+            List of decommutated science packets.
+
+        Returns
+        -------
+        xarray.Dataset
+            Dataset containing processed dust events.
+        """
         dust_events = {}
-        for packet in decom_packet_list:
+        for packet in science_decom_packet_list:
             if "IDX__SCI0TYPE" in packet:
                 scitype = packet["IDX__SCI0TYPE"]
                 event_number = packet["IDX__SCI0EVTNUM"]
                 if scitype == Scitype.FIRST_PACKET:
                     # Initial packet for new dust event
                     # Further packets will fill in data
-                    dust_events[event_number] = RawDustEvent(packet, data_version)
+                    dust_events[event_number] = RawDustEvent(packet)
                 elif event_number not in dust_events:
                     raise KeyError(
                         f"Have not receive header information from event number\
@@ -101,40 +139,43 @@ class PacketParser:
             dust_event.process() for dust_event in dust_events.values()
         ]
 
-        self.data = xr.concat(processed_dust_impact_list, dim="epoch")
-        idex_attrs = get_idex_attrs(data_version)
-        self.data.attrs = idex_attrs.get_global_attributes("imap_idex_l1a_sci")
+        data = xr.concat(processed_dust_impact_list, dim="epoch")
+        data.attrs = self.idex_attrs.get_global_attributes("imap_idex_l1a_sci")
 
         # Add high and low sample rate coords
-        self.data["time_low_sample_rate_index"] = xr.DataArray(
-            np.arange(len(self.data["time_low_sample_rate"][0])),
+        data["time_low_sample_rate_index"] = xr.DataArray(
+            np.arange(len(data["time_low_sample_rate"][0])),
             name="time_low_sample_rate_index",
             dims=["time_low_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_low_sample_rate_index"),
+            attrs=self.idex_attrs.get_variable_attributes("time_low_sample_rate_index"),
         )
 
-        self.data["time_high_sample_rate_index"] = xr.DataArray(
-            np.arange(len(self.data["time_high_sample_rate"][0])),
+        data["time_high_sample_rate_index"] = xr.DataArray(
+            np.arange(len(data["time_high_sample_rate"][0])),
             name="time_high_sample_rate_index",
             dims=["time_high_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_high_sample_rate_index"),
+            attrs=self.idex_attrs.get_variable_attributes(
+                "time_high_sample_rate_index"
+            ),
         )
         # NOTE: LABL_PTR_1 should be CDF_CHAR.
-        self.data["time_low_sample_rate_label"] = xr.DataArray(
-            self.data.time_low_sample_rate_index.values.astype(str),
+        data["time_low_sample_rate_label"] = xr.DataArray(
+            data.time_low_sample_rate_index.values.astype(str),
             name="time_low_sample_rate_label",
             dims=["time_low_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_low_sample_rate_label"),
+            attrs=self.idex_attrs.get_variable_attributes("time_low_sample_rate_label"),
         )
 
-        self.data["time_high_sample_rate_label"] = xr.DataArray(
-            self.data.time_high_sample_rate_index.values.astype(str),
+        data["time_high_sample_rate_label"] = xr.DataArray(
+            data.time_high_sample_rate_index.values.astype(str),
             name="time_high_sample_rate_label",
             dims=["time_high_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_high_sample_rate_label"),
+            attrs=self.idex_attrs.get_variable_attributes(
+                "time_high_sample_rate_label"
+            ),
         )
 
-        logger.info("IDEX L1A science data processing completed.")
+        return data
 
 
 def _read_waveform_bits(waveform_raw: str, high_sample: bool = True) -> list[int]:
@@ -198,8 +239,6 @@ class RawDustEvent:
     ----------
     header_packet : space_packet_parser.packets.CCSDSPacket
         The FPGA metadata event header.
-    data_version : str
-        The version of the data product being created.
 
     Attributes
     ----------
@@ -252,9 +291,7 @@ class RawDustEvent:
     MAX_HIGH_BLOCKS = 16
     MAX_LOW_BLOCKS = 64
 
-    def __init__(
-        self, header_packet: space_packet_parser.packets.CCSDSPacket, data_version: str
-    ) -> None:
+    def __init__(self, header_packet: space_packet_parser.packets.CCSDSPacket) -> None:
         """
         Initialize a raw dust event, with an FPGA Header Packet from IDEX.
 
@@ -268,8 +305,6 @@ class RawDustEvent:
         ----------
         header_packet : space_packet_parser.packets.CCSDSPacket
             The FPGA metadata event header.
-        data_version : str
-            Data version for CDF filename, in the format ``vXXX``.
         """
         # Calculate the impact time in seconds since epoch
         self.impact_time = 0
@@ -301,7 +336,7 @@ class RawDustEvent:
         self.Ion_Grid_bits = ""
 
         self.compressed = self.telemetry_items["idx__sci0comp"]
-        self.cdf_attrs = get_idex_attrs(data_version)
+        self.cdf_attrs = get_idex_attrs()
 
     def _append_raw_data(self, scitype: Scitype, bits: str) -> None:
         """
@@ -445,11 +480,12 @@ class RawDustEvent:
             List of the high sample waveform.
         """
         samples = self.MAX_HIGH_BLOCKS * self.NUMBER_SAMPLES_PER_HIGH_SAMPLE_BLOCK
+        ints: list[int] = []
         if self.compressed.raw_value == 1:
-            ints = rice_decode(waveform_raw, nbit10=True, sample_count=samples)
+            ints.extend(rice_decode(waveform_raw, nbit10=True, sample_count=samples))
             ints = ints[:-3]
         else:
-            ints = _read_waveform_bits(waveform_raw, high_sample=True)
+            ints.extend(_read_waveform_bits(waveform_raw, high_sample=True))
         return ints
 
     def _parse_low_sample_waveform(self, waveform_raw: str) -> list[int]:
@@ -470,10 +506,11 @@ class RawDustEvent:
             List of processed low sample waveform.
         """
         samples = self.MAX_LOW_BLOCKS * self.NUMBER_SAMPLES_PER_LOW_SAMPLE_BLOCK
+        ints: list[int] = []
         if self.compressed.raw_value == 1:
-            ints = rice_decode(waveform_raw, nbit10=False, sample_count=samples)
+            ints.extend(rice_decode(waveform_raw, nbit10=False, sample_count=samples))
         else:
-            ints = _read_waveform_bits(waveform_raw, high_sample=False)
+            ints.extend(_read_waveform_bits(waveform_raw, high_sample=False))
         return ints
 
     def _calc_low_sample_resolution(self, num_samples: int) -> npt.NDArray:
@@ -651,15 +688,10 @@ class RawDustEvent:
         return dataset
 
 
-def get_idex_attrs(data_version: str) -> ImapCdfAttributes:
+def get_idex_attrs() -> ImapCdfAttributes:
     """
     Load in CDF attributes for IDEX instrument.
 
-    Parameters
-    ----------
-    data_version : str
-        Data version for CDF filename, in the format "vXXX".
-
     Returns
     -------
     idex_attrs : ImapCdfAttributes
@@ -668,5 +700,4 @@ def get_idex_attrs(data_version: str) -> ImapCdfAttributes:
     idex_attrs = ImapCdfAttributes()
     idex_attrs.add_instrument_global_attrs("idex")
     idex_attrs.add_instrument_variable_attrs("idex", "l1a")
-    idex_attrs.add_global_attribute("Data_version", data_version)
     return idex_attrs

imap_processing/idex/idex_l1b.py

@@ -9,8 +9,8 @@ Examples
     from imap_processing.idex.idex_l1b import idex_l1b
 
     l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20231214_v001.pkts"
-    l1a_data = PacketParser(l0_file, data_version)
-    l1b_data = idex_l1b(l1a_data, data_version)
+    l1a_data = PacketParser(l0_file)
+    l1b_data = idex_l1b(l1a_data)
     write_cdf(l1b_data)
 """
 
@@ -77,7 +77,7 @@ class TriggerMode(Enum):
         return f"{channel.upper()}{TriggerMode(mode).name}"
 
 
-def idex_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+def idex_l1b(l1a_dataset: xr.Dataset) -> xr.Dataset:
     """
     Will process IDEX l1a data to create l1b data products.
 
@@ -85,8 +85,6 @@ def idex_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     ----------
     l1a_dataset : xarray.Dataset
         IDEX L1a dataset to process.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -101,7 +99,6 @@ def idex_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     idex_attrs = ImapCdfAttributes()
     idex_attrs.add_instrument_global_attrs(instrument="idex")
     idex_attrs.add_instrument_variable_attrs(instrument="idex", level="l1b")
-    idex_attrs.add_global_attribute("Data_version", data_version)
 
     var_information_path = (
         f"{imap_module_directory}/idex/idex_variable_unpacking_and_eu_conversion.csv"
@@ -295,10 +292,14 @@ def get_trigger_mode_and_level(
         # Bit-shift right 22 places and use a 10-bit mask to extract the level value.
         threshold_level = float((trigger_controls >> 22) & mask)
 
-        # If it is the high gain channel multiply the level by the conversion factor.
-        # TODO: determine why the idex team is only doing this for the high gain channel
+        # multiply the threshold level by the conversion factor.
         if gain_channel == "hg":
             threshold_level *= ConversionFactors["TOF_High"]
+        elif gain_channel == "mg":
+            threshold_level *= ConversionFactors["TOF_Mid"]
+        elif gain_channel == "lg":
+            threshold_level *= ConversionFactors["TOF_Low"]
+
         return mode_label, threshold_level
 
     for channel in channels:

imap_processing/idex/idex_l2a.py

@@ -10,16 +10,14 @@ Examples
     from imap_processing.idex.idex_l2a import idex_l2a
 
     l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20231214_v001.pkts"
-    l1a_data = PacketParser(l0_file, data_version)
-    l1b_data = idex_l1b(l1a_data, data_version)
-    l2a_data = idex_l2a(l1b_data, data_version)
+    l1a_data = PacketParser(l0_file)
+    l1b_data = idex_l1b(l1a_data)
+    l2a_data = idex_l2a(l1b_data)
     write_cdf(l2a_data)
 """
 
-# ruff: noqa: PLR0913
 import logging
 from enum import IntEnum
-from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -32,7 +30,6 @@ from scipy.stats import exponnorm
 
 from imap_processing import imap_module_directory
 from imap_processing.idex import idex_constants
-from imap_processing.idex.idex_constants import ConversionFactors
 from imap_processing.idex.idex_l1a import get_idex_attrs
 
 logger = logging.getLogger(__name__)
@@ -54,7 +51,7 @@ class BaselineNoiseTime(IntEnum):
     STOP = -5
 
 
-def idex_l2a(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+def idex_l2a(l1b_dataset: xr.Dataset) -> xr.Dataset:
     """
     Will process IDEX l1b data to create l2a data products.
 
@@ -70,8 +67,6 @@ def idex_l2a(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     ----------
     l1b_dataset : xarray.Dataset
         IDEX L1a dataset to process.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -104,7 +99,7 @@ def idex_l2a(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     kappa = calculate_kappa(mass_scales, peaks_2d)
 
     # Analyze peaks for estimating dust composition
-    peak_fits, area_under_fits = xr.apply_ufunc(
+    peak_fits_params, area_under_fits, fit_chisqr, fit_redchi = xr.apply_ufunc(
         analyze_peaks,
         tof_high,
         hs_time,
@@ -117,10 +112,11 @@ def idex_l2a(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
             ["time_high_sample_rate_index"],
             [],
         ],
-        # TODO: Determine dimension name
         output_core_dims=[
-            ["time_of_flight", "peak_fit_parameters"],
-            ["time_of_flight"],
+            ["mass", "peak_fit_parameters"],
+            ["mass"],
+            [],
+            [],
         ],
         vectorize=True,
     )
@@ -128,13 +124,11 @@ def idex_l2a(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     l2a_dataset = l1b_dataset.copy()
 
     for waveform in ["Target_Low", "Target_High", "Ion_Grid"]:
-        # Convert back to raw DNs for more accurate fits
-        waveform_dn = l1b_dataset[waveform] / ConversionFactors[waveform]
         # Get the dust mass estimates and fit results
         fit_results = xr.apply_ufunc(
             estimate_dust_mass,
             ls_time,
-            waveform_dn,
+            l1b_dataset[waveform],
             input_core_dims=[
                 ["time_low_sample_rate_index"],
                 ["time_low_sample_rate_index"],
@@ -152,20 +146,23 @@ def idex_l2a(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
         waveform_name = waveform.lower()
         # Add variables
         l2a_dataset[f"{waveform_name}_fit_parameters"] = fit_results[0]
-        l2a_dataset[f"{waveform_name}_fit_imapct_charge"] = fit_results[1]
+        l2a_dataset[f"{waveform_name}_fit_impact_charge"] = fit_results[1]
         # TODO: convert charge to mass
-        l2a_dataset[f"{waveform_name}_fit_imapct_mass_estimate"] = fit_results[1]
+        l2a_dataset[f"{waveform_name}_fit_impact_mass_estimate"] = fit_results[1]
         l2a_dataset[f"{waveform_name}_chi_squared"] = fit_results[2]
         l2a_dataset[f"{waveform_name}_reduced_chi_squared"] = fit_results[3]
         l2a_dataset[f"{waveform_name}_fit_results"] = fit_results[4]
 
-    l2a_dataset["tof_peak_fit_parameters"] = peak_fits
+    l2a_dataset["tof_peak_fit_parameters"] = peak_fits_params
     l2a_dataset["tof_peak_area_under_fit"] = area_under_fits
+    l2a_dataset["tof_peak_chi_square"] = fit_chisqr
+    l2a_dataset["tof_peak_reduced_chi_square"] = fit_redchi
+
     l2a_dataset["tof_peak_kappa"] = xr.DataArray(kappa, dims=["epoch"])
     l2a_dataset["tof_snr"] = xr.DataArray(snr, dims=["epoch"])
     l2a_dataset["mass"] = mass_scales_da
     # Update global attributes
-    idex_attrs = get_idex_attrs(data_version)
+    idex_attrs = get_idex_attrs()
     l2a_dataset.attrs = idex_attrs.get_global_attributes("imap_idex_l2a_sci")
 
     logger.info("IDEX L2A science data processing completed.")
@@ -361,7 +358,7 @@ def analyze_peaks(
     mass_scale: xr.DataArray,
     event_num: int,
     peaks_2d: np.ndarray,
-) -> tuple[NDArray, NDArray]:
+) -> tuple[NDArray, NDArray, float, float]:
     """
     Fit an EMG curve to the Time of Flight data around each peak.
 
@@ -404,8 +401,8 @@ def analyze_peaks(
         time_slice = high_sampling_time[start:end]
         tof_slice = tof_high[start:end]
 
-        param = fit_emg(time_slice, tof_slice, event_num)
-        if param is None:
+        param, chisqr, redchi = fit_emg(time_slice, tof_slice, event_num)
+        if np.all(np.isnan(param)):
             continue
 
         area = calculate_area_under_emg(time_slice, param)
@@ -427,7 +424,6 @@ def analyze_peaks(
         mass = max(0, round(mass))
         # Find the first index with non-zero fit parameters, starting from current mass
         non_zero_idxs = np.nonzero(np.all(fit_params[mass:] != 0, axis=-1))[0]
-
         # Determine index to use
         # If no non-zero parameters found, use current mass index
         # Otherwise, use the current mass plus offset to first non-zero index
@@ -437,16 +433,14 @@ def analyze_peaks(
             fit_params[idx] = np.array([mu, sigma, lam])
             area_under_emg[idx] = area
         else:
-            logger.warning(
-                f"Unable to find a slot for mass: {mass}. Discarding " f"value."
-            )
+            logger.warning(f"Unable to find a slot for mass: {mass}. Discarding value.")
 
-    return fit_params, area_under_emg
+    return fit_params, area_under_emg, chisqr, redchi
 
 
 def fit_emg(
     peak_time: np.ndarray, peak_signal: np.ndarray, event_num: int
-) -> Union[NDArray, None]:
+) -> tuple[NDArray, float, float]:
     """
     Fit an exponentially modified gaussian function to the peak signal.
 
@@ -465,9 +459,13 @@ def fit_emg(
 
     Returns
     -------
-    param : numpy.ndarray or None
+    param : numpy.ndarray
         Fitted EMG optimal values for the parameters (popt) [k (shape parameter), mu,
-        sigma] if fit successful, None otherwise.
+        sigma] if fit is successful, array of np.nans otherwise.
+    chisqr : float
+        Chi-square value if fit is successful, np.nan otherwise.
+    redchi : float
+        Reduced chi-square value if fit is successful, np.nan otherwise.
     """
     # Initial Guess for the parameters of the emg fit:
     # center of gaussian
@@ -490,11 +488,14 @@ def fit_emg(
             f"Time range: {peak_time[0]:.2f} to {peak_time[-1]:.2f}\n"
             f"Signal range: {min(peak_signal):.2f} to {max(peak_signal):.2f}\n"
             f"Event number: {event_num}\n"
-            "Returning None."
+            "Returning np.nan values."
         )
-        return None
+        return np.full(len(p0), np.nan), np.nan, np.nan
+
+    emg_fit = exponnorm.pdf(peak_time, *param)
+    chisqr, redchi = chi_square(peak_signal, emg_fit, len(p0))
 
-    return param
+    return param, chisqr, redchi
 
 
 def calculate_area_under_emg(time_slice: np.ndarray, param: np.ndarray) -> float:
@@ -555,8 +556,6 @@ def estimate_dust_mass(
     result : numpy.ndarray
         The model values evaluated at each time point.
     """
-    # TODO: The IDEX team is iterating on this Function and will provide more
-    #         information soon.
     signal = np.array(target_signal.data)
     time = np.array(low_sampling_time.data)
     good_mask = np.logical_and(
@@ -615,11 +614,7 @@ def estimate_dust_mass(
     impact_fit = fit_impact(time, *param)
     # Calculate the resulting signal amplitude after removing baseline noise
     sig_amp = max(impact_fit) - np.mean(signal_baseline)
-
-    # Calculate chi square and reduced chi square
-    chisqr = float(np.sum((signal - impact_fit) ** 2))
-    # To get reduced chi square divide by dof (number of points - number of params)
-    redchi = chisqr / (len(signal) - len(p0))
+    chisqr, redchi = chi_square(signal, impact_fit, len(p0))
 
     return param, float(sig_amp), chisqr, redchi, impact_fit
 
@@ -729,7 +724,7 @@ def remove_signal_noise(
 
 def sine_fit(time: np.ndarray, a: float, f: float, p: float) -> NDArray:
     """
-    Generate a sine wave with given amplitude, frequency, and phase.
+    Generate a sine wave with given amplitude, angular frequency, and phase.
 
     Parameters
     ----------
@@ -738,7 +733,7 @@ def sine_fit(time: np.ndarray, a: float, f: float, p: float) -> NDArray:
     a : float
         Amplitude of the sine wave.
     f : float
-        Frequency of the sine wave in Hz.
+        Angular frequency of the sine wave.
     p : float
         Phase shift of the sine wave in radians.
 
@@ -747,7 +742,7 @@ def sine_fit(time: np.ndarray, a: float, f: float, p: float) -> NDArray:
     numpy.ndarray
         Sine wave values calculated at the input time points.
     """
-    return a * np.sin(2 * np.pi * f * time + p)
+    return a * np.sin(f * time + p)
 
 
 def butter_lowpass_filter(
@@ -772,7 +767,6 @@ def butter_lowpass_filter(
     numpy.ndarray
         Filtered signal.
     """
-    # TODO: The IDEX team might be switching this function out for a different filter.
     sample_period = time[1] - time[0]
     # sampling frequency
     fs = (time[-1] - time[0]) / sample_period  # Hz
@@ -787,3 +781,43 @@ def butter_lowpass_filter(
     b, a = butter(order, normal_cutoff, btype="low", analog=False)
     y = filtfilt(b, a, signal)
     return y
+
+
+def chi_square(
+    observed: np.ndarray, expected: np.ndarray, num_params: int
+) -> tuple[float, float]:
+    """
+    Calculate the chi-square and reduced chi-square statistics.
+
+    This implementation follows the approach used in lmfit.minimize()'s
+    _calculate_statistics() method, which calculates chi-square as the sum of squared
+    residuals:
+
+        chisqr = (residual**2).sum()
+
+    And reduced chi-square as the chi-square divided by degrees of freedom:
+
+        ndata = len(residual)
+        nfree = ndata - number_of_parameters
+        redchi = chisqr / max(1, nfree)
+
+    Parameters
+    ----------
+    observed : numpy.ndarray
+       The observed signal.
+    expected : numpy.ndarray
+       The expected signal calculated with the fit parameters.
+    num_params : int
+       The number of parameters used in the fit.
+
+    Returns
+    -------
+    chisqr : float
+        The chi-square value.
+    redchi : float
+        The reduced chi-square value.
+    """
+    residuals = observed - expected
+    chisqr = float(np.sum(residuals**2))
+    redchi = chisqr / max(1, (len(observed) - num_params))
+    return chisqr, redchi