Update app.py

app.py

@@ -493,9 +493,8 @@ class BioprocessModel:
         X_ode_success = False 
 
         if y_pred_biomass_fit is None and not (use_differential and self.biomass_diff is not None and 'biomass' in self.params and self.params['biomass']):
-             # This case means biomass fitting itself failed. Plotting is not possible.
              print(f"Ajuste de biomasa falló para {experiment_name}, modelo {self.model_type}. No se generará gráfico.")
-             return None # Critical: if biomass fit fails, no plot.
+             return None 
         
         can_use_ode = use_differential and self.biomass_diff is not None and 'biomass' in self.params and self.params['biomass']
         
@@ -509,19 +508,18 @@ class BioprocessModel:
                 X_ode_success = True
             else: 
                 print(f"Solución EDO falló para {experiment_name}, {self.model_type}. Usando resultados de ajuste directo si existen.")
-                # Fallback to curve_fit results on fine grid if ODE failed
-                if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']: # Check if biomass fit was successful
+                if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']: 
                     b_params=list(self.params['biomass'].values())
-                    y_pred_b=self.biomass_model(time_curves,*b_params) # Use original y_pred_biomass_fit for this
+                    y_pred_b=self.biomass_model(time_curves,*b_params) 
                     if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params.get('substrate'):
                         s_params=list(self.params['substrate'].values()); y_pred_s=self.substrate(time_curves,*s_params,b_params)
                     else: y_pred_s=np.full_like(time_curves,np.nan)
                     if y_pred_product_fit is not None and 'product' in self.params and self.params.get('product'):
                         p_params=list(self.params['product'].values()); y_pred_p=self.product(time_curves,*p_params,b_params)
                     else: y_pred_p=np.full_like(time_curves,np.nan)
-                else: # Biomass fit itself failed, so predictions are NaN
+                else: 
                     y_pred_b,y_pred_s,y_pred_p = (np.full_like(time_curves,np.nan) for _ in range(3))
-        else: # Not using ODE, ensure curve_fit results are plotted on fine grid
+        else: 
             if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                 b_params=list(self.params['biomass'].values()); y_pred_b=self.biomass_model(time_curves,*b_params)
                 if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params.get('substrate'):
@@ -530,7 +528,7 @@ class BioprocessModel:
                 if y_pred_product_fit is not None and 'product' in self.params and self.params.get('product'):
                     p_params=list(self.params['product'].values()); y_pred_p=self.product(time_curves,*p_params,b_params)
                 else: y_pred_p=np.full_like(time_curves,np.nan)
-            else: # Biomass fit failed
+            else: 
                  y_pred_b,y_pred_s,y_pred_p = (np.full_like(time_curves,np.nan) for _ in range(3))
 
 
@@ -543,14 +541,12 @@ class BioprocessModel:
                   (ax3,product,y_pred_p,product_std,axis_labels['product_label'],'Modelo Producto',self.params.get('product',{}),self.r2.get('product',np.nan),self.rmse.get('product',np.nan))]
         
         for i,(ax,data,y_pred_curve,std,ylab,leg_lab,p_dict,r2_val,rmse_val) in enumerate(plot_cfg):
-            # Plot experimental data
             if data is not None and len(data)>0 and not np.all(np.isnan(data)):
                 if show_error_bars and std is not None and len(std)==len(data) and not np.all(np.isnan(std)):
                     ax.errorbar(time,data,yerr=std,fmt=marker_style,color=point_color,label='Datos experimentales',capsize=error_cap_size,elinewidth=error_line_width,markeredgewidth=1,markersize=5)
                 else: ax.plot(time,data,marker=marker_style,linestyle='',color=point_color,label='Datos experimentales',markersize=5)
             else: ax.text(0.5,0.5,'No hay datos experimentales.',transform=ax.transAxes,ha='center',va='center',color='gray', fontsize=9)
             
-            # Plot model curve
             if y_pred_curve is not None and len(y_pred_curve)>0 and not np.all(np.isnan(y_pred_curve)):
                 ax.plot(time_curves,y_pred_curve,linestyle=line_style,color=line_color,label=leg_lab)
             elif i == 0 and y_pred_biomass_fit is None: 
@@ -564,10 +560,11 @@ class BioprocessModel:
             if show_legend: ax.legend(loc=legend_position)
             if show_params and p_dict and any(np.isfinite(v) for v in p_dict.values()):
                 p_txt='\n'.join([f"{k}={v:.3g}" if np.isfinite(v) else f"{k}=N/A" for k,v in p_dict.items()])
-                # FIXED: Compute formatted strings separately
-                r2_str = f"{r2_val:.3f}" if np.isfinite(r2_val) else 'N/A'
-                rmse_str = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else 'N/A'
-                txt = f"{p_txt}\nR²={r2_str}\nRMSE={rmse_str}"
+                # *** CORRECTED LINES START ***
+                r2_str = f"{r2_val:.3f}" if np.isfinite(r2_val) else "N/A"
+                rmse_str = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else "N/A"
+                txt=f"{p_txt}\nR²={r2_str}\nRMSE={rmse_str}"
+                # *** CORRECTED LINES END ***
                 if params_position=='outside right': 
                     fig.subplots_adjust(right=0.70) 
                     ax.annotate(txt,xy=(1.05,0.5),xycoords='axes fraction',xytext=(10,0),textcoords='offset points',va='center',ha='left',bbox={'boxstyle':'round,pad=0.3','facecolor':'wheat','alpha':0.7}, fontsize=8)
@@ -605,7 +602,6 @@ class BioprocessModel:
         if axis_labels is None: axis_labels = {'x_label':'Tiempo','biomass_label':'Biomasa','substrate_label':'Sustrato','product_label':'Producto'}
         sns.set_style(style)
 
-        # Logic for ODE/curve_fit selection (similar to plot_results)
         if can_use_ode:
             X_ode_res,S_ode_res,P_ode_res,time_fine_ode = self.solve_differential_equations(time,biomass,substrate,product)
             if X_ode_res is not None: 
@@ -619,7 +615,7 @@ class BioprocessModel:
                     if y_pred_product_fit is not None and 'product' in self.params and self.params.get('product'): p_params=list(self.params['product'].values()); y_pred_p=self.product(time_curves,*p_params,b_params)
                     else: y_pred_p=np.full_like(time_curves,np.nan)
                 else: y_pred_b,y_pred_s,y_pred_p = (np.full_like(time_curves,np.nan) for _ in range(3))
-        else: # No ODE
+        else: 
             if y_pred_biomass_fit is not None and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                 b_params=list(self.params['biomass'].values()); y_pred_b=self.biomass_model(time_curves,*b_params)
                 if y_pred_substrate_fit is not None and 'substrate' in self.params and self.params.get('substrate'): s_params=list(self.params['substrate'].values()); y_pred_s=self.substrate(time_curves,*s_params,b_params)
@@ -673,10 +669,11 @@ class BioprocessModel:
                 (axis_labels['product_label'], self.params.get('product',{}), self.r2.get('product',np.nan), self.rmse.get('product',np.nan))]:
                 if p_dict and any(np.isfinite(v) for v in p_dict.values()):
                     p_list = [f"  {k}={v:.3g}" if np.isfinite(v) else f"  {k}=N/A" for k,v in p_dict.items()]
-                    # FIXED: Compute formatted strings separately
-                    r2_str = f"{r2_val:.3f}" if np.isfinite(r2_val) else 'N/A'
-                    rmse_str = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else 'N/A'
+                    # *** CORRECTED LINES START ***
+                    r2_str = f"{r2_val:.3f}" if np.isfinite(r2_val) else "N/A"
+                    rmse_str = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else "N/A"
                     all_param_text.append(f"{cat_label}:\n" + "\n".join(p_list) + f"\n  R²={r2_str}\n  RMSE={rmse_str}")
+                    # *** CORRECTED LINES END ***
             total_text = "\n\n".join(all_param_text)
             if total_text:
                 if params_position=='outside right': 
@@ -744,35 +741,32 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                 
                 exp_df_slice_multi = df[exp_group_name]
                 try:
-                    # Extract Time for this specific experiment group
-                    if 'Tiempo' not in exp_df_slice_multi.columns.get_level_values(0): # Check if 'Tiempo' is a primary key in the slice
+                    if 'Tiempo' not in exp_df_slice_multi.columns.get_level_values(0): 
                         all_plot_messages.append(f"No se encontró 'Tiempo' en el grupo '{exp_group_name}' de la hoja '{sheet_name}'.")
                         continue
                     
                     time_data_for_exp = exp_df_slice_multi['Tiempo']
-                    if isinstance(time_data_for_exp, pd.DataFrame): # Time itself has replicates (unusual)
+                    if isinstance(time_data_for_exp, pd.DataFrame): 
                         time_exp = time_data_for_exp.iloc[:,0].dropna().astype(float).values
-                    else: # Time is a single series
+                    else: 
                         time_exp = time_data_for_exp.dropna().astype(float).values
 
                     def get_comp_data_independent(component_name_str):
                         if component_name_str in exp_df_slice_multi.columns.get_level_values(0):
                             comp_data = exp_df_slice_multi[component_name_str]
-                            if isinstance(comp_data,pd.DataFrame): # Has replicates (e.g., R1, R2 columns under 'Biomasa')
-                                # Ensure all replicate columns are numeric before mean/std
+                            if isinstance(comp_data,pd.DataFrame): 
                                 numeric_cols = [col for col in comp_data.columns if pd.api.types.is_numeric_dtype(comp_data[col])]
                                 if not numeric_cols: return np.array([]), None
                                 comp_data_numeric = comp_data[numeric_cols]
                                 return comp_data_numeric.mean(axis=1).dropna().astype(float).values, comp_data_numeric.std(axis=1,ddof=1).dropna().astype(float).values
                             elif pd.api.types.is_numeric_dtype(comp_data):
-                                return comp_data.dropna().astype(float).values,None # Single numeric series
+                                return comp_data.dropna().astype(float).values,None 
                         return np.array([]),None
 
                     biomass_exp,biomass_std_exp=get_comp_data_independent('Biomasa')
                     substrate_exp,substrate_std_exp=get_comp_data_independent('Sustrato')
                     product_exp,product_std_exp=get_comp_data_independent('Producto')
                     
-                    # Align all data to the shortest length after NaNs and with time_exp
                     min_len=len(time_exp)
                     if len(biomass_exp)>0:min_len=min(min_len,len(biomass_exp))
                     if len(substrate_exp)>0:min_len=min(min_len,len(substrate_exp))
@@ -780,7 +774,7 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
 
                     time_exp=time_exp[:min_len]
                     if len(biomass_exp)>0:biomass_exp=biomass_exp[:min_len]
-                    else: biomass_exp = np.array([]) # Ensure it's an array
+                    else: biomass_exp = np.array([]) 
                     if biomass_std_exp is not None and len(biomass_std_exp)>0:biomass_std_exp=biomass_std_exp[:min_len]
                     
                     if len(substrate_exp)>0:substrate_exp=substrate_exp[:min_len]
@@ -802,13 +796,11 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                 for model_type_iter in model_types_selected:
                     model_instance = BioprocessModel(model_type=model_type_iter, maxfev=maxfev_val)
                     model_instance.fit_model() 
-                    y_pred_biomass = model_instance.fit_biomass(time_exp, biomass_exp) # This now gets filtered positive biomass
+                    y_pred_biomass = model_instance.fit_biomass(time_exp, biomass_exp) 
                     y_pred_substrate, y_pred_product = None, None
                     if y_pred_biomass is not None and model_instance.params.get('biomass'):
                         if len(substrate_exp)>0: y_pred_substrate = model_instance.fit_substrate(time_exp, substrate_exp, model_instance.params['biomass'])
                         if len(product_exp)>0: y_pred_product = model_instance.fit_product(time_exp, product_exp, model_instance.params['biomass'])
-                    # else: # Message for failed biomass fit is now inside fit_biomass or due to insufficient data
-                        # all_plot_messages.append(f"Ajuste de biomasa falló o datos insuficientes para {current_experiment_name}, modelo {model_type_iter}.")
                     
                     all_parameters_collected.setdefault(current_experiment_name, {})[model_type_iter] = model_instance.params
                     comparison_data.append({'Experimento':current_experiment_name,'Modelo':model_type_iter.capitalize(),
@@ -841,9 +833,7 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                 for mt_ in model_types_selected: comparison_data.append({'Experimento':current_experiment_name,'Modelo':mt_.capitalize(),'R² Biomasa':np.nan,'RMSE Biomasa':np.nan})
                 continue 
             
-            # This explicit check for average mode helps clarify why fitting might be skipped for the whole sheet average.
-            # The fit_biomass function itself will also perform checks on the data it receives.
-            if biomass_avg[0] <= 1e-9: # Check if the very first point of the averaged biomass is problematic
+            if biomass_avg[0] <= 1e-9: 
                 all_plot_messages.append(f"Biomasa inicial promedio (valor={biomass_avg[0]:.2e}) para '{current_sheet_name_base}' es <= 1e-9. Los modelos de biomasa no se ajustarán para el promedio de esta hoja.")
                 for mt_ in model_types_selected: 
                     comparison_data.append({'Experimento':current_experiment_name,'Modelo':mt_.capitalize(),'R² Biomasa':np.nan,'RMSE Biomasa':np.nan})
@@ -858,8 +848,6 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                 if y_pred_biomass is not None and model_instance.params.get('biomass'):
                     if len(substrate_avg)>0: y_pred_substrate = model_instance.fit_substrate(time_avg, substrate_avg, model_instance.params['biomass'])
                     if len(product_avg)>0: y_pred_product = model_instance.fit_product(time_avg, product_avg, model_instance.params['biomass'])
-                # else: # Message now handled by fit_biomass or insufficient data checks
-                    # all_plot_messages.append(f"Ajuste biomasa promedio falló o datos insuficientes: {current_experiment_name}, {model_type_iter}.")
 
                 all_parameters_collected.setdefault(current_experiment_name, {})[model_type_iter] = model_instance.params
                 comparison_data.append({'Experimento':current_experiment_name,'Modelo':model_type_iter.capitalize(),
@@ -886,7 +874,7 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
     if all_plot_messages: final_message += " Mensajes:\n" + "\n".join(list(set(all_plot_messages))) 
     if not figures_with_names and not comparison_df_sorted.empty: final_message += "\nNo se generaron gráficos, pero hay datos en la tabla."
     elif not figures_with_names and comparison_df_sorted.empty and not all_plot_messages : final_message += "\nNo se generaron gráficos ni datos para la tabla (posiblemente no hay datos válidos en el archivo)."
-    elif not figures_with_names and comparison_df_sorted.empty and all_plot_messages : pass # Messages already cover issues
+    elif not figures_with_names and comparison_df_sorted.empty and all_plot_messages : pass 
     
     return figures_with_names, comparison_df_sorted, final_message, all_parameters_collected
 
@@ -930,10 +918,64 @@ def create_interface():
         gr.Markdown("# Modelos Cinéticos de Bioprocesos")
         with gr.Tab("Teoría y Uso"):
             gr.Markdown(r"""
-            Análisis y visualización de datos de bioprocesos... (etc., same as before)
+            Análisis y visualización de datos de bioprocesos. Esta herramienta permite ajustar diferentes modelos cinéticos (Logistic, Gompertz, Moser, Baranyi)
+            a datos experimentales de crecimiento microbiano, consumo de sustrato y producción de metabolitos.
+            **Instrucciones:**
+            1.  Prepara tus datos en un archivo Excel (.xlsx). Cada hoja puede representar un experimento o condición diferente.
+            2.  El formato del Excel debe tener un encabezado de dos niveles:
+                *   Nivel 0: Nombre del Experimento/Grupo (ej: 'Control', 'Exp1_AltaTemp').
+                *   Nivel 1: Tipo de Dato ('Tiempo', 'Biomasa', 'Sustrato', 'Producto').
+                *   Sub-columnas (Nivel 2 implícito o explícito si hay réplicas): 'R1', 'R2', 'Promedio', etc. para los datos.
+            3.  Sube el archivo Excel.
+            4.  Selecciona el(los) modelo(s) a ajustar.
+            5.  Configura las opciones de simulación y gráficos según sea necesario.
+            6.  Haz clic en "Simular y Graficar".
+            7.  Revisa los resultados en la pestaña "Resultados".
+            **Modos de Análisis:**
+            *   `independent`: Analiza cada grupo de columnas (Nivel 0 del encabezado) en cada hoja como un experimento independiente.
+            *   `average`: Promedia todas las réplicas de Biomasa, Sustrato y Producto por hoja y ajusta un único modelo a estos promedios.
+                           Se usa el primer 'Tiempo' encontrado o un 'Tiempo' promedio si está estructurado así.
+            *   `combinado`: Similar a `average`, pero presenta los tres componentes (Biomasa, Sustrato, Producto) en un único gráfico con múltiples ejes Y.
+            **Salidas:**
+            *   Galería de imágenes con los gráficos de ajuste.
+            *   Tabla comparativa con R² y RMSE para cada modelo y componente.
+            *   Opciones para exportar la tabla (Excel, CSV), los parámetros del modelo (Excel) y las imágenes (ZIP).
             """)
             gr.Markdown(r"""
-            ## Modelos Matemáticos para Bioprocesos ... (etc., same as before)
+            ## Modelos Matemáticos para Bioprocesos
+
+            ### 1. Modelo Logístico (Verhulst)
+            Describe el crecimiento de la biomasa ($X$) limitado por la capacidad de carga ($X_m$).
+            $$ \frac{dX}{dt} = \mu_m X \left(1 - \frac{X}{X_m}\right) $$
+            Solución integral:
+            $$ X(t) = \frac{X_0 X_m e^{\mu_m t}}{X_m - X_0 + X_0 e^{\mu_m t}} $$
+            Parámetros: $X_0$ (biomasa inicial), $X_m$ (biomasa máxima), $\mu_m$ (tasa de crecimiento específica máxima).
+
+            ### 2. Modelo de Gompertz Modificado
+            Modelo sigmoidal usado frecuentemente para describir crecimiento con una fase de latencia ($\lambda$).
+            $$ X(t) = X_m \exp\left(-\exp\left(\frac{\mu_m e}{X_m}(\lambda - t) + 1\right)\right) $$
+            Parámetros: $X_m$ (biomasa máxima), $\mu_m$ (tasa de crecimiento específica máxima), $\lambda$ (fase de latencia).
+            Nota: La biomasa inicial $X_0$ es $X(t=0)$.
+
+            ### 3. Modelo de Moser
+            Modelo que relaciona la tasa de crecimiento con la concentración de sustrato limitante. La forma integrada aquí presentada es una simplificación que no modela explícitamente $S$.
+            $$ \frac{dX}{dt} = \mu_m \left(1 - \frac{X}{X_m}\right) X \quad (\text{forma simplificada para } X(t)) $$
+            La ecuación usada para el ajuste de $X(t)$ es:
+            $$ X(t) = X_m (1 - \exp(-\mu_m (t - K_s))) $$
+            Donde $K_s$ actúa como un parámetro de "tiempo de inicio" o "lag".
+            Parámetros: $X_m$ (biomasa máxima), $\mu_m$ (tasa de crecimiento), $K_s$ (constante de afinidad/lag).
+
+            ### 4. Modelo de Baranyi-Roberts
+            Modelo más complejo que incluye ajuste fisiológico de los microorganismos.
+            $$ X(t) = X_m \frac{\exp(\mu_m A(t))}{\exp(\mu_m A(t)) + \frac{X_m}{X_0} - 1} $$
+            Donde $A(t) = t + \frac{1}{\mu_m} \ln\left(e^{-\mu_m t} + e^{-\mu_m \lambda} - e^{-\mu_m (t+\lambda)}\right)$.
+            Parámetros: $X_0$ (biomasa inicial), $X_m$ (biomasa máxima), $\mu_m$ (tasa de crecimiento específica máxima), $\lambda$ (fase de latencia).
+
+            ### Modelos de Consumo de Sustrato y Formación de Producto (Luedeking-Piret)
+            Para sustrato ($S$) y producto ($P$):
+            $$ \frac{dS}{dt} = -Y_{X/S} \frac{dX}{dt} - m_S X \quad \implies S(t) = S_0 - p(X(t)-X_0) - q \int_0^t X(\tau)d\tau $$
+            $$ \frac{dP}{dt} = Y_{P/X} \frac{dX}{dt} + m_P X \quad \implies P(t) = P_0 + \alpha(X(t)-X_0) + \beta \int_0^t X(\tau)d\tau $$
+            Parámetros: $S_0, P_0$ (concentraciones iniciales), $p, Y_{X/S}$ (rendimiento biomasa/sustrato), $q, m_S$ (mantenimiento para sustrato), $\alpha, Y_{P/X}$ (rendimiento producto/biomasa), $\beta, m_P$ (mantenimiento para producto).
             """)
         with gr.Tab("Simulación"):
             with gr.Row():
@@ -972,14 +1014,13 @@ def create_interface():
             simulate_btn = gr.Button("Simular y Graficar", variant="primary")
         
         with gr.Tab("Resultados"):
-            status_message_ui = gr.Textbox(label="Estado del Procesamiento", interactive=False, lines=3, max_lines=10) # Increased lines for messages
+            status_message_ui = gr.Textbox(label="Estado del Procesamiento", interactive=False, lines=3, max_lines=10) 
             output_gallery_ui = gr.Gallery(label="Resultados Gráficos", columns=[2,1], height=600, object_fit="contain", preview=True)
             output_table_ui = gr.Dataframe(
                 label="Tabla Comparativa de Modelos",
                 headers=["Experimento","Modelo","R² Biomasa","RMSE Biomasa","R² Sustrato","RMSE Sustrato","R² Producto","RMSE Producto"],
                 interactive=False, 
                 wrap=True
-                # Removed height=400
             )
             state_df_ui = gr.State(pd.DataFrame()) 
             state_params_ui = gr.State({})