huff 1.4.0__py3-none-any.whl → 1.5.0__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.0
-# Last update: 2025-06-10 17:17
+# Version:     1.5.0
+# Last update: 2025-06-25 18:32
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -17,7 +17,7 @@ from math import sqrt
 import time
 from pandas.api.types import is_numeric_dtype
 from statsmodels.formula.api import ols
-from scipy.optimize import minimize
+from scipy.optimize import minimize, Bounds, LinearConstraint, NonlinearConstraint
 from shapely.geometry import Point
 from shapely import wkt
 import copy
@@ -77,9 +77,9 @@ class CustomerOrigins:
         if metadata["weighting"][0]["func"] is None and metadata["weighting"][0]["param"] is None:
             print("Transport cost weighting    not defined")
         elif metadata["weighting"][0]["func"] in ["power", "exponential"]:
-            print("Transport cost weighting   " + str(metadata["weighting"][0]["param"]) + " (" + metadata["weighting"][0]["func"] + ")")
+            print("Transport cost weighting   " + str(round(metadata["weighting"][0]["param"],3)) + " (" + metadata["weighting"][0]["func"] + ")")
         elif metadata["weighting"][0]["func"] == "logistic":
-            print("Transport cost weighting   " + str(metadata["weighting"][0]["param"][0]) + ", " + str(metadata["weighting"][0]["param"][1]) + " (" + metadata["weighting"][0]["func"] + ")")
+            print("Transport cost weighting   " + str(round(metadata["weighting"][0]["param"][0],3)) + ", " + str(round(metadata["weighting"][0]["param"][1],3)) + " (" + metadata["weighting"][0]["func"] + ")")
 
         print("Unique ID column           " + metadata["unique_id"])
         print("Input CRS                  " + str(metadata["crs_input"]))
@@ -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):
@@ -207,7 +226,6 @@ class CustomerOrigins:
 
         return self
 
-
 class SupplyLocations:
 
     def __init__(
@@ -260,7 +278,7 @@ class SupplyLocations:
         if metadata["weighting"][0]["func"] is None and metadata["weighting"][0]["param"] is None:
             print("Attraction weighting  not defined")
         else:
-            print("Attraction weighting  " + metadata["weighting"][0]["func"] + " with gamma = " + str(metadata["weighting"][0]["param"]))
+            print("Attraction weighting  " + metadata["weighting"][0]["func"] + " with gamma = " + str(round(metadata["weighting"][0]["param"],3)))
         
         print("Unique ID column      " + metadata["unique_id"])
         print("Input CRS             " + str(metadata["crs_input"]))
@@ -300,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
@@ -324,6 +344,7 @@ class SupplyLocations:
         metadata["attraction_col"] = metadata["attraction_col"] + [var] 
 
         metadata["weighting"][new_key] = {
+            "name": var,
             "func": func,
             "param": param
             }
@@ -342,7 +363,11 @@ class SupplyLocations:
         metadata = self.get_metadata()
 
         new_destinations_gpd_original = new_destinations.get_geodata_gpd_original()
+        new_destinations_gpd_original["j_update"] = 1
+        
         new_destinations_gpd = new_destinations.get_geodata_gpd()
+        new_destinations_gpd["j_update"] = 1
+        
         new_destinations_metadata = new_destinations.get_metadata()
 
         if list(new_destinations_gpd_original.columns) != list(geodata_gpd_original.columns):
@@ -350,14 +375,20 @@ class SupplyLocations:
         if list(new_destinations_gpd.columns) != list(geodata_gpd.columns):
             raise KeyError("Supply locations and new destinations data have different column names.")
 
-        geodata_gpd_original = geodata_gpd_original.append(
-            new_destinations_gpd_original, 
+        geodata_gpd_original = pd.concat(
+            [
+                geodata_gpd_original, 
+                new_destinations_gpd_original
+                ], 
             ignore_index=True
             )
-        
-        geodata_gpd = geodata_gpd.append(
-            new_destinations_gpd, 
-            ignore_index=True
+                
+        geodata_gpd = pd.concat(
+            [
+                geodata_gpd, 
+                new_destinations_gpd
+                ], 
+                ignore_index=True
             )
         
         metadata["no_points"] = metadata["no_points"]+new_destinations_metadata["no_points"]
@@ -440,13 +471,15 @@ class InteractionMatrix:
         self, 
         interaction_matrix_df,
         customer_origins,
-        supply_locations
+        supply_locations,
+        metadata
         ):
 
         self.interaction_matrix_df = interaction_matrix_df
         self.customer_origins = customer_origins
         self.supply_locations = supply_locations
-    
+        self.metadata = metadata
+
     def get_interaction_matrix_df(self):
         return self.interaction_matrix_df
     
@@ -456,41 +489,84 @@ class InteractionMatrix:
     def get_supply_locations(self):
         return self.supply_locations
     
+    def get_metadata(self):
+        return self.metadata
+
     def summary(self):
 
         customer_origins_metadata = self.get_customer_origins().get_metadata()
         supply_locations_metadata = self.get_supply_locations().get_metadata()
+        interaction_matrix_metadata = self.get_metadata()
 
         print("Interaction Matrix")
         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")
         else:
-            print("Market size column " + customer_origins_metadata["marketsize_col"])
+            print("Market size column  " + customer_origins_metadata["marketsize_col"])
+
+        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")
+        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(supply_locations_metadata["weighting"][0]["param"]) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"],3)) + " (" + 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(customer_origins_metadata["weighting"][0]["param"]) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
-            print("Transport costs   " + str(customer_origins_metadata["weighting"][0]["param"][0]) + ", " + str(customer_origins_metadata["weighting"][0]["param"][1]) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            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"] + ")")
+      
+
+        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:
+
+                    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"])
+
     def transport_costs(
         self,
         network: bool = True,
@@ -508,6 +584,7 @@ class InteractionMatrix:
             range_type = "distance"
         
         interaction_matrix_df = self.get_interaction_matrix_df()
+        interaction_matrix_metadata = self.get_metadata()
 
         customer_origins = self.get_customer_origins()
         customer_origins_geodata_gpd = customer_origins.get_geodata_gpd()
@@ -588,14 +665,87 @@ class InteractionMatrix:
             if distance_unit == "kilometers":
                 interaction_matrix_df["t_ij"] = interaction_matrix_df["t_ij"]/1000
 
+        interaction_matrix_metadata["transport_costs"] = {
+            "network": network,
+            "range_type": range_type,
+            "time_unit": time_unit,
+            "distance_unit": distance_unit,
+            "ors_server": ors_server,
+            "ors_auth": ors_auth
+            }
+
         self.interaction_matrix_df = interaction_matrix_df
+        self.metadata = interaction_matrix_metadata
 
         return self
     
+    def define_weightings(
+        self,
+        vars_funcs: dict
+        ):
+        
+        """
+        vars_funcs = {
+            0: {
+                "name": "A_j",
+                "func": "power"
+            },
+            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"]
+    
+        customer_origins_metadata["weighting"][0]["name"] = vars_funcs[1]["name"]
+        customer_origins_metadata["weighting"][0]["func"] = vars_funcs[1]["func"]
+
+        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"]
+                supply_locations_metadata["weighting"][key-1]["param"] = None
+
+        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():
@@ -609,6 +759,7 @@ class InteractionMatrix:
         customer_origins = self.customer_origins
         customer_origins_metadata = customer_origins.get_metadata()
         tc_weighting = customer_origins_metadata["weighting"][0]
+        
         if tc_weighting["func"] == "power":
             interaction_matrix_df["t_ij_weighted"] = interaction_matrix_df["t_ij"] ** tc_weighting["param"]
         elif tc_weighting["func"] == "exponential":
@@ -621,6 +772,7 @@ class InteractionMatrix:
         supply_locations = self.supply_locations
         supply_locations_metadata = supply_locations.get_metadata()
         attraction_weighting = supply_locations_metadata["weighting"][0]
+        
         if attraction_weighting["func"] == "power":
             interaction_matrix_df["A_j_weighted"] = interaction_matrix_df["A_j"] ** attraction_weighting["param"]
         elif tc_weighting["func"] == "exponential":
@@ -628,19 +780,51 @@ 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'])
+        interaction_matrix_df = interaction_matrix_df.drop(columns=["A_j_weighted", "t_ij_weighted"])
 
-        self.interaction_matrix_df = interaction_matrix_df
+        interaction_matrix_metadata["model"] = {
+            "model_type": "Huff"
+            }
 
+        self.interaction_matrix_df = interaction_matrix_df
+        self.metadata = interaction_matrix_metadata
+        
         return self
     
     def probabilities (self):
 
         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
 
@@ -666,6 +850,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()")
 
@@ -775,6 +961,8 @@ class InteractionMatrix:
 
         interaction_matrix_df = self.get_interaction_matrix_df()
 
+        interaction_matrix_metadata = self.get_metadata()
+
         cols_t = [col + "__LCT" for col in cols]
 
         if "p_ij__LCT" not in interaction_matrix_df.columns:
@@ -826,10 +1014,20 @@ 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,
-            supply_locations
+            supply_locations,
+            metadata=interaction_matrix_metadata
             )
         
         mci_model = MCIModel(
@@ -841,7 +1039,391 @@ class InteractionMatrix:
         
         return mci_model
 
+    def loglik(
+        self,
+        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 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")
+        
+        customer_origins_metadata = self.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["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
+
+        p_ij_emp = interaction_matrix_df["p_ij"]
+        E_ij_emp = interaction_matrix_df["E_ij"]         
+        
+        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()
+        
+        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
+        
+        LL = loglik(
+            observed = observed,
+            expected = expected
+            )        
+       
+        return -LL
+    
+    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
+        ):       
+
+        supply_locations = self.supply_locations
+        supply_locations_metadata = supply_locations.get_metadata()
+        
+        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:
+                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,
+            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
+            
+            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:
+
+            param_gamma = None
+            param_lambda = None
+            
+            supply_locations_metadata["weighting"][0]["param"] = param_gamma            
+            
+            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
+            
+            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
+        
+        if ml_result.success and update_estimates:
+            
+            self.metadata["fit"] = {
+                "function": "huff_ml_fit",
+                "fit_by": fit_by,
+                "initial_params": initial_params,
+                "method": method,
+                "bounds": bounds,
+                "constraints": constraints
+                }
+                
+            
+            self.interaction_matrix_df["p_ij_emp"] = self.interaction_matrix_df["p_ij"]
+            self.interaction_matrix_df["E_ij_emp"] = self.interaction_matrix_df["E_ij"]
+            
+            self = self.utility()
+            self = self.probabilities()
+            self = self.flows()            
+        
+        return self
+
+    def update(self):
+
+        interaction_matrix_df = self.get_interaction_matrix_df()
+        
+        interaction_matrix_metadata = self.get_metadata()
+
+        customer_origins = self.get_customer_origins()
+
+        supply_locations = self.get_supply_locations()        
+     
+        supply_locations_geodata_gpd = supply_locations.get_geodata_gpd().copy()
+        supply_locations_geodata_gpd_new = supply_locations_geodata_gpd[supply_locations_geodata_gpd["j_update"] == 1]
+        
+        if len(supply_locations_geodata_gpd_new) < 1:
+            raise ValueError("There are no new destinations for an interaction matrix update. Use SupplyLocations.add_new_destinations()")
+
+        supply_locations_geodata_gpd_original = supply_locations.get_geodata_gpd_original().copy()        
+        supply_locations_geodata_gpd_original_new = supply_locations_geodata_gpd_original[supply_locations_geodata_gpd_original["j_update"] == 1]
+        if len(supply_locations_geodata_gpd_original_new) < 1:
+            raise ValueError("There are no new destinations for an interaction matrix update. Use SupplyLocations.add_new_destinations()")
+
+        supply_locations_new = SupplyLocations(
+            geodata_gpd=supply_locations_geodata_gpd_new,
+            geodata_gpd_original=supply_locations_geodata_gpd_original_new,
+            metadata=supply_locations.metadata,
+            isochrones_gdf=supply_locations.isochrones_gdf,
+            buffers_gdf=supply_locations.buffers_gdf
+        )
+
+        interaction_matrix_new = create_interaction_matrix(
+            customer_origins=customer_origins,
+            supply_locations=supply_locations_new
+        )
+        
+        interaction_matrix_new_df = interaction_matrix_new.get_interaction_matrix_df() 
+     
+        if "transport_costs" not in interaction_matrix_metadata:
+            
+            print("New destination(s) included. No transport costs calculation because not defined in original interaction matrix.")
+            
+            interaction_matrix_df = pd.concat(
+                [
+                interaction_matrix_df, 
+                interaction_matrix_new_df
+                ], 
+                ignore_index=True
+                )
+            
+            interaction_matrix_df = interaction_matrix_df.sort_values(by = "ij")
+        
+            self.interaction_matrix_df = interaction_matrix_df   
+            
+        else:
+            
+            network = interaction_matrix_metadata["transport_costs"]["network"]
+            range_type = interaction_matrix_metadata["transport_costs"]["range_type"]
+            time_unit = interaction_matrix_metadata["transport_costs"]["time_unit"]
+            distance_unit = interaction_matrix_metadata["transport_costs"]["distance_unit"]
+            ors_server = interaction_matrix_metadata["transport_costs"]["ors_server"]
+            ors_auth = interaction_matrix_metadata["transport_costs"]["ors_auth"]
+            
+            interaction_matrix_new.transport_costs(
+                network=network,
+                range_type=range_type,
+                time_unit=time_unit,
+                distance_unit=distance_unit,
+                ors_server=ors_server,
+                ors_auth=ors_auth
+            )
+            
+            interaction_matrix_df = pd.concat(
+                [
+                    interaction_matrix_df, 
+                    interaction_matrix_new_df
+                ], 
+                ignore_index=True
+                )
+        
+            interaction_matrix_df = interaction_matrix_df.sort_values(by = "ij")
+            
+            self.interaction_matrix_df = interaction_matrix_df
+            
+            self.utility()
+            self.probabilities()
+            self.flows()
+
+        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
+        ):
+        
+        if not isinstance(model_object, (HuffModel, MCIModel)):
+            raise ValueError("Parameter 'interaction_matrix' must be of class HuffModel or MCIModel")
+        
+        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
+                )            
+    
+        if isinstance(model_object, HuffModel):
+            
+            model = HuffModel(
+                interaction_matrix = model_object.interaction_matrix,
+                market_areas_df = self.market_areas_df
+            )
+            
+        return model
+            
 class HuffModel:
 
     def __init__(
@@ -886,34 +1468,89 @@ class HuffModel:
 
         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(supply_locations_metadata["weighting"][0]["param"]) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+            print("Attraction          " + str(round(supply_locations_metadata["weighting"][0]["param"], 3)) + " (" + 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(customer_origins_metadata["weighting"][0]["param"]) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            print("Transport costs    " + str(round(customer_origins_metadata["weighting"][0]["param"],3)) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
-            print("Transport costs   " + str(customer_origins_metadata["weighting"][0]["param"][0]) + ", " + str(customer_origins_metadata["weighting"][0]["param"][1]) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")
+            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"] + ")")
+
+        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:
 
+                    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("----------------------------------")
+        
+        huff_modelfit = self.modelfit()
+        if huff_modelfit is not None:
+            
+            print ("Goodness-of-fit for probabilities")
+                    
+            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,
@@ -923,7 +1560,8 @@ class HuffModel:
 
         interaction_matrix = self.interaction_matrix
         interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
-        
+        interaction_matrix_metadata = interaction_matrix.get_metadata()       
+
         supply_locations = interaction_matrix.get_supply_locations()
         supply_locations_metadata = supply_locations.get_metadata()
 
@@ -979,10 +1617,20 @@ 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,
-            supply_locations
+            supply_locations,
+            metadata=interaction_matrix_metadata
             )
         
         mci_model = MCIModel(
@@ -994,132 +1642,42 @@ class HuffModel:
         
         return mci_model
 
-    def huff_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 two or three 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")
-
-        interaction_matrix = self.interaction_matrix
-        interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
-        
-        supply_locations = interaction_matrix.get_supply_locations()
-        supply_locations_metadata = supply_locations.get_metadata()
-
-        customer_origins = interaction_matrix.get_customer_origins()
-        customer_origins_metadata = customer_origins.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 weightig of type " + customer_origins_metadata["weighting"]["func"] + " must have two 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"]["func"] + " must have three input parameters")
-                        
-        customer_origins.metadata = customer_origins_metadata
-
-        interaction_matrix = self.interaction_matrix
-        interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
-        
-        p_ij_emp = interaction_matrix_df["p_ij"]
+    def update(self):
         
-        interaction_matrix_copy = copy.deepcopy(interaction_matrix)
-
-        interaction_matrix_copy.utility()
-        interaction_matrix_copy.probabilities()
-
-        interaction_matrix_df_copy = interaction_matrix_copy.get_interaction_matrix_df()
-        p_ij = interaction_matrix_df_copy["p_ij"]
+        self.interaction_matrix = self.interaction_matrix.update()
         
-        LL = loglik(
-            observed = p_ij_emp,
-            expected = p_ij
-            )
+        self.market_areas_df = self.interaction_matrix.marketareas().get_market_areas_df()
         
-        return LL
+        return self
     
-    def ml_fit(
+    def modelfit(
         self,
-        initial_params = [1.0, -2.0],
-        bounds = [(0.5, 1), (-3, -1)],
-        method = "L-BFGS-B"
+        by = "p_ij"
         ):
         
-        if len(initial_params) > 3 or len(initial_params) < 2:
-            raise ValueError("Parameter 'initial_params' must be a list with two or three entries")
-        
-        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)) + ")")
+        interaction_matrix = self.interaction_matrix        
+        interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
         
-        ml_result = minimize(
-            self.huff_loglik,
-            initial_params,
-            method = method,
-            bounds = bounds,
-            options={'disp': 3}
-            )      
-
-        if ml_result.success:
-            
-            fitted_params = ml_result.x
+        if (by in interaction_matrix_df.columns and by+"_emp" in interaction_matrix_df.columns):
             
-            if len(initial_params) == 2:
+            try:
             
-                param_gamma = fitted_params[0]
-                param_lambda = fitted_params[1]                
-                param_results = [
-                    float(param_gamma), 
-                    float(param_lambda)
-                    ]
+                huff_modelfit = modelfit(
+                    interaction_matrix_df[by+"_emp"],
+                    interaction_matrix_df[by]
+                )
                 
-            elif len (initial_params) == 3:
-        
-                param_gamma = fitted_params[0]
-                param_lambda = fitted_params[1]
-                param_lambda2 = fitted_params[2]                
-                param_results = [
-                    float(param_gamma), 
-                    float(param_lambda), 
-                    float(param_lambda2)
-                    ]
+                return huff_modelfit
+                
+            except:
                 
+                print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                return None
+        
         else:
-
-            param_gamma = None
-            param_lambda = None
-            param_results = [param_gamma, param_lambda]
             
-            if len(initial_params) == 3:                
-                param_lambda2 = None
-                param_results.append(param_lambda2)
-                
-            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.")
-
-        return param_results
-
-
+            return None
+    
 class MCIModel:
 
     def __init__(
@@ -1175,12 +1733,19 @@ class MCIModel:
         
         if ("p_ij" in interaction_matrix_df.columns and "p_ij_emp" in interaction_matrix_df.columns):
             
-            mci_modelfit = modelfit(
-                interaction_matrix_df["p_ij_emp"],
-                interaction_matrix_df["p_ij"]
-            )
+            try:
             
-            return mci_modelfit
+                mci_modelfit = modelfit(
+                    interaction_matrix_df["p_ij_emp"],
+                    interaction_matrix_df["p_ij"]
+                )
+                
+                return mci_modelfit
+                
+            except:
+                
+                print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                return None
         
         else:
             
@@ -1226,7 +1791,7 @@ class MCIModel:
         mci_modelfit = self.modelfit()
         if mci_modelfit is not None:
             
-            print ("Goodness-of-fit with respect to probabilities")
+            print ("Goodness-of-fit for probabilities")
                     
             print("Sum of squared residuals       ", round(mci_modelfit[1]["SQR"], 2))
             print("Sum of squares                 ", round(mci_modelfit[1]["SQT"], 2))
@@ -1234,13 +1799,25 @@ 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")
-            print("< 5 %                          ", round(mci_modelfit[1]["APE"]["resid_below5"], 2))
-            print("< 10 %                         ", round(mci_modelfit[1]["APE"]["resid_below10"], 2))
-            print("< 15 %                         ", round(mci_modelfit[1]["APE"]["resid_below15"], 2))
-            print("< 20 %                         ", round(mci_modelfit[1]["APE"]["resid_below20"], 2))
-            print("< 25 %                         ", round(mci_modelfit[1]["APE"]["resid_below25"], 2))
+            APE_list = [
+                ["< 5 % ", round(mci_modelfit[1]["APE"]["resid_below5"], 2), "  < 30 % ", round(mci_modelfit[1]["APE"]["resid_below30"], 2)],
+                ["< 10 % ", round(mci_modelfit[1]["APE"]["resid_below10"], 2), "  < 35 % ", round(mci_modelfit[1]["APE"]["resid_below35"], 2)],
+                ["< 15 % ", round(mci_modelfit[1]["APE"]["resid_below15"], 2), "  < 40 % ", round(mci_modelfit[1]["APE"]["resid_below40"], 2)],
+                ["< 20 % ", round(mci_modelfit[1]["APE"]["resid_below20"], 2), "  < 45 % ", round(mci_modelfit[1]["APE"]["resid_below45"], 2)],
+                ["< 25% ", round(mci_modelfit[1]["APE"]["resid_below25"], 2), "  < 50 % ", round(mci_modelfit[1]["APE"]["resid_below50"], 2)]
+                ]
+            APE_df = pd.DataFrame(
+                APE_list,
+                columns=["Resid.", "%", "Resid.", "%"]
+                )
+            print(APE_df.to_string(index=False))
             
             print("--------------------------------------------")
                   
@@ -1251,6 +1828,7 @@ class MCIModel:
         
         interaction_matrix = self.interaction_matrix        
         interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+        interaction_matrix_metadata = interaction_matrix.get_metadata()
 
         if interaction_matrix_df["t_ij"].isna().all():
             raise ValueError ("Transport cost variable is not defined")
@@ -1289,10 +1867,16 @@ class MCIModel:
         if transformation == "ILCT":
             interaction_matrix_df["U_ij"] = np.exp(interaction_matrix_df["U_ij"])
 
+        interaction_matrix_metadata["model"] = {
+            "model_type": "MCI",
+            "transformation": transformation
+            }
+
         interaction_matrix = InteractionMatrix(
             interaction_matrix_df,
             customer_origins,
-            supply_locations
+            supply_locations,
+            metadata=interaction_matrix_metadata
             )
         self.interaction_matrix = interaction_matrix
 
@@ -1459,7 +2043,7 @@ def load_geodata (
 
     geodata_gpd = geodata_gpd_original.to_crs(crs_output)
     geodata_gpd = geodata_gpd[[unique_id, "geometry"]]
-
+    
     metadata = {
         "location_type": location_type,
         "unique_id": unique_id,
@@ -1467,6 +2051,7 @@ def load_geodata (
         "marketsize_col": None,
         "weighting": {
             0: {
+                "name": None,
                 "func": None, 
                 "param": None
                 }
@@ -1474,17 +2059,23 @@ def load_geodata (
         "crs_input": crs_input,
         "crs_output": crs_output,
         "no_points": len(geodata_gpd)
-        }    
+        }
     
     if location_type == "origins":
+
         geodata_object = CustomerOrigins(
             geodata_gpd, 
             geodata_gpd_original, 
             metadata,
             None,
             None
-            )        
+            )
+                
     elif location_type == "destinations":
+        
+        geodata_gpd["j_update"] = 0
+        geodata_gpd_original["j_update"] = 0
+
         geodata_object = SupplyLocations(
             geodata_gpd, 
             geodata_gpd_original, 
@@ -1563,10 +2154,13 @@ def create_interaction_matrix(
     interaction_matrix_df["p_ij"] = None
     interaction_matrix_df["E_ij"] = None
 
+    metadata = {}
+
     interaction_matrix = InteractionMatrix(
         interaction_matrix_df,
         customer_origins,
-        supply_locations
+        supply_locations,
+        metadata
         )
          
     return interaction_matrix
@@ -1577,6 +2171,7 @@ def load_interaction_matrix(
     supply_locations_col: str,
     attraction_col: list,
     transport_costs_col: str,
+    flows_col: str = None,
     probabilities_col: str = None,
     market_size_col: str = None,
     customer_origins_coords_col = None,
@@ -1585,8 +2180,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):
@@ -1602,7 +2199,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:
@@ -1614,15 +2217,18 @@ def load_interaction_matrix(
         raise KeyError ("Column " + supply_locations_col + " not in data")
     
     cols_check = attraction_col + [transport_costs_col]
+    if flows_col is not None:
+        cols_check = cols_check + [flows_col]
     if probabilities_col is not None:
         cols_check = cols_check + [probabilities_col]
     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:
 
@@ -1677,6 +2283,7 @@ def load_interaction_matrix(
         "marketsize_col": market_size_col,
         "weighting": {
             0: {
+                "name": None,
                 "func": None, 
                 "param": None
                 }
@@ -1744,6 +2351,7 @@ def load_interaction_matrix(
         "marketsize_col": None,
         "weighting": {
             0: {
+                "name": None,
                 "func": None, 
                 "param": None
                 }
@@ -1770,6 +2378,13 @@ def load_interaction_matrix(
         }
         )
 
+    if flows_col is not None:
+        interaction_matrix_df = interaction_matrix_df.rename(
+            columns = {
+                flows_col: "E_ij"
+            }
+            )
+
     if probabilities_col is not None:
         interaction_matrix_df = interaction_matrix_df.rename(
             columns = {
@@ -1783,15 +2398,141 @@ def load_interaction_matrix(
                 market_size_col: "C_i"
             }
             )
-        
+    
+    metadata = {
+        "fit": {
+            "function": None,
+            "fit_by": None
+        }
+    }
+
     interaction_matrix = InteractionMatrix(
         interaction_matrix_df=interaction_matrix_df,
         customer_origins=customer_origins,
-        supply_locations=supply_locations
+        supply_locations=supply_locations,
+        metadata=metadata
         )
     
     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,
+    ref_col: str = None,
+    marketshares_col: str = "p_ij"
+    ):
+
+    check_vars(
+        df = df,
+        cols = [turnover_col]
+        )
+    
+    if ref_col is not None:
+
+        if ref_col not in df.columns:
+            raise KeyError(f"Column '{ref_col}' not in dataframe.")
+        
+        ms_refcol = pd.DataFrame(df.groupby(ref_col)[turnover_col].sum())
+        ms_refcol = ms_refcol.rename(columns = {turnover_col: "total"})
+        ms_refcol = ms_refcol.reset_index()
+
+        df = df.merge(
+            ms_refcol,
+            how = "left",
+            left_on = ref_col,
+            right_on= ref_col 
+        )
+
+    else:
+
+        ms_norefcol = pd.DataFrame([df[turnover_col].sum()], columns=["total"])
+        ms_norefcol = ms_norefcol.reset_index()
+
+        df["key_temp"] = 1
+        ms_norefcol["key_temp"] = 1
+        df = pd.merge(
+            df, 
+            ms_norefcol, 
+            on="key_temp"
+            ).drop(
+                "key_temp", 
+                axis=1
+                )
+
+    df[marketshares_col] = df[turnover_col]/df["total"]
+    
+    df = df.drop(columns="total")
+
+    return df
+
 def log_centering_transformation(
     df: pd.DataFrame,
     ref_col: str,
@@ -1822,12 +2563,18 @@ def log_centering_transformation(
             print ("Column " + str(var) + " is a dummy variable and requires/allows no log-centering transformation")
             continue
 
+        if (df[var] <= 0).any():
+            df[var+suffix] = float("nan")
+            print ("Column " + str(var) + " contains values <= 0. No log-centering transformation possible.")
+            continue
+
         var_t = df.groupby(ref_col)[var].apply(lct)
         var_t = var_t.reset_index()
         df[var+suffix] = var_t[var]
 
     return df
 
+
 def get_isochrones(
     geodata_gpd: gp.GeoDataFrame,
     unique_id_col: str,
@@ -1918,7 +2665,8 @@ def get_isochrones(
 
 def modelfit(
     observed, 
-    expected 
+    expected,
+    remove_nan: bool = True 
     ):
 
     observed_no = len(observed)
@@ -1933,12 +2681,41 @@ def modelfit(
     if not isinstance(expected, np.number):
         if not is_numeric_dtype(expected):
             raise ValueError("Expected column is not numeric")
-           
+    
+    if remove_nan:
+        
+        obs_exp = pd.DataFrame(
+            {
+                "observed": observed, 
+                "expected": expected
+                }
+            )
+        
+        obs_exp_clean = obs_exp.dropna(subset=["observed", "expected"])
+        
+        observed = obs_exp_clean["observed"].to_numpy()
+        expected = obs_exp_clean["expected"].to_numpy()
+    
+    else:
+        
+        if np.isnan(observed).any():
+            raise ValueError("Vector with observed data contains NaN")
+        if np.isnan(expected).any():
+            raise ValueError("Vector with expected data contains NaN")
+    
     residuals = np.array(observed)-np.array(expected)
     residuals_sq = residuals**2
     residuals_abs = abs(residuals)
  
-    APE = abs(observed-expected)/observed*100
+    if any(observed == 0):
+        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,
@@ -1946,25 +2723,31 @@ def modelfit(
         "residuals": residuals,
         "residuals_sq": residuals_sq,
         "residuals_abs": residuals_abs,
-        "APE": APE
+        "APE": APE,
+        "sAPE": sAPE
         })
 
     SQR = float(np.sum(residuals_sq))
-    SAR = float(np.sum(residuals_abs))
-    LL = float(np.sum(np.log(residuals_sq)))
+    SAR = float(np.sum(residuals_abs))    
     observed_mean = float(np.sum(observed)/observed_no)
     SQT = float(np.sum((observed-observed_mean)**2))
     Rsq = float(1-(SQR/SQT))
     MSE = float(SQR/observed_no)
     RMSE = float(sqrt(MSE))
     MAE = float(SAR/observed_no)
-    MAPE = float(np.mean(APE))
-
-    resid_below5 = float(len([APE < 5])/expected_no*100)
-    resid_below10 = float(len([APE < 10])/expected_no*100)
-    resid_below15 = float(len([APE < 15])/expected_no*100)
-    resid_below20 = float(len([APE < 20])/expected_no*100)
-    resid_below25 = float(len([APE < 25])/expected_no*100)
+    
+    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)
+    resid_below15 = float(len(data_residuals[data_residuals["APE"] < 15])/expected_no*100)
+    resid_below20 = float(len(data_residuals[data_residuals["APE"] < 20])/expected_no*100)
+    resid_below25 = float(len(data_residuals[data_residuals["APE"] < 25])/expected_no*100)
+    resid_below30 = float(len(data_residuals[data_residuals["APE"] < 30])/expected_no*100)
+    resid_below35 = float(len(data_residuals[data_residuals["APE"] < 35])/expected_no*100)
+    resid_below40 = float(len(data_residuals[data_residuals["APE"] < 40])/expected_no*100)
+    resid_below45 = float(len(data_residuals[data_residuals["APE"] < 45])/expected_no*100)
+    resid_below50 = float(len(data_residuals[data_residuals["APE"] < 50])/expected_no*100)
 
     data_lossfunctions = {
         "SQR": SQR,
@@ -1975,12 +2758,18 @@ def modelfit(
         "RMSE": RMSE,
         "MAE": MAE,
         "MAPE": MAPE,
+        "sMAPE": sMAPE,
         "APE": {
             "resid_below5": resid_below5,
             "resid_below10": resid_below10,
             "resid_below15": resid_below15,
             "resid_below20": resid_below20,
-            "resid_below25": resid_below25
+            "resid_below25": resid_below25,
+            "resid_below30": resid_below30,
+            "resid_below35": resid_below35,
+            "resid_below40": resid_below40,
+            "resid_below45": resid_below45,
+            "resid_below50": resid_below50,
         }   
     }    
     
@@ -2000,7 +2789,7 @@ def loglik(
             observed, 
             expected
             )    
-        residuals_sq = model_fit[0]["residuals_sq"]
+        residuals_sq = model_fit[0]["residuals_sq"]        
         
         LL = np.sum(np.log(residuals_sq))