Update app.py

app.py

@@ -110,40 +110,49 @@ def test(input_json):
 
     
     # ------------------------- Accessing input data from Grasshopper ------------------------- #
-    
 
-    matrix = inputs['input']["matrix"]
-    matrix_transport = inputs['input']["transportMatrix"]  
-    landuses = inputs['input']["landuse_areas"]    
-    
-   
-    if df_lu_filtered is None or df_lu_filtered.empty:
+    from config import useGrasshopperData 
+
+    if useGrasshopperData == True:
+        matrix = inputs['input']["matrix"]
         landuses = inputs['input']["landuse_areas"]    
-        df_landuses = pd.DataFrame(landuses).T
-        df_landuses = df_landuses.round(0).astype(int)
-    else:
-        df_landuses = df_lu_filtered
-        df_landuses = df_landuses.round(0).astype(int)
     
+        dfLanduses = pd.DataFrame(landuses).T
+        dfLanduses = dfLanduses.round(0).astype(int)
+
+        dfMatrix = pd.DataFrame(matrix).T
+        dfMatrix = dfMatrix.round(0).astype(int)
+    else:
+        dfLanduses = df_lu_filtered.copy()
+        dfLanduses = dfLanduses.round(0).astype(int)
+        
+        dfMatrix = df_dm.copy()
+        dfMatrix = dfMatrix.round(0).astype(int)
     
-    #df_landuses = df_lu_filtered
-    #df_landuses = df_landuses.round(0).astype(int)
-    
+
     attributeMapperDict_gh = inputs['input']["attributeMapperDict"]
     landuseMapperDict_gh = inputs['input']["landuseMapperDict"]
-    
-    alpha = inputs['input']["alpha"]
-    alpha = float(alpha)
-    threshold = inputs['input']["threshold"]
-    threshold = float(threshold)
-    
-    df_matrix = pd.DataFrame(matrix).T
-    df_matrix = df_matrix.round(0).astype(int)
 
+    if not inputs['input']["alpha"]:
+        from imports_utils import alpha
+    else:
+        alpha = inputs['input']["alpha"]
+        alpha = float(alpha)
+        
+    if not inputs['input']["threshold"]:
+        from imports_utils import threshold
+    else:
+        threshold = inputs['input']["threshold"]
+        threshold = float(threshold)
+
+        
+          
+    
 
 
     from imports_utils import splitDictByStrFragmentInColumnName
-    
+
+    """
     # List containing the substrings to check against
     tranportModes = ["DRT", "GMT", "HSR"]
 
@@ -157,48 +166,22 @@ def test(input_json):
     df_art_matrix = df_art_matrix.round(0).astype(int)  
     df_gmt_matrix = pd.DataFrame(gmt_dict).T
     df_gmt_matrix = df_art_matrix.round(0).astype(int)     
-    
+
+    """
 
     # create a mask based on the matrix size and ids, crop activity nodes to the mask
-    mask_connected = df_dm.index.tolist()
+    mask_connected = dfMatrix.index.tolist()
 
-    valid_indexes = [idx for idx in mask_connected if idx in df_landuses.index]
+    valid_indexes = [idx for idx in mask_connected if idx in dfLanduses.index]
     # Identify and report missing indexes
     missing_indexes = set(mask_connected) - set(valid_indexes)
     if missing_indexes:
         print(f"Error: The following indexes were not found in the DataFrame: {missing_indexes}, length: {len(missing_indexes)}")
     
     # Apply the filtered mask
-    df_landuses_filtered = df_landuses.loc[valid_indexes]
-
-    """
-    # find a set of unique domains, to which subdomains are aggregated    
-    temp = []
-    for key, values in livabilityMapperDict.items():
-      domain = livabilityMapperDict[key]['domain']
-      for item in domain:
-        if ',' in item:
-          domain_list = item.split(',')
-          livabilityMapperDict[key]['domain'] = domain_list
-          for domain in domain_list:
-            temp.append(domain) 
-        else:
-          if item != 0: 
-              temp.append(item)  
-    
-    domainsUnique = list(set(temp))
+    dfLanduses_filtered = dfLanduses.loc[valid_indexes]
 
-    
-    # find a list of unique subdomains, to which land uses are aggregated
-    temp = []    
-    for key, values in landuseMapperDict.items():
-      subdomain = str(landuseMapperDict[key]["subdomain livability"])
-      if subdomain != 0: 
-        temp.append(subdomain) 
-        
-    subdomainsUnique = list(set(temp))
 
-    """
     from imports_utils import findUniqueDomains
     from imports_utils import findUniqueSubdomains
     
@@ -212,35 +195,30 @@ def test(input_json):
     
     domainsUnique = findUniqueDomains(livabilityMapperDict)
     subdomainsUnique = findUniqueSubdomains(landuseMapperDict)
+       
+    LivabilitySubdomainsWeights = landusesToSubdomains(dfMatrix,df_lu_filtered,landuseMapperDict,subdomainsUnique)
     
-    
-    
-    LivabilitySubdomainsWeights = landusesToSubdomains(df_dm,df_lu_filtered,landuseMapperDict,subdomainsUnique)
-
-    
-    WorkplacesNumber = FindWorkplacesNumber(df_dm,livabilityMapperDict,LivabilitySubdomainsWeights,subdomainsUnique)
+    WorkplacesNumber = FindWorkplacesNumber(dfMatrix,livabilityMapperDict,LivabilitySubdomainsWeights,subdomainsUnique)
     
     # prepare an input weights dataframe for the parameter LivabilitySubdomainsInputs
     LivabilitySubdomainsInputs =pd.concat([LivabilitySubdomainsWeights, WorkplacesNumber], axis=1)
    
-    subdomainsAccessibility = computeAccessibility(df_dm,LivabilitySubdomainsInputs,alpha,threshold)   
-    artAccessibility = computeAccessibility_pointOfInterest(df_art_matrix,'ART',alpha,threshold)
-    gmtAccessibility = computeAccessibility_pointOfInterest(df_gmt_matrix,'GMT+HSR',alpha,threshold)
+    subdomainsAccessibility = computeAccessibility(dfMatrix,LivabilitySubdomainsInputs,alpha,threshold)   
+    #artAccessibility = computeAccessibility_pointOfInterest(df_art_matrix,'ART',alpha,threshold)
+    #gmtAccessibility = computeAccessibility_pointOfInterest(df_gmt_matrix,'GMT+HSR',alpha,threshold)
     
-    AccessibilityInputs = pd.concat([subdomainsAccessibility, artAccessibility,gmtAccessibility], axis=1)
+    #AccessibilityInputs = pd.concat([subdomainsAccessibility, artAccessibility,gmtAccessibility], axis=1)
         
 
     if 'jobs' not in subdomainsAccessibility.columns:
         print("Error: Column 'jobs' does not exist in the subdomainsAccessibility.")
 
-    livability = accessibilityToLivability(df_dm,AccessibilityInputs,livabilityMapperDict,domainsUnique)
+    livability = accessibilityToLivability(dfMatrix,subdomainsAccessibility,livabilityMapperDict,domainsUnique)
     
 
     livability_dictionary = livability.to_dict('index')
     LivabilitySubdomainsInputs_dictionary = LivabilitySubdomainsInputs.to_dict('index')
     subdomainsAccessibility_dictionary = AccessibilityInputs.to_dict('index')
-    artmatrix = df_art_matrix.to_dict('index')
-
     LivabilitySubdomainsWeights_dictionary = LivabilitySubdomainsWeights.to_dict('index')