demo version

README.md

@@ -1 +1,5 @@
 # TomorrowCities Python Library
+
+## Running GUI
+
+### 

docs/gui.rst

@@ -0,0 +1,16 @@
+:: _gui:
+
+Graphical User Interfaces
+=========================
+There are several graphical user interfaces (GUIs)
+prepared to show case the features of the library. 
+The codes related to GUIs are in the ``src/gui`` directory.
+
+
+Launching
+=========
+There are different ways to launch the GUIs depending 
+on how you obtain the library.
+
+
+

docs/install.rst

@@ -1,6 +1,5 @@
 :: _install:
 
-============
 Installation
 ============
 

docs/quickstart.rst

@@ -1,16 +1,22 @@
-===========
 Quick Start
 ===========
 
 .. highlight:: python
 
-After :ref:`install` tomorrowcities package, you can import and use
-as follows:
+After :doc:`/install`, you can import `tomorrowcities` 
+package and start generating exposure data or calculating
+impact metrics.
 
 .. code-block:: python
 
    import tomorrowcities as tc
    
-   dg = tc.DataGenerator(parameter_file='tests/Input_DistributionTables_20230614.xlsx',
-                    land_use_file='tests/polygonsTV50_v2b.zip')
+   dg = tc.DataGenerator(parameter_file='distribution_table.xlsx',
+                    land_use_file='landuse.zip')
+
+   building, household, individual, land_use = dg.generate(seed=42)
+
+   metrics = dg.run_engine(building, household, individual, land_use,
+                hazard_scenario="FLOOD", hazard_data="flood.xlsx", policies=None):
+
 

src/gui/app_engine.py

@@ -0,0 +1,394 @@
+import solara
+from solara.components.file_drop import FileInfo
+import os
+os.environ['USE_PYGEOS'] = '0'
+import geopandas as gpd
+import pandas as pd
+import json
+import numpy as np
+import ipyleaflet
+from engine import compute_flood
+import random
+from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
+import math
+
+plt.switch_backend("agg")
+
+# Static parameters
+initial_building_columns = set(['zoneID', 'bldID', 'nHouse', 'residents', 'specialFac', 'expStr', 'fptarea', 'repValue'])
+building_columns = set(['geometry','metric1','metric2','metric3','metric4','metric5','metric6','metric7','zoneID', 'bldID', 'nHouse', 'residents', 'specialFac', 'expStr', 'fptarea', 'repValue'])
+landuse_columns = set(['geometry', 'zoneID', 'LuF', 'population', 'densityCap', 'floorARat', 'setback', 'avgIncome'])
+household_columns = set(['hhID', 'nInd', 'income', 'bldID', 'CommFacID'])
+individual_columns = set(['indivId', 'hhID', 'gender', 'age', 'eduAttStat', 'head', 'indivFacID'])
+intensity_columns = set(['geometry','im'])
+vulnerabillity_columns = set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6'])
+all_layers = ["Landuse", "Buildings", "Household","Individual","Intensity","Vulnerability"]
+metrics_template = {"metric1": {"desc": "Number of workers unemployed", "value": 0, "max_value": 0},
+            "metric2": {"desc": "Number of children with no access to education", "value": 0, "max_value": 0},
+            "metric3": {"desc": "Number of households with no access to hospital", "value": 0, "max_value": 0},
+            "metric4": {"desc": "Number of individuals with no access to hospital", "value": 0, "max_value": 0},
+            "metric5": {"desc": "Number of homeless households", "value": 0, "max_value": 0},
+            "metric6": {"desc": "Number of homeless individuals", "value": 0, "max_value": 0},
+            "metric7": {"desc": "Population displacement", "value": 0, "max_value": 0},}
+
+layers = solara.reactive([])
+
+base_map = ipyleaflet.basemaps.OpenStreetMap.BZH
+
+default_zoom = 14
+default_radius = 10
+default_center = (41.03,28.94)
+
+center = solara.reactive(default_center)
+zoom = solara.reactive(default_zoom)
+bounds = solara.reactive(None)
+radius = solara.reactive(default_radius)
+
+building_df = solara.reactive(None)
+landuse_geojson = solara.reactive(None)
+clicked_df = solara.reactive(pd.DataFrame(columns=['attribute','value']))
+
+
+def building_click_handler(event=None, feature=None, id=None, properties=None):
+    df = pd.DataFrame(columns=['attribute','value'])
+    df['attribute'] = [k for k in properties.keys() if k != 'style']
+    df['value']= [str(properties[k]) for k in properties.keys() if k != 'style']
+    clicked_df.set(df)
+
+def landuse_click_handler(event=None, feature=None, id=None, properties=None):
+    df = pd.DataFrame(columns=['attribute','value'])
+    df['attribute'] = [k for k in properties.keys() if k != 'style']
+    df['value']= [str(properties[k]) for k in properties.keys() if k != 'style']
+    clicked_df.set(df)
+
+def landuse_colors(feature):
+    luf_type = feature['properties']['LuF']
+    if luf_type == 'RESIDENTIAL (HIGH DENSITY)':
+        luf_color = {
+        'color': 'black',
+        'fillColor': '#A0522D', # sienna
+        }    
+    elif luf_type == 'HISTORICAL PRESERVATION AREA':
+        luf_color = {
+        'color': 'black',
+        'fillColor': '#673147', # plum
+        }    
+    elif luf_type == 'RESIDENTIAL (MODERATE DENSITY)':
+        luf_color = {
+        'color': 'black',
+        'fillColor': '#cd853f', # peru
+        }   
+    elif luf_type == 'COMMERCIAL AND RESIDENTIAL':
+        luf_color = {
+        'color': 'black',
+        'fillColor': 'red',
+        }   
+    elif luf_type == 'CITY CENTER':
+        luf_color = {
+        'color': 'black',
+        'fillColor': '#E6E6FA', # lavender
+        }   
+    elif luf_type == 'INDUSTRY':
+        luf_color = {
+        'color': 'black',
+        'fillColor': 'grey',
+        }   
+    elif luf_type == 'RESIDENTIAL (LOW DENSITY)':
+        luf_color= {
+        'color': 'black',
+        'fillColor': '#D2B48C', # tan
+        }   
+    elif luf_type == 'RESIDENTIAL (GATED NEIGHBORHOOD)':
+        luf_color= {
+        'color': 'black',
+        'fillColor': 'orange',
+        }   
+    elif luf_type == 'AGRICULTURE':
+        luf_color= {
+        'color': 'black',
+        'fillColor': 'yellow',
+        }   
+    elif luf_type == 'FOREST':
+        luf_color= {
+        'color': 'black',
+        'fillColor': 'green',
+        }   
+    elif luf_type == 'VACANT ZONE':
+        luf_color = {
+        'color': 'black',
+        'fillColor': '#90EE90', # lightgreen
+        }   
+    elif luf_type == 'RECREATION AREA':
+        luf_color = {
+        'color': 'black',
+        'fillColor': '#32CD32', #lime
+        }   
+    else:
+        luf_color = {
+        'color': 'black',
+        'fillColor': random.choice(['red', 'yellow', 'green', 'orange','blue']),
+        } 
+    return luf_color
+
+def building_colors(feature):
+        print(feature['properties'])
+        #damage = 0
+        #for metric in metrics_template.keys():
+        #    damage += feature['properties'][metric]
+        # metric5 is the number of damaged households
+        if feature['properties']['metric5'] > 0:
+            return {'fillColor': 'red', 'color': 'red'}
+        else:
+            return {'fillColor': 'gray', 'color': 'blue'}
+         
+@solara.component
+def MapComponent():
+
+    extra_layers = [l['geojson'] for l in layers.value if 'geojson' in l.keys()]
+
+    if building_df.value is not None:               
+        json_data = json.loads(building_df.value.to_json())
+        building_layer = ipyleaflet.GeoJSON(data=json_data,
+                                            style={'opacity': 1, 'fillOpacity': 0.5, 'weight': 1},
+                                            hover_style={'color': 'red', 'dashArray': '0', 'fillOpacity': 0.5},
+                                            style_callback=building_colors)
+        building_layer.on_click(building_click_handler)
+        extra_layers.append(building_layer)
+
+
+
+        
+    print('rendering map, number of extra layers',len(extra_layers))
+
+    ipyleaflet.Map.element(
+        zoom=zoom.value,
+        on_zoom=zoom.set,
+        on_bounds=bounds.set,
+        center=center.value,
+        on_center=center.set,
+        scroll_wheel_zoom=True,
+        dragging=True,
+        double_click_zoom=True,
+        touch_zoom=True,
+        box_zoom=True,
+        keyboard=True,
+        layers=[ipyleaflet.TileLayer.element(url=base_map.build_url())]+extra_layers,
+    )
+
+@solara.component
+def DialWidget(desc, value, max_value=10000):
+    if max_value == 0:
+        max_value = 10000
+    fig = Figure(tight_layout=True,dpi=30,frameon=False)
+    fig.set_size_inches(1.5,1)
+    ax = fig.subplots()
+    ax.axis('equal')
+    ax.axis('off')
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    t = np.linspace(0, math.pi, 100)
+
+    cos = np.cos(t)
+    sin = np.sin(t)
+
+    ax.plot(cos,sin, linewidth=2)
+    value_t = math.pi * (1 - (value / max_value))
+
+    fill_color = 'red'
+    if value_t >  math.pi / 2  :
+        x1 = np.linspace(-1,np.cos(value_t),100)
+        y1 = np.sqrt(1 - x1**2)
+        ax.fill_between(x1,y1,color=fill_color)
+        x1 = np.linspace(np.cos(value_t),0,100)
+        y1 = np.tan(value_t) * x1
+        ax.fill_between(x1,y1,color=fill_color)
+    else:
+        x = np.linspace(-1, np.cos(value_t),100)
+        y1 = np.sqrt(1-x**2)
+        y2a = np.zeros(100)
+        y2b = np.tan(value_t) * x
+        y2 = np.maximum(y2a,y2b)
+        ax.fill_between(x,y1,y2,color=fill_color)
+
+    ax.text(0,0.5,value,fontdict={'fontsize':20},verticalalignment="center",
+        horizontalalignment="center",color="black")
+    ax.set_xlim(-1.1,1.1)
+    ax.set_ylim(-0.2,1.2)
+    solara.FigureMatplotlib(fig)
+
+@solara.component
+def VisioningScenarioViewer():
+
+    # State variables
+    loading, set_loading = solara.use_state(-1)
+    error_message, set_error_message = solara.use_state("")
+
+    selected_layer, set_selected_layer = solara.use_state(None)
+    metrics, set_metrics = solara.use_state(metrics_template)
+
+    def load(file: FileInfo):
+        try:
+            json_string = file['data'].decode('utf-8')
+            json_hash = hash(json_string)
+            json_data = json.loads(json_string)
+            print(json_data.keys())
+            # Load into dataframes
+            if "features" in json_data.keys():
+                # Add zero metrics to building layer
+                if set(json_data['features'][0]['properties'].keys()) == initial_building_columns:
+                    for metric in metrics.keys():
+                        for i in range(len(json_data['features'])):
+                            json_data['features'][i]['properties'][metric] = 0 
+
+                df = gpd.GeoDataFrame.from_features(json_data['features'])
+
+                if set(df.columns) == building_columns:
+                    building_df.set(df)
+
+                if set(df.columns) == landuse_columns:
+                    landuse_geojson.set(json_data)
+
+
+                new_center = (df.geometry.centroid.y.mean(), df.geometry.centroid.x.mean())
+                center.set(new_center)
+                print(df.head())
+                print(df.columns)
+            else:
+                df = pd.read_json(json_string)
+
+            existing_hashes = [l['hash'] for l in layers.value]
+            if json_hash in existing_hashes:
+                set_error_message("File already uploaded")
+                return
+            else:
+                new_layer = {'fileinfo': file, 'df': df, 'hash': json_hash}
+                df_columns = set(df.columns)
+                if df_columns == building_columns:
+                    new_layer['name'] = 'Buildings'
+                elif df_columns == landuse_columns:
+                    new_layer['name'] = 'Landuse'
+                    new_layer['geojson'] = ipyleaflet.GeoJSON(data=json_data,
+                                            style={'opacity': 1, 'dashArray': '9', 'fillOpacity': 0.5, 'weight': 1},
+                                            hover_style={'color': 'white', 'dashArray': '0', 'fillOpacity': 0.5},
+                                            style_callback=landuse_colors)    
+                    new_layer['geojson'].on_click(landuse_click_handler)
+
+                elif df_columns == intensity_columns:
+                    locs = np.array([df.geometry.y.to_list(), df.geometry.x.to_list(), df.im.to_list()]).transpose().tolist()
+                    new_layer['name'] = 'Intensity'
+                    new_layer['geojson'] = ipyleaflet.Heatmap(locations=locs, radius=radius.value) 
+                elif df_columns == household_columns:
+                    new_layer['name'] = 'Household'
+                elif df_columns == individual_columns:
+                    new_layer['name'] = 'Individual'
+                elif df_columns == vulnerabillity_columns:
+                    new_layer['name'] = 'Vulnerability'
+                           
+                layers.set(layers.value + [new_layer])
+            print(file['name'], list(df.columns))
+
+            #set_run_allowed(is_ready_to_run())
+            set_error_message("")
+        except UnicodeDecodeError:
+            set_error_message(f'{file["name"]} is not a text file')
+        except Exception as e:
+            set_error_message(f'file: {file["name"]} Exception:{e}')
+        
+
+    def progress(ratio):
+        print(f"loading {ratio}")
+        set_loading(ratio)
+
+    def is_ready_to_run():
+        layer_names = set([l['name'] for l in layers.value])
+        return set(all_layers) == layer_names
+
+    def get_building_layer():
+        dfs = {l['name']: l for l in layers.value}
+        if 'Buildings' in dfs.keys():
+            return dfs['Buildings']
+        else:
+            return None
+
+    def compute():
+        print("I'm computing")
+        dfs = {l['name']: l['df'] for l in layers.value}
+        print(dfs.keys())
+
+        if is_ready_to_run():
+            metrics, df_metrics = compute_flood(dfs['Buildings'], 
+                      dfs['Household'], 
+                      dfs['Individual'],
+                      dfs['Intensity'],
+                      dfs['Vulnerability'], 
+                      "flood")
+            print(metrics)
+            set_metrics(metrics['metrics'])
+
+            updated_df = building_df.value
+            for metric in df_metrics.keys():
+                updated_df[metric] = list(df_metrics[metric][metric])
+            building_df.set(updated_df)
+
+            #building_layer['geodata'] = ipyleaflet.GeoData(geo_dataframe=building_df,
+            #                                                  hover_style={'color': 'red', 'dashArray': '0', 'fillOpacity': 0.5},
+            #                                                  style_callback=building_colors)
+            #layers.set(layers)
+
+    with solara.Row():
+        solara.FileDrop(label="Drop layers", on_total_progress=progress, on_file=load,lazy=False)
+        solara.Info(f'Uploading {loading}%')
+        if error_message != "":
+            solara.Error(error_message)
+        solara.Button(label="Compute", on_click=compute, outlined=True)
+        
+        building_layer = get_building_layer()
+        for metric in metrics.keys():
+            if building_df.value is not None and bounds is not None:
+                ((ymin,xmin),(ymax,xmax)) = bounds.value
+                value = int(building_df.value.cx[xmin:xmax,ymin:ymax][metric].sum())
+            else:
+                value = 0
+            DialWidget(metric, value, max_value=10000)
+            #solara.Info(label=f'{metric}: {value}', dense=True)
+
+    with solara.Columns([80, 20]):
+        MapComponent()
+        solara.DataFrame(df=clicked_df.value, scrollable=True)
+
+    with solara.Card("Dataframes"):
+        solara.ToggleButtonsSingle(selected_layer, all_layers, on_value=set_selected_layer)
+        solara.Markdown(f"**Selected**: {selected_layer}")
+        found_layer = None
+        for layer in layers.value:
+            if layer['name'] == selected_layer:
+                found_layer = layer
+                break
+        
+        if found_layer:
+            df = found_layer['df']
+
+            # Generate new dataframe
+            if 'geometry' in list(df.columns):
+                df_new = gpd.GeoDataFrame(df)
+            else:
+                df_new = pd.DataFrame(df)
+
+            # Filter geopandas
+            if 'geometry' in list(df.columns):
+                ((ymin,xmin),(ymax,xmax)) = bounds.value
+                df_filtered = df_new.cx[xmin:xmax,ymin:ymax]
+                if selected_layer == 'Intensity':
+                    solara.DataFrame(df=pd.DataFrame(df_filtered))
+                else:
+                    solara.DataFrame(df=pd.DataFrame(df_filtered.drop(columns='geometry')))
+            else:
+                solara.DataFrame(df=df_new)
+        else:
+            solara.Info(f'No data uploaded yet for layer: {selected_layer}')
+@solara.component
+def Page():
+    VisioningScenarioViewer()

src/gui/engine.py

@@ -0,0 +1,286 @@
+#%%
+import warnings
+import json
+import sys
+import argparse
+import io
+import os
+import pandas as pd
+import psycopg2
+import geopandas
+import numpy as np
+from scipy.stats import norm
+from scipy.interpolate import interp1d
+
+def compute_flood(gdf_buildings, df_household, df_individual,gdf_intensity, df_flood, hazard_type):
+
+    column_names = {'zoneID':'zoneid','bldID':'bldid','nHouse':'nhouse',
+                    'specialFac':'specialfac','expStr':'expstr','repValue':'repvalue',
+                    'xCoord':'xcoord','yCoord':'ycoord','hhID':'hhid','nInd':'nind',
+                    'CommFacID':'commfacid','indivId':'individ','eduAttStat':'eduattstat',
+                    'indivFacID':'indivfacid','VALUE':'im'}
+
+    gdf_buildings = gdf_buildings.rename(columns=column_names)
+    df_household = df_household.rename(columns=column_names)
+    df_individual = df_individual.rename(columns=column_names)
+    gdf_intensity = gdf_intensity.rename(columns=column_names)
+
+    # Damage States
+    DS_NO = 1
+    DS_SLIGHT = 2
+    DS_MODERATE = 3
+    DS_EXTENSIZE = 4
+    DS_COLLAPSED = 5
+
+    # Hazard Types 
+    HAZARD_EARTHQUAKE = "earthquake"
+    HAZARD_FLOOD = "flood"
+    HAZARD_DEBRIS = "debris"
+
+    policies = []
+    threshold = 1
+    threshold_flood = 0.2
+    threshold_flood_distance = 10
+    epsg = 3857 
+    #epsg = 21037 # Arc 1960 / UTM zone 37S
+
+    # Replace strange TypeX LRS with RCi
+    df_flood['expstr'] = df_flood['expstr'].str.replace('Type[0-9]+','RCi',regex=True)
+
+    number_of_unique_buildings = len(pd.unique(gdf_buildings['bldid']))
+    print('number of unique building', number_of_unique_buildings)
+    print('number of records in building layer ', len(gdf_buildings['bldid']))
+     
+    # Convert both to the same target coordinate system
+    gdf_buildings = gdf_buildings.set_crs("EPSG:4326",allow_override=True)
+    gdf_intensity = gdf_intensity.set_crs("EPSG:4326",allow_override=True)
+    
+    gdf_buildings = gdf_buildings.to_crs(f"EPSG:{epsg}")
+    gdf_intensity = gdf_intensity.to_crs(f"EPSG:{epsg}")
+
+    print(gdf_buildings.head())
+    print(gdf_intensity.head())
+    #%%
+    gdf_building_intensity = geopandas.sjoin_nearest(gdf_buildings,gdf_intensity, 
+                how='left', rsuffix='intensity',distance_col='distance')
+    #%%
+    gdf_building_intensity = gdf_building_intensity.drop_duplicates(subset=['bldid'], keep='first')
+    # %%
+    # TODO: Check if the logic makes sense
+    if hazard_type == HAZARD_FLOOD:
+        away_from_flood = gdf_building_intensity['distance'] > threshold_flood_distance
+        print('threshold_flood_distance',threshold_flood_distance)
+        print('number of distant buildings', len(gdf_building_intensity.loc[away_from_flood, 'im']))
+        gdf_building_intensity.loc[away_from_flood, 'im'] = 0
+    # %%
+    gdf_building_intensity[['material','code_level','storeys','occupancy']] =  \
+        gdf_building_intensity['expstr'].str.split('+',expand=True)
+    gdf_building_intensity['height'] = gdf_building_intensity['storeys'].str.extract(r'([0-9]+)s').astype('int')
+    # %%
+    lr = (gdf_building_intensity['height'] <= 4)
+    mr = (gdf_building_intensity['height'] >= 5) & (gdf_building_intensity['height'] <= 8)
+    hr = (gdf_building_intensity['height'] >= 9)
+    gdf_building_intensity.loc[lr, 'height_level'] = 'LR'
+    gdf_building_intensity.loc[mr, 'height_level'] = 'MR'
+    gdf_building_intensity.loc[hr, 'height_level'] = 'HR'
+    # %%
+    gdf_building_intensity['vulnstreq'] = \
+        gdf_building_intensity[['material','code_level','height_level']] \
+            .agg('+'.join,axis=1)
+    # %%
+    if hazard_type == HAZARD_EARTHQUAKE:
+        bld_eq = gdf_building_intensity.merge(df_eq, on='vulnstreq', how='left')
+        nulls = bld_eq['muds1_g'].isna()
+        bld_eq.loc[nulls, ['muds1_g','muds2_g','muds3_g','muds4_g']] = [0.048,0.203,0.313,0.314]
+        bld_eq.loc[nulls, ['sigmads1','sigmads2','sigmads3','sigmads4']] = [0.301,0.276,0.252,0.253]
+        bld_eq['logim'] = np.log(bld_eq['im_x']/9.81)
+        for m in ['muds1_g','muds2_g','muds3_g','muds4_g']:
+            bld_eq[m] = np.log(bld_eq[m])
+
+        for i in [1,2,3,4]: 
+            bld_eq[f'prob_ds{i}'] = norm.cdf(bld_eq['logim'],bld_eq[f'muds{i}_g'],bld_eq[f'sigmads{i}'])
+        bld_eq[['prob_ds0','prob_ds5']] = [1,0]
+        for i in [1,2,3,4,5]:
+            bld_eq[f'ds_{i}'] = np.abs(bld_eq[f'prob_ds{i-1}'] - bld_eq[f'prob_ds{i}'])
+        df_ds = bld_eq[['ds_1','ds_2','ds_3','ds_4','ds_5']]
+        bld_eq['eq_ds'] = df_ds.idxmax(axis='columns').str.extract(r'ds_([0-9]+)').astype('int')
+
+        # Create a simplified building-hazard relation
+        bld_hazard = bld_eq[['bldid','occupancy','eq_ds']]
+        bld_hazard = bld_hazard.rename(columns={'eq_ds':'ds'})
+
+        ds_str = {1: 'No Damage',2:'Low',3:'Medium',4:'High',5:'Collapsed'}
+
+    elif hazard_type == HAZARD_FLOOD:
+        bld_flood = gdf_building_intensity.merge(df_flood, on='expstr', how='left')
+        x = np.array([0,0.5,1,1.5,2,3,4,5,6])
+        y = bld_flood[['hw0','hw0_5','hw1','hw1_5','hw2','hw3','hw4','hw5','hw6']].to_numpy()
+        xnew = bld_flood['im'].to_numpy()
+        flood_mapping = interp1d(x,y,axis=1,kind='linear',bounds_error=False, fill_value=(0,1))
+        # TODO: find another way for vectorized interpolate
+        bld_flood['fl_prob'] = np.diag(flood_mapping(xnew))
+        bld_flood['fl_ds'] = 0
+        bld_flood.loc[bld_flood['fl_prob'] > threshold_flood,'fl_ds'] = 1
+
+        # Create a simplified building-hazard relation
+        bld_hazard = bld_flood[['bldid','occupancy','fl_ds']]
+        bld_hazard = bld_hazard.rename(columns={'fl_ds':'ds'})
+
+        ds_str = {0: 'No Damage',1:'Flooded'}
+    # %%
+    bld_hazard['occupancy'] = pd.Categorical(bld_hazard['occupancy'])
+    for key, value in ds_str.items():
+        bld_hazard.loc[bld_hazard['ds'] == key,'damage_level'] = value
+    bld_hazard['damage_level'] = pd.Categorical(bld_hazard['damage_level'], list(ds_str.values()))
+
+    #%% Find the damage state of the building that the household is in
+    df_household_bld = df_household.merge(bld_hazard[['bldid','ds']], on='bldid', how='left',validate='many_to_one')
+
+    #%% find the damage state of the hospital that the household is associated with
+    df_hospitals = df_household.merge(bld_hazard[['bldid','damage_level', 'ds']], 
+            how='left', left_on='commfacid', right_on='bldid', suffixes=['','_comm'],
+            validate='many_to_one')
+
+    #%%
+    df_individual_occupancy = df_individual.merge(bld_hazard[['bldid','occupancy','damage_level', 'ds']], 
+                        how='inner',left_on='indivfacid',right_on='bldid',
+                        suffixes=['_l','_r'],validate='many_to_one')
+
+    #%%
+    df_workers = df_individual_occupancy.query('occupancy in ["Com","ResCom","Ind"]')
+
+    #%%
+    df_students = df_individual_occupancy.query('occupancy in ["Edu"]')
+
+    #%%
+    df_indiv_hosp = df_individual.merge(df_hospitals[['hhid','ds','bldid']], 
+                    how='left', on='hhid', validate='many_to_one')
+    #%%
+
+    # get the ds of household that individual lives in
+    df_indiv_household = df_individual[['hhid','individ']].merge(df_household_bld[['hhid','ds']])
+
+    df_displaced_indiv = df_indiv_hosp.rename(columns={'ds':'ds_hospital'})\
+        .merge(df_workers[['individ','ds']].rename(columns={'ds':'ds_workplace'}),on='individ', how='left')\
+        .merge(df_students[['individ','ds']].rename(columns={'ds':'ds_school'}), on='individ', how='left')\
+        .merge(df_indiv_household[['individ','ds']].rename(columns={'ds':'ds_household'}), on='individ',how='left')
+
+    # %%
+    #%%
+    if hazard_type == HAZARD_EARTHQUAKE:
+        # Effect of policies on thresholds
+        # First get the global threshold
+        thresholds = {f'metric{id}': threshold for id in range(8)}
+        # Policy-1: Loans for reconstruction for minor to moderate damages
+        # Changes: Damage state thresholds for “displacement”
+        # Increase thresholds from “slight to moderate” as fewer people will be displaced.
+        if 21 in policies and thresholds['metric7'] == DS_NO:
+            thresholds['metric7'] = DS_SLIGHT
+
+        # Policy-3: Cat-bond agreement for education and health facilities
+        # Changes: Damage state thresholds for “loss of access to hospitals” and “loss of access to schools”
+        # Increase thresholds from “slight to moderate” as fewer people will be displaced.
+        if 23 in policies and thresholds['metric3'] == DS_NO:
+            thresholds['metric3'] = DS_SLIGHT
+        if 23 in policies and thresholds['metric2'] == DS_NO:
+            thresholds['metric2'] = DS_SLIGHT
+
+        # Policy-2: Knowledge sharing about DRR in public and private schools
+        # Changes: Damage state thresholds for “loss of school access”
+        # Increase thresholds loss of school access to beyond current scale. So that the impact will be downgraded to “0”.
+        if 22 in policies:
+            thresholds['metric2'] = DS_COLLAPSED
+    elif hazard_type == HAZARD_FLOOD:
+        # For flood, there are only two states: 0 or 1. 
+        # So threshold is set to 0. 
+        thresholds = {f'metric{id}': 0 for id in range(8)}
+
+    #%% metric 1 number of unemployed workers in each building
+    print(df_workers[df_workers['bldid'] == 28])
+    df_workers_per_building = df_workers[df_workers['ds'] > thresholds['metric1']].groupby('bldid',as_index=False).agg({'individ':'count'})
+    
+    df_metric1 = bld_hazard.merge(df_workers_per_building,how='left',left_on='bldid',right_on = 'bldid')[['bldid','individ']]
+    print(df_metric1[df_metric1['bldid'] == 28])
+    df_metric1.rename(columns={'individ':'metric1'}, inplace=True)
+    df_metric1['metric1'] = df_metric1['metric1'].fillna(0).astype(int)
+
+    #%% metric 2 number of students in each building with no access to schools
+    df_students_per_building = df_students[df_students['ds'] > thresholds['metric2']].groupby('bldid',as_index=False).agg({'individ':'count'})
+    df_metric2 = bld_hazard.merge(df_students_per_building,how='left',left_on='bldid',right_on = 'bldid')[['bldid','individ']]
+    df_metric2.rename(columns={'individ':'metric2'}, inplace=True)
+    df_metric2['metric2'] = df_metric2['metric2'].fillna(0).astype(int)
+
+    #%% metric 3 number of households in each building with no access to hospitals
+    df_hospitals_per_household = df_hospitals[df_hospitals['ds'] > thresholds['metric3']].groupby('bldid',as_index=False).agg({'hhid':'count'})
+    df_metric3 = bld_hazard.merge(df_hospitals_per_household,how='left',left_on='bldid',right_on='bldid')[['bldid','hhid']]
+    df_metric3.rename(columns={'hhid':'metric3'}, inplace=True)
+    df_metric3['metric3'] = df_metric3['metric3'].fillna(0).astype(int)
+
+    #%% metric 4 number of individuals in each building with no access to hospitals
+    df_hospitals_per_individual = df_hospitals[df_hospitals['ds'] > thresholds['metric4']].groupby('bldid',as_index=False).agg({'nind':'sum'})
+    df_metric4 = bld_hazard.merge(df_hospitals_per_individual,how='left',left_on='bldid',right_on='bldid')[['bldid','nind']]
+    df_metric4.rename(columns={'nind':'metric4'}, inplace=True)
+    df_metric4['metric4'] = df_metric4['metric4'].fillna(0).astype(int)
+
+    #%% metric 5 number of damaged households in each building
+    df_homeless_households = df_household_bld[df_household_bld['ds'] > thresholds['metric5']].groupby('bldid',as_index=False).agg({'hhid':'count'})
+    df_metric5 = bld_hazard.merge(df_homeless_households,how='left',left_on='bldid',right_on='bldid')[['bldid','hhid']]
+    df_metric5.rename(columns={'hhid':'metric5'}, inplace=True)
+    df_metric5['metric5'] = df_metric5['metric5'].fillna(0).astype(int)
+
+    #%% metric 6 number of homeless individuals in each building
+    df_homeless_individuals = df_household_bld[df_household_bld['ds'] > thresholds['metric6']].groupby('bldid',as_index=False).agg({'nind':'sum'})
+    df_metric6 = bld_hazard.merge(df_homeless_individuals,how='left',left_on='bldid',right_on='bldid')[['bldid','nind']]
+    df_metric6.rename(columns={'nind':'metric6'}, inplace=True)
+    df_metric6['metric6'] = df_metric6['metric6'].fillna(0).astype(int)
+
+    #%% metric 7 the number of displaced individuals in each building
+    # more info: an individual is displaced if at least of the conditions below hold
+    df_disp_per_bld = df_displaced_indiv[(df_displaced_indiv['ds_household'] > thresholds['metric6']) |
+                                        (df_displaced_indiv['ds_school'] > thresholds['metric7']) |
+                                        (df_displaced_indiv['ds_workplace'] > thresholds['metric7']) |
+                                        (df_displaced_indiv['ds_hospital'] > thresholds['metric7'])].groupby('bldid',as_index=False).agg({'individ':'count'})
+    df_metric7 = bld_hazard.merge(df_disp_per_bld,how='left',left_on='bldid',right_on='bldid')[['bldid','individ']]
+    df_metric7.rename(columns={'individ':'metric7'}, inplace=True)
+    df_metric7['metric7'] = df_metric7['metric7'].fillna(0).astype(int)
+
+    #%%
+    df_metrics = {'metric1': df_metric1,
+                'metric2': df_metric2,
+                'metric3': df_metric3,
+                'metric4': df_metric4,
+                'metric5': df_metric5,
+                'metric6': df_metric6,
+                'metric7': df_metric7}
+
+    #%%
+    number_of_workers = len(df_workers)
+    print('number of workers', number_of_workers)
+
+    number_of_students = len(df_students)
+    print('number of students', number_of_students)
+
+    number_of_households = len(df_household)
+    print('number of households', number_of_households)
+
+    number_of_individuals = len(df_individual)
+    print('number of individuals', number_of_individuals)
+    metrics = {"metric1": {"desc": "Number of workers unemployed", "value": 0, "max_value": number_of_workers},
+                "metric2": {"desc": "Number of children with no access to education", "value": 0, "max_value": number_of_students},
+                "metric3": {"desc": "Number of households with no access to hospital", "value": 0, "max_value": number_of_households},
+                "metric4": {"desc": "Number of individuals with no access to hospital", "value": 0, "max_value": number_of_individuals},
+                "metric5": {"desc": "Number of homeless households", "value": 0, "max_value": number_of_households},
+                "metric6": {"desc": "Number of homeless individuals", "value": 0, "max_value": number_of_individuals},
+                "metric7": {"desc": "Population displacement", "value": 0, "max_value": number_of_individuals},}
+    metrics["metric1"]["value"] = int(df_metric1['metric1'].sum())
+    metrics["metric2"]["value"] = int(df_metric2['metric2'].sum())
+    metrics["metric3"]["value"] = int(df_metric3['metric3'].sum())
+    metrics["metric4"]["value"] = int(df_metric4['metric4'].sum())
+    metrics["metric5"]["value"] = int(df_metric5['metric5'].sum())
+    metrics["metric6"]["value"] = int(df_metric6['metric6'].sum())
+    metrics["metric7"]["value"] = int(df_metric7['metric7'].sum())
+
+    result = {"metrics": metrics}
+
+    return result, df_metrics
+    

src/gui/sandbox.py

@@ -0,0 +1,100 @@
+import solara
+import ipyleaflet
+from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
+import math
+import numpy as np
+
+plt.switch_backend("agg")
+
+@solara.component
+def DialWidget(desc, value, max_value=10000):
+    if max_value == 0:
+        max_value = 10000
+    fig = Figure(tight_layout=True,dpi=30,frameon=False)
+    fig.set_size_inches(1.5,1)
+    ax = fig.subplots()
+    ax.axis('equal')
+    ax.axis('off')
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    t = np.linspace(0, math.pi, 100)
+
+    cos = np.cos(t)
+    sin = np.sin(t)
+
+    ax.plot(cos,sin, linewidth=2)
+    value_t = math.pi * (1 - (value / max_value))
+
+    fill_color = 'red'
+    if value_t >  math.pi / 2  :
+        x1 = np.linspace(-1,np.cos(value_t),100)
+        y1 = np.sqrt(1 - x1**2)
+        ax.fill_between(x1,y1,color=fill_color)
+        x1 = np.linspace(np.cos(value_t),0,100)
+        y1 = np.tan(value_t) * x1
+        ax.fill_between(x1,y1,color=fill_color)
+    else:
+        x = np.linspace(-1, np.cos(value_t),100)
+        y1 = np.sqrt(1-x**2)
+        y2a = np.zeros(100)
+        y2b = np.tan(value_t) * x
+        y2 = np.maximum(y2a,y2b)
+        ax.fill_between(x,y1,y2,color=fill_color)
+
+    #ax.plot([0,0.9*np.cos(value_t)],[0, 0.9*np.sin(value_t)], linewidth=10)
+    #ax.scatter([0],[0],color='black',s=50)
+    #ax.text(-1.1,0,0,fontdict={'fontsize':14},verticalalignment="center",
+    #    horizontalalignment="right",color="black")
+    #ax.text(1.1,0,max_value,fontdict={'fontsize':14},verticalalignment="center",
+    #    horizontalalignment="left",color="black")
+    #ax.plot([-0.9,-1.1],[0,0],color="black")
+    #ax.plot([0.9,1.1],[0,0],color="black")
+    #ax.plot([0,0],[0.9,1.1],color="black")
+    horizontalalignment = "right" if value_t > math.pi/2 else "left"
+    #ax.text(1.1*np.cos(value_t),1.1*np.sin(value_t),value,fontdict={'fontsize':20},verticalalignment="center",
+    #    horizontalalignment=horizontalalignment,color="black")
+    ax.text(0,0.5,value,fontdict={'fontsize':20},verticalalignment="center",
+        horizontalalignment="center",color="black")
+    ax.set_xlim(-1.1,1.1)
+    ax.set_ylim(-0.2,1.2)
+    #ax.text(0, -0.1, desc,fontdict={'fontsize':20},verticalalignment="center",
+    #    horizontalalignment='center',color="white")
+    solara.FigureMatplotlib(fig)
+
+metrics_template = {"metric1": {"desc": "Number of workers unemployed", "value": 0, "max_value": 0},
+        "metric2": {"desc": "Number of children with no access to education", "value": 0, "max_value": 0},
+        "metric3": {"desc": "Number of households with no access to hospital", "value": 0, "max_value": 0},
+        "metric4": {"desc": "Number of individuals with no access to hospital", "value": 0, "max_value": 0},
+        "metric5": {"desc": "Number of homeless households", "value": 0, "max_value": 0},
+        "metric6": {"desc": "Number of homeless individuals", "value": 0, "max_value": 0},
+        "metric7": {"desc": "Population displacement", "value": 0, "max_value": 0},}
+
+metrics = solara.reactive(metrics_template)
+
+def generate_metrics():
+    
+    new_metrics = metrics_template.copy()
+    for m in new_metrics.keys():
+        max_value = np.random.randint(500, 10001)
+        value = int(np.random.random() * max_value)
+        new_metrics[m]["max_value"] = max_value
+        new_metrics[m]["value"] = value
+
+    metrics.set(new_metrics)
+    
+@solara.component
+def Page(): 
+
+
+
+
+    solara.Button(label="Generate", on_click=generate_metrics)
+    
+    for name, metric in metrics.value.items():
+        DialWidget(name, metric["value"], max_value=metric["max_value"])
+
+
+Page()

src/tests/nairobi_business_individual.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f46b176200fbf857d92ad7c9ec2ad65aab08fe5a09386245f1e8534f823a156f
+size 53053675

src/tests/nairobi_flood_depth_50yr.geojson

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:447f10956468e02f7688923cc4094609c749dc039c10ec76984e377c803616b0
+size 14778140