huff 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

huff/models.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.4.1
-# Last update: 2025-06-16 17:43
+# Version:     1.5.1
+# Last update: 2025-07-01 17:10
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -119,6 +119,24 @@ class CustomerOrigins:
         param_lambda = -2
         ):
 
+        """
+        metadata["weighting"] = {
+            0: {
+                "name": "t_ij",
+                "func": "power",
+                "param": -2
+            }
+        }
+        
+        metadata["weighting"] = {
+            0: {
+                "name": "t_ij",
+                "func": "logistic",
+                "param": [10, -0.5]
+            }
+        }
+        """
+                
         metadata = self.metadata
 
         if func not in ["power", "exponential", "logistic"]:
@@ -130,6 +148,7 @@ class CustomerOrigins:
         if isinstance(param_lambda, (int, float)) and func == "logistic":
             raise ValueError("Function type "+ func + " requires two parameters in a list")
         
+        metadata["weighting"][0]["name"] = "t_ij"
         metadata["weighting"][0]["func"] = func
 
         if isinstance(param_lambda, list):
@@ -299,8 +318,10 @@ class SupplyLocations:
         if metadata["attraction_col"] is None:
             raise ValueError ("Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
         
+        metadata["weighting"][0]["name"] = "A_j"
         metadata["weighting"][0]["func"] = func
         metadata["weighting"][0]["param"] = float(param_gamma)
+        
         self.metadata = metadata
 
         return self
@@ -323,6 +344,7 @@ class SupplyLocations:
         metadata["attraction_col"] = metadata["attraction_col"] + [var] 
 
         metadata["weighting"][new_key] = {
+            "name": var,
             "func": func,
             "param": param
             }
@@ -490,34 +512,84 @@ class InteractionMatrix:
         else:
             print("Market size column  " + customer_origins_metadata["marketsize_col"])
 
-        if interaction_matrix_metadata != {}:
-            if "transport_costs" in interaction_matrix_metadata:
-                print("----------------------------------")
-                if interaction_matrix_metadata["transport_costs"]["network"]:
-                    print("Transport cost type Time")
-                    print("Transport cost unit " + interaction_matrix_metadata["transport_costs"]["time_unit"])
-                else:
-                    print("Transport cost type Distance")
-                    print("Transport cost unit " + interaction_matrix_metadata["transport_costs"]["distance_unit"])
+        if interaction_matrix_metadata != {} and "transport_costs" in interaction_matrix_metadata:
+            print("----------------------------------")
+            if interaction_matrix_metadata["transport_costs"]["network"]:
+                print("Transport cost type Time")
+                print("Transport cost unit " + interaction_matrix_metadata["transport_costs"]["time_unit"])
+            else:
+                print("Transport cost type Distance")
+                print("Transport cost unit " + interaction_matrix_metadata["transport_costs"]["distance_unit"])
 
         print("----------------------------------")
         print("Partial utilities")
         print("                    Weights")
-        
+
         if supply_locations_metadata["weighting"][0]["func"] is None and supply_locations_metadata["weighting"][0]["param"] is None:
             print("Attraction          not defined")
         else:
-            print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            if supply_locations_metadata["weighting"][0]["param"] is not None:
+                print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Attraction          NA" + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")   
 
         if customer_origins_metadata["weighting"][0]["func"] is None and customer_origins_metadata["weighting"][0]["param"] is None:
             print("Transport costs     not defined")
         elif customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
-            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs     " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
-            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+
+        attrac_vars = supply_locations_metadata["attraction_col"]
+        attrac_vars_no = len(attrac_vars)
+        
+        if attrac_vars_no > 1:
+                        
+            for key, attrac_var in enumerate(attrac_vars):
+                
+                if key == 0:
+                    continue
+                
+                if key not in supply_locations_metadata["weighting"].keys():
+                    
+                    print(f"{attrac_vars[key][:16]:16}    not defined")
+                    
+                else:
+                    
+                    if supply_locations_metadata["weighting"][key]["func"] is None and supply_locations_metadata["weighting"][key]["param"]:
+                        
+                        print(f"{attrac_vars[key][:16]:16}    not defined")
+
+                    else:
+
+                        if supply_locations_metadata["weighting"][key]["param"] is not None:
+
+                            name = supply_locations_metadata["weighting"][key]["name"]
+                            param = supply_locations_metadata["weighting"][key]["param"]
+                            func = supply_locations_metadata["weighting"][key]["func"]
+                            
+                            print(f"{name[:16]:16}    {round(param, 3)} ({func})")
+
+                        else:
+
+                            print(f"{attrac_vars[key][:16]:16}    NA" + " (" + supply_locations_metadata["weighting"][0]["func"] + ")") 
+
 
         print("----------------------------------")
 
+        if interaction_matrix_metadata != {} and "fit" in interaction_matrix_metadata and interaction_matrix_metadata["fit"]["function"] is not None:
+            print("Parameter estimation")
+            print("Fit function        " + interaction_matrix_metadata["fit"]["function"])
+            print("Fit by              " + interaction_matrix_metadata["fit"]["fit_by"])
+            if interaction_matrix_metadata["fit"]["function"] == "huff_ml_fit":
+                print("Fit method          " + interaction_matrix_metadata["fit"]["method"] + " (Converged: " + str(interaction_matrix_metadata["fit"]["minimize_success"]) + ")")
+
     def transport_costs(
         self,
         network: bool = True,
@@ -630,12 +702,80 @@ class InteractionMatrix:
 
         return self
     
+    def define_weightings(
+        self,
+        vars_funcs: dict
+        ):
+        
+        """
+        vars_funcs = {
+            0: {
+                "name": "A_j",
+                "func": "power",
+                "param": 1
+            },
+            1: {
+                "name": "t_ij",
+                "func": "logistic"
+            },
+            2: {
+                "name": "second_attraction_variable",
+                "func": "power"
+            },
+            3: {
+                "name": "third_attraction_variable",
+                "func": "exponential"
+            },
+            ...
+        }
+        """
+
+        supply_locations_metadata = self.supply_locations.metadata
+        customer_origins_metadata = self.customer_origins.metadata
+
+        supply_locations_metadata["weighting"][0]["name"] = vars_funcs[0]["name"]
+        supply_locations_metadata["weighting"][0]["func"] = vars_funcs[0]["func"]
+        if "param" in vars_funcs[0]:
+            supply_locations_metadata["weighting"][0]["param"] = vars_funcs[0]["param"]
+    
+        customer_origins_metadata["weighting"][0]["name"] = vars_funcs[1]["name"]
+        customer_origins_metadata["weighting"][0]["func"] = vars_funcs[1]["func"]
+        if "param" in vars_funcs[1]:
+            customer_origins_metadata["weighting"][0]["param"] = vars_funcs[1]["param"]
+
+        if len(vars_funcs) > 2:
+            
+            for key, var in vars_funcs.items():
+
+                if key < 2:
+                    continue
+                
+                if key not in supply_locations_metadata["weighting"]:
+                    supply_locations_metadata["weighting"][key-1] = {
+                        "name": "attrac"+str(key),
+                        "func": "power",
+                        "param": None
+                        }
+
+                supply_locations_metadata["weighting"][key-1]["name"] = var["name"]
+                supply_locations_metadata["weighting"][key-1]["func"] = var["func"]
+
+                if "param" in var:
+                    supply_locations_metadata["weighting"][key-1]["param"] = var["param"]
+
+        self.supply_locations.metadata = supply_locations_metadata
+        self.customer_origins.metadata = customer_origins_metadata
+
     def utility(self):
         
         interaction_matrix_df = self.interaction_matrix_df
 
         interaction_matrix_metadata = self.get_metadata()
 
+        if "t_ij" not in interaction_matrix_df.columns:
+            raise ValueError ("No transport cost variable in interaction matrix")
+        if "A_j" not in interaction_matrix_df.columns:
+            raise ValueError ("No attraction variable in interaction matrix")
         if interaction_matrix_df["t_ij"].isna().all():
             raise ValueError ("Transport cost variable is not defined")
         if interaction_matrix_df["A_j"].isna().all():
@@ -670,6 +810,33 @@ class InteractionMatrix:
         else:
             raise ValueError ("Attraction weighting is not defined.")
         
+        attrac_vars = supply_locations_metadata["attraction_col"]
+        attrac_vars_no = len(attrac_vars)
+        attrac_var_key = 0
+
+        if attrac_vars_no > 1:
+            
+            for key, attrac_var in enumerate(attrac_vars):
+                
+                attrac_var_key = key #+1
+                if attrac_var_key == 0: #1:
+                    continue
+                
+                name = supply_locations_metadata["weighting"][attrac_var_key]["name"]
+                param = supply_locations_metadata["weighting"][attrac_var_key]["param"]
+                func = supply_locations_metadata["weighting"][attrac_var_key]["func"]
+
+                if func == "power":
+                    interaction_matrix_df[name+"_weighted"] = interaction_matrix_df[name] ** param
+                elif func == "exponential":
+                    interaction_matrix_df[name+"_weighted"] = np.exp(param * interaction_matrix_df[name])
+                else:
+                    raise ValueError ("Weighting for " + name + " is not defined.")
+                
+                interaction_matrix_df["A_j_weighted"] = interaction_matrix_df["A_j_weighted"]*interaction_matrix_df[name+"_weighted"]
+
+                interaction_matrix_df = interaction_matrix_df.drop(columns=[name+"_weighted"])
+
         interaction_matrix_df["U_ij"] = interaction_matrix_df["A_j_weighted"]*interaction_matrix_df["t_ij_weighted"]
         
         interaction_matrix_df = interaction_matrix_df.drop(columns=["A_j_weighted", "t_ij_weighted"])
@@ -687,7 +854,7 @@ class InteractionMatrix:
 
         interaction_matrix_df = self.interaction_matrix_df
 
-        if interaction_matrix_df["U_ij"].isna().all():
+        if "U_ij" not in interaction_matrix_df.columns or interaction_matrix_df["U_ij"].isna().all():
             self.utility()
             interaction_matrix_df = self.interaction_matrix_df
 
@@ -713,6 +880,8 @@ class InteractionMatrix:
 
         interaction_matrix_df = self.interaction_matrix_df
 
+        if "C_i" not in interaction_matrix_df.columns:
+            raise ValueError ("No market size variable in interaction matrix")
         if interaction_matrix_df["C_i"].isna().all():
             raise ValueError ("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
 
@@ -737,7 +906,8 @@ class InteractionMatrix:
         
         check_vars(
             df = interaction_matrix_df,
-            cols = ["E_ij"]
+            cols = ["E_ij"],
+            check_zero = False
             )
         
         market_areas_df = pd.DataFrame(interaction_matrix_df.groupby("j")["E_ij"].sum())
@@ -875,6 +1045,15 @@ class InteractionMatrix:
 
         customer_origins.metadata = customer_origins_metadata
         supply_locations.metadata = supply_locations_metadata
+        
+        interaction_matrix_metadata = {
+            "fit": {
+                "function": "mci_fit",
+                "fit_by": "probabilities",
+                "method": "OLS"
+                }
+            }
+               
         interaction_matrix = InteractionMatrix(
             interaction_matrix_df,
             customer_origins,
@@ -891,74 +1070,132 @@ class InteractionMatrix:
         
         return mci_model
 
-    def huff_loglik(
+    def loglik(
         self,
-        params
+        params,
+        fit_by = "probabilities"
         ):
+        
+        if fit_by not in ["probabilities", "flows"]:
+            raise ValueError ("Parameter 'fit_by' must be 'probabilities' or 'flows'")
 
         if not isinstance(params, list):
             if isinstance(params, np.ndarray):
                 params = params.tolist()
             else:
-                raise ValueError("Parameter 'params' must be a list or np.ndarray with two or three parameter values")
+                raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
         
-        if len(params) == 2:
-            param_gamma, param_lambda = params
-        elif len(params) == 3:
-            param_gamma, param_lambda, param_lambda2 = params
-        else:
-            raise ValueError("Parameter 'params' must be a list with two or three parameter values")        
+        if len(params) < 2:
+            raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+        
+        customer_origins = self.customer_origins
+        customer_origins_metadata = customer_origins.get_metadata()
+        
+        param_gamma, param_lambda = params[0], params[1]
+            
+        if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+            if len(params) < 3:
+                raise ValueError("When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
+        
+            param_gamma, param_lambda, param_lambda2 = params[0], params[1], params[2]
 
         interaction_matrix_df = self.interaction_matrix_df
         
         supply_locations = self.supply_locations
-        supply_locations_metadata = supply_locations.get_metadata()
-
-        customer_origins = self.customer_origins
-        customer_origins_metadata = customer_origins.get_metadata()
+        supply_locations_metadata = supply_locations.get_metadata()        
 
         supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
         supply_locations.metadata = supply_locations_metadata
 
         if customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
             
-            if len(params) == 2:
+            if len(params) >= 2:
+
                 customer_origins_metadata["weighting"][0]["param"] = float(param_lambda)
+            
             else:
-                raise ValueError ("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have two input parameters")
+                
+                raise ValueError ("Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
         
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
             
-            if len(params) == 3:
+            if len(params) >= 3:
+                
                 customer_origins_metadata["weighting"][0]["param"] = [float(param_lambda), float(param_lambda2)]
+            
             else:
-                raise ValueError("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have three input parameters")
-                        
+
+                raise ValueError("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
+
+        if (customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"] and len(params) > 2): 
+            
+            for key, param in enumerate(params):
+
+                if key <= 1:
+                    continue
+
+                supply_locations_metadata["weighting"][key-1]["param"] = float(param)
+
+        if (customer_origins_metadata["weighting"][0]["func"] == "logistic" and len(params) > 3):
+
+            for key, param in enumerate(params):
+
+                if key <= 2:
+                    continue
+
+                supply_locations_metadata["weighting"][key-2]["param"] = float(param)
+
         customer_origins.metadata = customer_origins_metadata
-       
-        p_ij_emp = interaction_matrix_df["p_ij"]
+
+        if "p_ij_emp" not in interaction_matrix_df.columns:
+            p_ij_emp = interaction_matrix_df["p_ij"]
+        else:
+            p_ij_emp = interaction_matrix_df["p_ij_emp"]
+
+        if "E_ij_emp" not in interaction_matrix_df.columns:
+            E_ij_emp = interaction_matrix_df["E_ij"]         
+        else:
+            E_ij_emp = interaction_matrix_df["E_ij_emp"]
         
         interaction_matrix_copy = copy.deepcopy(self)
 
         interaction_matrix_copy.utility()
         interaction_matrix_copy.probabilities()
+        interaction_matrix_copy.flows()
 
         interaction_matrix_df_copy = interaction_matrix_copy.get_interaction_matrix_df()
-        p_ij = interaction_matrix_df_copy["p_ij"]
         
-        LL = loglik(
-            observed = p_ij_emp,
+        if fit_by == "flows":            
+                       
+            E_ij = interaction_matrix_df_copy["E_ij"]
+        
+            observed = E_ij_emp
+            expected = E_ij            
+            
+        else:
+        
+            p_ij = interaction_matrix_df_copy["p_ij"]
+            
+            observed = p_ij_emp
             expected = p_ij
-            )
         
+        modelfit_metrics = modelfit(
+            observed = observed,
+            expected = expected
+        )
+
+        LL = modelfit_metrics[1]["LL"]       
+       
         return -LL
     
-    def ml_fit(
+    def huff_ml_fit(
         self,
         initial_params: list = [1.0, -2.0],
         method: str = "L-BFGS-B",
         bounds: list = [(0.5, 1), (-3, -1)],        
         constraints: list = [],
+        fit_by = "probabilities",
         update_estimates: bool = True
         ):       
 
@@ -967,41 +1204,62 @@ class InteractionMatrix:
         
         customer_origins = self.customer_origins
         customer_origins_metadata = customer_origins.get_metadata()
+
+        if customer_origins_metadata["weighting"][0]["param"] is None:            
+            params_metadata_customer_origins = 1            
+        else:            
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                if isinstance(customer_origins_metadata["weighting"][0]["param"], (int, float)):
+                    params_metadata_customer_origins = 1
+                else:
+                    params_metadata_customer_origins = len(customer_origins_metadata["weighting"][0]["param"])
+            
+        if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            params_metadata_customer_origins = 2
+        else:
+            params_metadata_customer_origins = 1
+            
+        params_metadata_supply_locations = len(supply_locations_metadata["weighting"])
         
-        if len(initial_params) > 3 or len(initial_params) < 2:
-            raise ValueError("Parameter 'initial_params' must be a list with two or three entries")
+        params_metadata = params_metadata_customer_origins+params_metadata_supply_locations
+
+        if len(initial_params) < 2 or len(initial_params) != params_metadata:
+            raise ValueError("Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
         
         if len(bounds) != len(initial_params):            
             raise ValueError("Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
-        
+
         ml_result = minimize(
-            self.huff_loglik,
+            self.loglik,
             initial_params,
+            args=fit_by,
             method = method,
             bounds = bounds,
             constraints = constraints,
             options={'disp': 3}
             )      
 
+        attrac_vars = len(supply_locations_metadata["weighting"])
+
         if ml_result.success:
             
             fitted_params = ml_result.x
             
-            if len(initial_params) == 2:
+            param_gamma = fitted_params[0]
+            supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
             
-                param_gamma = fitted_params[0]
+            if customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
+                            
                 param_lambda = fitted_params[1]                
                 param_results = [
                     float(param_gamma), 
                     float(param_lambda)
                     ]
-                
-                supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
+                                
                 customer_origins_metadata["weighting"][0]["param"] = float(param_lambda)
                 
-            elif len (initial_params) == 3:
+            elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
         
-                param_gamma = fitted_params[0]
                 param_lambda = fitted_params[1]
                 param_lambda2 = fitted_params[2]                
                 param_results = [
@@ -1010,43 +1268,91 @@ class InteractionMatrix:
                     float(param_lambda2)
                     ]
                 
-                supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
                 customer_origins_metadata["weighting"][0]["param"][0] = float(param_lambda)
-                customer_origins_metadata["weighting"][0]["param"][1] = float(param_lambda2)                          
+                customer_origins_metadata["weighting"][0]["param"][1] = float(param_lambda2)
                 
+            if attrac_vars > 1:
+
+                if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+                    fitted_params_add = 3
+                else:
+                    fitted_params_add = 2 
+
+                for key, var in supply_locations_metadata["weighting"].items():
+
+                    if key > len(supply_locations_metadata["weighting"])-fitted_params_add:
+                        break
+                    
+                    param = float(fitted_params[key+fitted_params_add])
+                    
+                    param_results = param_results + [param]
+
+                    supply_locations_metadata["weighting"][(key+1)]["param"] = float(param)
+                    
             print(f"Optimization via {method} algorithm succeeded with parameters: {', '.join(str(round(par, 3)) for par in param_results)}.")
    
         else:
 
-            param_gamma = None
-            param_lambda = None
+            # param_gamma = None
+            # param_lambda = None
             
-            supply_locations_metadata["weighting"][0]["param"] = param_gamma            
+            # supply_locations_metadata["weighting"][0]["param"] = param_gamma            
             
-            if len(initial_params) == 3:
+            # if customer_origins_metadata["weighting"][0]["func"] == "logistic":
                                
-                param_lambda2 = None                
-                customer_origins_metadata["weighting"][0]["param"][0] = param_lambda
-                customer_origins_metadata["weighting"][0]["param"][1] = param_lambda2
+            #     param_lambda2 = None                
+            #     customer_origins_metadata["weighting"][0]["param"][0] = param_lambda
+            #     customer_origins_metadata["weighting"][0]["param"][1] = param_lambda2
             
-            else:
-                customer_origins_metadata["weighting"][0]["param"] = param_lambda
+            # else:
+                
+            #     customer_origins_metadata["weighting"][0]["param"] = param_lambda
                 
             print(f"Optimiziation via {method} algorithm failed with error message: '{ml_result.message}'. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html for all available algorithms.")
 
         self.supply_locations.metadata = supply_locations_metadata    
-        self.customer_origins.metadata = customer_origins_metadata
+        self.customer_origins.metadata = customer_origins_metadata       
         
-        if ml_result.success and update_estimates:
-            
-            self.interaction_matrix_df["p_ij_emp"] = self.interaction_matrix_df["p_ij"]
-            self = self.utility()
-            self = self.probabilities()
-            self = self.flows()            
+        if update_estimates:
+
+            if "p_ij_emp" not in self.interaction_matrix_df.columns:
+                self.interaction_matrix_df["p_ij_emp"] = self.interaction_matrix_df["p_ij"]
+                print("Probabilties in interaction matrix are treated as empirical probabilties")
+            else:
+                print("Interaction matrix contains empirical probabilties")
+
+            if "E_ij_emp" not in self.interaction_matrix_df.columns:
+                self.interaction_matrix_df["E_ij_emp"] = self.interaction_matrix_df["E_ij"]
+                print("Customer interactions in interaction matrix are treated as empirical interactions")
+            else:
+                print("Interaction matrix contains empirical customer interactions")
+
+            if np.isnan(ml_result.x).any():
+
+                print("No update of estimates because fit parameters contain NaN")
+
+                update_estimates = False
+
+            else:
+
+                self = self.utility()
+                self = self.probabilities()
+                self = self.flows()            
+        
+        self.metadata["fit"] = {
+            "function": "huff_ml_fit",
+            "fit_by": fit_by,
+            "initial_params": initial_params,
+            "method": method,
+            "bounds": bounds,
+            "constraints": constraints,
+            "minimize_success": ml_result.success,
+            "minimize_fittedparams": ml_result.x,
+            "update_estimates": update_estimates
+            }
         
         return self
 
-
     def update(self):
 
         interaction_matrix_df = self.get_interaction_matrix_df()
@@ -1135,6 +1441,70 @@ class InteractionMatrix:
 
         return self
 
+class MarketAreas:
+
+    def __init__(
+        self, 
+        market_areas_df,        
+        metadata
+        ):
+
+        self.market_areas_df = market_areas_df
+        self.metadata = metadata
+   
+    def get_market_areas_df(self):
+        return self.market_areas_df
+    
+    def get_metadata(self):
+        return self.metadata
+    
+    def add_to_model(
+        self,
+        model_object,
+        output_model = "Huff"
+        ):
+        
+        if not isinstance(model_object, (HuffModel, MCIModel, InteractionMatrix)):
+            raise ValueError("Parameter 'interaction_matrix' must be of class HuffModel,  MCIModel, or InteractionMatrix")
+        
+        if isinstance(model_object, MCIModel):
+                        
+            model = MCIModel(
+                interaction_matrix = model_object.interaction_matrix,
+                coefs = model_object.get_coefs_dict(),
+                mci_ols_model = model_object.get_mci_ols_model(),
+                market_areas_df = self.market_areas_df
+                )            
+    
+        elif isinstance(model_object, HuffModel):
+            
+            model = HuffModel(
+                interaction_matrix = model_object.interaction_matrix,
+                market_areas_df = self.market_areas_df
+            )
+
+        elif isinstance(model_object, InteractionMatrix):
+
+            if output_model not in ["Huff", "MCI"]:
+                raise ValueError("Parameter 'output_model' must be either 'Huff' or 'MCI'")
+            
+            if output_model == "Huff":
+
+                model = HuffModel(
+                    interaction_matrix=model_object,
+                    market_areas_df=self.market_areas_df
+                )
+
+            if output_model == "MCI":
+
+                model = MCIModel(
+                    coefs=model_object.coefs,
+                    mci_ols_model=model_object.mci_ols_model,
+                    market_areas_df=self.market_areas_df
+                )
+
+        return model
+
 class HuffModel:
 
     def __init__(
@@ -1168,74 +1538,119 @@ class HuffModel:
         return customer_origins
 
     def get_market_areas_df(self):
+
         return self.market_areas_df
-    
+        
     def summary(self):
 
         interaction_matrix = self.interaction_matrix
 
         customer_origins_metadata = interaction_matrix.get_customer_origins().get_metadata()
         supply_locations_metadata = interaction_matrix.get_supply_locations().get_metadata()
+        interaction_matrix_metadata = interaction_matrix.get_metadata()
 
         print("Huff Model")
         print("----------------------------------")
-        print("Supply locations   " + str(supply_locations_metadata["no_points"]))
+        print("Supply locations    " + str(supply_locations_metadata["no_points"]))
         if supply_locations_metadata["attraction_col"][0] is None:
-            print("Attraction column  not defined")
+            print("Attraction column   not defined")
         else:
-            print("Attraction column  " + supply_locations_metadata["attraction_col"][0])
-        print("Customer origins   " + str(customer_origins_metadata["no_points"]))
+            print("Attraction column   " + supply_locations_metadata["attraction_col"][0])
+        print("Customer origins    " + str(customer_origins_metadata["no_points"]))
         if customer_origins_metadata["marketsize_col"] is None:
-            print("Market size column not defined")
+            print("Market size column  not defined")
         else:
-            print("Market size column " + customer_origins_metadata["marketsize_col"])
+            print("Market size column  " + customer_origins_metadata["marketsize_col"])
         print("----------------------------------")
 
         print("Partial utilities")
-        print("                   Weights")
+        print("                    Weights")
 
         if supply_locations_metadata["weighting"][0]["func"] is None and supply_locations_metadata["weighting"][0]["param"] is None:
-            print("Attraction         not defined")
+            print("Attraction          not defined")
         else:
-            print("Attraction         " + str(round(supply_locations_metadata["weighting"][0]["param"], 3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            if supply_locations_metadata["weighting"][0]["param"] is not None:
+                print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Attraction          NA" + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")   
 
         if customer_origins_metadata["weighting"][0]["func"] is None and customer_origins_metadata["weighting"][0]["param"] is None:
-            print("Transport costs    not defined")
+            print("Transport costs     not defined")
         elif customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
-            print("Transport costs   " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs     " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
-            print("Transport costs   " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            if customer_origins_metadata["weighting"][0]["param"] is not None:
+                print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"][0],3)) + ", " + str(round(customer_origins_metadata["weighting"][0]["param"][1],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            else:
+                print("Transport costs     NA" + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
 
-        print("----------------------------------")
+        attrac_vars = supply_locations_metadata["attraction_col"]
+        attrac_vars_no = len(attrac_vars)
         
-        huff_modelfit = self.modelfit()
-        if huff_modelfit is not None:
-            
-            print ("Goodness-of-fit for probabilities")
+        if attrac_vars_no > 1:
+                        
+            for key, attrac_var in enumerate(attrac_vars):
+                
+                if key == 0:
+                    continue
+                
+                if key not in supply_locations_metadata["weighting"].keys():
                     
-            print("Sum of squared residuals       ", round(huff_modelfit[1]["SQR"], 2))
-            print("Sum of squares                 ", round(huff_modelfit[1]["SQT"], 2))
-            print("R-squared                      ", round(huff_modelfit[1]["Rsq"], 2))
-            print("Mean squared error             ", round(huff_modelfit[1]["MSE"], 2))
-            print("Root mean squared error        ", round(huff_modelfit[1]["RMSE"], 2))
-            print("Mean absolute error            ", round(huff_modelfit[1]["MAE"], 2))
-            print("Mean absolute percentage error ", round(huff_modelfit[1]["MAPE"], 2))
-            print("Absolute percentage errors")
+                    print(f"{attrac_vars[key][:16]:16}    not defined")
+                    
+                else:
+
+                    name = supply_locations_metadata["weighting"][key]["name"]
+                    param = supply_locations_metadata["weighting"][key]["param"]
+                    func = supply_locations_metadata["weighting"][key]["func"]
+
+                    print(f"{name[:16]:16}    {round(param, 3)} ({func})")
+                    
+        print("----------------------------------")
+
+        if interaction_matrix_metadata != {} and "fit" in interaction_matrix_metadata and interaction_matrix_metadata["fit"]["function"] is not None:
+            print("Parameter estimation")
+            print("Fit function        " + interaction_matrix_metadata["fit"]["function"])
+            print("Fit by              " + interaction_matrix_metadata["fit"]["fit_by"])
+            if interaction_matrix_metadata["fit"]["function"] == "huff_ml_fit":
+                print("Fit method          " + interaction_matrix_metadata["fit"]["method"] + " (Converged: " + str(interaction_matrix_metadata["fit"]["minimize_success"]) + ")")
+
+            huff_modelfit = self.modelfit(by = interaction_matrix_metadata["fit"]["fit_by"])
             
-            APE_list = [
-                ["< 5 % ", round(huff_modelfit[1]["APE"]["resid_below5"], 2), "  < 30 % ", round(huff_modelfit[1]["APE"]["resid_below30"], 2)],
-                ["< 10 % ", round(huff_modelfit[1]["APE"]["resid_below10"], 2), "  < 35 % ", round(huff_modelfit[1]["APE"]["resid_below35"], 2)],
-                ["< 15 % ", round(huff_modelfit[1]["APE"]["resid_below15"], 2), "  < 40 % ", round(huff_modelfit[1]["APE"]["resid_below40"], 2)],
-                ["< 20 % ", round(huff_modelfit[1]["APE"]["resid_below20"], 2), "  < 45 % ", round(huff_modelfit[1]["APE"]["resid_below45"], 2)],
-                ["< 25% ", round(huff_modelfit[1]["APE"]["resid_below25"], 2), "  < 50 % ", round(huff_modelfit[1]["APE"]["resid_below50"], 2)]
-                ]
-            APE_df = pd.DataFrame(
-                APE_list,
-                columns=["Resid.", "%", "Resid.", "%"]
-                )
-            print(APE_df.to_string(index=False))
-                  
-            print("----------------------------------")
+            if huff_modelfit is not None:
+                
+                print ("Goodness-of-fit for " + interaction_matrix_metadata["fit"]["fit_by"])
+                        
+                print("Sum of squared residuals       ", round(huff_modelfit[1]["SQR"], 2))
+                print("Sum of squares                 ", round(huff_modelfit[1]["SQT"], 2))
+                print("R-squared                      ", round(huff_modelfit[1]["Rsq"], 2))
+                print("Mean squared error             ", round(huff_modelfit[1]["MSE"], 2))
+                print("Root mean squared error        ", round(huff_modelfit[1]["RMSE"], 2))
+                print("Mean absolute error            ", round(huff_modelfit[1]["MAE"], 2))
+                if huff_modelfit[1]["MAPE"] is not None:
+                    print("Mean absolute percentage error ", round(huff_modelfit[1]["MAPE"], 2))
+                else:
+                    print("Mean absolute percentage error  Not calculated")
+                print("Symmetric MAPE                 ", round(huff_modelfit[1]["sMAPE"], 2))
+                print("Absolute percentage errors")
+                
+                APE_list = [
+                    ["< 5 % ", round(huff_modelfit[1]["APE"]["resid_below5"], 2), "  < 30 % ", round(huff_modelfit[1]["APE"]["resid_below30"], 2)],
+                    ["< 10 % ", round(huff_modelfit[1]["APE"]["resid_below10"], 2), "  < 35 % ", round(huff_modelfit[1]["APE"]["resid_below35"], 2)],
+                    ["< 15 % ", round(huff_modelfit[1]["APE"]["resid_below15"], 2), "  < 40 % ", round(huff_modelfit[1]["APE"]["resid_below40"], 2)],
+                    ["< 20 % ", round(huff_modelfit[1]["APE"]["resid_below20"], 2), "  < 45 % ", round(huff_modelfit[1]["APE"]["resid_below45"], 2)],
+                    ["< 25% ", round(huff_modelfit[1]["APE"]["resid_below25"], 2), "  < 50 % ", round(huff_modelfit[1]["APE"]["resid_below50"], 2)]
+                    ]
+                APE_df = pd.DataFrame(
+                    APE_list,
+                    columns=["Resid.", "%", "Resid.", "%"]
+                    )
+                print(APE_df.to_string(index=False))
+                    
+                print("----------------------------------")
 
     def mci_fit(
         self,
@@ -1302,6 +1717,15 @@ class HuffModel:
 
         customer_origins.metadata = customer_origins_metadata
         supply_locations.metadata = supply_locations_metadata
+        
+        interaction_matrix_metadata = {
+            "fit": {
+                "function": "mci_fit",
+                "fit_by": "probabilities",
+                "method": "OLS"
+                }
+            }
+        
         interaction_matrix = InteractionMatrix(
             interaction_matrix_df,
             customer_origins,
@@ -1318,6 +1742,275 @@ class HuffModel:
         
         return mci_model
 
+    def loglik(
+        self,
+        params
+        ):
+
+        if not isinstance(params, list):
+            if isinstance(params, np.ndarray):
+                params = params.tolist()
+            else:
+                raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+        
+        if len(params) < 2:
+            raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+        
+        market_areas_df = self.market_areas_df
+        
+        customer_origins = self.interaction_matrix.customer_origins
+        customer_origins_metadata = customer_origins.get_metadata()
+        
+        param_gamma, param_lambda = params[0], params[1]
+            
+        if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+            if len(params) < 3:
+                raise ValueError("When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
+        
+            param_gamma, param_lambda, param_lambda2 = params[0], params[1], params[2]
+
+        supply_locations = self.interaction_matrix.supply_locations
+        supply_locations_metadata = supply_locations.get_metadata()        
+
+        supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
+        supply_locations.metadata = supply_locations_metadata
+
+        if customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
+            
+            if len(params) >= 2:
+
+                customer_origins_metadata["weighting"][0]["param"] = float(param_lambda)
+            
+            else:
+                
+                raise ValueError ("Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
+        
+        elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+            if len(params) >= 3:
+                
+                customer_origins_metadata["weighting"][0]["param"] = [float(param_lambda), float(param_lambda2)]
+            
+            else:
+
+                raise ValueError("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
+
+        if (customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"] and len(params) > 2): 
+            
+            for key, param in enumerate(params):
+
+                if key <= 1:
+                    continue
+
+                supply_locations_metadata["weighting"][key-1]["param"] = float(param)
+
+        if (customer_origins_metadata["weighting"][0]["func"] == "logistic" and len(params) > 3):
+
+            for key, param in enumerate(params):
+
+                if key <= 2:
+                    continue
+
+                supply_locations_metadata["weighting"][key-2]["param"] = float(param)
+
+        customer_origins.metadata = customer_origins_metadata        
+       
+        if "T_j_emp" not in market_areas_df.columns:
+            T_j_emp = market_areas_df["T_j"]
+        else:
+            T_j_emp = market_areas_df["T_j_emp"]
+
+
+        huff_model_copy = copy.deepcopy(self)
+
+        interaction_matrix_copy = copy.deepcopy(huff_model_copy.interaction_matrix)
+
+        interaction_matrix_copy = interaction_matrix_copy.utility()
+        interaction_matrix_copy = interaction_matrix_copy.probabilities()
+        interaction_matrix_copy = interaction_matrix_copy.flows()
+
+        huff_model_copy = interaction_matrix_copy.marketareas()
+
+        market_areas_df_copy = huff_model_copy.market_areas_df
+
+        observed = T_j_emp
+        expected = market_areas_df_copy["T_j"]
+        
+        modelfit_metrics = modelfit(
+            observed = observed,
+            expected = expected
+        )
+
+        LL = modelfit_metrics[1]["LL"]
+      
+        return -LL
+
+    def ml_fit(
+        self,
+        initial_params: list = [1.0, -2.0],
+        method: str = "L-BFGS-B",
+        bounds: list = [(0.5, 1), (-3, -1)],        
+        constraints: list = [],
+        fit_by = "probabilities",
+        update_estimates: bool = True
+        ):
+        
+        if fit_by in ["probabilities", "flows"]:
+
+            self.interaction_matrix.huff_ml_fit(
+                initial_params = initial_params,
+                method = method,
+                bounds = bounds,        
+                constraints = constraints,
+                fit_by = fit_by,
+                update_estimates = update_estimates
+                )
+        
+        elif fit_by == "totals":
+            
+            supply_locations = self.interaction_matrix.supply_locations
+            supply_locations_metadata = supply_locations.get_metadata()
+        
+            customer_origins = self.interaction_matrix.customer_origins
+            customer_origins_metadata = customer_origins.get_metadata()
+
+            if customer_origins_metadata["weighting"][0]["param"] is None:            
+                params_metadata_customer_origins = 1            
+            else:            
+                if customer_origins_metadata["weighting"][0]["param"] is not None:
+                    if isinstance(customer_origins_metadata["weighting"][0]["param"], (int, float)):
+                        params_metadata_customer_origins = 1
+                    else:
+                        params_metadata_customer_origins = len(customer_origins_metadata["weighting"][0]["param"])
+            
+            if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+                params_metadata_customer_origins = 2
+            else:
+                params_metadata_customer_origins = 1
+                
+            params_metadata_supply_locations = len(supply_locations_metadata["weighting"])
+            
+            params_metadata = params_metadata_customer_origins+params_metadata_supply_locations
+
+            if len(initial_params) < 2 or len(initial_params) != params_metadata:
+                raise ValueError("Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
+            
+            if len(bounds) != len(initial_params):            
+                raise ValueError("Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
+
+            ml_result = minimize(
+                self.loglik,
+                initial_params,
+                method = method,
+                bounds = bounds,
+                constraints = constraints,
+                options={'disp': 3}
+                )
+            
+            attrac_vars = len(supply_locations_metadata["weighting"])
+
+            if ml_result.success:
+                
+                fitted_params = ml_result.x
+                
+                param_gamma = fitted_params[0]
+                supply_locations_metadata["weighting"][0]["param"] = float(param_gamma)
+                
+                if customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"]:
+                                
+                    param_lambda = fitted_params[1]                
+                    param_results = [
+                        float(param_gamma), 
+                        float(param_lambda)
+                        ]
+                                    
+                    customer_origins_metadata["weighting"][0]["param"] = float(param_lambda)
+                    
+                elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
+            
+                    param_lambda = fitted_params[1]
+                    param_lambda2 = fitted_params[2]                
+                    param_results = [
+                        float(param_gamma), 
+                        float(param_lambda), 
+                        float(param_lambda2)
+                        ]
+                    
+                    customer_origins_metadata["weighting"][0]["param"][0] = float(param_lambda)
+                    customer_origins_metadata["weighting"][0]["param"][1] = float(param_lambda2)
+                    
+                if attrac_vars > 1:
+
+                    if customer_origins_metadata["weighting"][0]["func"] == "logistic":
+                        fitted_params_add = 3
+                    else:
+                        fitted_params_add = 2 
+
+                    for key, var in supply_locations_metadata["weighting"].items():
+
+                        if key > len(supply_locations_metadata["weighting"])-fitted_params_add:
+                            break
+                        
+                        param = float(fitted_params[key+fitted_params_add])
+                        
+                        param_results = param_results + [param]
+
+                        supply_locations_metadata["weighting"][(key+1)]["param"] = float(param)
+                        
+                print(f"Optimization via {method} algorithm succeeded with parameters: {', '.join(str(round(par, 3)) for par in param_results)}.")
+    
+            else:
+                   
+                print(f"Optimiziation via {method} algorithm failed with error message: '{ml_result.message}'. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html for all available algorithms.")
+
+            self.interaction_matrix.supply_locations.metadata = supply_locations_metadata    
+            self.interaction_matrix.customer_origins.metadata = customer_origins_metadata
+
+            if update_estimates:
+
+                if "T_j_emp" not in self.market_areas_df.columns:
+
+                    self.market_areas_df["T_j_emp"] = self.market_areas_df["T_j"]
+                    
+                    print("NOTE: Total values in market areas df are treated as empirical total values")
+                
+                else:
+
+                    print("NOTE: Total market areas df contains empirical total values")
+
+                if np.isnan(ml_result.x).any():
+
+                    print("WARNING: No update of estimates because fit parameters contain NaN")
+
+                    update_estimates = False
+
+                else:
+
+                    self.interaction_matrix.utility()
+                    self.interaction_matrix.probabilities()
+                    self.interaction_matrix.flows()
+                    
+                    self.interaction_matrix.marketareas()
+            
+            self.interaction_matrix.metadata["fit"] = {
+                "function": "huff_ml_fit",
+                "fit_by": fit_by,
+                "initial_params": initial_params,
+                "method": method,
+                "bounds": bounds,
+                "constraints": constraints,
+                "minimize_success": ml_result.success,
+                "minimize_fittedparams": ml_result.x,
+                "update_estimates": update_estimates
+                }
+            
+        else:
+
+            raise ValueError("Parameter 'fit_by' must be 'probabilities', 'flows' or 'totals'")
+
+        return self
+
     def update(self):
         
         self.interaction_matrix = self.interaction_matrix.update()
@@ -1326,30 +2019,94 @@ class HuffModel:
         
         return self
     
-    def modelfit(self):
-        
-        interaction_matrix = self.interaction_matrix        
-        interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+    def modelfit(
+        self,
+        by = "probabilities"
+        ):       
         
-        if ("p_ij" in interaction_matrix_df.columns and "p_ij_emp" in interaction_matrix_df.columns):
+        if by == "probabilities":
+
+            interaction_matrix = self.interaction_matrix        
+            interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+
+            if ("p_ij" in interaction_matrix_df.columns and "p_ij_emp" in interaction_matrix_df.columns):
+                
+                try:
+                
+                    huff_modelfit = modelfit(
+                        interaction_matrix_df["p_ij_emp"],
+                        interaction_matrix_df["p_ij"]
+                    )
+                    
+                    return huff_modelfit
+                    
+                except:
+                    
+                    print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    return None
             
-            try:
+            else:
+                
+                print("Goodness-of-fit metrics could not be calculated. No empirical values of probabilities in interaction matrix.")
+
+                return None
             
-                huff_modelfit = modelfit(
-                    interaction_matrix_df["p_ij_emp"],
-                    interaction_matrix_df["p_ij"]
-                )
+        elif by == "flows":
+
+            interaction_matrix = self.interaction_matrix        
+            interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+
+            if ("E_ij" in interaction_matrix_df.columns and "E_ij_emp" in interaction_matrix_df.columns):
                 
-                return huff_modelfit
+                try:
                 
-            except:
+                    huff_modelfit = modelfit(
+                        interaction_matrix_df["E_ij_emp"],
+                        interaction_matrix_df["E_ij"]
+                    )
+                    
+                    return huff_modelfit
+                    
+                except:
+                    
+                    print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    return None
+            
+            else:
                 
-                print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                print("Goodness-of-fit metrics could not be calculated. No empirical values of customer flows in interaction matrix.")
+
                 return None
-        
-        else:
             
-            return None
+        elif by == "totals":
+
+            market_areas_df = self.market_areas_df
+
+            if ("T_j" in market_areas_df.columns and "T_j_emp" in market_areas_df.columns):
+                
+                try:
+                
+                    huff_modelfit = modelfit(
+                        market_areas_df["T_j_emp"],
+                        market_areas_df["T_j"]
+                    )
+                    
+                    return huff_modelfit
+                    
+                except:
+                    
+                    print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    return None
+                
+            else:
+                
+                print("Goodness-of-fit metrics could not be calculated. No empirical values of T_j in market areas data.")
+
+                return None
+
+        else:
+
+            raise ValueError("Parameter 'by' must be 'probabilities', 'flows', or 'totals'")
     
 class MCIModel:
 
@@ -1472,7 +2229,11 @@ class MCIModel:
             print("Mean squared error             ", round(mci_modelfit[1]["MSE"], 2))
             print("Root mean squared error        ", round(mci_modelfit[1]["RMSE"], 2))
             print("Mean absolute error            ", round(mci_modelfit[1]["MAE"], 2))
-            print("Mean absolute percentage error ", round(mci_modelfit[1]["MAPE"], 2))
+            if mci_modelfit[1]["MAPE"] is not None:
+                print("Mean absolute percentage error ", round(mci_modelfit[1]["MAPE"], 2))
+            else:
+                print("Mean absolute percentage error  Not calculated")
+            print("Symmetric MAPE                 ", round(mci_modelfit[1]["sMAPE"], 2))
             
             print("Absolute percentage errors")
             APE_list = [
@@ -1559,8 +2320,11 @@ class MCIModel:
         interaction_matrix = self.interaction_matrix        
         interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
         
-        if "p_ij" in interaction_matrix_df.columns:
+        if "p_ij" in interaction_matrix_df.columns and "p_ij_emp" not in interaction_matrix_df.columns:
+            print("NOTE: Probabilities in interaction matrix are treated as empirical probabilities")
             interaction_matrix_df["p_ij_emp"] = interaction_matrix_df["p_ij"]
+        else:
+            print("NOTE: Interaction matrix contains empirical probabilities")
 
         if "U_ij" not in interaction_matrix_df.columns:
             self.utility(transformation = transformation)
@@ -1720,6 +2484,7 @@ def load_geodata (
         "marketsize_col": None,
         "weighting": {
             0: {
+                "name": None,
                 "func": None, 
                 "param": None
                 }
@@ -1727,7 +2492,7 @@ def load_geodata (
         "crs_input": crs_input,
         "crs_output": crs_output,
         "no_points": len(geodata_gpd)
-        }    
+        }
     
     if location_type == "origins":
 
@@ -1848,8 +2613,10 @@ def load_interaction_matrix(
     csv_sep = ";", 
     csv_decimal = ",", 
     csv_encoding="unicode_escape",
+    xlsx_sheet: str = None,
     crs_input = "EPSG:4326",
-    crs_output = "EPSG:4326"
+    crs_output = "EPSG:4326",
+    check_df_vars = True
     ):    
 
     if isinstance(data, pd.DataFrame):
@@ -1865,7 +2632,13 @@ def load_interaction_matrix(
                 encoding = csv_encoding
                 )    
         elif data_type == "xlsx":
-            interaction_matrix_df = pd.read_excel(data)
+            if xlsx_sheet is not None:
+                interaction_matrix_df = pd.read_excel(
+                    data, 
+                    sheet_name=xlsx_sheet
+                    )
+            else:
+                interaction_matrix_df = pd.read_excel(data)
         else:
             raise TypeError("Unknown type of data")
     else:
@@ -1884,10 +2657,11 @@ def load_interaction_matrix(
     if market_size_col is not None:
         cols_check = cols_check + [market_size_col]
 
-    check_vars(
-        interaction_matrix_df,
-        cols = cols_check
-        )
+    if check_df_vars:
+        check_vars(
+            interaction_matrix_df,
+            cols = cols_check
+            )
 
     if customer_origins_coords_col is not None:
 
@@ -1942,6 +2716,7 @@ def load_interaction_matrix(
         "marketsize_col": market_size_col,
         "weighting": {
             0: {
+                "name": None,
                 "func": None, 
                 "param": None
                 }
@@ -2009,6 +2784,7 @@ def load_interaction_matrix(
         "marketsize_col": None,
         "weighting": {
             0: {
+                "name": None,
                 "func": None, 
                 "param": None
                 }
@@ -2056,7 +2832,12 @@ def load_interaction_matrix(
             }
             )
     
-    metadata = {}
+    metadata = {
+        "fit": {
+            "function": None,
+            "fit_by": None
+        }
+    }
 
     interaction_matrix = InteractionMatrix(
         interaction_matrix_df=interaction_matrix_df,
@@ -2067,6 +2848,74 @@ def load_interaction_matrix(
     
     return interaction_matrix
 
+def load_marketareas(
+    data,
+    supply_locations_col: str,
+    total_col: str,  
+    data_type = "csv", 
+    csv_sep = ";", 
+    csv_decimal = ",", 
+    csv_encoding="unicode_escape",
+    xlsx_sheet: str = None,
+    check_df_vars = True
+    ):    
+
+    if isinstance(data, pd.DataFrame):
+        market_areas_df = data
+    elif isinstance(data, str):
+        if data_type not in ["csv", "xlsx"]:
+            raise ValueError ("data_type must be 'csv' or 'xlsx'")
+        if data_type == "csv":
+            market_areas_df = pd.read_csv(
+                data, 
+                sep = csv_sep, 
+                decimal = csv_decimal, 
+                encoding = csv_encoding
+                )    
+        elif data_type == "xlsx":            
+            if xlsx_sheet is not None:
+                market_areas_df = pd.read_excel(
+                    data, 
+                    sheet_name=xlsx_sheet
+                    )
+            else:
+                market_areas_df = pd.read_excel(data)
+        else:
+            raise TypeError("Unknown type of data")
+    else:
+        raise TypeError("data must be pandas.DataFrame or file (.csv, .xlsx)")
+    
+    if supply_locations_col not in market_areas_df.columns:
+        raise KeyError ("Column " + supply_locations_col + " not in data")
+    if total_col not in market_areas_df.columns:
+        raise KeyError ("Column " + supply_locations_col + " not in data")
+    
+    if check_df_vars:
+        check_vars(
+            market_areas_df,
+            cols = [total_col]
+            )
+    
+    market_areas_df = market_areas_df.rename(
+        columns = {
+            supply_locations_col: "j",
+            total_col: "T_j"
+        }
+        )
+    
+    metadata = {
+        "unique_id": supply_locations_col,
+        "total_col": total_col,
+        "no_points": len(market_areas_df)
+        }
+    
+    market_areas = MarketAreas(
+        market_areas_df,
+        metadata
+        )
+    
+    return market_areas  
+
 def market_shares(
     df: pd.DataFrame,
     turnover_col: str,
@@ -2250,7 +3099,8 @@ def get_isochrones(
 def modelfit(
     observed, 
     expected,
-    remove_nan: bool = True 
+    remove_nan: bool = True,
+    verbose: bool = False
     ):
 
     observed_no = len(observed)
@@ -2276,6 +3126,10 @@ def modelfit(
             )
         
         obs_exp_clean = obs_exp.dropna(subset=["observed", "expected"])
+
+        if len(obs_exp_clean) < len(observed) or len(obs_exp_clean) < len(expected):
+            if verbose:
+                print("Vectors 'observed' and/or 'expected' contain zeros which are dropped.")
         
         observed = obs_exp_clean["observed"].to_numpy()
         expected = obs_exp_clean["expected"].to_numpy()
@@ -2291,7 +3145,16 @@ def modelfit(
     residuals_sq = residuals**2
     residuals_abs = abs(residuals)
  
-    APE = abs(observed-expected)/observed*100
+    if any(observed == 0):
+        if verbose:
+            print ("Vector 'observed' contains values equal to zero. No APE/MAPE calculated.")
+        APE = np.full_like(observed, np.nan)
+        MAPE = None
+    else:
+        APE = abs(observed-expected)/observed*100
+        MAPE = float(np.mean(APE))
+        
+    sAPE = abs(observed-expected)/((abs(observed)+abs(expected))/2)*100
     
     data_residuals = pd.DataFrame({
         "observed": observed,
@@ -2299,7 +3162,8 @@ def modelfit(
         "residuals": residuals,
         "residuals_sq": residuals_sq,
         "residuals_abs": residuals_abs,
-        "APE": APE
+        "APE": APE,
+        "sAPE": sAPE
         })
 
     SQR = float(np.sum(residuals_sq))
@@ -2310,7 +3174,9 @@ def modelfit(
     MSE = float(SQR/observed_no)
     RMSE = float(sqrt(MSE))
     MAE = float(SAR/observed_no)
-    MAPE = float(np.mean(APE))
+    LL = np.sum(np.log(residuals_sq))
+    
+    sMAPE = float(np.mean(sAPE))
 
     resid_below5 = float(len(data_residuals[data_residuals["APE"] < 5])/expected_no*100)
     resid_below10 = float(len(data_residuals[data_residuals["APE"] < 10])/expected_no*100)
@@ -2332,6 +3198,8 @@ def modelfit(
         "RMSE": RMSE,
         "MAE": MAE,
         "MAPE": MAPE,
+        "sMAPE": sMAPE,
+        "LL": -LL,
         "APE": {
             "resid_below5": resid_below5,
             "resid_below10": resid_below10,
@@ -2353,34 +3221,23 @@ def modelfit(
 
     return modelfit_results
 
-def loglik(
-    observed,
-    expected    
-    ):
-
-        model_fit = modelfit(
-            observed, 
-            expected
-            )    
-        residuals_sq = model_fit[0]["residuals_sq"]
-        
-        LL = np.sum(np.log(residuals_sq))
-
-        return -LL
-
 def check_vars(
     df: pd.DataFrame,
-    cols: list
+    cols: list,
+    check_numeric: bool = True,
+    check_zero: bool = True
     ):
 
     for col in cols:
         if col not in df.columns:
             raise KeyError(f"Column '{col}' not in dataframe.")
     
-    for col in cols:
-        if not pd.api.types.is_numeric_dtype(df[col]):
-            raise ValueError(f"Column '{col}' is not numeric. All stated columns must be numeric.")
+    if check_numeric:
+        for col in cols:
+            if not pd.api.types.is_numeric_dtype(df[col]):
+                raise ValueError(f"Column '{col}' is not numeric. All stated columns must be numeric.")
     
-    for col in cols:
-        if (df[col] <= 0).any():
-            raise ValueError(f"Column '{col}' includes values <= 0. All values must be numeric and positive.")
+    if check_zero:
+        for col in cols:
+            if (df[col] <= 0).any():
+                raise ValueError(f"Column '{col}' includes values <= 0. All values must be numeric and positive.")