PyDPEET 0.2.0__py3-none-any.whl

pydpeet/process/analyze/extract/dva_ica.py

@@ -0,0 +1,224 @@
+import logging
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from scipy import integrate
+from scipy.signal import savgol_filter
+
+from pydpeet.process.analyze.configs.ocv_config import (
+    SEGMENT_SEQUENCE_CONFIG,
+    STEP_ANALYZER_PRIMITIVES_CONFIG,
+)
+from pydpeet.process.analyze.extract.ocv import extract_ocv_iocv
+from pydpeet.process.analyze.soc import add_soc
+from pydpeet.process.sequence.step_analyzer import (
+    add_primitive_segments,
+    extract_sequence_overview,
+)
+
+
+def compute_ocv_dva_ica(
+    df_primitives: pd.DataFrame = None,
+    df: pd.DataFrame = None,
+    min_pause_lenght: float = 120.0,
+    min_loops: float = 70,
+    soc_max_voltage: float = 4.21,
+    soc_min_voltage: float = 2.49,
+    soc_c_ref: float = 4.8,
+    savgol: bool = False,
+    savgol_window_lenght_percentage: float = 0.07,
+    visualize: bool = False,
+) -> pd.DataFrame:
+    """
+    Compute DVA and ICA curves from given data.
+
+    Parameters
+    ----------
+    df_primitives : pandas.DataFrame or None
+        DataFrame containing the primitives of the data.
+    df : pandas.DataFrame or None
+        DataFrame containing the original data.
+    min_pause_lenght : float
+        Minimum length of a pause in seconds.
+    min_loops : float
+        Minimum number of unique IDs.
+    soc_max_voltage : float
+        Maximum voltage of the battery.
+    soc_min_voltage : float
+        Minimum voltage of the battery.
+    soc_c_ref : float
+        Reference capacity of the battery.
+    savgol : bool
+        Whether to apply Savitzky-Golay filter to smooth the data.
+    savgol_window_lenght_percentage : float
+        Percentage of the window length for the Savitzky-Golay filter.
+    visualize : bool
+        Whether to visualize the DVA and ICA curves over SOC.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing all DVA and ICA curves.
+    """
+    logging.info("Executing DVA and ICA computation...")
+    # falls nur ein df übergeben wird:
+    if df is not None and df_primitives is not None:
+        raise ValueError("Please provide either df or df_primitives, not both!")
+
+    if df is not None:
+        df.drop_duplicates(subset=["Test_Time[s]"], inplace=True)
+        df.dropna(subset=["Test_Time[s]"], inplace=True)
+        df = df.sort_values("Test_Time[s]")
+
+        df_primitives = add_primitive_segments(
+            df=df,
+            STEP_ANALYZER_PRIMITIVES_CONFIG=STEP_ANALYZER_PRIMITIVES_CONFIG,
+            SHOW_RUNTIME=False,
+            check_CV_0Aend_segments_bool=False,
+            check_zero_length_segments_bool=False,
+            supress_IO_warnings=True,
+        )
+
+    if df_primitives is not None:
+        if df_primitives["Test_Time[s]"].duplicated().any():
+            raise ValueError("Duplicated 'Test_Time[s]' values found!")
+
+        if df_primitives["Test_Time[s]"].isna().any():
+            raise ValueError("NaN values found in 'Test_Time[s]'")
+
+        if not np.all(np.diff(df_primitives["Test_Time[s]"]) > 0):
+            raise ValueError("'Test_Time[s]' is not monotonically increasing!")
+
+        logging.info("Checking if SOC exists in dataframe...")
+        if "SOC" in df_primitives.columns:
+            logging.info("SOC already exists in df_primitives, skipping SOC calculation...")
+        else:
+            logging.info("SOC column does not exist in df_primitives, adding it...")
+            df_primitives = add_soc(
+                df_primitives,
+                method="withResetWhenFullAndEmpty",
+                max_Voltage=soc_max_voltage,
+                min_Voltage=soc_min_voltage,
+                C_ref=soc_c_ref,
+            )
+
+        df_segments_and_sequences = extract_sequence_overview(df_primitives, SEGMENT_SEQUENCE_CONFIG)
+
+    else:
+        raise ValueError("No df_primitives found!")
+
+    logging.info("Calling iOCV detection...")
+    # Get every iocv as df
+    dfs_per_block = extract_ocv_iocv(
+        min_pause_lenght=min_pause_lenght, min_loops=min_loops, visualize=False, df_primitives=df_primitives
+    )
+
+    # Compute SOC
+    logging.info("Checking if SOC exists in dataframe...")
+    if "SOC" in df_primitives.columns:
+        logging.info("SOC already exists in df_primitives, skipping SOC calculation...")
+    else:
+        logging.info("SOC column does not exist in df_primitives, adding it...")
+        df_primitives = add_soc(
+            df_primitives.copy(),
+            method="withResetWhenFullAndEmpty",
+            max_Voltage=soc_max_voltage,
+            min_Voltage=soc_min_voltage,
+            C_ref=soc_c_ref,
+        )
+
+    logging.info("Computing Capacity in Ah...")
+    capacity_Ah_points = (
+        integrate.cumulative_trapezoid((df_primitives["Current[A]"]), x=df_primitives["Test_Time[s]"], initial=0) / 3600
+    )
+    df_primitives["Capacity_Ah"] = capacity_Ah_points
+
+    logging.info("Labeling DVA/ICA blocks (Charge/Discharge)...")
+    dfs_with_type = []
+    for df_block in dfs_per_block:
+        if df_block.empty:
+            continue
+
+        first_id = df_block["ID"].iloc[0]
+        matching_row = df_segments_and_sequences[df_segments_and_sequences["ID"] == first_id]
+
+        if matching_row.empty:
+            block_type = "Unknown"
+        elif matching_row["Charge_iOCV"].iloc[0] != 0:
+            block_type = "Charge"
+        elif matching_row["Discharge_iOCV"].iloc[0] != 0:
+            block_type = "Discharge"
+
+        df_block["DVA_ICA_type"] = block_type
+        dfs_with_type.append(df_block)
+
+    dfs_per_block = dfs_with_type
+
+    logging.info("Computing DVA and ICA for every block...")
+    all_dva_ica_curves = []
+    for _, block in enumerate(dfs_per_block):
+        df_dva_ica = df_primitives.loc[df_primitives["Test_Time[s]"].isin(block["Test_Time[s]"])]
+
+        voltage = df_dva_ica["Voltage[V]"].to_numpy()
+        capacity = df_dva_ica["Capacity_Ah"].to_numpy()
+
+        dV = np.diff(voltage, prepend=np.nan)
+        dQ = np.diff(capacity, prepend=np.nan)
+
+        dv_dq = np.divide(dV, dQ)
+        df_dva_ica["dV_dQ"] = dv_dq
+        df_dva_ica["dQ_dV"] = 1 / df_dva_ica["dV_dQ"]
+
+        if savgol:
+            logging.info("Applying Savitzky-Golay filter...")
+            window_length = int(len(df_dva_ica["dQ_dV"]) * savgol_window_lenght_percentage)
+            if window_length % 2 == 0:
+                window_length += 1
+            window_length = max(window_length, 5)
+            df_dva_ica["dQ_dV"] = savgol_filter(df_dva_ica["dQ_dV"], window_length, 2)
+
+        df_dva_ica["DVA_ICA_type"] = block["DVA_ICA_type"].iloc[0]
+        all_dva_ica_curves.append(df_dva_ica)
+
+    if visualize:
+        logging.info("Plotting DVA and ICA curves...")
+        fig, (ax_dva, ax_ica) = plt.subplots(1, 2, figsize=(14, 6))
+
+        charge_blocks = [df for df in all_dva_ica_curves if df["DVA_ICA_type"].iloc[0] == "Charge"]
+        discharge_blocks = [df for df in all_dva_ica_curves if df["DVA_ICA_type"].iloc[0] == "Discharge"]
+
+        # Plot charge
+        for i, df_c in enumerate(charge_blocks):
+            ax_dva.plot(df_c["SOC"], df_c["dV_dQ"], color="blue", label=f"Charge DVA {i + 1}")
+            ax_ica.plot(df_c["SOC"], df_c["dQ_dV"], color="blue", label=f"Charge ICA {i + 1}")
+
+        # Plot discharge
+        for i, df_d in enumerate(discharge_blocks):
+            ax_dva.plot(df_d["SOC"], df_d["dV_dQ"], color="red", label=f"Discharge DVA {i + 1}")
+            ax_ica.plot(df_d["SOC"], df_d["dQ_dV"], color="red", label=f"Discharge ICA {i + 1}")
+
+        # Set DVA plot properties
+        ax_dva.set_xlabel("SOC", fontsize=15)
+        ax_dva.set_ylabel("dV/dQ", fontsize=15, color="blue")
+        ax_dva.set_title("Differential Voltage Analysis (DVA)", fontsize=15)
+        ax_dva.set_ylim(0, 4.00)
+        ax_dva.legend(fontsize=12, loc="upper left")
+        ax_dva.grid(True, linestyle="--", alpha=0.7)
+        ax_dva.tick_params(axis="both", which="major", labelsize=15)
+        ax_dva.tick_params(axis="y", labelcolor="b")
+
+        # Set ICA plot properties
+        ax_ica.set_xlabel("SOC", fontsize=15)
+        ax_ica.set_ylabel("dQ/dV", fontsize=15, color="blue")
+        ax_ica.set_title("Incremental Capacity Analysis (ICA)", fontsize=15)
+        ax_ica.legend(fontsize=12, loc="upper left")
+        ax_ica.grid(True, linestyle="--", alpha=0.7)
+        ax_ica.tick_params(axis="both", which="major", labelsize=15)
+        ax_ica.tick_params(axis="y", labelcolor="b")
+
+        plt.tight_layout()
+        plt.show()
+    logging.info("Returning DataFrame with all DVA and ICA Curves...")
+
+    return pd.concat(all_dva_ica_curves, ignore_index=True)

pydpeet/process/analyze/extract/ocv.py

@@ -0,0 +1,196 @@
+import logging
+
+# plot import
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.colors import LinearSegmentedColormap
+
+from pydpeet.process.analyze.configs.battery_config import BatteryConfig
+from pydpeet.process.analyze.configs.ocv_config import (
+    SEGMENT_SEQUENCE_CONFIG,
+    STEP_ANALYZER_PRIMITIVES_CONFIG,
+)
+from pydpeet.process.analyze.soc import (
+    SocMethod,
+    add_soc,
+)
+from pydpeet.process.sequence.step_analyzer import (
+    add_primitive_segments,
+    extract_sequence_overview,
+)
+from pydpeet.process.sequence.utils.postprocessing.filter_df import filter_and_split_df_by_blocks
+
+
+def extract_ocv_iocv(
+    min_pause_lenght: float = 120,
+    min_loops: float = 70,
+    visualize: bool = True,
+    df_primitives: pd.DataFrame = None,
+    df: pd.DataFrame = None,
+    config: BatteryConfig = None,
+) -> pd.DataFrame:
+    """
+    Compute iOCV blocks from given DataFrames.
+
+    Parameters
+    ----------
+    min_pause_lenght : float
+        The minimum length of a pause in seconds.
+    min_loops : float
+        The minimum number of unique IDs.
+    visualize : bool
+        Whether to visualize the iOCV curves.
+    df_primitives : pandas.DataFrame
+        The DataFrame containing the primitives.
+    df : pandas.DataFrame
+        The original DataFrame.
+    soc_max_voltage : float
+        The maximum voltage of the battery.
+    soc_min_voltage : float
+        The minimum voltage of the battery.
+    soc_c_ref : float
+        The reference capacity of the battery.
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame containing all iOCV blocks.
+
+    """
+
+    # Sanity Checks for Input
+    if df is not None and df_primitives is not None:
+        raise ValueError("Please provide either df or df_primitives, not both!")
+        raise ValueError("Please provide either df or df_primitives, not both!")
+
+    if df is not None:
+        df.drop_duplicates(subset=["Test_Time[s]"], inplace=True)
+        df.dropna(subset=["Test_Time[s]"], inplace=True)
+        df = df.sort_values("Test_Time[s]")
+
+        df_primitives = add_primitive_segments(
+            df=df,
+            STEP_ANALYZER_PRIMITIVES_CONFIG=STEP_ANALYZER_PRIMITIVES_CONFIG,
+            # SHOW_RUNTIME=False,
+            # check_CV_0Aend_segments_bool=False,
+            # check_zero_length_segments_bool=False,
+            # supress_IO_warnings=True
+        )
+
+    if df_primitives is not None:
+        if df_primitives["Test_Time[s]"].duplicated().any():
+            raise ValueError("Duplicated 'Test_Time[s]' values found!")
+
+        if df_primitives["Test_Time[s]"].isna().any():
+            raise ValueError("NaN values found in 'Test_Time[s]'")
+
+        if not np.all(np.diff(df_primitives["Test_Time[s]"]) > 0):
+            raise ValueError("'Test_Time[s]' is not monotonically increasing!")
+
+        logging.info("Checking if SOC exists in dataframe...")
+
+        if "SOC" in df_primitives.columns:
+            logging.info("SOC already exists in df_primitives, skipping SOC calculation...")
+        else:
+            logging.info("SOC column does not exist in df_primitives, adding it...")
+            df_primitives = add_soc(
+                df=df_primitives,
+                df_primitives=df_primitives,
+                standard_method=SocMethod.WITH_RESET_WHEN_FULL,
+                config=config,
+            )
+
+        df_segments_and_sequences = extract_sequence_overview(df_primitives, SEGMENT_SEQUENCE_CONFIG)
+
+    else:
+        raise ValueError("No df_primitives found!")
+
+    # Applying Rules for iOCV Sequences
+    _rules = ["Discharge_iOCV", "Charge_iOCV"]
+    _STANDARD_COLUMNS = [
+        "Test_Time[s]",
+        "Voltage[V]",
+        "Current[A]",
+        "Power[W]",
+    ]
+    logging.info("Applying rules and standard columns to compute iOCV blocks...")
+    dfs_per_block = filter_and_split_df_by_blocks(
+        df_segments_and_sequences=df_segments_and_sequences,
+        df_primitives=df_primitives,
+        rules=_rules,
+        # standard_columns=_STANDARD_COLUMNS,
+        combine_op="or",
+        print_blocks=True,
+    )
+
+    logging.info("Filtering iOCV Points...")
+
+    # Filtering iOCV Points
+    dfs_per_block = [df[df["Type"] == "Rest"] for df in dfs_per_block[0]]
+    dfs_per_block = [df.loc[df.groupby("ID")["Test_Time[s]"].idxmax()] for df in dfs_per_block]
+    dfs_per_block = [df for df in dfs_per_block if df["ID"].nunique() >= min_loops]
+    dfs_per_block = [df for df in dfs_per_block if df["Duration"].min() >= min_pause_lenght]
+
+    logging.info("Filtering iOCV Charge and Discharge blocks...")
+
+    dfs_with_type = []
+    for df_block in dfs_per_block:
+        if df_block.empty:
+            continue
+
+        first_id = df_block["ID"].iloc[0]
+        matching_row = df_segments_and_sequences[df_segments_and_sequences["ID"] == first_id]
+
+        if matching_row.empty:
+            iocv_type = "Unknown"
+        elif matching_row["Charge_iOCV"].iloc[0] != 0:
+            iocv_type = "Charge"
+        elif matching_row["Discharge_iOCV"].iloc[0] != 0:
+            iocv_type = "Discharge"
+        else:
+            iocv_type = "Unknown"
+
+        df_block["iOCV_type"] = iocv_type
+        dfs_with_type.append(df_block)
+
+    dfs_per_block = dfs_with_type
+
+    if visualize:
+        logging.info("Plotting iOCV curves...")
+
+        fig, ax1 = plt.subplots(figsize=(12, 8))
+        ax1.set_xlabel("SOC", fontsize=15)
+        ax1.set_ylabel("Voltage[V]", fontsize=15, color="blue")
+        ax1.tick_params(axis="y", labelcolor="b", labelsize=15)
+        ax1.tick_params(axis="x", labelsize=15)
+
+        # Separate Charge and Discharge blocks
+        charge_blocks = [df for df in dfs_per_block if df["iOCV_type"].iloc[0] == "Charge"]
+        discharge_blocks = [df for df in dfs_per_block if df["iOCV_type"].iloc[0] == "Discharge"]
+
+        # Custom colormaps
+        charge_cmap = LinearSegmentedColormap.from_list("charge_cmap", ["green", "blue"])
+        discharge_cmap = LinearSegmentedColormap.from_list("discharge_cmap", ["red", "yellow"])
+
+        for i, df in enumerate(charge_blocks):
+            color = charge_cmap(i / max(len(charge_blocks) - 1, 1))
+            label = f"Charge iOCV {i + 1}"
+            ax1.plot(df["SOC"], df["Voltage[V]"], color=color, label=label, linewidth=2, linestyle="-", markersize=1)
+
+        for i, df in enumerate(discharge_blocks):
+            color = discharge_cmap(i / max(len(discharge_blocks) - 1, 1))
+            label = f"Discharge iOCV {i + 1}"
+            ax1.plot(df["SOC"], df["Voltage[V]"], color=color, label=label, linewidth=2, linestyle="-", markersize=1)
+
+        # Combine legends
+        handles1, labels1 = ax1.get_legend_handles_labels()
+        ax1.legend(handles1, labels1, loc="lower right", fontsize=15)
+        ax1.set_title("iOCV over SOC", fontsize=15)
+        ax1.grid(True, linestyle="--", alpha=0.7)
+
+        plt.tight_layout()
+        plt.show()
+
+    logging.info("Returning Dataframe with iOCV blocks...")
+
+    return dfs_per_block

pydpeet/process/analyze/power.py

@@ -0,0 +1,32 @@
+import logging
+
+import pandas as pd
+
+from pydpeet.process.analyze.utils import (
+    StepTimer,
+    _check_columns,
+)
+
+
+def add_power(
+    df: pd.DataFrame,
+    verbose: bool = True,
+) -> pd.DataFrame:
+    """
+    Calculates power [W] from 'Current[A]' and 'Voltage[V]' columns and adds it as a new column.
+
+    Parameters:
+    - df (pandas.DataFrame): DataFrame containing 'Current[A]' and 'Voltage[V]' columns
+
+    Returns:
+    - pandas.DataFrame: DataFrame with added 'Power[W]' column
+    """
+    logging.info("Calculating Power[W]...")
+
+    df_mod = df.copy()
+    with StepTimer(verbose) as st:
+        _check_columns(df_mod, ["Current[A]", "Voltage[V]"])
+        df_mod["Power[W]"] = df_mod["Current[A]"] * df_mod["Voltage[V]"]
+        st.log("calculated Power[W]")
+
+    return df_mod

pydpeet/process/analyze/resistance.py

@@ -0,0 +1,87 @@
+import inspect
+import logging
+
+import numpy as np
+import pandas as pd
+
+from pydpeet.process.analyze.configs.battery_config import BatteryConfig
+from pydpeet.process.analyze.utils import (
+    StepTimer,
+    _check_columns,
+)
+
+
+def add_resistance_internal(
+    df: pd.DataFrame,
+    config: BatteryConfig = None,
+    verbose: bool = True,
+) -> pd.DataFrame:
+    """
+    Calculate the internal resistance of a battery from given test data.
+
+    The internal resistance is calculated from the voltage and current differences
+    between consecutive points. The calculation is only performed when the following
+    conditions are met:
+
+    1. The time difference is positive (i.e. time is increasing)
+    2. The absolute time difference is less than or equal to `max_time_diff`
+    3. The absolute current difference is greater than or equal to `min_current_diff`
+    4. The absolute voltage difference is greater than or equal to `min_voltage_diff`
+
+    If `ignore_negative_resistance_values` is True, any calculated internal resistances
+    with a value less than or equal to zero are set to NaN. (mainly for a bug in Neware)
+
+    Parameters:
+    df (pandas.DataFrame): Input DataFrame containing battery test data
+    config (BatteryConfig): Configuration object containing parameters for internal resistance calculation
+    ignore_negative_resistance_values (bool, optional): Whether to set calculated internal resistances with a value less than or equal to zero to NaN (should only appear for Neware cells)
+
+    Returns:
+    pandas.DataFrame: DataFrame with added 'internal_resistance[ohm]', 'delta_t', 'delta_current', and 'delta_voltage' columns
+    """
+    required_cols = ["Test_Time[s]", "Current[A]", "Voltage[V]"]
+    _check_columns(df, required_cols)
+
+    if config is None:
+        func_name = inspect.currentframe().f_code.co_name
+        raise ValueError(f"config is None, please provide a valid config for {func_name}")
+
+    min_current_diff = config.min_current_diff
+    max_time_diff = config.max_time_diff
+    min_voltage_diff = config.min_voltage_diff
+    ignore_negative_resistance_values = config.ignore_negative_resistance_values
+
+    df_mod = df.copy()
+    logging.info(f"Starting internal resistance computation on dataframe of size {len(df_mod)}...")
+
+    # Calculate differences
+    with StepTimer(verbose) as st:
+        delta_t = df_mod["Test_Time[s]"].diff()
+        delta_current = df_mod["Current[A]"].diff()
+        delta_voltage = df_mod["Voltage[V]"].diff()
+        st.log("calculated delta_t, delta_I, delta_V")
+
+    # Only calculate resistance when:
+    mask = (
+        (delta_t > 0)  # Time is increasing
+        & ((delta_t <= max_time_diff) | (delta_t == 0))  # Within max time window
+        & (abs(delta_current) >= min_current_diff)  # Significant current change
+        & (abs(delta_voltage) >= min_voltage_diff)  # Significant voltage change
+    )
+
+    # Calculate resistance only for valid points
+    with StepTimer(verbose) as st:
+        with np.errstate(divide="ignore", invalid="ignore"):
+            resistance = delta_voltage / delta_current
+            resistance[~((delta_current != 0) & mask)] = np.nan  # Set invalid calculations to NaN
+        st.log("computed internal resistance for valid points")
+
+    # Assign the calculated resistances
+    df_mod["InternalResistance[ohm]"] = resistance
+
+    if ignore_negative_resistance_values:
+        df_mod["InternalResistance[ohm]"] = df_mod["InternalResistance[ohm]"].mask(
+            df_mod["InternalResistance[ohm]"] <= 0
+        )
+
+    return df_mod