Update app.py

app.py

@@ -1,7 +1,7 @@
-#import os
-#!pip install gradio seaborn scipy scikit-learn openpyxl pydantic==1.10.0 -q
+# import os # No parece usarse directamente, se puede quitar si no hay un uso oculto
+# !pip install gradio seaborn scipy scikit-learn openpyxl pydantic==1.10.0 -q # Ejecutar en el entorno
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel # ConfigDict ya no es necesario en Pydantic V2 si solo usas arbitrary_types_allowed
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -14,7 +14,20 @@ import io
 from PIL import Image
 import tempfile
 
-class YourModel(BaseModel):
+# --- Constantes para nombres de columnas y etiquetas ---
+# ### NUEVO ###
+COL_TIME = 'Tiempo'
+COL_BIOMASS = 'Biomasa'
+COL_SUBSTRATE = 'Sustrato'
+COL_PRODUCT = 'Producto'
+
+LABEL_TIME = 'Tiempo'
+LABEL_BIOMASS = 'Biomasa'
+LABEL_SUBSTRATE = 'Sustrato'
+LABEL_PRODUCT = 'Producto'
+# --- Fin Constantes ---
+
+class YourModel(BaseModel): # Esto parece ser un vestigio, no se usa. Se puede quitar si es así.
     class Config:
         arbitrary_types_allowed = True
 
@@ -36,17 +49,22 @@ class BioprocessModel:
         self.biomass_diff = None
         self.model_type = model_type
         self.maxfev = maxfev
+        self.time = np.array([]) # Inicializar time
 
     @staticmethod
     def logistic(time, xo, xm, um):
-        return (xo * np.exp(um * time)) / (1 - (xo / xm) * (1 - np.exp(um * time)))
+        # Evitar division por cero o log de negativo si xm es muy pequeño o xo/xm >= 1
+        denominator = (1 - (xo / xm) * (1 - np.exp(um * time)))
+        # Añadir un pequeño epsilon para evitar división por cero si es necesario
+        denominator = np.where(np.abs(denominator) < 1e-9, np.sign(denominator) * 1e-9 if np.any(denominator) else 1e-9, denominator)
+        return (xo * np.exp(um * time)) / denominator
 
     @staticmethod
     def gompertz(time, xm, um, lag):
         return xm * np.exp(-np.exp((um * np.e / xm) * (lag - time) + 1))
 
     @staticmethod
-    def moser(time, Xm, um, Ks):
+    def moser(time, Xm, um, Ks): # Modelo simplificado, no es el Moser clásico con dependencia de S
         return Xm * (1 - np.exp(-um * (time - Ks)))
 
     @staticmethod
@@ -60,50 +78,83 @@ class BioprocessModel:
         return X * (um * np.e / xm) * np.exp((um * np.e / xm) * (lag - t) + 1)
 
     @staticmethod
-    def moser_diff(X, t, params):
+    def moser_diff(X, t, params): # Diferencial del Moser simplificado usado
         Xm, um, Ks = params
-        return um * (Xm - X)
-
-    def substrate(self, time, so, p, q, biomass_params):
-        X_t = self.biomass_model(time, *biomass_params)
-        dXdt = np.gradient(X_t, time)
-        integral_X = np.cumsum(X_t) * np.gradient(time)
-        return so - p * (X_t - biomass_params[0]) - q * integral_X
+        return um * (Xm - X) # Asumiendo X(0) es tal que la forma integrada tiene sentido
 
-    def product(self, time, po, alpha, beta, biomass_params):
-        X_t = self.biomass_model(time, *biomass_params)
-        dXdt = np.gradient(X_t, time)
-        integral_X = np.cumsum(X_t) * np.gradient(time)
-        return po + alpha * (X_t - biomass_params[0]) + beta * integral_X
+    def _get_biomass_model_params_as_list(self):
+        """Helper para obtener los parámetros de biomasa como lista para los modelos."""
+        # ### NUEVO ### (Helper interno)
+        if 'biomass' not in self.params or not self.params['biomass']:
+            return None
+        if self.model_type == 'logistic':
+            return [self.params['biomass']['xo'], self.params['biomass']['xm'], self.params['biomass']['um']]
+        elif self.model_type == 'gompertz':
+            return [self.params['biomass']['xm'], self.params['biomass']['um'], self.params['biomass']['lag']]
+        elif self.model_type == 'moser':
+            return [self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['Ks']]
+        return None
+
+    def substrate(self, time, so, p, q, biomass_params_list):
+        # ### MODIFICADO ###: Recibe directamente la lista de parámetros
+        if biomass_params_list is None: return np.full_like(time, so) # O manejar error
+        X_t = self.biomass_model(time, *biomass_params_list)
+        # dXdt = np.gradient(X_t, time) # np.gradient puede ser ruidoso
+        # Usar la forma diferencial si está disponible y es más estable
+        # Para el ajuste, usamos la forma integrada de X_t
+        integral_X = np.cumsum(X_t) * np.gradient(time) # Aproximación de la integral
+        return so - p * (X_t - biomass_params_list[0]) - q * integral_X
+
+    def product(self, time, po, alpha, beta, biomass_params_list):
+        # ### MODIFICADO ###: Recibe directamente la lista de parámetros
+        if biomass_params_list is None: return np.full_like(time, po) # O manejar error
+        X_t = self.biomass_model(time, *biomass_params_list)
+        integral_X = np.cumsum(X_t) * np.gradient(time) # Aproximación de la integral
+        return po + alpha * (X_t - biomass_params_list[0]) + beta * integral_X
 
     def process_data(self, df):
-        biomass_cols = [col for col in df.columns if col[1] == 'Biomasa']
-        substrate_cols = [col for col in df.columns if col[1] == 'Sustrato']
-        product_cols = [col for col in df.columns if col[1] == 'Producto']
-
-        time_col = [col for col in df.columns if col[1] == 'Tiempo'][0]
+        # ### MODIFICADO ###: Usa constantes
+        biomass_cols = [col for col in df.columns if col[1] == COL_BIOMASS]
+        substrate_cols = [col for col in df.columns if col[1] == COL_SUBSTRATE]
+        product_cols = [col for col in df.columns if col[1] == COL_PRODUCT]
+
+        time_col_tuple = [col for col in df.columns if col[1] == COL_TIME]
+        if not time_col_tuple:
+            raise ValueError(f"No se encontró la columna de '{COL_TIME}' en los datos.")
+        time_col = time_col_tuple[0]
         time = df[time_col].values
 
-        data_biomass = [df[col].values for col in biomass_cols]
-        data_biomass = np.array(data_biomass)
-        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))
-
-        data_substrate = [df[col].values for col in substrate_cols]
-        data_substrate = np.array(data_substrate)
-        self.datas.append(data_substrate)
-        self.datasp.append(np.mean(data_substrate, axis=0))
-        self.datas_std.append(np.std(data_substrate, axis=0, ddof=1))
-
-        data_product = [df[col].values for col in product_cols]
-        data_product = np.array(data_product)
-        self.datap.append(data_product)
-        self.datapp.append(np.mean(data_product, axis=0))
-        self.datap_std.append(np.std(data_product, axis=0, ddof=1))
+        if biomass_cols:
+            data_biomass = np.array([df[col].values for col in biomass_cols])
+            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: # Manejar el caso de que no haya datos de biomasa
+            self.dataxp.append(np.zeros_like(time))
+            self.datax_std.append(np.zeros_like(time))
+
+
+        if substrate_cols:
+            data_substrate = np.array([df[col].values for col in substrate_cols])
+            self.datas.append(data_substrate)
+            self.datasp.append(np.mean(data_substrate, axis=0))
+            self.datas_std.append(np.std(data_substrate, axis=0, ddof=1))
+        else:
+            self.datasp.append(np.zeros_like(time))
+            self.datas_std.append(np.zeros_like(time))
+
+        if product_cols:
+            data_product = np.array([df[col].values for col in product_cols])
+            self.datap.append(data_product)
+            self.datapp.append(np.mean(data_product, axis=0))
+            self.datap_std.append(np.std(data_product, axis=0, ddof=1))
+        else:
+            self.datapp.append(np.zeros_like(time))
+            self.datap_std.append(np.zeros_like(time))
 
         self.time = time
 
+
     def fit_model(self):
         if self.model_type == 'logistic':
             self.biomass_model = self.logistic
@@ -114,811 +165,770 @@ class BioprocessModel:
         elif self.model_type == 'moser':
             self.biomass_model = self.moser
             self.biomass_diff = self.moser_diff
+        else:
+            raise ValueError(f"Tipo de modelo desconocido: {self.model_type}")
 
-    def fit_biomass(self, time, biomass):
-        try:
-            if self.model_type == 'logistic':
-                p0 = [min(biomass), max(biomass)*1.5 if max(biomass)>0 else 1.0, 0.1]
-                popt, _ = curve_fit(self.logistic, time, biomass, p0=p0, maxfev=self.maxfev)
-                self.params['biomass'] = {'xo': popt[0], 'xm': popt[1], 'um': popt[2]}
-                y_pred = self.logistic(time, *popt)
-            elif self.model_type == 'gompertz':
-                p0 = [max(biomass) if max(biomass)>0 else 1.0, 0.1, time[np.argmax(np.gradient(biomass))]]
-                popt, _ = curve_fit(self.gompertz, time, biomass, p0=p0, maxfev=self.maxfev)
-                self.params['biomass'] = {'xm': popt[0], 'um': popt[1], 'lag': popt[2]}
-                y_pred = self.gompertz(time, *popt)
-            elif self.model_type == 'moser':
-                p0 = [max(biomass) if max(biomass)>0 else 1.0, 0.1, min(time)]
-                popt, _ = curve_fit(self.moser, time, biomass, p0=p0, maxfev=self.maxfev)
-                self.params['biomass'] = {'Xm': popt[0], 'um': popt[1], 'Ks': popt[2]}
-                y_pred = self.moser(time, *popt)
 
-            self.r2['biomass'] = 1 - (np.sum((biomass - y_pred) ** 2) / np.sum((biomass - np.mean(biomass)) ** 2))
+    def fit_biomass(self, time, biomass, bounds=None):
+        # ### MODIFICADO ###: Acepta bounds
+        p0 = None
+        fit_func = None
+        param_names = []
+
+        if self.model_type == 'logistic':
+            p0 = [max(1e-6,min(biomass)), max(biomass)*1.5 if max(biomass)>0 else 1.0, 0.1]
+            fit_func = self.logistic
+            param_names = ['xo', 'xm', 'um']
+        elif self.model_type == 'gompertz':
+            # Estimación de lag: tiempo hasta alcanzar ~10% de Xmax o donde la pendiente es máxima
+            grad_b = np.gradient(biomass)
+            lag_guess = time[np.argmax(grad_b)] if len(time) > 1 and np.any(grad_b > 1e-3) else time[0]
+            p0 = [max(biomass) if max(biomass)>0 else 1.0, 0.1, lag_guess]
+            fit_func = self.gompertz
+            param_names = ['xm', 'um', 'lag']
+        elif self.model_type == 'moser':
+            p0 = [max(biomass) if max(biomass)>0 else 1.0, 0.1, time[0]] # Ks como tiempo inicial
+            fit_func = self.moser
+            param_names = ['Xm', 'um', 'Ks']
+        
+        if fit_func is None:
+            print(f"Modelo de biomasa no configurado para {self.model_type}")
+            return None
+            
+        try:
+            # Asegurar que p0 esté dentro de los bounds si se proveen
+            if bounds:
+                p0_bounded = []
+                for i, val in enumerate(p0):
+                    low = bounds[0][i] if bounds[0] and i < len(bounds[0]) else -np.inf
+                    high = bounds[1][i] if bounds[1] and i < len(bounds[1]) else np.inf
+                    p0_bounded.append(np.clip(val, low, high))
+                p0 = p0_bounded
+            
+            popt, _ = curve_fit(fit_func, time, biomass, p0=p0, maxfev=self.maxfev, bounds=bounds or (-np.inf, np.inf))
+            self.params['biomass'] = dict(zip(param_names, popt))
+            y_pred = fit_func(time, *popt)
+
+            # Evitar R2 nan o inf si biomasa es constante
+            if np.sum((biomass - np.mean(biomass)) ** 2) < 1e-9: # Si la varianza es casi cero
+                 self.r2['biomass'] = 1.0 if np.sum((biomass - y_pred) ** 2) < 1e-9 else 0.0
+            else:
+                self.r2['biomass'] = 1 - (np.sum((biomass - y_pred) ** 2) / np.sum((biomass - np.mean(biomass)) ** 2))
             self.rmse['biomass'] = np.sqrt(mean_squared_error(biomass, y_pred))
             return y_pred
         except Exception as e:
             print(f"Error en fit_biomass_{self.model_type}: {e}")
+            self.params['biomass'] = {} # Evitar errores posteriores
             return None
 
-    def fit_substrate(self, time, substrate, biomass_params):
-        try:
-            if self.model_type == 'logistic':
-                p0 = [min(substrate), 0.01, 0.01]
-                popt, _ = curve_fit(
-                    lambda t, so, p, q: self.substrate(t, so, p, q, [biomass_params['xo'], biomass_params['xm'], biomass_params['um']]),
-                    time, substrate, p0=p0, maxfev=self.maxfev
-                )
-                self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
-                y_pred = self.substrate(time, *popt, [biomass_params['xo'], biomass_params['xm'], biomass_params['um']])
-            elif self.model_type == 'gompertz':
-                p0 = [min(substrate), 0.01, 0.01]
-                popt, _ = curve_fit(
-                    lambda t, so, p, q: self.substrate(t, so, p, q, [biomass_params['xm'], biomass_params['um'], biomass_params['lag']]),
-                    time, substrate, p0=p0, maxfev=self.maxfev
-                )
-                self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
-                y_pred = self.substrate(time, *popt, [biomass_params['xm'], biomass_params['um'], biomass_params['lag']])
-            elif self.model_type == 'moser':
-                p0 = [min(substrate), 0.01, 0.01]
-                popt, _ = curve_fit(
-                    lambda t, so, p, q: self.substrate(t, so, p, q, [biomass_params['Xm'], biomass_params['um'], biomass_params['Ks']]),
-                    time, substrate, p0=p0, maxfev=self.maxfev
-                )
-                self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
-                y_pred = self.substrate(time, *popt, [biomass_params['Xm'], biomass_params['um'], biomass_params['Ks']])
-            self.r2['substrate'] = 1 - (np.sum((substrate - y_pred) ** 2) / np.sum((substrate - np.mean(substrate)) ** 2))
-            self.rmse['substrate'] = np.sqrt(mean_squared_error(substrate, y_pred))
-            return y_pred
-        except Exception as e:
-            print(f"Error en fit_substrate_{self.model_type}: {e}")
+    def _fit_consumption_production(self, time, data, fit_type, p0_values, param_names):
+        # ### NUEVO ### (Helper interno para sustrato y producto)
+        biomass_params_list = self._get_biomass_model_params_as_list()
+        if biomass_params_list is None:
+            print(f"Parámetros de biomasa no disponibles para ajustar {fit_type}.")
             return None
 
-    def fit_product(self, time, product, biomass_params):
+        model_func = self.substrate if fit_type == 'substrate' else self.product
+
         try:
-            if self.model_type == 'logistic':
-                p0 = [min(product), 0.01, 0.01]
-                popt, _ = curve_fit(
-                    lambda t, po, alpha, beta: self.product(t, po, alpha, beta, [biomass_params['xo'], biomass_params['xm'], biomass_params['um']]),
-                    time, product, p0=p0, maxfev=self.maxfev
-                )
-                self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
-                y_pred = self.product(time, *popt, [biomass_params['xo'], biomass_params['xm'], biomass_params['um']])
-            elif self.model_type == 'gompertz':
-                p0 = [min(product), 0.01, 0.01]
-                popt, _ = curve_fit(
-                    lambda t, po, alpha, beta: self.product(t, po, alpha, beta, [biomass_params['xm'], biomass_params['um'], biomass_params['lag']]),
-                    time, product, p0=p0, maxfev=self.maxfev
-                )
-                self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
-                y_pred = self.product(time, *popt, [biomass_params['xm'], biomass_params['um'], biomass_params['lag']])
-            elif self.model_type == 'moser':
-                p0 = [min(product), 0.01, 0.01]
-                popt, _ = curve_fit(
-                    lambda t, po, alpha, beta: self.product(t, po, alpha, beta, [biomass_params['Xm'], biomass_params['um'], biomass_params['Ks']]),
-                    time, product, p0=p0, maxfev=self.maxfev
-                )
-                self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
-                y_pred = self.product(time, *popt, [biomass_params['Xm'], biomass_params['um'], biomass_params['Ks']])
-            self.r2['product'] = 1 - (np.sum((product - y_pred) ** 2) / np.sum((product - np.mean(product)) ** 2))
-            self.rmse['product'] = np.sqrt(mean_squared_error(product, y_pred))
+            popt, _ = curve_fit(
+                lambda t, *params_fit: model_func(t, *params_fit, biomass_params_list),
+                time, data, p0=p0_values, maxfev=self.maxfev
+            )
+            self.params[fit_type] = dict(zip(param_names, popt))
+            y_pred = model_func(time, *popt, biomass_params_list)
+
+            if np.sum((data - np.mean(data)) ** 2) < 1e-9: # Si la varianza es casi cero
+                 self.r2[fit_type] = 1.0 if np.sum((data - y_pred) ** 2) < 1e-9 else 0.0
+            else:
+                self.r2[fit_type] = 1 - (np.sum((data - y_pred) ** 2) / np.sum((data - np.mean(data)) ** 2))
+            self.rmse[fit_type] = np.sqrt(mean_squared_error(data, y_pred))
             return y_pred
         except Exception as e:
-            print(f"Error en fit_product_{self.model_type}: {e}")
+            print(f"Error en fit_{fit_type}_{self.model_type}: {e}")
+            self.params[fit_type] = {}
             return None
 
+    def fit_substrate(self, time, substrate):
+        # ### MODIFICADO ###: Usa helper
+        p0 = [max(1e-6, min(substrate)) if len(substrate)>0 else 1.0, 0.01, 0.01] # so, p, q
+        param_names = ['so', 'p', 'q']
+        return self._fit_consumption_production(time, substrate, 'substrate', p0, param_names)
+
+    def fit_product(self, time, product):
+        # ### MODIFICADO ###: Usa helper
+        p0 = [max(1e-6, min(product)) if len(product)>0 else 0.0, 0.01, 0.01] # po, alpha, beta
+        param_names = ['po', 'alpha', 'beta']
+        return self._fit_consumption_production(time, product, 'product', p0, param_names)
+
+
     def generate_fine_time_grid(self, time):
+        if len(time) < 2: return time # Evitar error si time no es suficiente
         time_fine = np.linspace(time.min(), time.max(), 500)
         return time_fine
 
-    def system(self, y, t, biomass_params, substrate_params, product_params, model_type):
+    def system(self, y, t, biomass_params_list, substrate_params_dict, product_params_dict):
+        # ### MODIFICADO ### para mayor claridad
         X, S, P = y
 
-        if model_type == 'logistic':
-            dXdt = self.logistic_diff(X, t, biomass_params)
-        elif model_type == 'gompertz':
-            dXdt = self.gompertz_diff(X, t, biomass_params)
-        elif model_type == 'moser':
-            dXdt = self.moser_diff(X, t, biomass_params)
+        if self.model_type == 'logistic':
+            dXdt = self.logistic_diff(X, t, biomass_params_list)
+        elif self.model_type == 'gompertz':
+            dXdt = self.gompertz_diff(X, t, biomass_params_list)
+        elif self.model_type == 'moser':
+            dXdt = self.moser_diff(X, t, biomass_params_list)
         else:
-            dXdt = 0.0
-
-        so, p, q = substrate_params
-        po, alpha, beta = product_params
+            dXdt = 0.0 # Fallback, debería lanzar error o ser manejado
+        
+        # Usar .get con default para evitar KeyError si los params no están ajustados
+        p = substrate_params_dict.get('p', 0)
+        q = substrate_params_dict.get('q', 0)
+        alpha = product_params_dict.get('alpha', 0)
+        beta = product_params_dict.get('beta', 0)
 
         dSdt = -p * dXdt - q * X
         dPdt = alpha * dXdt + beta * X
         return [dXdt, dSdt, dPdt]
 
     def get_initial_conditions(self, time, biomass, substrate, product):
-        if 'biomass' in self.params:
+        X0, S0, P0 = biomass[0], substrate[0], product[0] # Default a los primeros datos
+
+        if 'biomass' in self.params and self.params['biomass']:
             if self.model_type == 'logistic':
-                xo = self.params['biomass']['xo']
-                X0 = xo
+                X0 = self.params['biomass']['xo']
             elif self.model_type == 'gompertz':
-                xm = self.params['biomass']['xm']
-                um = self.params['biomass']['um']
-                lag = self.params['biomass']['lag']
-                X0 = xm * np.exp(-np.exp((um * np.e / xm)*(lag - 0)+1))
+                # Gompertz en t=0
+                xm, um, lag = self.params['biomass']['xm'], self.params['biomass']['um'], self.params['biomass']['lag']
+                X0 = xm * np.exp(-np.exp((um * np.e / xm)*(lag - time.min())+1)) # Usar time.min()
             elif self.model_type == 'moser':
-                Xm = self.params['biomass']['Xm']
-                um = self.params['biomass']['um']
-                Ks = self.params['biomass']['Ks']
-                X0 = Xm*(1 - np.exp(-um*(0 - Ks)))
-        else:
-            X0 = biomass[0]
-
-        if 'substrate' in self.params:
-            so = self.params['substrate']['so']
-            S0 = so
-        else:
-            S0 = substrate[0]
-
-        if 'product' in self.params:
-            po = self.params['product']['po']
-            P0 = po
-        else:
-            P0 = product[0]
+                Xm, um, Ks = self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['Ks']
+                X0 = Xm*(1 - np.exp(-um*(time.min() - Ks))) # Usar time.min()
+        
+        if 'substrate' in self.params and self.params['substrate']:
+            S0 = self.params['substrate']['so']
+        
+        if 'product' in self.params and self.params['product']:
+            P0 = self.params['product']['po']
 
         return [X0, S0, P0]
 
+
     def solve_differential_equations(self, time, biomass, substrate, product):
-        if 'biomass' not in self.params or not self.params['biomass']:
+        biomass_params_list = self._get_biomass_model_params_as_list()
+        if biomass_params_list is None:
             print("No hay parámetros de biomasa, no se pueden resolver las EDO.")
             return None, None, None, time
 
-        if self.model_type == 'logistic':
-            biomass_params = [self.params['biomass']['xo'], self.params['biomass']['xm'], self.params['biomass']['um']]
-        elif self.model_type == 'gompertz':
-            biomass_params = [self.params['biomass']['xm'], self.params['biomass']['um'], self.params['biomass']['lag']]
-        elif self.model_type == 'moser':
-            biomass_params = [self.params['biomass']['Xm'], self.params['biomass']['um'], self.params['biomass']['Ks']]
-        else:
-            biomass_params = [0,0,0]
-
-        if 'substrate' in self.params:
-            substrate_params = [self.params['substrate']['so'], self.params['substrate']['p'], self.params['substrate']['q']]
-        else:
-            substrate_params = [0,0,0]
-
-        if 'product' in self.params:
-            product_params = [self.params['product']['po'], self.params['product']['alpha'], self.params['product']['beta']]
-        else:
-            product_params = [0,0,0]
-
+        # Usar .get con default para evitar KeyError si no se ajustaron
+        substrate_params_dict = self.params.get('substrate', {})
+        product_params_dict = self.params.get('product', {})
+        
         initial_conditions = self.get_initial_conditions(time, biomass, substrate, product)
         time_fine = self.generate_fine_time_grid(time)
-        sol = odeint(self.system, initial_conditions, time_fine,
-                     args=(biomass_params, substrate_params, product_params, self.model_type))
-
-        X = sol[:, 0]
-        S = sol[:, 1]
-        P = sol[:, 2]
+        
+        try:
+            sol = odeint(self.system, initial_conditions, time_fine,
+                         args=(biomass_params_list, substrate_params_dict, product_params_dict))
+            X, S, P = sol[:, 0], sol[:, 1], sol[:, 2]
+            return X, S, P, time_fine
+        except Exception as e:
+            print(f"Error al resolver EDOs: {e}")
+            return None, None, None, time_fine
 
-        return X, S, P, time_fine
 
     def plot_results(self, time, biomass, substrate, product,
                      y_pred_biomass, y_pred_substrate, y_pred_product,
                      biomass_std=None, substrate_std=None, product_std=None,
                      experiment_name='', legend_position='best', params_position='upper right',
-                     show_legend=True, show_params=True,
-                     style='whitegrid',
+                     show_legend=True, show_params=True, style='whitegrid',
                      line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
-                     use_differential=False):
+                     use_differential=False,
+                     # ### NUEVO ###: Parámetros para unidades
+                     time_unit='', biomass_unit='', substrate_unit='', product_unit=''):
 
-        if y_pred_biomass is None:
-            print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type}. Omitiendo figura.")
+        if y_pred_biomass is None and not use_differential: # Si no hay ajuste y no se usan EDOs
+            print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type} y no se usan EDOs. Omitiendo figura.")
             return None
 
         sns.set_style(style)
-
-        if use_differential and 'biomass' in self.params and self.params['biomass']:
-            X, S, P, time_to_plot = self.solve_differential_equations(time, biomass, substrate, product)
-            if X is not None:
-                y_pred_biomass, y_pred_substrate, y_pred_product = X, S, P
-            else:
-                time_to_plot = time
-        else:
-            time_to_plot = time
-
+        time_to_plot = time # Por defecto
+
+        if use_differential:
+            # Forzar la resolución de EDOs aquí si se quiere usar para graficar siempre
+            # aunque no haya ajuste previo de sustrato/producto.
+            # Los parámetros para sustrato/producto podrían ser cero si no se ajustaron.
+            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
+            else: # Fallback si EDOs fallan
+                print(f"Fallo al resolver EDOs para {experiment_name}, usando ajustes si existen.")
+                if y_pred_biomass is None: return None # No hay nada que graficar
+        
         fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15))
-        fig.suptitle(f'{experiment_name}', fontsize=16)
-
-        plots = [
-            (ax1, biomass, y_pred_biomass, biomass_std, 'Biomasa', 'Modelo', self.params.get('biomass', {}),
-             self.r2.get('biomass', np.nan), self.rmse.get('biomass', np.nan)),
-            (ax2, substrate, y_pred_substrate, substrate_std, 'Sustrato', 'Modelo', self.params.get('substrate', {}),
-             self.r2.get('substrate', np.nan), self.rmse.get('substrate', np.nan)),
-            (ax3, product, y_pred_product, product_std, 'Producto', 'Modelo', self.params.get('product', {}),
-             self.r2.get('product', np.nan), self.rmse.get('product', np.nan))
+        fig.suptitle(f'{experiment_name} (Modelo: {self.model_type.capitalize()})', fontsize=16)
+
+        # ### MODIFICADO ###: Construcción de etiquetas de ejes con unidades
+        xlabel_full = f'{LABEL_TIME} ({time_unit})' if time_unit else LABEL_TIME
+        ylabel_biomass_full = f'{LABEL_BIOMASS} ({biomass_unit})' if biomass_unit else LABEL_BIOMASS
+        ylabel_substrate_full = f'{LABEL_SUBSTRATE} ({substrate_unit})' if substrate_unit else LABEL_SUBSTRATE
+        ylabel_product_full = f'{LABEL_PRODUCT} ({product_unit})' if product_unit else LABEL_PRODUCT
+        
+        plots_config = [
+            (ax1, biomass, y_pred_biomass, biomass_std, ylabel_biomass_full, 'biomass'),
+            (ax2, substrate, y_pred_substrate, substrate_std, ylabel_substrate_full, 'substrate'),
+            (ax3, product, y_pred_product, product_std, ylabel_product_full, 'product')
         ]
 
-        for idx, (ax, data, y_pred, data_std, ylabel, model_name, params, r2, rmse) in enumerate(plots):
-            if data_std is not None:
+        for ax, data, y_pred, data_std, ylabel, param_key in plots_config:
+            if data_std is not None and len(data_std) == len(time):
                 ax.errorbar(time, data, yerr=data_std, fmt=marker_style, color=point_color,
                             label='Datos experimentales', capsize=5)
             else:
                 ax.plot(time, data, marker=marker_style, linestyle='', color=point_color,
                         label='Datos experimentales')
 
-            if y_pred is not None:
-                ax.plot(time_to_plot, y_pred, linestyle=line_style, color=line_color, label=model_name)
+            if y_pred is not None and len(y_pred) == len(time_to_plot):
+                ax.plot(time_to_plot, y_pred, linestyle=line_style, color=line_color, label='Modelo')
 
-            ax.set_xlabel('Tiempo')
+            ax.set_xlabel(xlabel_full) # ### MODIFICADO ###
             ax.set_ylabel(ylabel)
             if show_legend:
                 ax.legend(loc=legend_position)
-            ax.set_title(f'{ylabel}')
-
-            if show_params and params and all(np.isfinite(list(map(float, params.values())))):
-                param_text = '\n'.join([f"{k} = {v:.3f}" for k, v in params.items()])
-                text = f"{param_text}\nR² = {r2:.3f}\nRMSE = {rmse:.3f}"
-                if params_position == 'outside right':
-                    bbox_props = dict(boxstyle='round', facecolor='white', alpha=0.5)
+            ax.set_title(f'{ylabel.split(" (")[0]}') # Título sin unidad
+
+            current_params = self.params.get(param_key, {})
+            r2 = self.r2.get(param_key, np.nan)
+            rmse = self.rmse.get(param_key, np.nan)
+
+            if show_params and current_params: # Solo mostrar si hay params
+                # Filtrar NaNs o Infs de los parámetros para el texto
+                valid_params = {k: v for k, v in current_params.items() if np.isfinite(v)}
+                param_text = '\n'.join([f"{k} = {v:.3g}" for k, v in valid_params.items()]) # Usar .3g para mejor formato
+                text = f"{param_text}\nR² = {r2:.3f}\nRMSE = {rmse:.3g}"
+                
+                # Lógica de posición del texto (simplificada de tu código original)
+                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')
+                if params_position == 'outside right': # Manejo especial para outside right
+                    fig.subplots_adjust(right=0.75) # Hacer espacio
                     ax.annotate(text, xy=(1.05, 0.5), xycoords='axes fraction',
-                                verticalalignment='center', bbox=bbox_props)
+                                verticalalignment='center', bbox=dict(boxstyle='round', facecolor='white', alpha=0.7))
                 else:
-                    if params_position in ['upper right', 'lower right']:
-                        text_x = 0.95
-                        ha = 'right'
-                    else:
-                        text_x = 0.05
-                        ha = 'left'
-
-                    if params_position in ['upper right', 'upper left']:
-                        text_y = 0.95
-                        va = 'top'
-                    else:
-                        text_y = 0.05
-                        va = 'bottom'
-
                     ax.text(text_x, text_y, text, transform=ax.transAxes,
-                            verticalalignment=va, horizontalalignment=ha,
-                            bbox={'boxstyle': 'round', 'facecolor':'white', 'alpha':0.5})
+                        verticalalignment=va, horizontalalignment=ha,
+                        bbox={'boxstyle': 'round', 'facecolor':'white', 'alpha':0.7})
 
-        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
 
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+        
         buf = io.BytesIO()
         fig.savefig(buf, format='png')
         buf.seek(0)
         image = Image.open(buf).convert("RGB")
         plt.close(fig)
-
         return image
 
+
     def plot_combined_results(self, time, biomass, substrate, product,
                               y_pred_biomass, y_pred_substrate, y_pred_product,
                               biomass_std=None, substrate_std=None, product_std=None,
                               experiment_name='', legend_position='best', params_position='upper right',
-                              show_legend=True, show_params=True,
-                              style='whitegrid',
+                              show_legend=True, show_params=True, style='whitegrid',
                               line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
-                              use_differential=False):
-
-        if y_pred_biomass is None:
-            print(f"No se pudo ajustar biomasa para {experiment_name} con {self.model_type}. Omitiendo figura.")
+                              use_differential=False,
+                              # ### NUEVO ###: Parámetros para unidades
+                              time_unit='', biomass_unit='', substrate_unit='', product_unit=''):
+        
+        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 EDOs. Omitiendo figura combinada.")
             return None
 
         sns.set_style(style)
+        time_to_plot = time
 
-        if use_differential and 'biomass' in self.params and self.params['biomass']:
-            X, S, P, time_to_plot = self.solve_differential_equations(time, biomass, substrate, product)
-            if X is not None:
-                y_pred_biomass, y_pred_substrate, y_pred_product = X, S, P
+        if use_differential:
+            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
             else:
-                time_to_plot = time
-        else:
-            time_to_plot = time
+                print(f"Fallo al resolver EDOs para {experiment_name} (combinado), usando ajustes si existen.")
+                if y_pred_biomass is None: return None
 
-        fig, ax1 = plt.subplots(figsize=(10, 7))
-        fig.suptitle(f'{experiment_name}', fontsize=16)
+        fig, ax1 = plt.subplots(figsize=(12, 7)) # Ajustar tamaño para acomodar leyenda de params si es 'outside right'
+        fig.suptitle(f'{experiment_name} (Modelo: {self.model_type.capitalize()})', fontsize=16)
+
+        # ### MODIFICADO ###: Construcción de etiquetas de ejes con unidades
+        xlabel_full = f'{LABEL_TIME} ({time_unit})' if time_unit else LABEL_TIME
+        ylabel_biomass_full = f'{LABEL_BIOMASS} ({biomass_unit})' if biomass_unit else LABEL_BIOMASS
+        ylabel_substrate_full = f'{LABEL_SUBSTRATE} ({substrate_unit})' if substrate_unit else LABEL_SUBSTRATE
+        ylabel_product_full = f'{LABEL_PRODUCT} ({product_unit})' if product_unit else LABEL_PRODUCT
 
         colors = {'Biomasa': 'blue', 'Sustrato': 'green', 'Producto': 'red'}
 
-        ax1.set_xlabel('Tiempo')
-        ax1.set_ylabel('Biomasa', color=colors['Biomasa'])
-        if biomass_std is not None:
+        # Biomasa (ax1)
+        ax1.set_xlabel(xlabel_full)
+        ax1.set_ylabel(ylabel_biomass_full, color=colors['Biomasa'])
+        if biomass_std is not None and len(biomass_std) == len(time):
             ax1.errorbar(time, biomass, yerr=biomass_std, fmt=marker_style, color=colors['Biomasa'],
-                         label='Biomasa (Datos)', capsize=5)
+                         label=f'{LABEL_BIOMASS} (Datos)', capsize=5)
         else:
             ax1.plot(time, biomass, marker=marker_style, linestyle='', color=colors['Biomasa'],
-                     label='Biomasa (Datos)')
-        ax1.plot(time_to_plot, y_pred_biomass, linestyle=line_style, color=colors['Biomasa'],
-                 label='Biomasa (Modelo)')
+                     label=f'{LABEL_BIOMASS} (Datos)')
+        if y_pred_biomass is not None and len(y_pred_biomass) == len(time_to_plot):
+            ax1.plot(time_to_plot, y_pred_biomass, linestyle=line_style, color=colors['Biomasa'],
+                     label=f'{LABEL_BIOMASS} (Modelo)')
         ax1.tick_params(axis='y', labelcolor=colors['Biomasa'])
 
+        # Sustrato (ax2)
         ax2 = ax1.twinx()
-        ax2.set_ylabel('Sustrato', color=colors['Sustrato'])
-        if substrate_std is not None:
-            ax2.errorbar(time, substrate, yerr=substrate_std, fmt=marker_style, color=colors['Sustrato'],
-                         label='Sustrato (Datos)', capsize=5)
-        else:
-            ax2.plot(time, substrate, marker=marker_style, linestyle='', color=colors['Sustrato'],
-                     label='Sustrato (Datos)')
-        if y_pred_substrate is not None:
+        ax2.set_ylabel(ylabel_substrate_full, color=colors['Sustrato'])
+        if substrate is not None: # Solo graficar si hay datos de sustrato
+            if substrate_std is not None and len(substrate_std) == len(time):
+                ax2.errorbar(time, substrate, yerr=substrate_std, fmt=marker_style, color=colors['Sustrato'],
+                             label=f'{LABEL_SUBSTRATE} (Datos)', capsize=5)
+            else:
+                ax2.plot(time, substrate, marker=marker_style, linestyle='', color=colors['Sustrato'],
+                         label=f'{LABEL_SUBSTRATE} (Datos)')
+        if y_pred_substrate is not None and len(y_pred_substrate) == len(time_to_plot):
             ax2.plot(time_to_plot, y_pred_substrate, linestyle=line_style, color=colors['Sustrato'],
-                     label='Sustrato (Modelo)')
+                     label=f'{LABEL_SUBSTRATE} (Modelo)')
         ax2.tick_params(axis='y', labelcolor=colors['Sustrato'])
 
+        # Producto (ax3)
         ax3 = ax1.twinx()
-        ax3.spines["right"].set_position(("axes", 1.2))
+        ax3.spines["right"].set_position(("axes", 1.15)) # Ajustar posición para que no se solape con ax2
         ax3.set_frame_on(True)
         ax3.patch.set_visible(False)
-        for sp in ax3.spines.values():
-            sp.set_visible(True)
-
-        ax3.set_ylabel('Producto', color=colors['Producto'])
-        if product_std is not None:
-            ax3.errorbar(time, product, yerr=product_std, fmt=marker_style, color=colors['Producto'],
-                         label='Producto (Datos)', capsize=5)
-        else:
-            ax3.plot(time, product, marker=marker_style, linestyle='', color=colors['Producto'],
-                     label='Producto (Datos)')
-        if y_pred_product is not None:
+        
+        ax3.set_ylabel(ylabel_product_full, color=colors['Producto'])
+        if product is not None: # Solo graficar si hay datos de producto
+            if product_std is not None and len(product_std) == len(time):
+                ax3.errorbar(time, product, yerr=product_std, fmt=marker_style, color=colors['Producto'],
+                             label=f'{LABEL_PRODUCT} (Datos)', capsize=5)
+            else:
+                ax3.plot(time, product, marker=marker_style, linestyle='', color=colors['Producto'],
+                         label=f'{LABEL_PRODUCT} (Datos)')
+        if y_pred_product is not None and len(y_pred_product) == len(time_to_plot):
             ax3.plot(time_to_plot, y_pred_product, linestyle=line_style, color=colors['Producto'],
-                     label='Producto (Modelo)')
+                     label=f'{LABEL_PRODUCT} (Modelo)')
         ax3.tick_params(axis='y', labelcolor=colors['Producto'])
 
-        lines_labels = [ax.get_legend_handles_labels() for ax in [ax1, ax2, ax3]]
-        lines, labels = [sum(lol, []) for lol in zip(*lines_labels)]
+        # Leyenda combinada
         if show_legend:
-            ax1.legend(lines, labels, loc=legend_position)
+            handles, labels = [], []
+            for ax in [ax1, ax2, ax3]:
+                h, l = ax.get_legend_handles_labels()
+                handles.extend(h)
+                labels.extend(l)
+            # Evitar duplicados en leyenda si los hay
+            unique_labels = {}
+            for h, l in zip(handles, labels):
+                if l not in unique_labels:
+                    unique_labels[l] = h
+            ax1.legend(unique_labels.values(), unique_labels.keys(), loc=legend_position)
+
 
         if show_params:
-            param_text_biomass = ''
-            if 'biomass' in self.params:
-                param_text_biomass = '\n'.join([f"{k} = {v:.3f}" for k, v in self.params['biomass'].items()])
-            text_biomass = f"Biomasa:\n{param_text_biomass}\nR² = {self.r2.get('biomass', np.nan):.3f}\nRMSE = {self.rmse.get('biomass', np.nan):.3f}"
-
-            param_text_substrate = ''
-            if 'substrate' in self.params:
-                param_text_substrate = '\n'.join([f"{k} = {v:.3f}" for k, v in self.params['substrate'].items()])
-            text_substrate = f"Sustrato:\n{param_text_substrate}\nR² = {self.r2.get('substrate', np.nan):.3f}\nRMSE = {self.rmse.get('substrate', np.nan):.3f}"
-
-            param_text_product = ''
-            if 'product' in self.params:
-                param_text_product = '\n'.join([f"{k} = {v:.3f}" for k, v in self.params['product'].items()])
-            text_product = f"Producto:\n{param_text_product}\nR² = {self.r2.get('product', np.nan):.3f}\nRMSE = {self.rmse.get('product', np.nan):.3f}"
-
-            total_text = f"{text_biomass}\n\n{text_substrate}\n\n{text_product}"
-
-            if params_position == 'outside right':
-                bbox_props = dict(boxstyle='round', facecolor='white', alpha=0.5)
-                ax3.annotate(total_text, xy=(1.2, 0.5), xycoords='axes fraction',
-                             verticalalignment='center', bbox=bbox_props)
-            else:
-                if params_position in ['upper right', 'lower right']:
-                    text_x = 0.95
-                    ha = 'right'
-                else:
-                    text_x = 0.05
-                    ha = 'left'
+            texts = []
+            for param_key, param_label in [('biomass', LABEL_BIOMASS), ('substrate', LABEL_SUBSTRATE), ('product', LABEL_PRODUCT)]:
+                current_params = self.params.get(param_key, {})
+                r2 = self.r2.get(param_key, np.nan)
+                rmse = self.rmse.get(param_key, np.nan)
+                if current_params: # Solo agregar si hay params
+                    valid_params = {k: v for k, v in current_params.items() if np.isfinite(v)}
+                    param_text_ind = '\n'.join([f"{k} = {v:.3g}" for k, v in valid_params.items()])
+                    texts.append(f"{param_label}:\n{param_text_ind}\nR² = {r2:.3f}\nRMSE = {rmse:.3g}")
+            
+            total_text = "\n\n".join(texts)
+
+            if total_text: # Solo mostrar si hay algo que poner
+                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')
 
-                if params_position in ['upper right', 'upper left']:
-                    text_y = 0.95
-                    va = 'top'
+                if params_position == 'outside right':
+                    fig.subplots_adjust(right=0.70) # Ajustar para hacer espacio al texto
+                    # Usar ax3 para anotar fuera, ya que es el más a la derecha
+                    ax3.annotate(total_text, xy=(1.25, 0.5), xycoords='axes fraction', # Aumentar xy[0]
+                                 fontsize=8, # Reducir un poco la fuente para que quepa mejor
+                                 verticalalignment='center', bbox=dict(boxstyle='round', facecolor='white', alpha=0.7))
                 else:
-                    text_y = 0.05
-                    va = 'bottom'
-
-                ax1.text(text_x, text_y, total_text, transform=ax1.transAxes,
-                         verticalalignment=va, horizontalalignment=ha,
-                         bbox={'boxstyle':'round', 'facecolor':'white', 'alpha':0.5})
-
-        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+                    ax1.text(text_x, text_y, total_text, transform=ax1.transAxes,
+                             fontsize=8,
+                             verticalalignment=va, horizontalalignment=ha,
+                             bbox={'boxstyle':'round', 'facecolor':'white', 'alpha':0.7})
 
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95]) # Ajustar rect si es necesario
+        
         buf = io.BytesIO()
         fig.savefig(buf, format='png')
         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, experiment_names, lower_bounds, upper_bounds,
-                     mode='independent', style='whitegrid', line_color='#0000FF', point_color='#000000',
-                     line_style='-', marker_style='o', show_legend=True, show_params=True, use_differential=False, maxfev_val=50000):
+
+# ### NUEVO ###: Helper function para `process_all_data`
+def _process_and_plot_single_experiment(
+    time_exp, biomass, substrate, product, biomass_std, substrate_std, product_std,
+    experiment_name, model_type_str, maxfev_val,
+    legend_position, params_position, show_legend, show_params,
+    style, line_color, point_color, line_style, marker_style,
+    use_differential, plot_mode, bounds_biomass,
+    # Unidades
+    time_unit, biomass_unit, substrate_unit, product_unit):
+
+    model = BioprocessModel(model_type=model_type_str, maxfev=maxfev_val)
+    model.fit_model() # Prepara las funciones del modelo
+
+    y_pred_biomass = model.fit_biomass(time_exp, biomass, bounds=bounds_biomass)
+    
+    current_comparison_data = {
+        'Experimento': experiment_name,
+        'Modelo': model_type_str.capitalize(),
+        'R² Biomasa': np.nan, 'RMSE Biomasa': np.nan,
+        'R² Sustrato': np.nan, 'RMSE Sustrato': np.nan,
+        'R² Producto': np.nan, 'RMSE Producto': np.nan
+    }
+
+    y_pred_substrate, y_pred_product = None, None
+    if y_pred_biomass is not None and 'biomass' in model.params and model.params['biomass']:
+        current_comparison_data.update({
+            'R² Biomasa': model.r2.get('biomass', np.nan),
+            'RMSE Biomasa': model.rmse.get('biomass', np.nan)
+        })
+        if substrate is not None and len(substrate) > 0:
+            y_pred_substrate = model.fit_substrate(time_exp, substrate)
+            if y_pred_substrate is not None:
+                 current_comparison_data.update({
+                    'R² Sustrato': model.r2.get('substrate', np.nan),
+                    'RMSE Sustrato': model.rmse.get('substrate', np.nan)
+                })
+        if product is not None and len(product) > 0:
+            y_pred_product = model.fit_product(time_exp, product)
+            if y_pred_product is not None:
+                current_comparison_data.update({
+                    'R² Producto': model.r2.get('product', np.nan),
+                    'RMSE Producto': model.rmse.get('product', np.nan)
+                })
+    else: # Falló el ajuste de biomasa
+        print(f"No se pudo ajustar biomasa para {experiment_name} con {model_type_str}. No se ajustará sustrato/producto.")
+        # Los NaNs ya están en current_comparison_data
+
+    fig = None
+    plot_args = (time_exp, biomass, substrate, product,
+                 y_pred_biomass, y_pred_substrate, y_pred_product,
+                 biomass_std, substrate_std, product_std,
+                 experiment_name, legend_position, params_position,
+                 show_legend, show_params, style,
+                 line_color, point_color, line_style, marker_style,
+                 use_differential,
+                 time_unit, biomass_unit, substrate_unit, product_unit) # Pasar unidades
+
+    if plot_mode == 'combinado':
+        fig = model.plot_combined_results(*plot_args)
+    else: # 'independent' o 'average' (que usan plot_results)
+        fig = model.plot_results(*plot_args)
+    
+    return fig, current_comparison_data
+
+
+def process_all_data(file, legend_position, params_position, model_types_selected, analysis_mode, experiment_names,
+                     # ### MODIFICADO ###: bounds ahora son específicos
+                     lower_bounds_biomass_str, upper_bounds_biomass_str,
+                     style_plot, line_color_plot, point_color_plot, line_style_plot, marker_style_plot,
+                     show_legend_plot, show_params_plot, use_differential_eqs, maxfev_val,
+                     # ### NUEVO ###: Unidades para ejes
+                     time_unit_str, biomass_unit_str, substrate_unit_str, product_unit_str):
+
+    if file is None:
+        return [], pd.DataFrame(), "Por favor, sube un archivo Excel."
 
     try:
         xls = pd.ExcelFile(file.name)
     except Exception as e:
-        print(f"Error al leer el archivo Excel: {e}")
-        return [], pd.DataFrame()
+        return [], pd.DataFrame(), f"Error al leer el archivo Excel: {e}"
 
     sheet_names = xls.sheet_names
-    figures = []
-    comparison_data = []
-    experiment_counter = 0
+    figures_list = []
+    comparison_data_list = []
+    experiment_counter = 0 # Para asignar nombres de `experiment_names`
+
+    # Parsear bounds para biomasa (asumimos 3 parámetros para todos los modelos de biomasa)
+    # ### MODIFICADO ###: Procesamiento de bounds más específico
+    parsed_bounds_biomass = ([-np.inf]*3, [np.inf]*3) # Default: sin bounds
+    try:
+        if lower_bounds_biomass_str.strip():
+            lb = [float(x.strip()) for x in lower_bounds_biomass_str.split(',')]
+            if len(lb) == 3 : parsed_bounds_biomass = (lb, parsed_bounds_biomass[1])
+        if upper_bounds_biomass_str.strip():
+            ub = [float(x.strip()) for x in upper_bounds_biomass_str.split(',')]
+            if len(ub) == 3 : parsed_bounds_biomass = (parsed_bounds_biomass[0], ub)
+    except ValueError:
+        print("Advertencia: Bounds para biomasa no son válidos, se usarán bounds por defecto (-inf, inf). Formato: num,num,num")
+
 
     for sheet_name in sheet_names:
         try:
-            df = pd.read_excel(file.name, sheet_name=sheet_name, header=[0, 1])
+            df = pd.read_excel(xls, sheet_name=sheet_name, header=[0, 1])
+            # Asegurar que las columnas de datos (Biomasa, Sustrato, Producto) sean numéricas
+            for col_level0 in df.columns.levels[0]:
+                for col_level1 in [COL_BIOMASS, COL_SUBSTRATE, COL_PRODUCT, COL_TIME]:
+                    if (col_level0, col_level1) in df.columns:
+                        df[(col_level0, col_level1)] = pd.to_numeric(df[(col_level0, col_level1)], errors='coerce')
+            df = df.dropna(how='all', subset=[(c[0], c[1]) for c in df.columns if c[1] in [COL_TIME, COL_BIOMASS]]) # Eliminar filas totalmente vacías en T y X
+        
         except Exception as e:
             print(f"Error al leer la hoja '{sheet_name}': {e}")
             continue
 
-        model_dummy = BioprocessModel()
-        model_dummy.process_data(df)
-        time = model_dummy.time
+        if analysis_mode == 'independent':
+            # Asumimos que cada columna de nivel 0 es un experimento diferente
+            # y que 'Tiempo', 'Biomasa', etc., son subcolumnas (nivel 1)
+            unique_experiments_in_sheet = df.columns.levels[0]
 
-        if mode == 'independent':
-            num_experiments = len(df.columns.levels[0])
-            for idx in range(num_experiments):
-                col = df.columns.levels[0][idx]
+            for exp_col_name in unique_experiments_in_sheet:
                 try:
-                    time_exp = df[(col, 'Tiempo')].dropna().values
-                    biomass = df[(col, 'Biomasa')].dropna().values
-                    substrate = df[(col, 'Sustrato')].dropna().values
-                    product = df[(col, 'Producto')].dropna().values
+                    # Extraer datos para este experimento específico
+                    time_exp = df[(exp_col_name, COL_TIME)].dropna().values
+                    # Si no hay tiempo, saltar este experimento
+                    if len(time_exp) == 0: continue
+
+                    biomass_exp = df[(exp_col_name, COL_BIOMASS)].dropna().values if (exp_col_name, COL_BIOMASS) in df else np.array([])
+                    substrate_exp = df[(exp_col_name, COL_SUBSTRATE)].dropna().values if (exp_col_name, COL_SUBSTRATE) in df else np.array([])
+                    product_exp = df[(exp_col_name, COL_PRODUCT)].dropna().values if (exp_col_name, COL_PRODUCT) in df else np.array([])
+                    
+                    # Asegurar que todos tengan la misma longitud que time_exp o estén vacíos
+                    # Esto es simplista; un preprocesamiento más robusto podría ser necesario
+                    biomass_exp = biomass_exp[:len(time_exp)] if len(biomass_exp) >= len(time_exp) else np.pad(biomass_exp, (0, len(time_exp) - len(biomass_exp)), 'constant', constant_values=np.nan)
+                    substrate_exp = substrate_exp[:len(time_exp)] if len(substrate_exp) >= len(time_exp) else np.pad(substrate_exp, (0, len(time_exp) - len(substrate_exp)), 'constant', constant_values=np.nan)
+                    product_exp = product_exp[:len(time_exp)] if len(product_exp) >= len(time_exp) else np.pad(product_exp, (0, len(time_exp) - len(product_exp)), 'constant', constant_values=np.nan)
+
+
+                    current_exp_name_label = (experiment_names[experiment_counter] if experiment_counter < len(experiment_names)
+                                           else f"{sheet_name} - {exp_col_name}")
+
+                    for model_t in model_types_selected:
+                        fig, comp_data = _process_and_plot_single_experiment(
+                            time_exp, biomass_exp, substrate_exp, product_exp,
+                            None, None, None, # No std dev para modo 'independent' por ahora
+                            current_exp_name_label, model_t, int(maxfev_val),
+                            legend_position, params_position, show_legend_plot, show_params_plot,
+                            style_plot, line_color_plot, point_color_plot, line_style_plot, marker_style_plot,
+                            use_differential_eqs, analysis_mode, parsed_bounds_biomass,
+                            time_unit_str, biomass_unit_str, substrate_unit_str, product_unit_str
+                        )
+                        if fig: figures_list.append(fig)
+                        comparison_data_list.append(comp_data)
+                    experiment_counter += 1
                 except KeyError as e:
-                    print(f"Error al procesar el experimento '{col}': {e}")
+                    print(f"Advertencia: Falta la columna {e} para el experimento '{exp_col_name}' en la hoja '{sheet_name}'. Saltando.")
                     continue
+                except Exception as e_exp:
+                    print(f"Error procesando experimento '{exp_col_name}' en hoja '{sheet_name}': {e_exp}")
+                    continue
+
 
-                biomass_std = None
-                substrate_std = None
-                product_std = None
-                if biomass.ndim > 1:
-                    biomass_std = np.std(biomass, axis=0, ddof=1)
-                    biomass = np.mean(biomass, axis=0)
-                if substrate.ndim > 1:
-                    substrate_std = np.std(substrate, axis=0, ddof=1)
-                    substrate = np.mean(substrate, axis=0)
-                if product.ndim > 1:
-                    product_std = np.std(product, axis=0, ddof=1)
-                    product = np.mean(product, axis=0)
-
-                experiment_name = (experiment_names[experiment_counter] if experiment_counter < len(experiment_names)
-                                   else f"Tratamiento {experiment_counter + 1}")
-
-                for model_type in model_types:
-                    model = BioprocessModel(model_type=model_type, maxfev=maxfev_val)
-                    model.fit_model()
-
-                    y_pred_biomass = model.fit_biomass(time_exp, biomass)
-                    if y_pred_biomass is None:
-                        comparison_data.append({
-                            'Experimento': experiment_name,
-                            'Modelo': model_type.capitalize(),
-                            'R² Biomasa': np.nan,
-                            'RMSE Biomasa': np.nan,
-                            'R² Sustrato': np.nan,
-                            'RMSE Sustrato': np.nan,
-                            'R² Producto': np.nan,
-                            'RMSE Producto': np.nan
-                        })
-                        continue
-                    else:
-                        if 'biomass' in model.params and model.params['biomass']:
-                            y_pred_substrate = model.fit_substrate(time_exp, substrate, model.params['biomass'])
-                            y_pred_product = model.fit_product(time_exp, product, model.params['biomass'])
-                        else:
-                            y_pred_substrate = None
-                            y_pred_product = None
-
-                        comparison_data.append({
-                            'Experimento': experiment_name,
-                            'Modelo': model_type.capitalize(),
-                            'R² Biomasa': model.r2.get('biomass', np.nan),
-                            'RMSE Biomasa': model.rmse.get('biomass', np.nan),
-                            'R² Sustrato': model.r2.get('substrate', np.nan),
-                            'RMSE Sustrato': model.rmse.get('substrate', np.nan),
-                            'R² Producto': model.r2.get('product', np.nan),
-                            'RMSE Producto': model.rmse.get('product', np.nan)
-                        })
-
-                        if mode == 'combinado':
-                            fig = model.plot_combined_results(time_exp, biomass, substrate, product,
-                                                              y_pred_biomass, y_pred_substrate, y_pred_product,
-                                                              biomass_std, substrate_std, product_std,
-                                                              experiment_name,
-                                                              legend_position, params_position,
-                                                              show_legend, show_params,
-                                                              style,
-                                                              line_color, point_color, line_style, marker_style,
-                                                              use_differential)
-                        else:
-                            fig = model.plot_results(time_exp, biomass, substrate, product,
-                                                     y_pred_biomass, y_pred_substrate, y_pred_product,
-                                                     biomass_std, substrate_std, product_std,
-                                                     experiment_name,
-                                                     legend_position, params_position,
-                                                     show_legend, show_params,
-                                                     style,
-                                                     line_color, point_color, line_style, marker_style,
-                                                     use_differential)
-                        if fig is not None:
-                            figures.append(fig)
-
-                experiment_counter += 1
-
-        elif mode in ['average', 'combinado']:
+        elif analysis_mode in ['average', 'combinado']:
+            # Para 'average' y 'combinado', se promedian las réplicas dentro de una hoja
+            model_data_loader = BioprocessModel() # Usar una instancia para procesar datos de la hoja
             try:
-                time_exp = df[(df.columns.levels[0][0], 'Tiempo')].dropna().values
-                biomass = model_dummy.dataxp[-1]
-                substrate = model_dummy.datasp[-1]
-                product = model_dummy.datapp[-1]
-            except IndexError as e:
-                print(f"Error al obtener los datos promedio de la hoja '{sheet_name}': {e}")
-                continue
+                model_data_loader.process_data(df)
+            except ValueError as ve: # Capturar error de columna de tiempo faltante
+                 print(f"Error en la hoja '{sheet_name}': {ve}. Saltando esta hoja.")
+                 continue
 
-            biomass_std = model_dummy.datax_std[-1]
-            substrate_std = model_dummy.datas_std[-1]
-            product_std = model_dummy.datap_std[-1]
-
-            experiment_name = (experiment_names[experiment_counter] if experiment_counter < len(experiment_names)
-                               else f"Tratamiento {experiment_counter + 1}")
-
-            for model_type in model_types:
-                model = BioprocessModel(model_type=model_type, maxfev=maxfev_val)
-                model.fit_model()
-
-                y_pred_biomass = model.fit_biomass(time_exp, biomass)
-                if y_pred_biomass is None:
-                    comparison_data.append({
-                        'Experimento': experiment_name,
-                        'Modelo': model_type.capitalize(),
-                        'R² Biomasa': np.nan,
-                        'RMSE Biomasa': np.nan,
-                        'R² Sustrato': np.nan,
-                        'RMSE Sustrato': np.nan,
-                        'R² Producto': np.nan,
-                        'RMSE Producto': np.nan
-                    })
-                    continue
-                else:
-                    if 'biomass' in model.params and model.params['biomass']:
-                        y_pred_substrate = model.fit_substrate(time_exp, substrate, model.params['biomass'])
-                        y_pred_product = model.fit_product(time_exp, product, model.params['biomass'])
-                    else:
-                        y_pred_substrate = None
-                        y_pred_product = None
-
-                    comparison_data.append({
-                        'Experimento': experiment_name,
-                        'Modelo': model_type.capitalize(),
-                        'R² Biomasa': model.r2.get('biomass', np.nan),
-                        'RMSE Biomasa': model.rmse.get('biomass', np.nan),
-                        'R² Sustrato': model.r2.get('substrate', np.nan),
-                        'RMSE Sustrato': model.rmse.get('substrate', np.nan),
-                        'R² Producto': model.r2.get('product', np.nan),
-                        'RMSE Producto': model.rmse.get('product', np.nan)
-                    })
-
-                    if mode == 'combinado':
-                        fig = model.plot_combined_results(time_exp, biomass, substrate, product,
-                                                          y_pred_biomass, y_pred_substrate, y_pred_product,
-                                                          biomass_std, substrate_std, product_std,
-                                                          experiment_name,
-                                                          legend_position, params_position,
-                                                          show_legend, show_params,
-                                                          style,
-                                                          line_color, point_color, line_style, marker_style,
-                                                          use_differential)
-                    else:
-                        fig = model.plot_results(time_exp, biomass, substrate, product,
-                                                 y_pred_biomass, y_pred_substrate, y_pred_product,
-                                                 biomass_std, substrate_std, product_std,
-                                                 experiment_name,
-                                                 legend_position, params_position,
-                                                 show_legend, show_params,
-                                                 style,
-                                                 line_color, point_color, line_style, marker_style,
-                                                 use_differential)
-                    if fig is not None:
-                        figures.append(fig)
 
-            experiment_counter += 1
+            if len(model_data_loader.time) == 0:
+                print(f"No se encontraron datos de tiempo válidos en la hoja '{sheet_name}'. Saltando.")
+                continue
 
-    comparison_df = pd.DataFrame(comparison_data)
+            time_avg = model_data_loader.time
+            biomass_avg = model_data_loader.dataxp[-1] if model_data_loader.dataxp else np.array([])
+            substrate_avg = model_data_loader.datasp[-1] if model_data_loader.datasp else np.array([])
+            product_avg = model_data_loader.datapp[-1] if model_data_loader.datapp else np.array([])
+
+            biomass_std_avg = model_data_loader.datax_std[-1] if model_data_loader.datax_std and len(model_data_loader.datax_std[-1]) == len(time_avg) else None
+            substrate_std_avg = model_data_loader.datas_std[-1] if model_data_loader.datas_std and len(model_data_loader.datas_std[-1]) == len(time_avg) else None
+            product_std_avg = model_data_loader.datap_std[-1] if model_data_loader.datap_std and len(model_data_loader.datap_std[-1]) == len(time_avg) else None
+            
+            current_exp_name_label = (experiment_names[experiment_counter] if experiment_counter < len(experiment_names)
+                                   else f"{sheet_name} (Promedio)")
+
+            for model_t in model_types_selected:
+                fig, comp_data = _process_and_plot_single_experiment(
+                    time_avg, biomass_avg, substrate_avg, product_avg,
+                    biomass_std_avg, substrate_std_avg, product_std_avg,
+                    current_exp_name_label, model_t, int(maxfev_val),
+                    legend_position, params_position, show_legend_plot, show_params_plot,
+                    style_plot, line_color_plot, point_color_plot, line_style_plot, marker_style_plot,
+                    use_differential_eqs, analysis_mode, parsed_bounds_biomass, # plot_mode es analysis_mode aquí
+                    time_unit_str, biomass_unit_str, substrate_unit_str, product_unit_str
+                )
+                if fig: figures_list.append(fig)
+                comparison_data_list.append(comp_data)
+            experiment_counter += 1
 
+    comparison_df = pd.DataFrame(comparison_data_list)
     if not comparison_df.empty:
         comparison_df_sorted = comparison_df.sort_values(
             by=['R² Biomasa', 'R² Sustrato', 'R² Producto', 'RMSE Biomasa', 'RMSE Sustrato', 'RMSE Producto'],
             ascending=[False, False, False, True, True, True]
         ).reset_index(drop=True)
     else:
-        comparison_df_sorted = comparison_df
+        comparison_df_sorted = pd.DataFrame(columns=[ # DataFrame vacío con columnas esperadas
+            'Experimento', 'Modelo', 'R² Biomasa', 'RMSE Biomasa',
+            'R² Sustrato', 'RMSE Sustrato', 'R² Producto', 'RMSE Producto'
+        ])
+
+    return figures_list, comparison_df_sorted, "Proceso completado." # Añadir mensaje de estado
 
-    return figures, comparison_df_sorted
 
 def create_interface():
-    with gr.Blocks() as demo:
+    with gr.Blocks(theme=gr.themes.Soft()) as demo: # Usar un tema
         gr.Markdown("# Modelos de Bioproceso: Logístico, Gompertz, Moser y Luedeking-Piret")
-
         gr.Markdown(r"""
-## Ecuaciones Diferenciales Utilizadas
-
-**Biomasa:**
-
-- Logístico:
-$$
-\frac{dX}{dt} = \mu_m X\left(1 - \frac{X}{X_m}\right)
-$$
-
-- Gompertz:
-$$
-X(t) = X_m \exp\left(-\exp\left(\left(\frac{\mu_m e}{X_m}\right)(\text{lag}-t)+1\right)\right)
-$$
-
-Ecuación diferencial:
-$$
-\frac{dX}{dt} = X(t)\left(\frac{\mu_m e}{X_m}\right)\exp\left(\left(\frac{\mu_m e}{X_m}\right)(\text{lag}-t)+1\right)
-$$
-
-- Moser (simplificado):
-$$
-X(t)=X_m(1-e^{-\mu_m(t-K_s)})
-$$
-
-$$
-\frac{dX}{dt}=\mu_m(X_m - X)
-$$
-
-**Sustrato y Producto (Luedeking-Piret):**
-$$
-\frac{dS}{dt} = -p \frac{dX}{dt} - q X
-$$
-
-$$
-\frac{dP}{dt} = \alpha \frac{dX}{dt} + \beta X
-$$
-        """)
-
-        file_input = gr.File(label="Subir archivo Excel")
-
-        with gr.Row():
-            with gr.Column():
-                legend_position = gr.Radio(
-                    choices=["upper left", "upper right", "lower left", "lower right", "best"],
-                    label="Posición de la leyenda",
-                    value="best"
-                )
-                show_legend = gr.Checkbox(label="Mostrar Leyenda", value=True)
-
-            with gr.Column():
-                params_positions = ["upper left", "upper right", "lower left", "lower right", "outside right"]
-                params_position = gr.Radio(
-                    choices=params_positions,
-                    label="Posición de los parámetros",
-                    value="upper right"
+        ## Ecuaciones ... (sin cambios)
+        """) # Tu markdown de ecuaciones aquí
+
+        with gr.Tabs():
+            with gr.TabItem("Configuración Principal"):
+                file_input = gr.File(label="Subir archivo Excel (.xlsx)")
+                experiment_names = gr.Textbox(
+                    label="Nombres de los experimentos (uno por línea, opcional)",
+                    placeholder="Tratamiento A\nTratamiento B\n...\nSi se deja vacío, se usarán nombres de hoja/columna.",
+                    lines=3
                 )
-                show_params = gr.Checkbox(label="Mostrar Parámetros", value=True)
-
-        model_types = gr.CheckboxGroup(
-            choices=["logistic", "gompertz", "moser"],
-            label="Tipo(s) de Modelo",
-            value=["logistic"]
-        )
-        mode = gr.Radio(["independent", "average", "combinado"], label="Modo de Análisis", value="independent")
-        use_differential = gr.Checkbox(label="Usar ecuaciones diferenciales para graficar", value=False)
-
-        experiment_names = gr.Textbox(
-            label="Nombres de los experimentos (uno por línea)",
-            placeholder="Experimento 1\nExperimento 2\n...",
-            lines=5
-        )
-
-        with gr.Row():
-            with gr.Column():
-                lower_bounds = gr.Textbox(
-                    label="Lower Bounds (uno por línea, formato: param1,param2,param3)",
-                    placeholder="0,0,0\n0,0,0\n...",
-                    lines=5
+                model_types = gr.CheckboxGroup(
+                    choices=["logistic", "gompertz", "moser"],
+                    label="Tipo(s) de Modelo de Biomasa",
+                    value=["logistic"]
                 )
-
-            with gr.Column():
-                upper_bounds = gr.Textbox(
-                    label="Upper Bounds (uno por línea, formato: param1,param2,param3)",
-                    placeholder="inf,inf,inf\ninf,inf,inf\n...",
-                    lines=5
+                analysis_mode = gr.Radio(
+                    choices=[
+                        ("Procesar cada réplica/columna independientemente", "independent"),
+                        ("Promediar réplicas por hoja (gráficos separados)", "average"),
+                        ("Promediar réplicas por hoja (gráfico combinado)", "combinado")
+                    ],
+                    label="Modo de Análisis de Datos del Excel", value="independent"
                 )
-
-        styles = ['white', 'dark', 'whitegrid', 'darkgrid', 'ticks']
-        style_dropdown = gr.Dropdown(choices=styles, label="Selecciona el estilo de gráfico", value='whitegrid')
-
-        line_color_picker = gr.ColorPicker(label="Color de la línea", value='#0000FF')
-        point_color_picker = gr.ColorPicker(label="Color de los puntos", value='#000000')
-
-        line_style_options = ['-', '--', '-.', ':']
-        line_style_dropdown = gr.Dropdown(choices=line_style_options, label="Estilo de línea", value='-')
-
-        marker_style_options = ['o', 's', '^', 'v', 'D', 'x', '+', '*']
-        marker_style_dropdown = gr.Dropdown(choices=marker_style_options, label="Estilo de punto", value='o')
-
-        maxfev_input = gr.Number(label="maxfev (Máx. evaluaciones para el ajuste)", value=50000)
-
-        simulate_btn = gr.Button("Simular")
-
-        output_gallery = gr.Gallery(label="Resultados", columns=2, height='auto')
+                use_differential = gr.Checkbox(label="Usar EDOs para predecir y graficar curvas (en lugar de las formas integradas ajustadas)", value=False)
+                maxfev_input = gr.Number(label="maxfev (Máx. iteraciones para ajuste de curvas)", value=50000, precision=0)
+
+                with gr.Accordion("Bounds para Parámetros de Biomasa (opcional)", open=False):
+                    gr.Markdown("Especificar bounds como `valor1,valor2,valor3`. Los parámetros son (X0, Xm, um) para Logístico, (Xm, um, lag) para Gompertz, (Xm, um, Ks) para Moser.")
+                    lower_bounds_biomass = gr.Textbox(
+                        label="Lower Bounds Biomasa (ej: 0.01,1,0.01)",
+                        placeholder="Dejar vacío para -infinito para todos"
+                    )
+                    upper_bounds_biomass = gr.Textbox(
+                        label="Upper Bounds Biomasa (ej: 1,10,1)",
+                        placeholder="Dejar vacío para +infinito para todos"
+                    )
+
+            with gr.TabItem("Personalización de Gráficos"):
+                with gr.Row():
+                    show_legend = gr.Checkbox(label="Mostrar Leyenda", value=True)
+                    legend_position = gr.Dropdown(
+                        choices=["best", "upper left", "upper right", "lower left", "lower right", "center left", "center right", "lower center", "upper center", "center"],
+                        label="Posición Leyenda", value="best"
+                    )
+                with gr.Row():
+                    show_params = gr.Checkbox(label="Mostrar Parámetros/Estadísticas", value=True)
+                    params_position = gr.Dropdown(
+                        choices=["upper left", "upper right", "lower left", "lower right", "outside right"],
+                        label="Posición Parámetros", value="upper right"
+                    )
+                with gr.Row():
+                    style_dropdown = gr.Dropdown(choices=['whitegrid', 'darkgrid', 'white', 'dark', 'ticks'], label="Estilo Seaborn", value='whitegrid')
+                    line_style_dropdown = gr.Dropdown(choices=['-', '--', '-.', ':'], label="Estilo de Línea Modelo", value='-')
+                    marker_style_dropdown = gr.Dropdown(choices=['o', 's', '^', 'v', 'D', 'x', '+', '*'], label="Estilo de Punto Datos", value='o')
+                with gr.Row():
+                    line_color_picker = gr.ColorPicker(label="Color Línea Modelo", value='#0000FF')
+                    point_color_picker = gr.ColorPicker(label="Color Puntos Datos", value='#000000')
+                
+                gr.Markdown("### Unidades para los Ejes (opcional)")
+                with gr.Row():
+                    time_unit_input = gr.Textbox(label="Unidad de Tiempo", placeholder="ej: h, días")
+                    biomass_unit_input = gr.Textbox(label="Unidad de Biomasa", placeholder="ej: g/L, UFC/mL")
+                with gr.Row():
+                    substrate_unit_input = gr.Textbox(label="Unidad de Sustrato", placeholder="ej: g/L, %")
+                    product_unit_input = gr.Textbox(label="Unidad de Producto", placeholder="ej: g/L, UI/mL")
+
+        simulate_btn = gr.Button("Generar Modelos y Gráficos", variant="primary")
+        
+        status_message = gr.Textbox(label="Estado", interactive=False) # Para mostrar mensajes de error o éxito
+        
+        output_gallery = gr.Gallery(label="Resultados Gráficos", columns=[1,2], height='auto', object_fit="contain")
         output_table = gr.Dataframe(
             label="Tabla Comparativa de Modelos",
             headers=["Experimento", "Modelo", "R² Biomasa", "RMSE Biomasa",
                      "R² Sustrato", "RMSE Sustrato", "R² Producto", "RMSE Producto"],
-            interactive=False
+            interactive=False,
+            wrap=True
         )
-
-        state_df = gr.State()
-
-        def process_and_plot(file, legend_position, params_position, model_types, mode, experiment_names,
-                             lower_bounds, upper_bounds, style,
-                             line_color, point_color, line_style, marker_style,
-                             show_legend, show_params, use_differential, maxfev_input):
-
-            experiment_names_list = experiment_names.strip().split('\n') if experiment_names.strip() else []
-            lower_bounds_list = []
-            if lower_bounds.strip():
-                for lb in lower_bounds.strip().split('\n'):
-                    lb_values = []
-                    for val in lb.split(','):
-                        val = val.strip().lower()
-                        if val in ['inf', 'infty', 'infinity']:
-                            lb_values.append(-np.inf)
-                        else:
-                            try:
-                                lb_values.append(float(val))
-                            except ValueError:
-                                lb_values.append(0.0)
-                    lower_bounds_list.append(tuple(lb_values))
-            upper_bounds_list = []
-            if upper_bounds.strip():
-                for ub in upper_bounds.strip().split('\n'):
-                    ub_values = []
-                    for val in ub.split(','):
-                        val = val.strip().lower()
-                        if val in ['inf', 'infty', 'infinity']:
-                            ub_values.append(np.inf)
-                        else:
-                            try:
-                                ub_values.append(float(val))
-                            except ValueError:
-                                ub_values.append(np.inf)
-                    upper_bounds_list.append(tuple(ub_values))
-
-            figures, comparison_df = process_all_data(file, legend_position, params_position, model_types, experiment_names_list,
-                                                     lower_bounds_list, upper_bounds_list, mode, style,
-                                                     line_color, point_color, line_style, marker_style,
-                                                     show_legend, show_params, use_differential, maxfev_val=int(maxfev_input))
-
-            return figures, comparison_df, comparison_df
-
-        simulate_output = simulate_btn.click(
-            fn=process_and_plot,
-            inputs=[file_input,
-                    legend_position,
-                    params_position,
-                    model_types,
-                    mode,
-                    experiment_names,
-                    lower_bounds,
-                    upper_bounds,
-                    style_dropdown,
-                    line_color_picker,
-                    point_color_picker,
-                    line_style_dropdown,
-                    marker_style_dropdown,
-                    show_legend,
-                    show_params,
-                    use_differential,
-                    maxfev_input],
-            outputs=[output_gallery, output_table, state_df]
+        
+        state_df_for_export = gr.State() # Para guardar el DataFrame para exportar
+
+        def run_simulation_wrapper(
+            file, exp_names_str, models_sel, mode_sel, use_diff_eq, maxfev,
+            lb_biomass_str, ub_biomass_str, # Bounds
+            show_leg, leg_pos, show_par, par_pos, # Leyenda y params
+            style_sel, lstyle_sel, mstyle_sel, lcolor, pcolor, # Estilos
+            # Unidades
+            t_unit, b_unit, s_unit, p_unit):
+
+            exp_names_list = [name.strip() for name in exp_names_str.strip().split('\n') if name.strip()]
+
+            figures, comparison_df, message = process_all_data(
+                file, leg_pos, par_pos, models_sel, mode_sel, exp_names_list,
+                lb_biomass_str, ub_biomass_str, # Pasamos bounds como strings
+                style_sel, lcolor, pcolor, lstyle_sel, mstyle_sel,
+                show_leg, show_par, use_diff_eq, maxfev,
+                # Unidades
+                t_unit, b_unit, s_unit, p_unit
+            )
+            return figures, comparison_df, comparison_df, message # Devolver mensaje para status_message
+
+        simulate_btn.click(
+            fn=run_simulation_wrapper,
+            inputs=[
+                file_input, experiment_names, model_types, analysis_mode, use_differential, maxfev_input,
+                lower_bounds_biomass, upper_bounds_biomass, # Bounds
+                show_legend, legend_position, show_params, params_position, # Leyenda y params
+                style_dropdown, line_style_dropdown, marker_style_dropdown, line_color_picker, point_color_picker, # Estilos
+                # Unidades
+                time_unit_input, biomass_unit_input, substrate_unit_input, product_unit_input
+            ],
+            outputs=[output_gallery, output_table, state_df_for_export, status_message] # Añadido status_message
         )
 
-        def export_excel(df):
-            if df.empty:
-                return None
+        def export_excel(df_to_export):
+            if df_to_export is None or df_to_export.empty:
+                # Devolver un archivo temporal vacío o un mensaje
+                # Para Gradio >3.0, puedes devolver None y se mostrará "No file"
+                # o un gr.Warning("No hay datos para exportar.")
+                # Por ahora, devolvemos un archivo con un nombre que indique que está vacío.
+                with tempfile.NamedTemporaryFile(prefix="no_data_", suffix=".xlsx", delete=False) as tmp:
+                    # Opcional: escribir un mensaje en el Excel
+                    pd.DataFrame({"Mensaje": ["No hay datos para exportar."]}).to_excel(tmp.name, index=False)
+                    return tmp.name
+
             with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
-                df.to_excel(tmp.name, index=False)
+                df_to_export.to_excel(tmp.name, index=False)
                 return tmp.name
 
         export_btn = gr.Button("Exportar Tabla a Excel")
-        file_output = gr.File()
+        file_output_excel = gr.File(label="Descargar Tabla Excel")
 
         export_btn.click(
             fn=export_excel,
-            inputs=state_df,
-            outputs=file_output
+            inputs=state_df_for_export,
+            outputs=file_output_excel
         )
-
     return demo
 
-demo = create_interface()
-demo.launch(share=True)
+if __name__ == '__main__':
+    app_interface = create_interface()
+    app_interface.launch(share=True, debug=True) # debug=True es útil durante el desarrollo