Update app.py

app.py

@@ -41,18 +41,14 @@ class BioprocessModel:
 
     @staticmethod
     def logistic(time, xo, xm, um):
-        # Ensure xm is not zero and xo/xm is not 1 to avoid division by zero or log(0)
-        if xm == 0 or (xo / xm == 1 and np.any(um * time > 0)): # Simplified check
-            return np.full_like(time, np.nan) # or handle appropriately
-        # Add a small epsilon to prevent division by zero in the denominator
+        if xm == 0 or (xo / xm == 1 and np.any(um * time > 0)):
+            return np.full_like(time, np.nan)
         denominator = (1 - (xo / xm) * (1 - np.exp(um * time)))
-        denominator = np.where(denominator == 0, 1e-9, denominator) # Replace 0 with small number
+        denominator = np.where(denominator == 0, 1e-9, denominator)
         return (xo * np.exp(um * time)) / denominator
 
-
     @staticmethod
     def gompertz(time, xm, um, lag):
-        # Ensure xm is not zero
         if xm == 0:
             return np.full_like(time, np.nan)
         return xm * np.exp(-np.exp((um * np.e / xm) * (lag - time) + 1))
@@ -64,14 +60,14 @@ class BioprocessModel:
     @staticmethod
     def logistic_diff(X, t, params):
         xo, xm, um = params
-        if xm == 0: # Prevent division by zero
+        if xm == 0:
             return 0
         return um * X * (1 - X / xm)
 
     @staticmethod
     def gompertz_diff(X, t, params):
         xm, um, lag = params
-        if xm == 0: # Prevent division by zero
+        if xm == 0:
             return 0
         return X * (um * np.e / xm) * np.exp((um * np.e / xm) * (lag - t) + 1)
 
@@ -84,44 +80,32 @@ class BioprocessModel:
         if self.biomass_model is None or not biomass_params:
             return np.full_like(time, np.nan)
         X_t = self.biomass_model(time, *biomass_params)
-        if np.any(np.isnan(X_t)): # If biomass model returned NaN
+        if np.any(np.isnan(X_t)):
              return np.full_like(time, np.nan)
-        # dXdt = np.gradient(X_t, time, edge_order=2) # Use edge_order=2 for better boundary derivatives
-        # integral_X = np.cumsum(X_t) * np.gradient(time)
-        # A more robust way to calculate integral, especially for non-uniform time
         integral_X = np.zeros_like(X_t)
         if len(time) > 1:
-            dt = np.diff(time, prepend=time[0] - (time[1]-time[0] if len(time)>1 else 1)) # Estimate dt
+            dt = np.diff(time, prepend=time[0] - (time[1]-time[0] if len(time)>1 else 1))
             integral_X = np.cumsum(X_t * dt)
 
-
-        # Initial biomass value is the first element of biomass_params for logistic (xo)
-        # For Gompertz and Moser, biomass_params[0] is Xm. We need X(t=0)
         if self.model_type == 'logistic':
             X0 = biomass_params[0]
         elif self.model_type == 'gompertz':
-             # X(0) for Gompertz
             X0 = self.gompertz(0, *biomass_params)
         elif self.model_type == 'moser':
-            # X(0) for Moser
             X0 = self.moser(0, *biomass_params)
         else:
-            X0 = X_t[0] # Fallback
-
+            X0 = X_t[0]
         return so - p * (X_t - X0) - q * integral_X
 
-
     def product(self, time, po, alpha, beta, biomass_params):
         if self.biomass_model is None or not biomass_params:
             return np.full_like(time, np.nan)
         X_t = self.biomass_model(time, *biomass_params)
-        if np.any(np.isnan(X_t)): # If biomass model returned NaN
+        if np.any(np.isnan(X_t)):
              return np.full_like(time, np.nan)
-        # dXdt = np.gradient(X_t, time, edge_order=2)
-        # integral_X = np.cumsum(X_t) * np.gradient(time)
         integral_X = np.zeros_like(X_t)
         if len(time) > 1:
-            dt = np.diff(time, prepend=time[0] - (time[1]-time[0] if len(time)>1 else 1)) # Estimate dt
+            dt = np.diff(time, prepend=time[0] - (time[1]-time[0] if len(time)>1 else 1))
             integral_X = np.cumsum(X_t * dt)
 
         if self.model_type == 'logistic':
@@ -132,7 +116,6 @@ class BioprocessModel:
             X0 = self.moser(0, *biomass_params)
         else:
             X0 = X_t[0]
-
         return po + alpha * (X_t - X0) + beta * integral_X
 
     def process_data(self, df):
@@ -151,12 +134,11 @@ class BioprocessModel:
             self.datax.append(data_biomass)
             self.dataxp.append(np.mean(data_biomass, axis=0))
             self.datax_std.append(np.std(data_biomass, axis=0, ddof=1))
-        else: # Handle case where Biomass columns might be missing
+        else:
             self.datax.append(np.array([]))
             self.dataxp.append(np.array([]))
             self.datax_std.append(np.array([]))
 
-
         if len(substrate_cols) > 0:
             data_substrate = [df[col].values for col in substrate_cols]
             data_substrate = np.array(data_substrate)
@@ -178,8 +160,6 @@ class BioprocessModel:
             self.datap.append(np.array([]))
             self.datapp.append(np.array([]))
             self.datap_std.append(np.array([]))
-
-
         self.time = time
 
     def fit_model(self):
@@ -195,35 +175,28 @@ class BioprocessModel:
 
     def fit_biomass(self, time, biomass):
         try:
-            # Ensure biomass has some variation, otherwise std dev can be 0
-            if len(np.unique(biomass)) < 2 : # or np.std(biomass) == 0:
+            if len(np.unique(biomass)) < 2 :
                 print(f"Biomasa constante para {self.model_type}, no se puede ajustar el modelo.")
                 return None
 
             if self.model_type == 'logistic':
-                # Ensure initial xo is less than xm. Max biomass could be initial guess for xm.
-                # xo guess: first non-zero biomass value or a small positive number
                 xo_guess = biomass[biomass > 1e-6][0] if np.any(biomass > 1e-6) else 1e-3
                 xm_guess = max(biomass) * 1.1 if max(biomass) > xo_guess else xo_guess * 2
-                if xm_guess <= xo_guess: xm_guess = xo_guess + 1e-3 # ensure xm > xo
+                if xm_guess <= xo_guess: xm_guess = xo_guess + 1e-3
                 p0 = [xo_guess, xm_guess, 0.1]
                 bounds = ([1e-9, 1e-9, 1e-9], [np.inf, np.inf, np.inf])
                 popt, _ = curve_fit(self.logistic, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
-                # Check for xm > xo after fit
                 if popt[1] <= popt[0]:
                      print(f"Advertencia: En modelo logístico, Xm ({popt[1]:.2f}) no es mayor que Xo ({popt[0]:.2f}). Ajuste puede no ser válido.")
-                     # Optionally, try to re-fit with constraints or return None
                 self.params['biomass'] = {'xo': popt[0], 'xm': popt[1], 'um': popt[2]}
                 y_pred = self.logistic(time, *popt)
 
             elif self.model_type == 'gompertz':
                 xm_guess = max(biomass) if max(biomass) > 0 else 1.0
                 um_guess = 0.1
-                # Estimate lag phase: time until significant growth starts
-                # This is a rough estimate, could be improved
                 lag_guess = time[np.argmax(np.gradient(biomass))] if len(biomass) > 1 and np.any(np.gradient(biomass) > 1e-6) else time[0]
                 p0 = [xm_guess, um_guess, lag_guess]
-                bounds = ([1e-9, 1e-9, 0], [np.inf, np.inf, max(time) if len(time)>0 else 100]) # Lag can't be negative
+                bounds = ([1e-9, 1e-9, 0], [np.inf, np.inf, max(time) if len(time)>0 else 100])
                 popt, _ = curve_fit(self.gompertz, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                 self.params['biomass'] = {'xm': popt[0], 'um': popt[1], 'lag': popt[2]}
                 y_pred = self.gompertz(time, *popt)
@@ -231,9 +204,8 @@ class BioprocessModel:
             elif self.model_type == 'moser':
                 Xm_guess = max(biomass) if max(biomass) > 0 else 1.0
                 um_guess = 0.1
-                Ks_guess = time[0] # Ks is like a time shift
+                Ks_guess = time[0]
                 p0 = [Xm_guess, um_guess, Ks_guess]
-                # Ks could be negative if growth starts before t=0 effectively
                 bounds = ([1e-9, 1e-9, -np.inf], [np.inf, np.inf, max(time) if len(time)>0 else 100])
                 popt, _ = curve_fit(self.moser, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9)
                 self.params['biomass'] = {'Xm': popt[0], 'um': popt[1], 'Ks': popt[2]}
@@ -247,18 +219,17 @@ class BioprocessModel:
                 self.rmse['biomass'] = np.nan
                 return None
 
-            # Ensure R2 calculation is robust against constant biomass data (already checked, but good practice)
             ss_res = np.sum((biomass - y_pred) ** 2)
             ss_tot = np.sum((biomass - np.mean(biomass)) ** 2)
-            if ss_tot == 0: # Avoid division by zero if biomass is constant
-                self.r2['biomass'] = 1.0 if ss_res == 0 else 0.0 # Perfect fit if residuals are also 0
+            if ss_tot == 0:
+                self.r2['biomass'] = 1.0 if ss_res == 0 else 0.0
             else:
                 self.r2['biomass'] = 1 - (ss_res / ss_tot)
             self.rmse['biomass'] = np.sqrt(mean_squared_error(biomass, y_pred))
             return y_pred
         except RuntimeError as e:
             print(f"Error de Runtime en fit_biomass_{self.model_type} (probablemente no se pudo ajustar): {e}")
-            self.params['biomass'] = {} # Clear params on failure
+            self.params['biomass'] = {}
             self.r2['biomass'] = np.nan
             self.rmse['biomass'] = np.nan
             return None
@@ -270,11 +241,10 @@ class BioprocessModel:
             return None
 
     def fit_substrate(self, time, substrate, biomass_params_dict):
-        if not biomass_params_dict: # Check if biomass_params_dict is empty
+        if not biomass_params_dict:
             print(f"Error en fit_substrate_{self.model_type}: Parámetros de biomasa no disponibles.")
             return None
         try:
-            # Extract parameters based on model type
             if self.model_type == 'logistic':
                 biomass_params_values = [biomass_params_dict['xo'], biomass_params_dict['xm'], biomass_params_dict['um']]
             elif self.model_type == 'gompertz':
@@ -285,12 +255,11 @@ class BioprocessModel:
                 return None
 
             so_guess = substrate[0] if len(substrate) > 0 else 1.0
-            p_guess = 0.1 # Yxs inverse (biomass/substrate)
-            q_guess = 0.01 # Maintenance
+            p_guess = 0.1
+            q_guess = 0.01
             p0 = [so_guess, p_guess, q_guess]
-            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf]) # Parameters should be non-negative
+            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf])
 
-            # Use a lambda that directly takes the parameter values list
             popt, _ = curve_fit(
                 lambda t, so, p, q: self.substrate(t, so, p, q, biomass_params_values),
                 time, substrate, p0=p0, maxfev=self.maxfev, bounds=bounds, ftol=1e-9, xtol=1e-9
@@ -340,10 +309,10 @@ class BioprocessModel:
                 return None
 
             po_guess = product[0] if len(product) > 0 else 0.0
-            alpha_guess = 0.1 # Growth-associated
-            beta_guess = 0.01 # Non-growth-associated
+            alpha_guess = 0.1
+            beta_guess = 0.01
             p0 = [po_guess, alpha_guess, beta_guess]
-            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf]) # Parameters should be non-negative
+            bounds = ([0, 0, 0], [np.inf, np.inf, np.inf])
 
             popt, _ = curve_fit(
                 lambda t, po, alpha, beta: self.product(t, po, alpha, beta, biomass_params_values),
@@ -381,98 +350,67 @@ class BioprocessModel:
 
     def generate_fine_time_grid(self, time):
         if time is None or len(time) == 0:
-             return np.array([0]) # Default if time is not set
+             return np.array([0])
         time_fine = np.linspace(time.min(), time.max(), 500)
         return time_fine
 
     def system(self, y, t, biomass_params_list, substrate_params_list, product_params_list, model_type):
-        X, S, P = y # X, S, P current values
+        X, S, P = y
 
-        # Biomass growth (dX/dt)
         if model_type == 'logistic':
-            # biomass_params_list for logistic: [xo, xm, um]
-            # logistic_diff expects X (current biomass), t, params=[xo, xm, um]
-            # However, logistic_diff is defined as um * X * (1 - X / xm) using current X
-            # For ODE integration, xo is part of initial conditions, not the rate params.
-            # So, params for logistic_diff should be [xm, um] effectively, if xo is handled by y[0]
-            # Let's assume biomass_params_list = [xo, xm, um] from fitted model
-            # The differential equation for logistic growth does not directly use xo.
-            # It's um * X * (1 - X / Xm). So params = [Xm, um]
-            # For consistency, we pass all fitted params and let the diff eq select.
             dXdt = self.logistic_diff(X, t, biomass_params_list)
         elif model_type == 'gompertz':
-            # biomass_params_list for gompertz: [xm, um, lag]
             dXdt = self.gompertz_diff(X, t, biomass_params_list)
         elif model_type == 'moser':
-            # biomass_params_list for moser: [Xm, um, Ks]
             dXdt = self.moser_diff(X, t, biomass_params_list)
         else:
-            dXdt = 0.0 # Should not happen if model_type is validated
+            dXdt = 0.0
 
-        # Substrate consumption (dS/dt)
-        # substrate_params_list: [so, p, q]
-        # dS/dt = -p * dX/dt - q * X
-        # so is initial substrate, not used in differential form directly
         p_val = substrate_params_list[1] if len(substrate_params_list) > 1 else 0
         q_val = substrate_params_list[2] if len(substrate_params_list) > 2 else 0
         dSdt = -p_val * dXdt - q_val * X
 
-        # Product formation (dP/dt)
-        # product_params_list: [po, alpha, beta]
-        # dP/dt = alpha * dX/dt + beta * X
-        # po is initial product, not used in differential form directly
         alpha_val = product_params_list[1] if len(product_params_list) > 1 else 0
         beta_val = product_params_list[2] if len(product_params_list) > 2 else 0
         dPdt = alpha_val * dXdt + beta_val * X
 
         return [dXdt, dSdt, dPdt]
 
-
     def get_initial_conditions(self, time, biomass, substrate, product):
-        # Use experimental data for initial conditions if params are not available or to be robust
         X0_exp = biomass[0] if len(biomass) > 0 else 0
         S0_exp = substrate[0] if len(substrate) > 0 else 0
         P0_exp = product[0] if len(product) > 0 else 0
 
-        # Initial biomass (X0)
         if 'biomass' in self.params and self.params['biomass']:
             if self.model_type == 'logistic':
-                # xo is the initial biomass in logistic model definition
                 X0 = self.params['biomass'].get('xo', X0_exp)
             elif self.model_type == 'gompertz':
-                # X(t=0) for Gompertz
                 xm = self.params['biomass'].get('xm', 1)
                 um = self.params['biomass'].get('um', 0.1)
                 lag = self.params['biomass'].get('lag', 0)
-                X0 = self.gompertz(0, xm, um, lag) # Calculate X at t=0
-                if np.isnan(X0): X0 = X0_exp # Fallback if calculation fails
+                X0 = self.gompertz(0, xm, um, lag)
+                if np.isnan(X0): X0 = X0_exp
             elif self.model_type == 'moser':
-                # X(t=0) for Moser
                 Xm_param = self.params['biomass'].get('Xm', 1)
                 um_param = self.params['biomass'].get('um', 0.1)
                 Ks_param = self.params['biomass'].get('Ks', 0)
-                X0 = self.moser(0, Xm_param, um_param, Ks_param) # Calculate X at t=0
-                if np.isnan(X0): X0 = X0_exp # Fallback
+                X0 = self.moser(0, Xm_param, um_param, Ks_param)
+                if np.isnan(X0): X0 = X0_exp
             else:
-                X0 = X0_exp # Fallback for unknown model type
+                X0 = X0_exp
         else:
             X0 = X0_exp
 
-        # Initial substrate (S0)
         if 'substrate' in self.params and self.params['substrate']:
-            # so is the initial substrate in the Luedeking-Piret substrate model
             S0 = self.params['substrate'].get('so', S0_exp)
         else:
             S0 = S0_exp
 
-        # Initial product (P0)
         if 'product' in self.params and self.params['product']:
-            # po is the initial product in the Luedeking-Piret product model
             P0 = self.params['product'].get('po', P0_exp)
         else:
             P0 = P0_exp
             
-        # Ensure initial conditions are not NaN
         X0 = X0 if not np.isnan(X0) else 0.0
         S0 = S0 if not np.isnan(S0) else 0.0
         P0 = P0 if not np.isnan(P0) else 0.0
@@ -483,40 +421,25 @@ class BioprocessModel:
         if 'biomass' not in self.params or not self.params['biomass']:
             print("No hay parámetros de biomasa, no se pueden resolver las EDO.")
             return None, None, None, time
-        if time is None or len(time) == 0 : # Check if time is valid
+        if time is None or len(time) == 0 :
             print("Tiempo no válido para resolver EDOs.")
             return None, None, None, np.array([])
 
-
-        # Prepare biomass_params_list for ODE system
-        # These are the parameters *of the differential equation itself*, not necessarily all fitted constants
-        # For logistic_diff: expects [xm, um] effectively if xo is IC.
-        # But our diff functions are written to take the full fitted set.
         if self.model_type == 'logistic':
-            # self.params['biomass'] = {'xo': popt[0], 'xm': popt[1], 'um': popt[2]}
             biomass_params_list = [self.params['biomass']['xo'], self.params['biomass']['xm'], self.params['biomass']['um']]
         elif self.model_type == 'gompertz':
-            # self.params['biomass'] = {'xm': popt[0], 'um': popt[1], 'lag': popt[2]}
             biomass_params_list = [self.params['biomass']['xm'], self.params['biomass']['um'], self.params['biomass']['lag']]
         elif self.model_type == 'moser':
-            # self.params['biomass'] = {'Xm': popt[0], 'um': popt[1], 'Ks': popt[2]}
             biomass_params_list = [self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['Ks']]
         else:
             print(f"Tipo de modelo de biomasa desconocido: {self.model_type}")
             return None, None, None, time
 
-        # Prepare substrate_params_list for ODE system
-        # self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
-        # The ODE system uses p and q. so is an initial condition.
         substrate_params_list = [
             self.params.get('substrate', {}).get('so', 0),
             self.params.get('substrate', {}).get('p', 0),
             self.params.get('substrate', {}).get('q', 0)
         ]
-
-        # Prepare product_params_list for ODE system
-        # self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
-        # The ODE system uses alpha and beta. po is an initial condition.
         product_params_list = [
             self.params.get('product', {}).get('po', 0),
             self.params.get('product', {}).get('alpha', 0),
@@ -532,10 +455,9 @@ class BioprocessModel:
         try:
             sol = odeint(self.system, initial_conditions, time_fine,
                          args=(biomass_params_list, substrate_params_list, product_params_list, self.model_type),
-                         rtol=1e-6, atol=1e-6) # Added tolerances
+                         rtol=1e-6, atol=1e-6)
         except Exception as e:
             print(f"Error al resolver EDOs con odeint: {e}")
-            # Try with lsoda if default fails (often more robust)
             try:
                 print("Intentando con método 'lsoda'...")
                 sol = odeint(self.system, initial_conditions, time_fine,
@@ -545,11 +467,9 @@ class BioprocessModel:
                 print(f"Error al resolver EDOs con odeint (método lsoda): {e_lsoda}")
                 return None, None, None, time_fine
 
-
         X = sol[:, 0]
         S = sol[:, 1]
         P = sol[:, 2]
-
         return X, S, P, time_fine
 
     def plot_results(self, time, biomass, substrate, product,
@@ -559,17 +479,16 @@ class BioprocessModel:
                      show_legend=True, show_params=True,
                      style='whitegrid',
                      line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
-                     use_differential=False, axis_labels=None):
+                     use_differential=False, axis_labels=None,
+                     show_error_bars=True, error_cap_size=3, error_line_width=1): # Added error bar parameters
 
-        if y_pred_biomass is None and not use_differential: # If using differential, biomass params might still be there
+        if y_pred_biomass is None and not use_differential:
              print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} y no se usan EDO. Omitiendo figura.")
              return None
         if use_differential and ('biomass' not in self.params or not self.params['biomass']):
             print(f"Se solicitó usar EDO pero no hay parámetros de biomasa para {experiment_name}. Omitiendo EDO.")
-            use_differential = False # Fallback to curve_fit results if any
-
+            use_differential = False
 
-        # Set axis labels with defaults
         if axis_labels is None:
             axis_labels = {
                 'x_label': 'Tiempo',
@@ -579,21 +498,17 @@ class BioprocessModel:
             }
 
         sns.set_style(style)
-        time_to_plot = time # Default time grid
+        time_to_plot = time
 
         if use_differential and 'biomass' in self.params and self.params['biomass']:
             X_ode, S_ode, P_ode, time_fine_ode = self.solve_differential_equations(time, biomass, substrate, product)
             if X_ode is not None:
                 y_pred_biomass, y_pred_substrate, y_pred_product = X_ode, S_ode, P_ode
-                time_to_plot = time_fine_ode # Use the fine time grid for ODE results
+                time_to_plot = time_fine_ode
             else:
                 print(f"Fallo al resolver EDOs para {experiment_name}, usando resultados de curve_fit si existen.")
-                # Keep original y_pred_biomass etc. from curve_fit if ODE failed
-                time_to_plot = time # Revert to original time if ODE failed
+                time_to_plot = time
         else:
-             # If not using differential or if biomass params are missing, use the curve_fit time
-             # For curve_fit, the predictions are already on the original 'time' grid.
-             # If we want smoother curve_fit lines, we need to evaluate them on a finer grid too.
             if not use_differential and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                 time_fine_curvefit = self.generate_fine_time_grid(time)
                 if time_fine_curvefit is not None and len(time_fine_curvefit)>0:
@@ -606,23 +521,20 @@ class BioprocessModel:
                     else:
                         y_pred_substrate_fine = np.full_like(time_fine_curvefit, np.nan)
 
-
                     if 'product' in self.params and self.params['product']:
                         product_params_values = list(self.params['product'].values())
                         y_pred_product_fine = self.product(time_fine_curvefit, *product_params_values, biomass_params_values)
                     else:
                         y_pred_product_fine = np.full_like(time_fine_curvefit, np.nan)
 
-                    # Check if any fine predictions are all NaN
                     if not np.all(np.isnan(y_pred_biomass_fine)):
                         y_pred_biomass = y_pred_biomass_fine
-                        time_to_plot = time_fine_curvefit # Update time_to_plot only if biomass_fine is valid
+                        time_to_plot = time_fine_curvefit
                     if not np.all(np.isnan(y_pred_substrate_fine)):
                         y_pred_substrate = y_pred_substrate_fine
                     if not np.all(np.isnan(y_pred_product_fine)):
                         y_pred_product = y_pred_product_fine
 
-
         fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15))
         fig.suptitle(f'{experiment_name} ({self.model_type.capitalize()})', fontsize=16)
 
@@ -636,11 +548,16 @@ class BioprocessModel:
         ]
 
         for idx, (ax, data_exp, y_pred_model, data_std_exp, ylabel, model_name_legend, params_dict, r2_val, rmse_val) in enumerate(plots_config):
-            # Plot experimental data if available and not all NaN
             if data_exp is not None and len(data_exp) > 0 and not np.all(np.isnan(data_exp)):
-                if data_std_exp is not None and len(data_std_exp) == len(data_exp) and not np.all(np.isnan(data_std_exp)):
-                    ax.errorbar(time, data_exp, yerr=data_std_exp, fmt=marker_style, color=point_color,
-                                label='Datos experimentales', capsize=5, elinewidth=1, markeredgewidth=1)
+                if show_error_bars and data_std_exp is not None and len(data_std_exp) == len(data_exp) and not np.all(np.isnan(data_std_exp)):
+                    ax.errorbar(
+                        time, data_exp, yerr=data_std_exp, 
+                        fmt=marker_style, color=point_color,
+                        label='Datos experimentales', 
+                        capsize=error_cap_size,
+                        elinewidth=error_line_width,
+                        markeredgewidth=1
+                    )
                 else:
                     ax.plot(time, data_exp, marker=marker_style, linestyle='', color=point_color,
                             label='Datos experimentales')
@@ -649,11 +566,9 @@ class BioprocessModel:
                         horizontalalignment='center', verticalalignment='center',
                         transform=ax.transAxes, fontsize=10, color='gray')
 
-
-            # Plot model prediction if available and not all NaN
             if y_pred_model is not None and len(y_pred_model) > 0 and not np.all(np.isnan(y_pred_model)):
                 ax.plot(time_to_plot, y_pred_model, linestyle=line_style, color=line_color, label=model_name_legend)
-            elif idx == 0 and y_pred_biomass is None: # Special message if biomass model failed
+            elif idx == 0 and y_pred_biomass is None:
                  ax.text(0.5, 0.6, 'Modelo de biomasa no ajustado.',
                         horizontalalignment='center', verticalalignment='center',
                         transform=ax.transAxes, fontsize=10, color='red')
@@ -667,7 +582,6 @@ class BioprocessModel:
                         horizontalalignment='center', verticalalignment='center',
                         transform=ax.transAxes, fontsize=10, color='orange')
 
-
             ax.set_xlabel(axis_labels['x_label'])
             ax.set_ylabel(ylabel)
             if show_legend:
@@ -675,18 +589,16 @@ class BioprocessModel:
             ax.set_title(f'{ylabel}')
 
             if show_params and params_dict and all(isinstance(v, (int, float)) and np.isfinite(v) for v in params_dict.values()):
-                param_text = '\n'.join([f"{k} = {v:.3g}" for k, v in params_dict.items()]) # Use .3g for general format
-                # Ensure R2 and RMSE are finite for display
+                param_text = '\n'.join([f"{k} = {v:.3g}" for k, v in params_dict.items()])
                 r2_display = f"{r2_val:.3f}" if np.isfinite(r2_val) else "N/A"
                 rmse_display = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else "N/A"
                 text = f"{param_text}\nR² = {r2_display}\nRMSE = {rmse_display}"
 
                 if params_position == 'outside right':
                     bbox_props = dict(boxstyle='round,pad=0.3', facecolor='wheat', alpha=0.5)
-                    # Adjust x position to be truly outside
-                    fig.subplots_adjust(right=0.75) # Make space for the annotation
+                    fig.subplots_adjust(right=0.75)
                     ax.annotate(text, xy=(1.05, 0.5), xycoords='axes fraction',
-                                xytext=(10,0), textcoords='offset points', # Small offset for padding
+                                xytext=(10,0), textcoords='offset points',
                                 verticalalignment='center', horizontalalignment='left',
                                 bbox=bbox_props)
                 else:
@@ -700,15 +612,12 @@ class BioprocessModel:
                         horizontalalignment='center', verticalalignment='center',
                         transform=ax.transAxes, fontsize=9, color='grey')
 
-
-        plt.tight_layout(rect=[0, 0.03, 1, 0.95]) # Adjust rect to accommodate suptitle
-
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
         buf = io.BytesIO()
         fig.savefig(buf, format='png', bbox_inches='tight')
         buf.seek(0)
         image = Image.open(buf).convert("RGB")
         plt.close(fig)
-
         return image
 
     def plot_combined_results(self, time, biomass, substrate, product,
@@ -718,9 +627,9 @@ class BioprocessModel:
                               show_legend=True, show_params=True,
                               style='whitegrid',
                               line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
-                              use_differential=False, axis_labels=None):
+                              use_differential=False, axis_labels=None,
+                              show_error_bars=True, error_cap_size=3, error_line_width=1): # Added error bar parameters
 
-        # Similar checks as in plot_results
         if y_pred_biomass is None and not use_differential:
             print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} (combinado). Omitiendo figura.")
             return None
@@ -728,7 +637,6 @@ class BioprocessModel:
             print(f"Se solicitó usar EDO (combinado) pero no hay parámetros de biomasa para {experiment_name}. Omitiendo EDO.")
             use_differential = False
 
-
         if axis_labels is None:
             axis_labels = {
                 'x_label': 'Tiempo',
@@ -738,7 +646,7 @@ class BioprocessModel:
             }
 
         sns.set_style(style)
-        time_to_plot = time # Default
+        time_to_plot = time
 
         if use_differential and 'biomass' in self.params and self.params['biomass']:
             X_ode, S_ode, P_ode, time_fine_ode = self.solve_differential_equations(time, biomass, substrate, product)
@@ -747,8 +655,8 @@ class BioprocessModel:
                 time_to_plot = time_fine_ode
             else:
                 print(f"Fallo al resolver EDOs para {experiment_name} (combinado), usando resultados de curve_fit si existen.")
-                time_to_plot = time # Revert
-        else: # Smoother curve_fit lines if not using ODE
+                time_to_plot = time
+        else:
             if not use_differential and self.biomass_model and 'biomass' in self.params and self.params['biomass']:
                 time_fine_curvefit = self.generate_fine_time_grid(time)
                 if time_fine_curvefit is not None and len(time_fine_curvefit)>0:
@@ -775,21 +683,25 @@ class BioprocessModel:
                     if not np.all(np.isnan(y_pred_product_fine)):
                         y_pred_product = y_pred_product_fine
 
-
-        fig, ax1 = plt.subplots(figsize=(12, 7)) # Increased width for params possibly outside
+        fig, ax1 = plt.subplots(figsize=(12, 7))
         fig.suptitle(f'{experiment_name} ({self.model_type.capitalize()})', fontsize=16)
 
         colors = {'Biomasa': 'blue', 'Sustrato': 'green', 'Producto': 'red'}
         data_colors = {'Biomasa': 'darkblue', 'Sustrato': 'darkgreen', 'Producto': 'darkred'}
         model_colors = {'Biomasa': 'cornflowerblue', 'Sustrato': 'limegreen', 'Producto': 'salmon'}
 
-
         ax1.set_xlabel(axis_labels['x_label'])
         ax1.set_ylabel(axis_labels['biomass_label'], color=colors['Biomasa'])
         if biomass is not None and len(biomass) > 0 and not np.all(np.isnan(biomass)):
-            if biomass_std is not None and len(biomass_std) == len(biomass) and not np.all(np.isnan(biomass_std)):
-                ax1.errorbar(time, biomass, yerr=biomass_std, fmt=marker_style, color=data_colors['Biomasa'],
-                             label=f'{axis_labels["biomass_label"]} (Datos)', capsize=3, elinewidth=1, markersize=5)
+            if show_error_bars and biomass_std is not None and len(biomass_std) == len(biomass) and not np.all(np.isnan(biomass_std)):
+                ax1.errorbar(
+                    time, biomass, yerr=biomass_std, 
+                    fmt=marker_style, color=data_colors['Biomasa'],
+                    label=f'{axis_labels["biomass_label"]} (Datos)', 
+                    capsize=error_cap_size,
+                    elinewidth=error_line_width,
+                    markersize=5
+                )
             else:
                 ax1.plot(time, biomass, marker=marker_style, linestyle='', color=data_colors['Biomasa'],
                          label=f'{axis_labels["biomass_label"]} (Datos)', markersize=5)
@@ -801,9 +713,15 @@ class BioprocessModel:
         ax2 = ax1.twinx()
         ax2.set_ylabel(axis_labels['substrate_label'], color=colors['Sustrato'])
         if substrate is not None and len(substrate) > 0 and not np.all(np.isnan(substrate)):
-            if substrate_std is not None and len(substrate_std) == len(substrate) and not np.all(np.isnan(substrate_std)):
-                ax2.errorbar(time, substrate, yerr=substrate_std, fmt=marker_style, color=data_colors['Sustrato'],
-                             label=f'{axis_labels["substrate_label"]} (Datos)', capsize=3, elinewidth=1, markersize=5)
+            if show_error_bars and substrate_std is not None and len(substrate_std) == len(substrate) and not np.all(np.isnan(substrate_std)):
+                ax2.errorbar(
+                    time, substrate, yerr=substrate_std, 
+                    fmt=marker_style, color=data_colors['Sustrato'],
+                    label=f'{axis_labels["substrate_label"]} (Datos)', 
+                    capsize=error_cap_size,
+                    elinewidth=error_line_width,
+                    markersize=5
+                )
             else:
                 ax2.plot(time, substrate, marker=marker_style, linestyle='', color=data_colors['Sustrato'],
                          label=f'{axis_labels["substrate_label"]} (Datos)', markersize=5)
@@ -813,16 +731,21 @@ class BioprocessModel:
         ax2.tick_params(axis='y', labelcolor=colors['Sustrato'])
 
         ax3 = ax1.twinx()
-        ax3.spines["right"].set_position(("axes", 1.15)) # Adjusted position for third axis
+        ax3.spines["right"].set_position(("axes", 1.15))
         ax3.set_frame_on(True)
         ax3.patch.set_visible(False)
 
-
         ax3.set_ylabel(axis_labels['product_label'], color=colors['Producto'])
         if product is not None and len(product) > 0 and not np.all(np.isnan(product)):
-            if product_std is not None and len(product_std) == len(product) and not np.all(np.isnan(product_std)):
-                ax3.errorbar(time, product, yerr=product_std, fmt=marker_style, color=data_colors['Producto'],
-                             label=f'{axis_labels["product_label"]} (Datos)', capsize=3, elinewidth=1, markersize=5)
+            if show_error_bars and product_std is not None and len(product_std) == len(product) and not np.all(np.isnan(product_std)):
+                ax3.errorbar(
+                    time, product, yerr=product_std, 
+                    fmt=marker_style, color=data_colors['Producto'],
+                    label=f'{axis_labels["product_label"]} (Datos)', 
+                    capsize=error_cap_size,
+                    elinewidth=error_line_width,
+                    markersize=5
+                )
             else:
                 ax3.plot(time, product, marker=marker_style, linestyle='', color=data_colors['Producto'],
                          label=f'{axis_labels["product_label"]} (Datos)', markersize=5)
@@ -831,21 +754,18 @@ class BioprocessModel:
                      label=f'{axis_labels["product_label"]} (Modelo)')
         ax3.tick_params(axis='y', labelcolor=colors['Producto'])
 
-        # Collect legends from all axes
         lines_labels_collect = []
         for ax_current in [ax1, ax2, ax3]:
             h, l = ax_current.get_legend_handles_labels()
-            if h: # Only add if there are handles/labels
+            if h:
                  lines_labels_collect.append((h,l))
         
         if lines_labels_collect:
-            lines, labels = [sum(lol, []) for lol in zip(*[(h,l) for h,l in lines_labels_collect])] # careful with empty h,l
-            # Filter out duplicate labels for legend, keeping order
+            lines, labels = [sum(lol, []) for lol in zip(*[(h,l) for h,l in lines_labels_collect])]
             unique_labels_dict = dict(zip(labels, lines))
             if show_legend:
                 ax1.legend(unique_labels_dict.values(), unique_labels_dict.keys(), loc=legend_position)
 
-
         if show_params:
             texts_to_display = []
             param_categories = [
@@ -860,22 +780,18 @@ class BioprocessModel:
                     r2_display = f"{r2_val:.3f}" if np.isfinite(r2_val) else "N/A"
                     rmse_display = f"{rmse_val:.3f}" if np.isfinite(rmse_val) else "N/A"
                     texts_to_display.append(f"{label}:\n{param_text}\n  R² = {r2_display}\n  RMSE = {rmse_display}")
-                elif params_dict: # Some params but maybe not all finite, or model failed
+                elif params_dict:
                      texts_to_display.append(f"{label}:\n  Parámetros no válidos o N/A")
-                # else: No params for this category, skip.
-
 
             total_text = "\n\n".join(texts_to_display)
 
-            if total_text: # Only display if there's something to show
+            if total_text:
                 if params_position == 'outside right':
-                    fig.subplots_adjust(right=0.70) # Make more space for text outside
+                    fig.subplots_adjust(right=0.70)
                     bbox_props = dict(boxstyle='round,pad=0.3', facecolor='wheat', alpha=0.7)
-                    # Annotate relative to the figure, not a specific axis, for true "outside"
                     fig.text(0.72, 0.5, total_text, transform=fig.transFigure,
                              verticalalignment='center', horizontalalignment='left',
                              bbox=bbox_props, fontsize=8)
-
                 else:
                     text_x, ha = (0.95, 'right') if 'right' in params_position else (0.05, 'left')
                     text_y, va = (0.95, 'top') if 'upper' in params_position else (0.05, 'bottom')
@@ -884,39 +800,34 @@ class BioprocessModel:
                              bbox={'boxstyle':'round,pad=0.3', 'facecolor':'wheat', 'alpha':0.7}, fontsize=8)
 
         plt.tight_layout(rect=[0, 0.03, 1, 0.95])
-        # For combined plot, ensure right spine of ax3 is visible if params are outside
         if params_position == 'outside right':
             fig.subplots_adjust(right=0.70)
 
-
         buf = io.BytesIO()
         fig.savefig(buf, format='png', bbox_inches='tight')
         buf.seek(0)
         image = Image.open(buf).convert("RGB")
         plt.close(fig)
-
         return image
 
 def process_all_data(file, legend_position, params_position, model_types_selected, experiment_names_str,
-                     lower_bounds_str, upper_bounds_str, # These are not used in current model fit, but kept for future
+                     lower_bounds_str, upper_bounds_str,
                      mode, style, line_color, point_color, line_style, marker_style,
                      show_legend, show_params, use_differential, maxfev_val,
-                     axis_labels_dict): # Added axis_labels_dict
+                     axis_labels_dict,
+                     show_error_bars, error_cap_size, error_line_width): # New error bar parameters
 
     if file is None:
         return [], pd.DataFrame(), "Por favor, sube un archivo Excel."
 
     try:
-        # Try reading with multi-index header first
         try:
             xls = pd.ExcelFile(file.name)
-        except AttributeError: # If file is already a path (e.g. from tempfile)
+        except AttributeError:
             xls = pd.ExcelFile(file)
-
         sheet_names = xls.sheet_names
         if not sheet_names:
             return [], pd.DataFrame(), "El archivo Excel está vacío o no contiene hojas."
-
     except Exception as e:
         return [], pd.DataFrame(), f"Error al leer el archivo Excel: {e}"
 
@@ -926,7 +837,6 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
     experiment_names_list = experiment_names_str.strip().split('\n') if experiment_names_str.strip() else []
     all_plot_messages = []
 
-
     for sheet_name_idx, sheet_name in enumerate(sheet_names):
         current_experiment_name_base = (experiment_names_list[sheet_name_idx]
                                     if sheet_name_idx < len(experiment_names_list) and experiment_names_list[sheet_name_idx]
@@ -936,39 +846,27 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
             if df.empty:
                 all_plot_messages.append(f"Hoja '{sheet_name}' está vacía.")
                 continue
-            # Basic validation of expected column structure (Tiempo, Biomasa, etc.)
             if not any(col_level2 == 'Tiempo' for _, col_level2 in df.columns):
                 all_plot_messages.append(f"Hoja '{sheet_name}' no contiene la subcolumna 'Tiempo'. Saltando hoja.")
                 continue
-
         except Exception as e:
             all_plot_messages.append(f"Error al leer la hoja '{sheet_name}': {e}. Saltando hoja.")
             continue
 
-        # Create a dummy model instance to process data for this sheet
         model_dummy_for_sheet = BioprocessModel()
         try:
             model_dummy_for_sheet.process_data(df)
-        except ValueError as e: # Catch specific errors from process_data
+        except ValueError as e:
             all_plot_messages.append(f"Error procesando datos de la hoja '{sheet_name}': {e}. Saltando hoja.")
             continue
 
-        time_exp_full = model_dummy_for_sheet.time # Time from the first experiment in the sheet usually
-
-        # INDEPENDENT MODE: Iterate through top-level columns (experiments)
         if mode == 'independent':
-            # df.columns.levels[0] gives unique top-level column names
-            # However, direct iteration over df.columns.levels[0] might not align if some experiments are missing certain sub-columns.
-            # A safer way is to group by the first level of the column index.
             grouped_cols = df.columns.get_level_values(0).unique()
-
             for exp_idx, exp_col_name in enumerate(grouped_cols):
                 current_experiment_name = f"{current_experiment_name_base} - Exp {exp_idx + 1} ({exp_col_name})"
-                exp_df = df[exp_col_name] # DataFrame for the current experiment
-
+                exp_df = df[exp_col_name]
                 try:
                     time_exp = exp_df['Tiempo'].dropna().values
-                    # Ensure data is 1D array of numbers, handle potential errors
                     biomass_exp = exp_df['Biomasa'].dropna().astype(float).values if 'Biomasa' in exp_df else np.array([])
                     substrate_exp = exp_df['Sustrato'].dropna().astype(float).values if 'Sustrato' in exp_df else np.array([])
                     product_exp = exp_df['Producto'].dropna().astype(float).values if 'Producto' in exp_df else np.array([])
@@ -976,9 +874,8 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                     if len(time_exp) == 0:
                          all_plot_messages.append(f"No hay datos de tiempo para {current_experiment_name}. Saltando.")
                          continue
-                    if len(biomass_exp) == 0 : # Biomass is essential for fitting other models
+                    if len(biomass_exp) == 0 :
                          all_plot_messages.append(f"No hay datos de biomasa para {current_experiment_name}. Saltando modelos para este experimento.")
-                         # Still add to comparison_data as NaN
                          for model_type_iter in model_types_selected:
                             comparison_data.append({
                                 'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
@@ -986,8 +883,6 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                                 **{f'RMSE {comp}': np.nan for comp in ['Biomasa', 'Sustrato', 'Producto']}
                             })
                          continue
-
-
                 except KeyError as e:
                     all_plot_messages.append(f"Faltan columnas (Tiempo, Biomasa, Sustrato, Producto) en '{current_experiment_name}': {e}. Saltando.")
                     continue
@@ -995,19 +890,13 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                     all_plot_messages.append(f"Error extrayendo datos para '{current_experiment_name}': {e_data}. Saltando.")
                     continue
 
-
-                # For independent mode, standard deviation is not applicable unless replicates are within this exp_df
-                # Assuming exp_df contains single replicate data here. If it has sub-columns for replicates,
-                # then mean/std should be calculated here. For now, pass None for std.
                 biomass_std_exp, substrate_std_exp, product_std_exp = None, None, None
 
                 for model_type_iter in model_types_selected:
                     model_instance = BioprocessModel(model_type=model_type_iter, maxfev=maxfev_val)
-                    model_instance.fit_model() # Sets self.biomass_model and self.biomass_diff
-
+                    model_instance.fit_model()
                     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'])
@@ -1016,16 +905,11 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                     else:
                         all_plot_messages.append(f"Ajuste de biomasa falló para {current_experiment_name} con modelo {model_type_iter}.")
 
-
                     comparison_data.append({
-                        'Experimento': current_experiment_name,
-                        'Modelo': model_type_iter.capitalize(),
-                        'R² Biomasa': model_instance.r2.get('biomass', np.nan),
-                        'RMSE Biomasa': model_instance.rmse.get('biomass', np.nan),
-                        'R² Sustrato': model_instance.r2.get('substrate', np.nan),
-                        'RMSE Sustrato': model_instance.rmse.get('substrate', np.nan),
-                        'R² Producto': model_instance.r2.get('product', np.nan),
-                        'RMSE Producto': model_instance.rmse.get('product', np.nan)
+                        'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
+                        'R² Biomasa': model_instance.r2.get('biomass', np.nan), 'RMSE Biomasa': model_instance.rmse.get('biomass', np.nan),
+                        'R² Sustrato': model_instance.r2.get('substrate', np.nan), 'RMSE Sustrato': model_instance.rmse.get('substrate', np.nan),
+                        'R² Producto': model_instance.r2.get('product', np.nan), 'RMSE Producto': model_instance.rmse.get('product', np.nan)
                     })
 
                     fig = model_instance.plot_results(
@@ -1035,19 +919,17 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                         current_experiment_name, legend_position, params_position,
                         show_legend, show_params, style,
                         line_color, point_color, line_style, marker_style,
-                        use_differential, axis_labels_dict # Pass axis_labels_dict
+                        use_differential, axis_labels_dict,
+                        show_error_bars=show_error_bars, # Pass new parameters
+                        error_cap_size=error_cap_size,
+                        error_line_width=error_line_width
                     )
                     if fig: figures.append(fig)
                 experiment_counter +=1
 
-
-        # AVERAGE or COMBINADO MODE: Use processed data (mean, std) from model_dummy_for_sheet
         elif mode in ['average', 'combinado']:
             current_experiment_name = f"{current_experiment_name_base} - Promedio"
-
-            # Data from model_dummy_for_sheet (which processed the whole sheet)
-            # These are lists, take the last appended (corresponds to current sheet)
-            time_avg = model_dummy_for_sheet.time # Should be consistent across sheet
+            time_avg = model_dummy_for_sheet.time
             biomass_avg = model_dummy_for_sheet.dataxp[-1] if model_dummy_for_sheet.dataxp else np.array([])
             substrate_avg = model_dummy_for_sheet.datasp[-1] if model_dummy_for_sheet.datasp else np.array([])
             product_avg = model_dummy_for_sheet.datapp[-1] if model_dummy_for_sheet.datapp else np.array([])
@@ -1069,14 +951,11 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                     })
                 continue
 
-
             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_avg, biomass_avg)
                 y_pred_substrate, y_pred_product = None, None
-
                 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'])
@@ -1085,16 +964,11 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                 else:
                     all_plot_messages.append(f"Ajuste de biomasa promedio falló para {current_experiment_name} con modelo {model_type_iter}.")
 
-
                 comparison_data.append({
-                    'Experimento': current_experiment_name,
-                    'Modelo': model_type_iter.capitalize(),
-                    'R² Biomasa': model_instance.r2.get('biomass', np.nan),
-                    'RMSE Biomasa': model_instance.rmse.get('biomass', np.nan),
-                    'R² Sustrato': model_instance.r2.get('substrate', np.nan),
-                    'RMSE Sustrato': model_instance.rmse.get('substrate', np.nan),
-                    'R² Producto': model_instance.r2.get('product', np.nan),
-                    'RMSE Producto': model_instance.rmse.get('product', np.nan)
+                    'Experimento': current_experiment_name, 'Modelo': model_type_iter.capitalize(),
+                    'R² Biomasa': model_instance.r2.get('biomass', np.nan), 'RMSE Biomasa': model_instance.rmse.get('biomass', np.nan),
+                    'R² Sustrato': model_instance.r2.get('substrate', np.nan), 'RMSE Sustrato': model_instance.rmse.get('substrate', np.nan),
+                    'R² Producto': model_instance.r2.get('product', np.nan), 'RMSE Producto': model_instance.rmse.get('product', np.nan)
                 })
 
                 plot_func = model_instance.plot_combined_results if mode == 'combinado' else model_instance.plot_results
@@ -1105,25 +979,25 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
                     current_experiment_name, legend_position, params_position,
                     show_legend, show_params, style,
                     line_color, point_color, line_style, marker_style,
-                    use_differential, axis_labels_dict # Pass axis_labels_dict
+                    use_differential, axis_labels_dict,
+                    show_error_bars=show_error_bars, # Pass new parameters
+                    error_cap_size=error_cap_size,
+                    error_line_width=error_line_width
                 )
                 if fig: figures.append(fig)
             experiment_counter +=1
 
-
     comparison_df = pd.DataFrame(comparison_data)
     if not comparison_df.empty:
-        # Ensure numeric columns for sorting, coerce errors to NaN
         for col in ['R² Biomasa', 'RMSE Biomasa', 'R² Sustrato', 'RMSE Sustrato', 'R² Producto', 'RMSE Producto']:
             if col in comparison_df.columns:
                 comparison_df[col] = pd.to_numeric(comparison_df[col], errors='coerce')
-
         comparison_df_sorted = comparison_df.sort_values(
             by=['Experimento', 'Modelo', 'R² Biomasa', 'R² Sustrato', 'R² Producto', 'RMSE Biomasa', 'RMSE Sustrato', 'RMSE Producto'],
-            ascending=[True, True, False, False, False, True, True, True] # Sort R² descending, RMSE ascending
+            ascending=[True, True, False, False, False, True, True, True]
         ).reset_index(drop=True)
     else:
-        comparison_df_sorted = pd.DataFrame(columns=[ # Ensure empty DF has correct columns
+        comparison_df_sorted = pd.DataFrame(columns=[
             'Experimento', 'Modelo', 'R² Biomasa', 'RMSE Biomasa',
             'R² Sustrato', 'RMSE Sustrato', 'R² Producto', 'RMSE Producto'
         ])
@@ -1135,11 +1009,8 @@ def process_all_data(file, legend_position, params_position, model_types_selecte
         final_message += "\nNo se generaron gráficos, pero hay datos en la tabla."
     elif not figures and comparison_df_sorted.empty:
         final_message += "\nNo se generaron gráficos ni datos para la tabla."
-
-
     return figures, comparison_df_sorted, final_message
 
-
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
         gr.Markdown("# Modelos Cinéticos de Bioprocesos")
@@ -1252,8 +1123,8 @@ def create_interface():
             with gr.Row():
                 style_dropdown = gr.Dropdown(choices=['white', 'dark', 'whitegrid', 'darkgrid', 'ticks'],
                                              label="Estilo de Gráfico (Seaborn)", value='whitegrid')
-                line_color_picker = gr.ColorPicker(label="Color de Línea (Modelo)", value='#0072B2') # Seaborn blue
-                point_color_picker = gr.ColorPicker(label="Color de Puntos (Datos)", value='#D55E00') # Seaborn orange
+                line_color_picker = gr.ColorPicker(label="Color de Línea (Modelo)", value='#0072B2')
+                point_color_picker = gr.ColorPicker(label="Color de Puntos (Datos)", value='#D55E00')
 
             with gr.Row():
                 line_style_dropdown = gr.Dropdown(choices=['-', '--', '-.', ':'], label="Estilo de Línea", value='-')
@@ -1265,37 +1136,37 @@ def create_interface():
             with gr.Row():
                 substrate_axis_label_input = gr.Textbox(label="Título Eje Y (Sustrato)", value="Sustrato (g/L)", placeholder="Sustrato (unidades)")
                 product_axis_label_input = gr.Textbox(label="Título Eje Y (Producto)", value="Producto (g/L)", placeholder="Producto (unidades)")
+            
+            # ADDED ERROR BAR CONTROLS
+            with gr.Row():
+                show_error_bars_ui = gr.Checkbox(label="Mostrar barras de error", value=True)
+                error_cap_size_ui = gr.Slider(label="Tamaño de tapa de barras de error", minimum=1, maximum=10, step=1, value=3)
+                error_line_width_ui = gr.Slider(label="Grosor de línea de error", minimum=0.5, maximum=5, step=0.5, value=1.0)
 
-
-        # Lower/Upper bounds are not currently used by the curve_fit in BioprocessModel,
-        # but kept here for potential future implementation.
         with gr.Accordion("Configuración Avanzada de Ajuste (No implementado aún)", open=False):
             with gr.Row():
                 lower_bounds_str = gr.Textbox(label="Lower Bounds (no usado actualmente)", lines=3)
                 upper_bounds_str = gr.Textbox(label="Upper Bounds (no usado actualmente)", lines=3)
 
         simulate_btn = gr.Button("Simular y Graficar", variant="primary")
-        
         status_message = gr.Textbox(label="Estado del Procesamiento", interactive=False)
-
         output_gallery = gr.Gallery(label="Resultados Gráficos", columns=[2,1], height='auto', object_fit="contain")
-        # Change the gr.Dataframe initialization
         output_table = gr.Dataframe(
             label="Tabla Comparativa de Modelos (Ordenada por R² Biomasa Descendente)",
             headers=["Experimento", "Modelo", "R² Biomasa", "RMSE Biomasa",
                     "R² Sustrato", "RMSE Sustrato", "R² Producto", "RMSE Producto"],
-            interactive=False, wrap=True # Remove height=400
+            interactive=False, wrap=True
         )
-
-        state_df = gr.State(pd.DataFrame()) # To store the dataframe for export
+        state_df = gr.State(pd.DataFrame())
 
         def run_simulation_interface(file, legend_pos, params_pos, models_sel, analysis_mode, exp_names,
                                      low_bounds, up_bounds, plot_style,
                                      line_col, point_col, line_sty, marker_sty,
                                      show_leg, show_par, use_diff, maxfev,
-                                     x_label, biomass_label, substrate_label, product_label):
+                                     x_label, biomass_label, substrate_label, product_label,
+                                     show_error_bars_arg, error_cap_size_arg, error_line_width_arg): # New error bar args
             if file is None:
-                return [], pd.DataFrame(), "Error: Por favor, sube un archivo Excel."
+                return [], pd.DataFrame(), "Error: Por favor, sube un archivo Excel.", pd.DataFrame()
 
             axis_labels = {
                 'x_label': x_label if x_label else 'Tiempo',
@@ -1304,18 +1175,18 @@ def create_interface():
                 'product_label': product_label if product_label else 'Producto'
             }
             
-            if not models_sel: # Check if no models are selected
-                 return [], pd.DataFrame(), "Error: Por favor, selecciona al menos un tipo de modelo de biomasa."
-
+            if not models_sel:
+                 return [], pd.DataFrame(), "Error: Por favor, selecciona al menos un tipo de modelo de biomasa.", pd.DataFrame()
 
             figures, comparison_df, message = process_all_data(
                 file, legend_pos, params_pos, models_sel, exp_names,
                 low_bounds, up_bounds, analysis_mode, plot_style,
                 line_col, point_col, line_sty, marker_sty,
                 show_leg, show_par, use_diff, int(maxfev),
-                axis_labels # Pass the constructed dictionary
+                axis_labels,
+                show_error_bars_arg, error_cap_size_arg, error_line_width_arg # Pass new args
             )
-            return figures, comparison_df, message, comparison_df # Pass df to state too
+            return figures, comparison_df, message, comparison_df
 
         simulate_btn.click(
             fn=run_simulation_interface,
@@ -1324,62 +1195,52 @@ def create_interface():
                 lower_bounds_str, upper_bounds_str, style_dropdown,
                 line_color_picker, point_color_picker, line_style_dropdown, marker_style_dropdown,
                 show_legend, show_params, use_differential, maxfev_input,
-                x_axis_label_input, biomass_axis_label_input, substrate_axis_label_input, product_axis_label_input # New axis label inputs
+                x_axis_label_input, biomass_axis_label_input, substrate_axis_label_input, product_axis_label_input,
+                show_error_bars_ui, error_cap_size_ui, error_line_width_ui # New UI inputs
             ],
             outputs=[output_gallery, output_table, status_message, state_df]
         )
 
         def export_excel_interface(df_to_export):
             if df_to_export is None or df_to_export.empty:
-                # Create a temporary empty file to satisfy Gradio's file output expectation
                 with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
                      tmp.write(b"No hay datos para exportar.")
-                     return tmp.name # Return path to this dummy file
-                # Alternatively, raise an error or return a specific message if Gradio handles None better
-                # For now, returning a dummy file path is safer.
-
+                     return tmp.name
             try:
                 with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False, mode='w+b') as tmp:
                     df_to_export.to_excel(tmp.name, index=False)
                     return tmp.name
             except Exception as e:
-                # print(f"Error al exportar a Excel: {e}")
                 with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
                      tmp.write(f"Error al exportar a Excel: {e}".encode())
                      return tmp.name
 
-
         export_btn = gr.Button("Exportar Tabla a Excel")
         download_file_output = gr.File(label="Descargar archivo Excel", interactive=False)
 
         export_btn.click(
             fn=export_excel_interface,
-            inputs=state_df, # Get the DataFrame from the state
+            inputs=state_df,
             outputs=download_file_output
         )
         
         gr.Examples(
             examples=[
-                [None, "best", "upper right", ["logistic"], "independent", "Exp A\nExp B", "", "", "whitegrid", "#0072B2", "#D55E00", "-", "o", True, True, False, 50000, "Tiempo (días)", "Células (millones/mL)", "Glucosa (mM)", "Anticuerpo (mg/L)"]
+                [None, "best", "upper right", ["logistic"], "independent", "Exp A\nExp B", "", "", "whitegrid", "#0072B2", "#D55E00", "-", "o", True, True, False, 50000, "Tiempo (días)", "Células (millones/mL)", "Glucosa (mM)", "Anticuerpo (mg/L)", True, 3, 1.0]
             ],
             inputs=[
                 file_input, legend_position, params_position, model_types_selected, mode, experiment_names_str,
                 lower_bounds_str, upper_bounds_str, style_dropdown,
                 line_color_picker, point_color_picker, line_style_dropdown, marker_style_dropdown,
                 show_legend, show_params, use_differential, maxfev_input,
-                x_axis_label_input, biomass_axis_label_input, substrate_axis_label_input, product_axis_label_input
+                x_axis_label_input, biomass_axis_label_input, substrate_axis_label_input, product_axis_label_input,
+                show_error_bars_ui, error_cap_size_ui, error_line_width_ui # Added example values for new inputs
             ],
             label="Ejemplo de Configuración (subir archivo manualmente)"
         )
-
-
     return demo
 
 if __name__ == '__main__':
-    # For local execution without explicit share=True, Gradio might choose a local URL.
-    # share=True is useful for Colab or when needing external access.
-    # For robust execution, explicitly manage the server if needed.
-    # Check if running in a Google Colab environment
     try:
         import google.colab
         IN_COLAB = True
@@ -1387,5 +1248,4 @@ if __name__ == '__main__':
         IN_COLAB = False
 
     demo_instance = create_interface()
-    # demo_instance.launch(share=IN_COLAB) # Share only if in Colab, otherwise local
-    demo_instance.launch(share=True) # Force share for testing purposes
+    demo_instance.launch(share=True) # Use share=IN_COLAB for conditional sharing