Optimization and dataframe api for iob and ice computation

Author: miriamkw

.gitignore

@@ -12,4 +12,4 @@ dist/
 loop_to_python_api.egg-info/
 loop_to_python_api/__pycache__/
 python_tests/__pycache__/
-
+venv/

README.md

@@ -153,6 +153,42 @@ Fetches the active insulin based on the provided JSON input.
 
 -------------------------
 
+
+### Add Insulin Counteraction Effect to DataFrame
+
+`add_insulin_counteraction_effect_to_df(df, basal, isf, cr, insulin_type='novolog')`
+
+Adds an insulin counteraction effect column to the DataFrame input.
+
+- **Parameters**: 
+  - `df`: The dataframe data input, with at least the columns basal, bolus and CGM, with datetime index.
+  - `basal`: Basal insulin rate (units/hour). 
+  - `isf`: Insulin sensitivity factor (mg/dL per unit). 
+  - `cr`: Carbohydrate ratio (grams per unit of insulin). 
+  - `insulin_type`: Type of insulin (default 'novolog').
+- **Returns**: The dataframe with an "ice" column.
+
+
+-------------------------
+
+### Add Insulin on Board to DataFrame
+
+`add_insulin_on_board_to_df(df, basal, isf, cr, insulin_type='novolog', lookback=72)`
+
+Adds an insulin counteraction effect column to the DataFrame input.
+
+- **Parameters**: 
+  - `df`: The dataframe data input, with at least the columns basal, bolus and CGM, with datetime index.
+  - `basal`: Basal insulin rate (units/hour). 
+  - `isf`: Insulin sensitivity factor (mg/dL per unit). 
+  - `cr`: Carbohydrate ratio (grams per unit of insulin). 
+  - `insulin_type`: Type of insulin (default 'novolog').
+  - `lookback`: Lookback to use for computing insulin on board (default 72).
+- **Returns**: The dataframe with an "ice" column.
+
+-------------------------
+
+
 ### Percent Absorption at Percent Time
 
 `percent_absorption_at_percent_time(percent_time)`
@@ -216,12 +252,14 @@ After making changes in the Swift code, rebuild the dynamic library by running `
 Run command `pytest`.
 
 
-## Debugging Advice
+## Debugging Advice and Disclaimers
+
+This library does currently only work on Mac, but work is in progress to support other operating systems. 
 
 Debugging with this pipeline can be a pain... Calling functions with python does not give informative error messages, even though the `initialize_exception_handlers()` helps a little bit.
 
 What I found the most useful is to go into LoopAlgorithm repository and run existing tests, but changing the input json files to the input json file that I am trying to use with this repository.
 
-
+Getting `zsh: killed` error in the terminal indicates that there are too many processes running, and you have to make sure to stop them - so be aware that this error does not necessarily mean that the dynamic library is corrupted. It is a to do to make the `api.py` a class that automatically makes sure that processes are properly closed after running. 
 
 

Sources/LoopAlgorithmToPython/LoopAlgorithmToPython.swift

@@ -169,7 +169,7 @@ public func getGlucoseEffectVelocity(jsonData: UnsafePointer<Int8>?) -> UnsafeMu
             useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
         )
         var glucoseEffectVelocities: [Double] = []
-                    
+                
         for val in prediction.effects.insulinCounteraction {
             glucoseEffectVelocities.append(val.quantity.doubleValue(for: HKUnit(from: "mg/dL·s")))
         }
@@ -188,7 +188,7 @@ public func getGlucoseEffectVelocityDates(jsonData: UnsafePointer<Int8>?) -> Uns
 
     do {
         let input = try getDecoder().decode(LoopPredictionInput.self, from: data)
-                        
+                            
         let prediction = LoopAlgorithm.generatePrediction(
             start: input.glucoseHistory.last?.startDate ?? Date(),
             glucoseHistory: input.glucoseHistory,
@@ -214,14 +214,36 @@ public func getGlucoseEffectVelocityDates(jsonData: UnsafePointer<Int8>?) -> Uns
     }
 }
 
+@_cdecl("getGlucoseEffectVelocityAndDates")
+public func getGlucoseEffectVelocityAndDates(jsonData: UnsafePointer<Int8>?) -> UnsafePointer<CChar> {
+    let data = getDataFromJson(jsonData: jsonData)
+
+    do {
+        let input = try getDecoder().decode(AlgorithmInputFixture.self, from: data)
+        let output = LoopAlgorithm.run(input: input)
+
+        // Prepare prediction dates as a comma-separated string
+        var predictionsAndDates: String = ""
+        for val in output.effects.insulinCounteraction {
+            predictionsAndDates += val.startDate.ISO8601Format() + ","
+            predictionsAndDates += val.quantity.doubleValue(for: HKUnit(from: "mg/dL·s")).description + " "
+        }
+        let cString = strdup(predictionsAndDates)!
+        
+        return UnsafePointer<CChar>(cString)
+
+    } catch {
+        fatalError("Error reading or decoding JSON file: \(error)")
+    }
+}
+
 @_cdecl("getActiveCarbs")
 public func getActiveCarbs(jsonData: UnsafePointer<Int8>?) -> Double {
     let data = getDataFromJson(jsonData: jsonData)
 
     do {
         let input = try getDecoder().decode(AlgorithmInputFixture.self, from: data)
         let output = LoopAlgorithm.run(input: input)
-                        
         return output.activeCarbs!
     } catch {
         fatalError("Error reading or decoding JSON file: \(error)")
@@ -235,9 +257,9 @@ public func getActiveInsulin(jsonData: UnsafePointer<Int8>?) -> Double {
 
     do {
         let input = try getDecoder().decode(AlgorithmInputFixture.self, from: data)
-        let output = LoopAlgorithm.run(input: input)
-                        
-        return output.activeInsulin!
+        let dosesRelativeToBasal = input.doses.annotated(with: input.basal)
+        let activeInsulin = dosesRelativeToBasal.insulinOnBoard(at: input.predictionStart)
+        return activeInsulin
     } catch {
         fatalError("Error reading or decoding JSON file: \(error)")
     }

examples/main.py

@@ -0,0 +1,22 @@
+import pandas as pd
+import loop_to_python_api.api as api
+
+# Read from csv file
+# file_path = 'examples/EXAMPLE.csv'
+# data = pd.read_csv(file_path, parse_dates=['date'], index_col='date', low_memory=False)
+
+# Generate datetime index with 5-minute intervals
+index = pd.date_range(start="2024-02-28 00:00", periods=60, freq="5T")
+
+# Create DataFrame
+df = pd.DataFrame({
+    "bolus": [10] + [0] * 59,  # First row is 10, rest are 0
+    "basal": [1] * 60,           # Always 1
+    "CGM": 100 * 60
+}, index=index)
+
+insulin_type = "afrezza"
+df = api.add_insulin_on_board_to_df(df, 1, 45, 12, insulin_type=insulin_type)
+df = api.add_insulin_counteraction_effect_to_df(df, 1, 45, 12, insulin_type=insulin_type)
+
+print("Dataframe with iob and ice:", df)

loop_to_python_api/api.py

@@ -2,12 +2,14 @@
 This file provides an API for calling the functions in the dynamic library. These functions are c-embeddings
 for swift functions, found in Sources/LoopAlgorithmToPython/LoopAlgorithmToPython.swift.
 """
-from loop_to_python_api.helpers import get_bytes_from_json
+import numpy as np
+import pandas as pd
 
+import loop_to_python_api.helpers as helpers
 import ctypes
 import os
 import ast
-
+import time
 
 # swift_lib = ctypes.CDLL('python_api/libLoopAlgorithmToPython.dylib')
 
@@ -31,7 +33,7 @@ def initialize_exception_handlers():
 
 
 def generate_prediction(json_file, len=72):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.generatePrediction.argtypes = [ctypes.c_char_p]
     swift_lib.generatePrediction.restype = ctypes.POINTER(ctypes.c_double)
@@ -41,7 +43,7 @@ def generate_prediction(json_file, len=72):
 
 
 def get_prediction_dates(json_file):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getPredictionDates.argtypes = [ctypes.c_char_p]
     swift_lib.getPredictionDates.restype = ctypes.c_char_p
@@ -60,7 +62,7 @@ def get_prediction_values_and_dates(json_file):
 
 
 def get_dose_recommendations(json_file):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getDoseRecommendations.argtypes = [ctypes.c_char_p]
     swift_lib.getDoseRecommendations.restype = ctypes.c_char_p
@@ -72,7 +74,7 @@ def get_dose_recommendations(json_file):
 
 # "Glucose effect velocity" is equivalent to insulin counteraction effect (ICE)
 def get_glucose_effect_velocity(json_file, len=72):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getGlucoseEffectVelocity.argtypes = [ctypes.c_char_p]
     swift_lib.getGlucoseEffectVelocity.restype = ctypes.POINTER(ctypes.c_double)
@@ -82,7 +84,7 @@ def get_glucose_effect_velocity(json_file, len=72):
 
 
 def get_glucose_effect_velocity_dates(json_file):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getGlucoseEffectVelocityDates.argtypes = [ctypes.c_char_p]
     swift_lib.getGlucoseEffectVelocityDates.restype = ctypes.c_char_p
@@ -94,16 +96,27 @@ def get_glucose_effect_velocity_dates(json_file):
     return date_list
 
 
-def get_glucose_velocity_values_and_dates(json_file):
-    # TODO: Add validation of json dates here to be more flexible?
+def get_glucose_effect_velocity_and_dates(json_file):
+    json_bytes = helpers.get_bytes_from_json(json_file)
+
+    swift_lib.getGlucoseEffectVelocityAndDates.argtypes = [ctypes.c_char_p]
+    swift_lib.getGlucoseEffectVelocityAndDates.restype = ctypes.c_char_p
+
+    result = swift_lib.getGlucoseEffectVelocityAndDates(json_bytes).decode('utf-8')
+
+    values = []
+    dates = []
+    # Parse the string that contains both dates and values
+    for item in result.split():
+        date_str, float_str = item.split(',')
+        dates.append(pd.to_datetime(date_str))
+        values.append(float(float_str))
 
-    dates = get_glucose_effect_velocity_dates(json_file)
-    values = get_glucose_effect_velocity(json_file, len(dates))
     return values, dates
 
 
 def get_active_carbs(json_file):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getActiveCarbs.argtypes = [ctypes.c_char_p]
     swift_lib.getActiveCarbs.restype = ctypes.c_double
@@ -112,14 +125,71 @@ def get_active_carbs(json_file):
 
 
 def get_active_insulin(json_file):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getActiveInsulin.argtypes = [ctypes.c_char_p]
     swift_lib.getActiveInsulin.restype = ctypes.c_double
 
     return swift_lib.getActiveInsulin(json_bytes)
 
 
+def add_insulin_counteraction_effect_to_df(df, basal, isf, cr, insulin_type='novolog'):
+    """
+    Takes a dataframe with at least the columns CGM, bolus, and basal.
+    Important note: this function assumes you only give data for a single subject at a time.
+    # TODO: The therapy settings should be columns in the dataframe so we can support schedules.
+
+    :param df: Dataframe with at least a "basal" and a "bolus" column, and a datetime index.
+    :param basal: Basal rate
+    :param isf: Insulin sensitivity factor
+    :param cr: Carbohydrate ratio (will not impact the results)
+    :param insulin_type: Which insulin profile to use to compute the insulin on board
+    :return: The input df with columns for insulin on board and insulin counteraction effects.
+    """
+    data = df[['basal', 'bolus', 'CGM']].copy()  # Extract only necessary data to improve performance
+    data.loc[:, 'bolus'] = data['bolus'].replace(0.0, np.nan)
+    json_data = helpers.get_json_loop_prediction_input_from_df(data, basal, isf, cr, data.index[-1], insulin_type)
+
+    ice_values, dates = get_glucose_effect_velocity_and_dates(json_file=json_data)
+    dates = [date.tz_localize(None) for date in dates]  # If you want to align to UTC
+
+    df.loc[:, "ice"] = np.nan
+    df.loc[dates, "ice"] = ice_values
+    return df
+
+
+def add_insulin_on_board_to_df(df, basal, isf, cr, insulin_type='novolog', lookback=72):
+    """
+    Adding insulin on board to a dataframe to each row, by using data from the previous rows given by lookback.
+    IMPORTANT NOTE: This function does not handle separate subjects within a single dataframe. A subject's data should
+    be passed individually.
+
+    :param df: Dataframe with at least a "basal" and a "bolus" column, and a datetime index.
+    :param basal: Basal rate
+    :param isf: Insulin sensitivity factor
+    :param cr: Carbohydrate ratio (will not impact the results)
+    :param insulin_type: Which insulin profile to use to compute the insulin on board
+    :param lookback: Lookback used to compute each iob value. Increasing lookback will lower performance, but will be
+    necessary for insulin types that are long-lasting, or for high datetime frequencies. The default of 72 is based on
+    6 hours duration of 5-minute intervals.
+    :return: The original dataframe with a new column "iob"
+    """
+    data = df[['basal', 'bolus']].copy()  # Extract only necessary data to improve performance
+    data.loc[:, 'bolus'] = data['bolus'].replace(0.0, np.nan)
+
+    iobs = []
+    for i, date in enumerate(data.index[1:]):
+        start_index = max(0, i - lookback + 1)
+        json_data = helpers.get_json_loop_prediction_input_from_df(data.iloc[start_index:i+1], basal, isf, cr,
+                                                                   data.index[i+1], insulin_type=insulin_type)
+        iob = get_active_insulin(json_data)
+        iobs += [iob]
+
+    df.loc[:, "iob"] = np.nan
+    df.loc[df.index[1:], "iob"] = iobs
+    return df
+
+
 # Calculating the percentage of carbohydrate absorption at the percent time, with piecewise linear model
 # Input is percent as fraction
 def percent_absorption_at_percent_time(percent_time):
@@ -147,7 +217,7 @@ def linear_percent_rate_at_percent_time(percent_time):
 
 
 def get_dynamic_carbs_on_board(json_file):
-    json_bytes = get_bytes_from_json(json_file)
+    json_bytes = helpers.get_bytes_from_json(json_file)
 
     swift_lib.getDynamicCarbsOnBoard.argtypes = [ctypes.c_char_p]
     swift_lib.getDynamicCarbsOnBoard.restype = ctypes.c_double