initial commit

app.py

@@ -0,0 +1,165 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.integrate import odeint
+from scipy.optimize import fsolve
+import gradio as gr
+
+# Population and time settings
+population_size = 100
+time_points = np.linspace(0, 24, 100)
+
+# PK parameters for Enrofloxacin and Ciprofloxacin
+pk_parameters = {
+    'Enrofloxacin': {
+        'Cmax_mean': 1.35, 'Cmax_std': 0.15,
+        'Tmax_mean': 4.00, 'Tmax_std': 1,
+        'Ke_mean': 0.03, 'Ke_std': 0.003,
+        'F_mean': 0.7, 'F_std': 0.1,
+        'Vd_mean': 24.76, 'Vd_std': 3.67,
+        'pKa': 6.0,
+        'type': 'acidic'
+    },
+    'Ciprofloxacin': {
+        'Cmax_mean': 0.08, 'Cmax_std': 0.01,
+        'Tmax_mean': 3.44, 'Tmax_std': 1.01,
+        'Ke_mean': 0.04, 'Ke_std': 0.01,
+        'F_mean': 0.6, 'F_std': 0.1,
+        'Vd_mean': 17.46, 'Vd_std': 6.40,
+        'pKa': 7.7,
+        'type': 'acidic'
+    }
+}
+
+# MIC values for pathogens
+MIC_values = {
+    'E.coli': 0.06,
+    'S.Enteritidis': 0.1,
+    'M.gallisepticum': 0.1,
+    'C.perfringens': 0.12
+}
+
+# Ionization calculations
+def unionized_fraction_acidic(pH, pKa):
+    return 1 / (1 + 10 ** (pH - pKa))
+
+def unionized_fraction_basic(pH, pKa):
+    return 1 / (1 + 10 ** (pKa - pH))
+
+def calculate_unionized_concentration(concentration, pH, pKa, drug_type):
+    if drug_type == "acidic":
+        unionized_fraction = unionized_fraction_acidic(pH, pKa)
+    elif drug_type == "basic":
+        unionized_fraction = unionized_fraction_basic(pH, pKa)
+    else:
+        raise ValueError("Invalid drug type. Must be 'acidic' or 'basic'.")
+    return concentration * unionized_fraction
+
+# Simulate drug concentration
+def pk_model(C, t, ka, ke, Vd, F, dose):
+    dCdt = (F * dose * ka / Vd) * np.exp(-ka * t) - (ke * C[0])
+    return dCdt
+
+def solve_for_ka(Tmax_target, ke):
+    ka_guess = max(ke * 2, 0.01)
+    def equation(ka): return (np.log(ka) - np.log(ke)) / (ka - ke) - Tmax_target
+    ka_solution = fsolve(equation, ka_guess)
+    return ka_solution[0] if ka_solution[0] > 0 else 0.05
+
+def simulate_concentration(dose, ke, Vd, F, Cmax_target, drug_type, pH, pKa):
+    ka = solve_for_ka(pk_parameters['Enrofloxacin']['Tmax_mean'], ke)
+    concentration = odeint(pk_model, [0], time_points, args=(ka, ke, Vd, F, dose))[:, 0]
+    if np.max(concentration) > 0:
+        concentration *= (Cmax_target / np.max(concentration))
+    return calculate_unionized_concentration(concentration, pH, pKa, drug_type)
+
+def simulate_multiple_doses(pk_params, doses, pH):
+    all_data = []
+    for molecule, params in pk_params.items():
+        for i in range(population_size):
+            F = np.random.normal(params['F_mean'], params['F_std'])
+            ke = np.random.normal(params['Ke_mean'], params['Ke_std'])
+            Vd = np.random.normal(params['Vd_mean'], params['Vd_std'])
+            Cmax_target = np.random.normal(params['Cmax_mean'], params['Cmax_std'])
+            pKa = params['pKa']
+            ref_conc = simulate_concentration(10, ke, Vd, F, Cmax_target, params['type'], pH, pKa)
+            for dose in doses:
+                scaled_conc = ref_conc * (dose / 10)
+                all_data.extend([{
+                    'Individual': i + 1,
+                    'Molecule': molecule,
+                    'Dose': dose,
+                    'Time': t,
+                    'Concentration': conc
+                } for t, conc in zip(time_points, scaled_conc)])
+    return pd.DataFrame(all_data)
+
+def calculate_pkpd_metrics(concentrations, time_points, MIC):
+    AUC = np.trapz(concentrations, time_points)
+    Cmax = np.max(concentrations)
+    T_above_MIC = time_points[concentrations > MIC]
+    T_above_MIC_duration = (T_above_MIC[-1] - T_above_MIC[0]) if len(T_above_MIC) > 0 else 0
+    AUIC = np.trapz(concentrations[concentrations > MIC] - MIC, time_points[concentrations > MIC]) if np.any(concentrations > MIC) else 0
+    return AUC, Cmax, T_above_MIC_duration, AUIC
+
+def plot_pkpd_and_ionization(pk_params, df, MIC, doses, pH_range):
+    fig, axes = plt.subplots(len(pk_params), len(doses) + 1, figsize=(20, len(pk_params) * 5))
+    for row, (molecule, params) in enumerate(pk_params.items()):
+        pKa = params['pKa']
+        for col, dose in enumerate(doses):
+            group = df[(df['Molecule'] == molecule) & (df['Dose'] == dose)]
+            mean_conc = group.groupby('Time')['Concentration'].mean().values
+            ax = axes[row, col]
+            ax.plot(time_points[:len(mean_conc)], mean_conc, label=f"{molecule}, Dose: {dose} mg/kg")
+            ax.axhline(MIC, color='red', linestyle='--', label=f'MIC = {MIC:.2f}')
+
+            # Calculate PKPD metrics
+            AUC, Cmax, T_above_MIC, AUIC = calculate_pkpd_metrics(mean_conc, time_points[:len(mean_conc)], MIC)
+
+            # Fill AUIC area
+            ax.fill_between(time_points[:len(mean_conc)], MIC, mean_conc, where=(mean_conc > MIC), color='green', alpha=0.3, label="AUIC")
+            ax.text(0.6 * time_points[-1], 0.8 * np.max(mean_conc),
+                    f"AUC: {AUC:.2f}\nCmax: {Cmax:.2f}\nT>MIC: {T_above_MIC:.2f} h\nAUIC: {AUIC:.2f}",
+                    fontsize=9, bbox=dict(facecolor='white', alpha=0.8))
+
+            ax.set_title(f"{molecule} - Dose {dose} mg/kg")
+            ax.set_xlabel('Time (h)')
+            ax.set_ylabel('Concentration (mg/L)')
+            ax.legend()
+        ax = axes[row, -1]
+        unionized = [unionized_fraction_acidic(pH, pKa) for pH in pH_range]
+        ax.plot(pH_range, unionized, label=f"Ionization Profile ({molecule})")
+        ax.set_title(f"Ionization Profile: {molecule}")
+        ax.set_xlabel('pH')
+        ax.set_ylabel('Unionized Fraction')
+        ax.legend()
+    plt.tight_layout()
+    return fig
+
+# Gradio Function
+def gradio_function(pH_input, pathogen, dose_input):
+    if pathogen not in MIC_values:
+        raise ValueError("Invalid pathogen.")
+    MIC = MIC_values[pathogen]
+    doses = [int(d) for d in dose_input.split(',')]
+    pH_range = np.linspace(0, 14, 100)
+    df = simulate_multiple_doses(pk_parameters, doses, pH_input)
+    fig = plot_pkpd_and_ionization(pk_parameters, df, MIC, doses, pH_range)
+    return fig
+
+
+# Gradio Interface
+interface = gr.Interface(
+    fn=gradio_function,
+    inputs=[
+        gr.Slider(0, 14, step=0.1, label="Water pH Value"),
+        gr.Dropdown(list(MIC_values.keys()), label="Pathogen"),
+        gr.Textbox(value="5,15,20", label="Doses (mg/kg, comma-separated)")
+    ],
+    outputs=gr.Plot(),
+    title="Qomics All Rights Reserved (C)",
+    live=True
+)
+
+
+interface.launch()