| 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_size = 100 |
| time_points = np.linspace(0, 24, 100) |
|
|
| |
| 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 = { |
| 'E.coli': 0.06, |
| 'S.Enteritidis': 0.1, |
| 'M.gallisepticum': 0.1, |
| 'C.perfringens': 0.12 |
| } |
|
|
| |
| 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 |
|
|
| |
| 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}') |
|
|
| |
| AUC, Cmax, T_above_MIC, AUIC = calculate_pkpd_metrics(mean_conc, time_points[:len(mean_conc)], MIC) |
|
|
| |
| 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 |
|
|
| |
| 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 |
|
|
|
|
| |
| 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() |
