PyDPEET 0.2.0__py3-none-any.whl

pydpeet/process/sequence/utils/processing/check_CV_results.py

@@ -0,0 +1,226 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from numba import njit
+
+from pydpeet.process.sequence.utils.console_prints.log_time import log_time
+from pydpeet.process.sequence.utils.postprocessing.df_primitives_correction import df_primitives_correction
+
+
+@njit(cache=True)
+def _find_zero_segments(
+    times: np.ndarray,
+    currents: np.ndarray,
+    tolerance: float,
+) -> list[tuple[np.ndarray, np.ndarray]]:
+    """
+    Find segments where the absolute value of the current is less than or equal to the given tolerance.
+
+    Parameters:
+        times (np.ndarray): Array of timestamps.
+        currents (np.ndarray): Array of current values.
+        tolerance (float): Maximum absolute value of the current. [-tol,tol] is accepted
+
+    Returns:
+        list: List of tuples of start and end times for each zero segment.
+    """
+    n = len(currents)
+    mask = (~np.isnan(currents)) & (np.abs(currents) <= tolerance)
+
+    zero_segments = []
+    in_seg = False
+    start_idx = 0
+
+    for i in range(n):
+        if mask[i]:
+            if not in_seg:
+                start_idx = i
+                in_seg = True
+        else:
+            if in_seg:
+                zero_segments.append((times[start_idx], times[i - 1]))
+                in_seg = False
+
+    if in_seg:  # ended inside a segment
+        zero_segments.append((times[start_idx], times[n - 1]))
+
+    return zero_segments
+
+
+@njit(cache=True)
+def _get_id_tol_range(
+    times: np.ndarray,
+    currents: np.ndarray,
+    tolerance: float,
+) -> tuple[float, float]:
+    """
+    Return (tmin, tmax) where tmin and tmax are the minimum and maximum times, respectively,
+    where the absolute value of the current is less than or equal to the given tolerance.
+
+    Parameters:
+        times (np.ndarray): Array of timestamps.
+        currents (np.ndarray): Array of current values.
+        tolerance (float): Maximum absolute value of the current. [-tol,tol] is accepted
+
+    Returns:
+        tuple: (tmin, tmax)
+    """
+    n = len(currents)
+    found = False
+    tmin = 0.0
+    tmax = 0.0
+
+    for i in range(n):
+        if np.abs(currents[i]) <= tolerance and not np.isnan(currents[i]):
+            if not found:
+                tmin = times[i]
+                tmax = times[i]
+                found = True
+            else:
+                if times[i] < tmin:
+                    tmin = times[i]
+                if times[i] > tmax:
+                    tmax = times[i]
+
+    if not found:
+        return np.nan, np.nan
+
+    return tmin, tmax
+
+
+@njit(cache=True)
+def _compute_new_ids(ids) -> np.ndarray:
+    """
+    Compute a new array of IDs based on the input array to have contiguous IDs
+    after inserting the falsely suppressed CC segment back in.
+
+    Parameters:
+        ids (np.ndarray): Input array of IDs.
+
+    Returns:
+        np.ndarray: New array of IDs.
+    """
+    n = len(ids)
+    new_ids = np.ones(n, dtype=np.int64)
+    for i in range(1, n):
+        if ids[i] > ids[i - 1]:
+            new_ids[i] = new_ids[i - 1] + 1
+        elif ids[i] == -2 and ids[i - 1] != -2:
+            new_ids[i] = new_ids[i - 1] + 1
+        else:
+            new_ids[i] = new_ids[i - 1]
+    return new_ids
+
+
+def _check_CV_0Aend_segments(
+    df_primitives: pd.DataFrame,
+    tolerance: float,
+    SHOW_RUNTIME: bool,
+    DATA_COLUMNS: dict[str, str],
+    THRESHOLDS_PRIMITIVE_ANNOTATION: dict[str, float],
+    supress_IO_warnings: bool,
+    THRESHOLD_CONSOLE_PRINTS_CV_CHECK: int,
+    THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK: int,
+) -> pd.DataFrame:
+    """
+    Check CV Segments that end with 0A to identify and correct falsely suppressed CC segment at the end,
+    that happen due to the slow sloping of the CV.
+
+    Parameters:
+    df_primitives (pd.DataFrame): DataFrame containing the primitives
+    tolerance (float): maximum absolute value of current that is allowed in the CV segment
+    SHOW_RUNTIME (bool): whether to print runtime information
+    DATA_COLUMNS (dict): dictionary of column names to be kept in the DataFrame
+        Example: {"I": "Current", "P": "Power", "V": "Voltage"}
+    THRESHOLDS_PRIMITIVE_ANNOTATION (dict): dictionary of threshold values for primitive annotation
+        Example: {"I": 0.1, "P": 0.1, "V": 0.1}
+    supress_IO_warnings (bool): whether to suppress runtime warnings
+    THRESHOLD_CONSOLE_PRINTS_CV_CHECK (int): threshold for the number of corrected segments to print
+    THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK (int): threshold for the number of segments to print
+
+    Returns:
+    pd.DataFrame: Dataframe with added columns for annotated primitives
+    """
+
+    with log_time("checking CV Segments that end with 0A", SHOW_RUNTIME=SHOW_RUNTIME):
+        # convert once to numpy
+        times = df_primitives["Test_Time[s]"].to_numpy(np.float64)
+        currents = df_primitives["Current[A]"].to_numpy(np.float64)
+
+        # 1) compute global zero-current segments
+        zero_segments = _find_zero_segments(times, currents, tolerance)
+
+        # 2) get last entry per ID, restricted to Variable=='V' and ~0 current
+        last_entries = df_primitives.groupby("ID", sort=False).tail(1)
+        mask_V = last_entries["Variable"].to_numpy() == "V"
+        mask_tol = np.abs(last_entries["Current[A]"].to_numpy(np.float64)) <= tolerance
+        candidate_ids = last_entries.loc[mask_V & mask_tol, "ID"].to_numpy()
+
+        expanded_ranges = {}
+
+        # 3) process each candidate ID with numba-accelerated range finder
+        for id_val in candidate_ids:
+            sub = df_primitives[df_primitives["ID"] == id_val]
+            sub_times = sub["Test_Time[s]"].to_numpy(np.float64)
+            sub_currents = sub["Current[A]"].to_numpy(np.float64)
+
+            seg_min, seg_max = _get_id_tol_range(sub_times, sub_currents, tolerance)
+            if np.isnan(seg_min):
+                continue
+
+            # expand by global zero_segments
+            for zero_segments_start, zero_segments_end in zero_segments:
+                if zero_segments_end >= seg_min and zero_segments_start <= seg_max:  # overlap
+                    seg_min = min(seg_min, zero_segments_start)
+                    seg_max = max(seg_max, zero_segments_end)
+
+            expanded_ranges[id_val] = (float(seg_min), float(seg_max))
+
+    with log_time("correcting CV Segments that end with 0A", SHOW_RUNTIME=SHOW_RUNTIME):
+        correction_config = {
+            "replace_time_and_merge": {(start, end): "I" for _, (start, end) in expanded_ranges.items()},
+        }
+        starts = np.array([s for s, e in expanded_ranges.values()])
+        ends = np.array([e for s, e in expanded_ranges.values()])
+        times = df_primitives["Test_Time[s]"].to_numpy(np.float64)
+
+        # single mask: True if time is inside any (start, end)
+        mask = np.zeros(len(times), dtype=bool)
+        for s, e in zip(starts, ends, strict=False):
+            mask |= (times >= s) & (times <= e)
+
+        df_CV_0Aend_segments = df_primitives.loc[mask]
+
+        df_CV_0Aend_segments = df_primitives_correction(
+            df_primitives=df_CV_0Aend_segments,
+            correction_config=correction_config,
+            data_columns=DATA_COLUMNS,
+            thresholds=THRESHOLDS_PRIMITIVE_ANNOTATION,
+            reindex=False,
+            reannotate=False,
+        )
+
+        # Update df_primitives with df_CV_0Aend_segments
+        df_CV_0Aend_segments["ID"] = -2
+        cols_to_update = ["ID", "Variable", "Duration", "Length", "Min", "Max", "Avg", "Type", "Direction", "Slope"]
+        df_primitives.loc[df_CV_0Aend_segments.index, cols_to_update] = df_CV_0Aend_segments[cols_to_update]
+
+        # Extract as numpy arrays
+        ids = df_primitives["ID"].to_numpy(dtype=np.int64)
+
+        # Run with numba
+        df_primitives["ID"] = _compute_new_ids(ids)
+
+        if not supress_IO_warnings:
+            if expanded_ranges:
+                logging.warning("Suspicious Voltage Segments that end with Current[A] = 0.0 found.")
+            if THRESHOLD_CONSOLE_PRINTS_CV_CHECK:
+                expanded_ranges_items = list(expanded_ranges.items())
+                if len(expanded_ranges_items) > THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK:
+                    preview = expanded_ranges_items[:THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK]
+                    logging.warning(f"Turned into CC segments: {preview}, ...")
+                else:
+                    logging.warning(f"Turned into CC segments: {expanded_ranges_items}")
+
+    return df_primitives

pydpeet/process/sequence/utils/processing/check_power_zero_watt_segments.py

@@ -0,0 +1,85 @@
+import logging
+
+import numpy as np
+import pandas as pd
+
+from pydpeet.process.sequence.utils.console_prints.log_time import log_time
+from pydpeet.process.sequence.utils.postprocessing.df_primitives_correction import df_primitives_correction
+
+
+def _check_power_zero_watt_segments(
+    df_primitives: pd.DataFrame,
+    SHOW_RUNTIME: bool,
+    THRESHOLDS_PRIMITIVE_ANNOTATION: dict[str, float],
+    supress_IO_warnings: bool,
+    THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK: int,
+    DATA_COLUMNS: dict[str, str],
+) -> pd.DataFrame:
+    """
+    Check all segments in the dataframe for power segments with 0W and correct them by replacing them with a current or voltage segment.
+
+    Parameters:
+    df_primitives (pd.DataFrame): DataFrame containing the primitives
+    SHOW_RUNTIME (bool): whether to print runtime information
+    THRESHOLDS_PRIMITIVE_ANNOTATION (dict): dictionary of threshold values for primitive annotation
+        Example: {"I": 0.1, "P": 0.1, "V": 0.1}
+    supress_IO_warnings (bool): whether to suppress runtime warnings
+    THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK (int): threshold for the number of corrected segments to print
+    DATA_COLUMNS (dict): dictionary of column names to be kept in the DataFrame
+        Example: {"I": "Current[A]", "P": "Power[W]", "V": "Voltage[V]"}
+
+    Returns:
+    pd.DataFrame: Dataframe with added columns for annotated primitives
+    """
+    with log_time("checking Power segments with 0W", SHOW_RUNTIME=SHOW_RUNTIME):
+        tol_current = THRESHOLDS_PRIMITIVE_ANNOTATION["I"]
+        tol_voltage = THRESHOLDS_PRIMITIVE_ANNOTATION["V"]
+
+        mask_P_current_zero = (df_primitives["Variable"] == "P") & (np.abs(df_primitives["Current[A]"]) < tol_current)
+        mask_P_current_nonzero = (df_primitives["Variable"] == "P") & (
+            np.abs(df_primitives["Voltage[V]"]) < tol_voltage
+        )
+
+        zero_Watt_ids_current = df_primitives.loc[mask_P_current_zero, "ID"].unique().tolist()
+        zero_Watt_ids_voltage = df_primitives.loc[mask_P_current_nonzero, "ID"].unique().tolist()
+
+        if not supress_IO_warnings:
+            if zero_Watt_ids_current or zero_Watt_ids_voltage:
+                logging.warning("Power Segments with 0W found.")
+            if THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK:
+                if zero_Watt_ids_current:
+                    if len(zero_Watt_ids_current) > THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK:
+                        logging.warning(
+                            f"Replaced with current segment: {zero_Watt_ids_current[:THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK]}, ..."
+                        )
+                    else:
+                        logging.warning(
+                            f"Replaced with current segment: {zero_Watt_ids_current[:THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK]}"
+                        )
+                if zero_Watt_ids_voltage:
+                    if len(zero_Watt_ids_voltage) > THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK:
+                        logging.warning(
+                            f"Replaced with voltage segment: {zero_Watt_ids_voltage[:THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK]}, ..."
+                        )
+                    else:
+                        logging.warning(
+                            f"Replaced with voltage segment: {zero_Watt_ids_voltage[:THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK]}"
+                        )
+
+    with log_time("correcting Power segments with 0W", SHOW_RUNTIME=SHOW_RUNTIME):
+        correction_config = {
+            "replace_ID": {
+                **{id: "I" for id in zero_Watt_ids_current},
+                **{id: "V" for id in zero_Watt_ids_voltage},
+            }
+        }
+        df_primitives = df_primitives_correction(
+            df_primitives=df_primitives,
+            correction_config=correction_config,
+            data_columns=DATA_COLUMNS,
+            thresholds=THRESHOLDS_PRIMITIVE_ANNOTATION,
+            reindex=False,
+            reannotate=False,
+        )
+
+    return df_primitives

pydpeet/process/sequence/utils/processing/check_zero_length.py

@@ -0,0 +1,117 @@
+import logging
+
+import numpy as np
+import pandas as pd
+
+from pydpeet.process.sequence.utils.console_prints.log_time import log_time
+from pydpeet.process.sequence.utils.postprocessing.df_primitives_correction import df_primitives_correction
+
+
+def _check_zero_length_segments(
+    df_primitives: pd.DataFrame,
+    SHOW_RUNTIME: bool,
+    DATA_COLUMNS: dict[str, str],
+    THRESHOLDS_PRIMITIVE_ANNOTATION: dict[str, float],
+    supress_IO_warnings: bool,
+    THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK: int,
+) -> pd.DataFrame:
+    """
+    Checks all segments in the dataframe for zero length segments and correct them by merging with the closest neighbor segment.
+
+    Parameters:
+    df_primitives (pd.DataFrame): DataFrame containing the primitives
+    SHOW_RUNTIME (bool): whether to print runtime information
+    DATA_COLUMNS (dict): dictionary of column names to be kept in the DataFrame
+        Example: {"I": "Current[A]", "P": "Power[W]", "V": "Voltage[V]"}
+    THRESHOLDS_PRIMITIVE_ANNOTATION (dict): dictionary of threshold values for primitive annotation
+        Example: {"I": 0.1, "P": 0.1, "V": 0.1}
+    supress_IO_warnings (bool): whether to suppress runtime warnings
+    THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK (int): threshold for the number of corrected segments to print
+
+    Returns:
+    pd.DataFrame: Dataframe with added columns for annotated primitives
+    """
+    with log_time("checking zero length segments", SHOW_RUNTIME=SHOW_RUNTIME):
+        zero_length_ids = df_primitives[df_primitives["Length"] == 0]["ID"].unique().tolist()
+
+        zero_length_ids_left_merge = []
+        zero_length_ids_right_merge = []
+
+        for zero_id in zero_length_ids:
+            # Get the first row where this ID appears
+            zero_rows = df_primitives[df_primitives["ID"] == zero_id]
+            if zero_rows.empty:
+                continue
+
+            zero_idx = zero_rows.index[0]
+            try:
+                idx_pos = df_primitives.index.get_loc(zero_idx)
+            except KeyError:
+                continue
+
+            # Get the row's Voltage, Current, Power
+            zero_vals = df_primitives.iloc[idx_pos][["Voltage[V]", "Current[A]", "Power[W]"]].values
+
+            # Initialize distances
+            dist_left = np.inf
+            dist_right = np.inf
+
+            # Compare with left neighbor if available and different ID
+            if idx_pos > 0:
+                left_row = df_primitives.iloc[idx_pos - 1]
+                if left_row["ID"] != zero_id:
+                    left_vals = left_row[["Voltage[V]", "Current[A]", "Power[W]"]].values
+                    dist_left = np.linalg.norm(zero_vals - left_vals)
+
+            # Compare with right neighbor if available and different ID
+            if idx_pos < len(df_primitives) - 1:
+                right_row = df_primitives.iloc[idx_pos + 1]
+                if right_row["ID"] != zero_id:
+                    right_vals = right_row[["Voltage[V]", "Current[A]", "Power[W]"]].values
+                    dist_right = np.linalg.norm(zero_vals - right_vals)
+
+            # Pick closer neighbor
+            if dist_left < dist_right:
+                zero_length_ids_left_merge.append(zero_id)
+            else:
+                zero_length_ids_right_merge.append(zero_id)
+
+    with log_time("correcting zero length segments", SHOW_RUNTIME=SHOW_RUNTIME):
+        correction_config = {
+            "merge_left": [*zero_length_ids_left_merge],
+            "merge_right": [*zero_length_ids_right_merge],
+        }
+
+        df_primitives = df_primitives_correction(
+            df_primitives=df_primitives,
+            correction_config=correction_config,
+            data_columns=DATA_COLUMNS,
+            thresholds=THRESHOLDS_PRIMITIVE_ANNOTATION,
+            reindex=False,
+            reannotate=False,
+        )
+
+        if not supress_IO_warnings:
+            if zero_length_ids_left_merge or zero_length_ids_right_merge:
+                logging.warning("Segments with duration of 1 sample found.")
+            if THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK:
+                if zero_length_ids_left_merge:
+                    if len(zero_length_ids_left_merge) > THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK:
+                        logging.warning(
+                            f"Merged with left neighbor: {zero_length_ids_left_merge[:THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK]}, ..."
+                        )
+                    else:
+                        logging.warning(
+                            f"Merged with left neighbor: {zero_length_ids_left_merge[:THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK]}"
+                        )
+                if zero_length_ids_right_merge:
+                    if len(zero_length_ids_right_merge) > THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK:
+                        logging.warning(
+                            f"Merged with right neighbor: {zero_length_ids_right_merge[:THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK]}, ..."
+                        )
+                    else:
+                        logging.warning(
+                            f"Merged with right neighbor: {zero_length_ids_right_merge[:THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK]}"
+                        )
+
+    return df_primitives

pydpeet/process/sequence/utils/processing/split_in_segments.py

@@ -0,0 +1,97 @@
+import numpy as np
+import pandas as pd
+from numba import njit
+
+
+@njit(cache=True)
+def _assign_segments_with_fit(
+    times: np.ndarray,
+    values: np.ndarray,
+    threshold: float,
+) -> np.ndarray:
+    """
+    Assign segment IDs to each point in a time series by incrementally fitting linear
+    segments using least squares. A new segment is started when either the current
+    point OR the starting point of the segment deviates from the fitted line beyond
+    the threshold.
+
+    Parameters:
+    times (np.ndarray): Array of time values in seconds.
+    values (np.ndarray): Array of corresponding signal values.
+    threshold (float): Maximum allowed deviation from the fitted line to continue the segment.
+
+    Returns:
+    np.ndarray: Array of segment IDs assigned to each point.
+    """
+    n = times.shape[0]
+    seg_ids = np.empty(n, dtype=np.int32)
+    seg_ids[0] = 0
+
+    start = 0
+    sum_x = times[0]
+    sum_y = values[0]
+    sum_xx = times[0] ** 2
+    sum_xy = times[0] * values[0]
+    count = 1
+
+    for i in range(1, n):
+        sum_x += times[i]
+        sum_y += values[i]
+        sum_xx += times[i] ** 2
+        sum_xy += times[i] * values[i]
+        count += 1
+
+        denom = count * sum_xx - sum_x**2
+        if denom == 0:
+            slope = 0.0
+            intercept = values[start]
+        else:
+            slope = (count * sum_xy - sum_x * sum_y) / denom
+            intercept = (sum_y - slope * sum_x) / count
+
+        # Check deviation for current point and first point in segment
+        expected_current = slope * times[i] + intercept
+        deviation_current = abs(values[i] - expected_current)
+
+        expected_start = slope * times[start] + intercept
+        deviation_start = abs(values[start] - expected_start)
+
+        if deviation_current <= threshold and deviation_start <= threshold:
+            seg_ids[i] = seg_ids[i - 1]
+        else:
+            start = i
+            seg_ids[i] = seg_ids[i - 1] + 1
+            sum_x = times[i]
+            sum_y = values[i]
+            sum_xx = times[i] ** 2
+            sum_xy = times[i] * values[i]
+            count = 1
+
+    return seg_ids
+
+
+def _split_in_segments_using_incremental_linear_fit(
+    df: pd.DataFrame,
+    column_name: str,
+    threshold: float,
+) -> pd.DataFrame:
+    """
+    Detect near-linear segments in columns of a DataFrame using incremental least squares fitting.
+
+    Parameters:
+    df (pd.DataFrame): Input DataFrame with a datetime index and a numeric column.
+    column_name (str): Name of the column containing the signal values.
+    threshold (float): Maximum deviation allowed from the fitted line to consider a point as part of the current segment.
+
+    Returns:
+    pd.DataFrame: The original DataFrame with an added column 'Segment_<column_name>' indicating segment IDs.
+
+    Assumes:
+    Column "Test_Time[s]" exists and is in seconds and a float
+    """
+    times = df["Test_Time[s]"].to_numpy()
+    values = df[column_name].to_numpy()
+    seg_ids = _assign_segments_with_fit(times, values, threshold)
+    df[f"Segment_{column_name}"] = seg_ids
+
+    return df

pydpeet/process/sequence/utils/processing/supress_smaller_segments.py

@@ -0,0 +1,99 @@
+import numpy as np
+import pandas as pd
+from numba import njit
+
+
+@njit(cache=True)
+def _compute_segment_lengths_numba(
+    segment_ids: np.ndarray,
+    times: np.ndarray,
+    max_id: int,
+) -> np.ndarray:
+    """
+    Compute the length (time) of each segment in the given DataFrame.
+
+    Parameters:
+        segment_ids (np.ndarray): Array of segment IDs.
+        times (np.ndarray): Array of corresponding times.
+        max_id (int): Maximum segment ID.
+
+    Returns:
+        np.ndarray: Array of segment durations.
+
+    """
+    first_time = np.full(max_id + 1, -1.0)
+    last_time = np.full(max_id + 1, -1.0)
+
+    n = len(segment_ids)
+    for i in range(n):
+        seg_id = segment_ids[i]
+        t = times[i]
+        if seg_id == -1:
+            continue
+        if first_time[seg_id] == -1.0:
+            first_time[seg_id] = t
+        last_time[seg_id] = t
+
+    durations = last_time - first_time
+
+    result = np.full(n, 0.0)
+    valid = segment_ids != -1
+    result[valid] = durations[segment_ids[valid]]
+
+    return result
+
+
+def _add_segment_lengths(
+    df: pd.DataFrame,
+    column_name: str,
+) -> pd.DataFrame:
+    """
+    Compute the length (time) of each segment in the given DataFrame.
+
+    Parameters:
+        df (pd.DataFrame): Input DataFrame containing 'Test_Time[s]' and 'Segment_<column_name>' columns.
+        column_name (str): Name of the column containing the signal values.
+
+    Returns:
+        pd.DataFrame: Modified DataFrame with an added column 'Length_Segment_<column_name>' containing segment durations.
+    """
+    segment_name = f"Segment_{column_name}"
+    segment_ids = df[segment_name].to_numpy(dtype=np.int32)
+    times = df["Test_Time[s]"].to_numpy(dtype=np.float64)
+
+    max_id = segment_ids.max()
+    durations = _compute_segment_lengths_numba(segment_ids, times, max_id)
+
+    df[f"Length_{segment_name}"] = durations
+
+    return df
+
+
+def _keep_max_segment_id(
+    df: pd.DataFrame,
+    keep_max_segment_id_config: list[tuple[int, str]],
+) -> pd.DataFrame:
+    """
+    For each row in the DataFrame, retain the segment ID in the Segment column that has the
+    maximum associated length. Set all other segment IDs to -1.
+
+    Parameters:
+    df (pd.DataFrame): The input DataFrame.
+    keep_max_segment_id_config (list of tuples): List of (length_column, segment_column) pairs.
+
+    Returns:
+    pd.DataFrame: Modified DataFrame with updated Segment columns.
+    """
+    # Extract the length columns into a NumPy array for fast comparison
+    length_data = np.stack([df[length_col].values for length_col, _ in keep_max_segment_id_config], axis=1)
+
+    # Determine the index of the max length column per row
+    max_indices = np.argmax(length_data, axis=1)
+
+    # Set all segment columns to -1 where not the max, retain value otherwise
+    for i, (_, segment_col) in enumerate(keep_max_segment_id_config):
+        segment_data = df[segment_col].values.copy()
+        segment_data[max_indices != i] = -1
+        df[segment_col] = segment_data
+
+    return df