performant version

Author: jonathanfischer97

README.md

@@ -334,7 +334,7 @@ The codebase is organized into several modules, each handling different aspects
 
 4. **Analyze Results:**
 
-   - If instead you want to re-solve for an existing solution from a `DataFrame` dataset, you can use the `solve_row` function.
+   - If instead you want to re-solve for an existing solution from a `DataFrame` dataset, you can use the `solve_row` method.
 
    ```julia
    #- Activate the project
@@ -366,6 +366,35 @@ The codebase is organized into several modules, each handling different aspects
    LpA = sol[:LpA]
    ```
 
+   **For High-Throughput Analysis:** If you need to solve many rows from the same `DataFrame` efficiently, use the performant version that returns a solver function. This is useful for loops or parallel processing.
+
+   ```julia
+   # Create a performant solver function (one-time setup)
+   fast_solver = solve_row(results_df, fullrn)
+
+   # Now solve any row efficiently
+   sol1 = fast_solver(1)      # Solve first row
+   sol42 = fast_solver(42)    # Solve 42nd row
+   sol1000 = fast_solver(1000) # Solve 1000th row
+
+   # Perfect for loops or parallel processing
+   solutions = [fast_solver(i) for i in 1:100]  # Solve first 100 rows
+   
+   # Or for specific analysis
+   interesting_rows = [1, 42, 100, 500, 1000]
+   interesting_solutions = [fast_solver(i) for i in interesting_rows]
+   ```
+
+   **Performance Benefits:**
+   - **One-time setup cost**: Column extraction and setter creation happens once
+   - **Fast repeated solves**: Uses pre-extracted matrices and SymbolicIndexingInterface
+   - **Thread-safe**: Each call creates isolated problem copies
+   - **Memory efficient**: Uses `view()` for zero-copy matrix access
+
+   **When to Use Each Method:**
+   - **`solve_row(row, odeprob)`**: For interactive use, single solves, or when you have individual rows
+   - **`solve_row(df, odeprob)`**: For high-throughput workflows, loops, or when you need to solve many rows from the same DataFrame
+   ```
 
 
 

src/utils/datahandling.jl

@@ -79,21 +79,26 @@ function solve_row(data::AbstractDataFrame, odeprob::ODEProblem; tspan = (0.0, 2
     parameter_cols = r"k|DF"
     species_cols = r"^(L|K|P|A|B|C|D)$"
 
+    # Pre-extract data to matrices for fast indexing
+    param_matrix = Matrix(data[!, parameter_cols])
+    species_matrix = Matrix(data[!, species_cols])
+
     # Create fast setters
     set_params = setp(odeprob, parameter_cols)
     set_species = setu(odeprob, species_cols)
 
     # Return function that uses fast setters
     return function(row_index::Int; kwargs...)
-        # Get the row
-        row = data[row_index, :]
-
-        # Set the parameters and species
-        set_params(odeprob, row[parameter_cols])
-        set_species(odeprob, row[species_cols])
-
+        
+        # Create thread-safe problem copy
+        prob = remake(odeprob, p = copy(odeprob.p), u0 = copy(odeprob.u0))
+        
+        # Set the parameters and species using fast matrix indexing
+        set_params(prob, view(param_matrix, row_index, :))
+        set_species(prob, view(species_matrix, row_index, :))
+        
         # Solve and return
-        return solve(odeprob, Rodas5P(autodiff = AutoForwardDiff(chunksize = length(odeprob.u0))), abstol = abstol, reltol = reltol, tspan = tspan, kwargs...)
+        return solve(prob, Rodas5P(autodiff = AutoForwardDiff(chunksize = length(odeprob.u0))), abstol = abstol, reltol = reltol, tspan = tspan, kwargs...)
     end
 end