Update interface.py

interface.py

@@ -48,6 +48,7 @@ class BioprocessModel:
         self.datax_std = []
         self.datas_std = []
         self.datap_std = []
+        self.models = {}  # Initialize the models dictionary
 
     @staticmethod
     def logistic(time, xo, xm, um):
@@ -108,36 +109,70 @@ class BioprocessModel:
 
         self.time = time
 
-    def fit_model(self, model_type='logistic'):
-        if model_type == 'logistic':
-            self.fit_biomass = self.fit_biomass_logistic
-            self.fit_substrate = self.fit_substrate_logistic
-            self.fit_product = self.fit_product_logistic
-
-    def fit_biomass_logistic(self, time, biomass, bounds):
-        popt, _ = curve_fit(self.logistic, time, biomass, bounds=bounds, maxfev=10000)
-        self.params['biomass'] = {'xo': popt[0], 'xm': popt[1], 'um': popt[2]}
-        y_pred = self.logistic(time, *popt)
-        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
-
-    def fit_substrate_logistic(self, time, substrate, biomass_params, bounds):
-        popt, _ = curve_fit(lambda t, so, p, q: self.substrate(t, so, p, q, *biomass_params.values()),
-                            time, substrate, bounds=bounds)
-        self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
-        y_pred = self.substrate(time, *popt, *biomass_params.values())
-        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
-
-    def fit_product_logistic(self, time, product, biomass_params, bounds):
-        popt, _ = curve_fit(lambda t, po, alpha, beta: self.product(t, po, alpha, beta, *biomass_params.values()),
-                            time, product, bounds=bounds)
-        self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
-        y_pred = self.product(time, *popt, *biomass_params.values())
-        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))
+    def set_model(self, model_type, equation, params_str):
+        """
+        Sets up the model based on the type, equation, and parameters.
+        
+        :param model_type: Type of the model ('biomass', 'substrate', 'product')
+        :param equation: The equation as a string
+        :param params_str: Comma-separated string of parameter names
+        """
+        t_symbol = symbols('t')
+        expr = sympify(equation)
+        params = [param.strip() for param in params_str.split(',')]
+        params_symbols = symbols(params)
+        
+        if model_type == 'biomass':
+            # Assuming biomass is a function of time only for logistic
+            func_expr = expr
+            func = lambdify(t_symbol, func_expr, 'numpy')
+            self.models['biomass'] = {
+                'function': func,
+                'params': params
+            }
+        elif model_type in ['substrate', 'product']:
+            # These models depend on biomass, which should already be set
+            if 'biomass' not in self.models:
+                raise ValueError("Biomass model must be set before substrate or product models.")
+            biomass_func = self.models['biomass']['function']
+            func_expr = expr.subs('X(t)', biomass_func(t_symbol))
+            func = lambdify((t_symbol, *params_symbols), func_expr, 'numpy')
+            self.models[model_type] = {
+                'function': func,
+                'params': params
+            }
+        else:
+            raise ValueError(f"Unsupported model type: {model_type}")
+
+    def fit_model(self, model_type, time, data, bounds=([-np.inf], [np.inf])):
+        """
+        Fits the model to the data.
+        
+        :param model_type: Type of the model ('biomass', 'substrate', 'product')
+        :param time: Time data
+        :param data: Observed data to fit
+        :param bounds: Bounds for the parameters
+        :return: Predicted data from the model
+        """
+        if model_type not in self.models:
+            raise ValueError(f"Model type '{model_type}' is not set. Please use set_model first.")
+
+        func = self.models[model_type]['function']
+        params = self.models[model_type]['params']
+        
+        # Define the fitting function based on model type
+        if model_type == 'biomass':
+            def fit_func(t, *args):
+                return func(t, *args)
+        else:
+            def fit_func(t, *args):
+                return func(t, *args)
+
+        popt, _ = curve_fit(fit_func, time, data, bounds=bounds, maxfev=10000)
+        self.params[model_type] = {param: val for param, val in zip(params, popt)}
+        y_pred = fit_func(time, *popt)
+        self.r2[model_type] = 1 - (np.sum((data - y_pred) ** 2) / np.sum((data - np.mean(data)) ** 2))
+        self.rmse[model_type] = np.sqrt(mean_squared_error(data, y_pred))
         return y_pred
 
     def plot_combined_results(self, time, biomass, substrate, product,
@@ -305,8 +340,8 @@ def process_and_plot(
 
     # Usa el primer modelo de biomasa para X(t)
     biomass_model = biomass_results[0]['model']
-    X_t_func = biomass_model.models['biomass']['function']
     biomass_params_values = list(biomass_model.params['biomass'].values())
+    biomass_func = biomass_model.models['biomass']['function']
 
     # Ajusta los modelos de Sustrato
     for i in range(len(substrate_eqs)):
@@ -315,20 +350,7 @@ def process_and_plot(
         bounds_str = substrate_bounds[i]
 
         model = BioprocessModel()
-
-        t_symbol = symbols('t')
-        expr_substrate = sympify(equation)
-        substrate_params_symbols = symbols([param.strip() for param in params_str.split(',')])
-        substrate_func_expr = expr_substrate.subs('X(t)', X_t_func(t_symbol, *biomass_params_values))
-        substrate_func = lambdify(
-            (t_symbol, *substrate_params_symbols),
-            substrate_func_expr,
-            'numpy'
-        )
-        model.models['substrate'] = {
-            'function': substrate_func,
-            'params': [param.strip() for param in params_str.split(',')]
-        }
+        model.set_model('substrate', equation, params_str)
 
         params = model.models['substrate']['params']
         lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
@@ -350,20 +372,7 @@ def process_and_plot(
         bounds_str = product_bounds[i]
 
         model = BioprocessModel()
-
-        t_symbol = symbols('t')
-        expr_product = sympify(equation)
-        product_params_symbols = symbols([param.strip() for param in params_str.split(',')])
-        product_func_expr = expr_product.subs('X(t)', X_t_func(t_symbol, *biomass_params_values))
-        product_func = lambdify(
-            (t_symbol, *product_params_symbols),
-            product_func_expr,
-            'numpy'
-        )
-        model.models['product'] = {
-            'function': product_func,
-            'params': [param.strip() for param in params_str.split(',')]
-        }
+        model.set_model('product', equation, params_str)
 
         params = model.models['product']['params']
         lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))