Engine is embedded in a portal v0.0.1

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+
+#USER root
+RUN apt update
+RUN apt -y install gdal-bin libgdal-dev
+
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+COPY --chown=user . $HOME/app
+
+WORKDIR $HOME/app
+
+
+
+RUN (cd tomorrowcities & pip install -e .)
+
+CMD ["solara", "run", "tomorrowcities.pages",  "--host", "0.0.0.0", "--port", "7860"]
+#COPY ./requirements.txt $HOME/app/requirements.txt
+
+
+
+#RUN pip install --no-cache-dir --upgrade -r $HOME/app/requirements.txt
+
+#COPY . .
+
+#CMD ["solara", "run", "app_engine.py", "--host", "0.0.0.0", "--port", "7860"]
+

LICENSE

@@ -1,28 +1,21 @@
-BSD 3-Clause License
+The MIT License (MIT)
 
-Copyright (c) 2023, Tomorrow's Cities
+Copyright (c) 2022
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Procfile

@@ -0,0 +1,7 @@
+# heroku by default sets WEB_CONCURRENCY=2
+# see: https://devcenter.heroku.com/changelog-items/618
+# which uvicorn picks up, unless we explicitly set --workers --1
+# see https://www.uvicorn.org/deployment/
+# we do not support multiple workers yet
+# we also need to bind to 0.0.0.0 otherwise heroku cannot route to our server
+web: solara run tomorrowcities.pages --port=$PORT --no-open --host=0.0.0.0 --workers 1

README.md

@@ -1,5 +1,4 @@
-# TomorrowCities Python Library
+# Release Notes
 
-## Running GUI
-
-### 
+## v0.0.1
+* 

docs/conf.py

@@ -1,27 +0,0 @@
-# Configuration file for the Sphinx documentation builder.
-#
-# For the full list of built-in configuration values, see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Project information -----------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
-
-project = 'TomorrowCities'
-copyright = '2023, H. Kaya'
-author = 'H. Kaya'
-
-# -- General configuration ---------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
-
-extensions = []
-
-templates_path = ['_templates']
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-
-
-# -- Options for HTML output -------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
-
-html_theme = 'sphinx_rtd_theme'
-html_static_path = ['_static']

docs/gui.rst

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

docs/index.rst

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

docs/install.rst

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

docs/make.bat

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

docs/quickstart.rst

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

mypy.ini

@@ -0,0 +1,3 @@
+[mypy]
+check_untyped_defs = True
+ignore_missing_imports = True

pyproject.toml

@@ -1,24 +1,35 @@
 [build-system]
-requires = ["hatchling","fiona","geopandas","pandas","uuid","numpy"]
+requires = ["hatchling >=0.25"]
 build-backend = "hatchling.build"
 
 [project]
 name = "tomorrowcities"
-version = "0.0.2"
-authors = [
-  { name="Huseyin Kaya", email="hkayabilisim@gmail.com" },
-  { name="Prashant Rawal", email="prashantrawal@nset.org.np" },
-  { name="Erdem Ozer", email="ozerer@gmail.com" },
-]
-description = "Tomorrow Cities' Python Library"
-readme = "README.md"
-requires-python = ">=3.7"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
+license = {file = "LICENSE"}
+classifiers = ["License :: OSI Approved :: MIT License"]
+dynamic = ["version", "description"]
+dependencies = [
+    "solara", 
+    "geopandas", 
+    "ipyleaflet", 
+    "plotly",
+    "lorem_text", 
+    "matplotlib",
+    "psycopg2-binary",
+    "scipy", 
+    "pandas",
+    "networkx"
 ]
 
+[tool.hatch.version]
+path = "tomorrowcities/__init__.py"
+
+
+
 [project.urls]
-"Homepage" = "https://github.com/TomorrowsCities/tomorrowcities"
-"Bug Tracker" = "https://github.com/TomorrowsCities/tomorrowcities"
+Home = "https://github.com/TomorrowsCities/tomorrowcities"
+
+[tool.black]
+line-length = 160
+
+[tool.isort]
+profile = "black"

src/gui/requirements.txt → requirements.txt

@@ -5,4 +5,5 @@ plotly
 lorem_text
 matplotlib
 psycopg2-binary 
-scipy
+scipy
+pandas

src/gui/Dockerfile

@@ -1,23 +0,0 @@
-FROM python:3.9
-
-RUN useradd -m -u 1000 user
-
-USER user
-
-ENV HOME=/home/user \
-	PATH=/home/user/.local/bin:$PATH
-
-COPY --chown=user . $HOME/app
-
-WORKDIR $HOME/app
-
-COPY ./requirements.txt $HOME/app/requirements.txt
-
-#RUN sudo apt -y install gdal-bin libgdal-dev
-
-RUN pip install --no-cache-dir --upgrade -r $HOME/app/requirements.txt
-
-COPY . .
-
-CMD ["solara", "run", "app_engine.py", "--host", "0.0.0.0", "--port", "7860"]
-

src/gui/app_datagenerator.py

@@ -1,63 +0,0 @@
-import gradio as gr
-from tomorrowcities import DataGenerator
-import warnings
-import uuid
-import os
-import matplotlib.pyplot as plt
-
-
-warnings.simplefilter(action='ignore')
-
-plt.switch_backend("agg")
-
-def generate(land_use_file, parameter_file, seed):
-    oppath='.'
-    dg = DataGenerator(parameter_file=parameter_file.name,
-                    land_use_file=land_use_file.name)
-    
-    building, household, individual, land_use = dg.generate(seed)
-
-    
-    # Generate unique filenames
-    opfile_map = 'map'+str(uuid.uuid4())+'.png'
-    opfile_building = 'building_layer_'+str(uuid.uuid4())+'.xlsx'
-    opfile_household = 'household_layer_'+str(uuid.uuid4())+'.xlsx'
-    opfile_individual = 'individual_layer_'+str(uuid.uuid4())+'.xlsx'
-    opfile_landuse =  'landuse_layer_'+str(uuid.uuid4())+'.xlsx'
-
-    fig, ax = plt.subplots(1,1,figsize=(10,10))
-    
-    building.plot(ax=ax)
-    plt.savefig(opfile_map)
-
-    # Save to Excel files
-    building.to_excel(os.path.join(oppath,opfile_building),index=False)
-    household.to_excel(os.path.join(oppath,opfile_household),index=False)
-    individual.to_excel(os.path.join(oppath,opfile_individual),index=False)
-    land_use.to_excel(os.path.join(oppath,opfile_landuse),index=False)                                                                     
-
-    info = f'# buildings: {len(building)}, # households: {len(household)}, # individuals: {len(individual)}'
-    return opfile_building, opfile_household, opfile_individual, opfile_landuse, opfile_map, info
-
-with gr.Blocks() as demo:
-    with gr.Row():
-        land_use_file = gr.File(label="Upload Land Use File")
-        parameter_file = gr.File(label="Upload Parameter File")
-        seed = gr.Slider(label="Seed", minimum=0, maximum=1000, value=0, step=1)
-    btn = gr.Button("Generate")
-    with gr.Row():
-        with gr.Column():
-            building = gr.File(label="Buildings")
-            household = gr.File(label="Households")
-        with gr.Column():
-            individual = gr.File(label="Individuals")
-            land_use = gr.File(label="Land Use")
-        map = gr.Image(label="Map")
-    info = gr.Textbox(label="Info")
-    gr.Examples(examples=[['tests/polygonsTV50_v2b.zip','tests/Input_DistributionTables_20230614.xlsx',0]],
-                inputs=[land_use_file, parameter_file, seed])
-
-    btn.click(fn=generate, inputs=[land_use_file, parameter_file, seed], 
-              outputs=[building, household, individual, land_use, map, info])
-
-demo.launch()

src/gui/app_engine.py

@@ -1,515 +0,0 @@
-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 ipyleaflet import AwesomeIcon, Marker
-import engine
-import random
-from matplotlib.figure import Figure
-import matplotlib.pyplot as plt
-import math
-
-css = """
-
-"""
-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','ds','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'])
-power_edge_columns = set(['FROM_NODE', 'direction', 'pipetype', 'EDGE_ID', 'guid', 'capacity', 'geometry', 'TO_NODE', 'length'])
-power_node_columns = set(['geometry', 'FLTYTYPE', 'STRCTYPE', 'UTILFCLTYC', 'INDPNODE', 'guid',
-       'NODE_ID', 'x_coord', 'y_coord', 'pwr_plant', 'serv_area', 'n_bldgs',
-       'income', 'eq_vuln'])
-vulnerabillity_columns = set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6'])
-fragility_columns = set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4'])
-power_fragility_columns = set(['vuln_string', 'med_Slight', 'med_Moderate', 'med_Extensive', 'med_Complete', 'beta_Slight', 'beta_Moderate', 'beta_Extensive', 'beta_Complete', 'description'])
-all_layers = ["Landuse", "Buildings", "Household","Individual","Intensity","Vulnerability","Fragility","Power Links","Power Nodes", "Power Fragility"]
-infra_options = ["power",'buildings']
-
-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)
-
-
-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)
-hazard = solara.reactive("earthquake")
-infra = solara.reactive([])
-
-loading = solara.reactive(-1)
-
-building_df = 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 power_node_click_handler(event=None, feature=None, properties=None):
-    print(locals())
-    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):
-        ds_to_color = {0: 'lavender', 1:'violet',2:'fuchsia',3:'indigo',4:'darkslateblue',5:'black'}
-        ds = feature['properties']['ds'] 
-
-        return {'color': ds_to_color[ds], 'fillColor': ds_to_color[ds]}
-
-def power_node_style(feature,):
-    return dict(
-        opacity=0.5,
-        color='black',
-        weight=0.9
-    )
-
-
-@solara.component
-def MapComponent():
-
-    extra_layers = [l['geojson'] for l in layers.value if 'geojson' in l.keys() and l['visible'].value]
-
-    # MarkerGroup Layer
-    dataframes = {l['name']:l['df'] for l in layers.value if l['visible'].value}
-    if 'Power Nodes' in dataframes.keys():
-        df = dataframes['Power Nodes'].value
-        markers = []
-        for index, node in df.iterrows():
-            x = node.geometry.x
-            y = node.geometry.y
-            marker_color = 'blue' if node['is_operational'] else 'red'
-            icon_name = 'fa-industry' if node['pwr_plant'] else 'bolt'
-            icon_color = 'black'
-            marker = Marker(icon=AwesomeIcon(
-                        name=icon_name,
-                        marker_color=marker_color,
-                        icon_color=icon_color,
-                        spin=False
-                    ),location=(y,x),title=f'{node["NODE_ID"]}')
-
-            markers.append(marker)
-        power_node_layer= ipyleaflet.MarkerCluster(markers=markers,
-                                                   disable_clustering_at_zoom=5)
-        extra_layers.append(power_node_layer)
-
-    
-
-
-
-    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(name, value, max_value=10000):
-    print('value',value,'max_value',max_value)
-    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':18},verticalalignment="center",
-        horizontalalignment="center",color="black")
-    ax.text(1,0,max_value,fontdict={'fontsize':8},verticalalignment="center",
-        horizontalalignment="right",color="black")
-    ax.text(0,-0.1,name,fontdict={'fontsize':10},verticalalignment="top",
-        horizontalalignment="center",color="black")
-    ax.set_xlim(-1.1,1.1)
-    ax.set_ylim(-0.2,1.2)
-    solara.FigureMatplotlib(fig)
-
-@solara.component
-def ExistingLayers():
-    with solara.Column(gap="0px"):
-        for layer in layers.value:
-            solara.Checkbox(label=layer['name'],
-                            value=layer['visible'],
-                            style="margin-top: 0px; padding-top: 0px; min-height: 0px;")
-                
-@solara.component
-def VisioningScenarioViewer():
-
-    # State variables
-    error_message, set_error_message = solara.use_state("")
-
-    selected_layer, set_selected_layer = solara.use_state("Landuse")
-
-    def load(file: FileInfo):
-        try:
-            json_string = file['data'].decode('utf-8')
-            json_hash = hash(json_string)
-            json_data = json.loads(json_string)
-            print('loaded json data keys',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.value.keys():
-                        for i in range(len(json_data['features'])):
-                            json_data['features'][i]['properties'][metric] = 0 
-                    # initial damage states set to zero
-                    for i in range(len(json_data['features'])):
-                        json_data['features'][i]['properties']['ds'] = 0
- 
-                df = gpd.GeoDataFrame.from_features(json_data['features'])
-
-                if set(df.columns) == building_columns:
-                    building_df.set(df)
-
-                new_center = (df.geometry.centroid.y.mean(), df.geometry.centroid.x.mean())
-                center.set(new_center)
-
-            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, 'hash': json_hash, 'visible': solara.reactive(True)}
-                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'
-                elif df_columns == fragility_columns:
-                    new_layer['name'] = 'Fragility'
-                elif df_columns == power_fragility_columns:
-                    new_layer['name'] = 'Power Fragility'
-                elif df_columns == power_edge_columns:
-                    new_layer['name'] = 'Power Links'
-                    new_layer['geojson'] = ipyleaflet.GeoJSON(data=json_data)
-                elif df_columns == power_node_columns:
-                    new_layer['name'] = 'Power Nodes'
-                    df['ds'] = 0
-                    df['is_damaged'] = False
-                    df['is_operational'] = True
-                
-                new_layer['df'] = solara.reactive(df)
-                if new_layer['name'] in [l['name'] for l in layers.value]:
-                    for i, l in enumerate(layers.value):
-                        if l['name'] == new_layer['name']:
-                            layers.value[i] = new_layer
-                            break
-                    #layers.set(layers.value)
-                else:
-                    layers.set(layers.value + [new_layer])
-
-            #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}")
-        loading.set(ratio)
-
-    def is_ready_to_run():
-        print('infra.value',infra.value)
-        existing_layers = set([l['name'] for l in layers.value])
-        missing = []
-
-
-           
-        if hazard.value == "earthquake":
-            if "power" in  infra.value:
-                missing += list(set(["Power Links","Power Nodes","Intensity","Power Fragility"]) - existing_layers)
-            if "buildings" in infra.value:
-                missing += list(set(["Buildings","Household","Individual","Intensity","Fragility"]) - existing_layers)
-        elif hazard.value == "flood":
-            if "power" in  infra.value:
-                missing += list(set(["Power Links","Power Nodes","Intensity","Power Vulnerability"]) - existing_layers)
-            if "buildings" in infra.value:
-                missing += list(set(["Buildings","Household","Individual","Intensity","Vulnerability"]) - existing_layers)
- 
-        if infra.value == []:
-            missing += ['You should select power and/or buildings']
-        return missing == [], missing
-
-    def compute():
-        print("I'm computing")
-        dfs = {l['name']: l['df'].value for l in layers.value}
-        dfs_reactive = {l['name']: l['df'] for l in layers.value}
-
-        is_ready, missing = is_ready_to_run()
-
-
-
-        if is_ready:
-            set_error_message("")
-
-            if 'power' in infra.value:
-                
-                eq_ds, is_damaged, is_operational = engine.compute_power_infra(dfs['Power Nodes'], 
-                                           dfs['Power Links'],
-                                           dfs['Intensity'],
-                                           dfs['Power Fragility'])
-                
-                power_node_df =  dfs['Power Nodes'].copy()                         
-                power_node_df['ds'] = list(eq_ds)
-                power_node_df['is_damaged'] = list(is_damaged)
-                power_node_df['is_operational'] = list(is_operational)
-
-                dfs_reactive['Power Nodes'].set(power_node_df)
-
-
-
-            if 'buildings' in infra.value:
-                computed_metrics, df_metrics, df_bld_hazard = engine.compute(dfs['Buildings'], 
-                        dfs['Household'], 
-                        dfs['Individual'],
-                        dfs['Intensity'],
-                        dfs['Fragility'] if hazard.value == "earthquake" else dfs['Vulnerability'], 
-                        hazard.value)
-
-                print(computed_metrics)
-                updated_df = building_df.value
-                for metric in df_metrics.keys():
-                    updated_df[metric] = list(df_metrics[metric][metric])
-                updated_df['ds'] = list(df_bld_hazard['ds'])
-                building_df.set(updated_df)
-                
-                ((ymin,xmin),(ymax,xmax)) = bounds.value
-                for metric in df_metrics.keys():
-                    computed_metrics[metric]['value']  = int(updated_df.cx[xmin:xmax,ymin:ymax][metric].sum())
-
-                metrics.set(computed_metrics)
-        else:
-            set_error_message(f'Layers {missing} are missing')
-
-    with solara.Row():
-        with solara.Column():
-            solara.FileDrop(label="Drop layers", on_total_progress=progress, on_file=load,lazy=False)
-            if loading.value > -1 and loading.value < 100:
-                solara.Info(f'Uploading {loading.value}%')
-
-        with solara.Column():
-            solara.ToggleButtonsSingle(hazard.value, ["earthquake","flood"], on_value=hazard.set)
-            solara.ToggleButtonsMultiple(infra.value,infra_options, on_value=infra.set)
-            solara.Button(label="Compute", on_click=compute, outlined=True)
-            
-        #building_layer = get_building_layer()            
-        with solara.GridFixed(columns=4):
-            for metric_name, metric in metrics.value.items():
-                metric_description = metric['desc']
-                if building_df.value is not None and bounds.value is not None:
-                    ((ymin,xmin),(ymax,xmax)) = bounds.value
-                    value = int(building_df.value.cx[xmin:xmax,ymin:ymax][metric_name].sum())
-                else:
-                    value = 0
-                #with solara.Column(gap="1px",classes=['metriccontainer'],align="center", margin="1"):
-                with solara.Tooltip(metric_description):
-                    with solara.Column():
-                        DialWidget(metric_name, value, max_value=metric['max_value'])
-                #solara.HTML(tag="div",unsafe_innerHTML=f'{metric_description}',
-                    #            classes=["metricdescription"])
-        if error_message != "":
-            solara.Error(error_message)
-    with solara.Columns([10, 70, 20]):
-        ExistingLayers()
-        MapComponent()
-        solara.DataFrame(df=clicked_df.value, scrollable=True)
-
-    solara.ToggleButtonsSingle(selected_layer, all_layers, on_value=set_selected_layer)
-    found_layer = None
-    for layer in layers.value:
-        if layer['name'] == selected_layer and layer['visible'].value:
-            found_layer = layer
-            break
-    
-    if found_layer:
-        df = found_layer['df'].value
-        print('found layer', found_layer['name'])
-        if 'geometry' in list(df.columns) and bounds.value is not None:
-            ((ymin,xmin),(ymax,xmax)) = bounds.value
-            solara.DataFrame(df=df.cx[xmin:xmax,ymin:ymax].drop(columns='geometry'))
-        else:
-            solara.DataFrame(df=df)
-        
-    else:
-        solara.Info(f'{selected_layer} is not uploaded or set to invisible')
-@solara.component
-def Page():
-    solara.Style(css)
-    VisioningScenarioViewer()

src/gui/sandbox.py

@@ -1,100 +0,0 @@
-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/Input_DistributionTables_20230614.xlsx

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

src/tests/nairobi_business_buildings.geojson

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

src/tests/nairobi_business_household.json

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

src/tests/nairobi_business_individual.json

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

src/tests/nairobi_business_landuse.geojson

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

src/tests/nairobi_earthquake_fragility.json

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

src/tests/nairobi_earthquake_intensity.geojson

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

src/tests/nairobi_flood_depth_50yr.geojson

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

src/tests/nairobi_flood_vulnerability.json

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

src/tests/nairobi_power_edges.geojson

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

src/tests/nairobi_power_fragility.json

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

src/tests/nairobi_power_nodes.geojson

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

src/tests/polygonsTV50_v2b.zip

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

src/tomorrowcities/__init__.py

@@ -1,7 +0,0 @@
-from tomorrowcities.core import (
-    DataGenerator,
-)
-
-__all__ = [ 
-    'DataGenerator',
-]

src/tomorrowcities/core.py

@@ -1,1463 +0,0 @@
-from tomorrowcities.utils import read_zipshp 
-import pandas as pd
-import uuid
-import json
-import io
-import fiona
-import os.path
-import numpy as np
-import pandas as pd
-import geopandas as gpd
-import random
-from random import sample
-from numpy.random import multinomial, randint
-from math import ceil
-import math
-from itertools import repeat, chain
-import warnings
-warnings.simplefilter(action='ignore')
-
-class DataGenerator:
-  def __init__(self, parameter_file, land_use_file):
-    self.parameter_file = parameter_file
-    self.land_use_file = land_use_file
-
-  def generate(self, seed=42):
-    ipfile = self.parameter_file
-    random.seed(seed)
-    np.random.seed(seed)
-    df_nc = pd.read_excel(ipfile,sheet_name=1, header=None)
-    ipdf = pd.read_excel(ipfile,sheet_name=2, header=None)
-    df1 = pd.read_excel(ipfile,sheet_name=3, header=None)
-    df2 = pd.read_excel(ipfile,sheet_name=4, header=None)
-    df3 = pd.read_excel(ipfile,sheet_name=5, header=None)
-
-
-    #%% Extract the nomenclature for load resisting system and land use types
-    startmarker = '\['
-    startidx = df_nc[df_nc.apply(lambda row: row.astype(str).str.contains(\
-                    startmarker,case=False).any(), axis=1)]
-        
-    endmarker = '\]'
-    endidx = df_nc[df_nc.apply(lambda row: row.astype(str).str.contains(\
-                    endmarker,case=False).any(), axis=1)]
-        
-    # Load resisting system types
-    lrs_types_temp = df_nc.loc[list(range(startidx.index[0]+1,endidx.index[0]))]
-    lrs_types = lrs_types_temp[1].to_numpy().astype(str)
-    lrsidx = {}
-    count = 0
-    for key in lrs_types:
-        lrsidx[str(key)] = count
-        count+=1
-        
-    # Landuse Types 
-    lut_types_temp = df_nc.loc[list(range(startidx.index[1]+1,endidx.index[1]))]
-    lut_types = lut_types_temp[1].astype(str)
-    lutidx = {}
-    count = 0
-    for key in lut_types:
-        lutidx[key] = count
-        count+=1
-
-    
-    #%% Inputs extracted from the excel input file
-
-    opfile_building = 'building_layer_'+str(uuid.uuid4())+'.xlsx'
-    opfile_household = 'household_layer_'+str(uuid.uuid4())+'.xlsx'
-    opfile_individual = 'individual_layer_'+str(uuid.uuid4())+'.xlsx'
-    opfile_landuse =  'landuse_layer_'+str(uuid.uuid4())+'.xlsx'
-              
-    savefile = ipdf.iloc[8,1]
-
-    # Income types is hardcoded
-    avg_income_types =np.array(['lowIncomeA','lowIncomeB','midIncome','highIncome'])
-
-    #Average dwelling area (sqm) wrt income type (44 for LI, 54 for MI, 
-    #67 for HI in Tomorrovwille)
-    #Range of footprint area fpt_area (sqm) wrt. income type (32-66 for LI,
-    # 32-78 for MI and 70-132 for HI in Tomorrowville)                 
-    average_dwelling_area = np.array([ipdf.iloc[21,2],ipdf.iloc[21,3],\
-                                      ipdf.iloc[21,4],ipdf.iloc[21,5]])
-
-    fpt_area = {'lowIncomeA':np.fromstring(ipdf.iloc[22,2],dtype=float,sep=','),
-                'lowIncomeB':np.fromstring(ipdf.iloc[22,3],dtype=float,sep=','),
-                'midIncome':np.fromstring(ipdf.iloc[22,4],dtype=float,sep=','),
-                'highIncome':np.fromstring(ipdf.iloc[22,5],dtype=float,sep=',')}
-
-    # Storey definition 1- Low rise (LR) 1-4, 2- Mid rise (MR) 5-8,
-    # 3- High rise (HR) 9-19
-    storey_range = {0:np.fromstring(ipdf.iloc[25,2],dtype=int,sep=','),
-                    1:np.fromstring(ipdf.iloc[25,3],dtype=int,sep=','),
-                    2:np.fromstring(ipdf.iloc[25,4],dtype=int,sep=',')}
-
-    # Code Compliance Levels (Low, Medium, High): 1 - LC, 2 - MC, 3 - HC
-    code_level = np.array(['LC','MC','HC'])
-
-    # Nr of commercial buildings per 1000 individuals
-    numb_com = ipdf.iloc[10,1]
-    # Nr of industrial buildings per 1000 individuals
-    numb_ind = ipdf.iloc[11,1]
-
-    # Area constraints in percentage (AC) for residential and commercial zones. 
-    # Total built-up areas in these zones cannot exceed (AC*available area)
-    AC_com = ipdf.iloc[14,1] # in percent
-    AC_ind = ipdf.iloc[15,1] # in percent
-
-    # Assumption 14 and 15: 1 school per 10000 individuals,
-    # 1 hospital per 25000 individuals
-    nsch_pi = ipdf.iloc[17,1]
-    nhsp_pi = ipdf.iloc[18,1]
-
-    # Unit price for replacement wrt occupancy type and special facility 
-    # status of the building
-    # Occupancy type is unchangeable, only replacement value is taken from user input
-    Unit_price={'Res':ipdf.iloc[28,2],'Com':ipdf.iloc[28,3],'Ind':ipdf.iloc[28,4],
-                'ResCom':ipdf.iloc[28,5],'Edu':ipdf.iloc[28,6],'Hea':ipdf.iloc[28,7]}
-
-    #household_building_match = 'footprint' # 'footprint' or 'number_of_units'
-
-    landuse_shp = read_zipshp(self.land_use_file)
-
-
-    #Calculate area of landuse zones using polygons only if area is not already. 
-    # First, convert coordinate system to cartesian
-    if 'area' not in landuse_shp.columns:
-        landuse_shp_cartesian = landuse_shp.copy()
-        landuse_shp_cartesian = landuse_shp_cartesian.to_crs({'init': 'epsg:3857'})
-        landuse_shp_cartesian['area']=landuse_shp_cartesian['geometry'].area # m^2
-        landuse_shp_cartesian['area']=landuse_shp_cartesian['area']/10**4 # Hectares
-        landuse_shp_cartesian = landuse_shp_cartesian.drop(columns=['geometry'])
-        landuse = landuse_shp_cartesian.copy()
-    else:
-        landuse = landuse_shp.copy()
-        landuse = landuse.drop(columns=['geometry'])
-
-
-    #%% Concatenate the dataframes and process the data
-    tabledf = pd.concat([df1,df2,df3]).reset_index(drop=True)
-
-    # Define a dictionary containing data distribution tables
-    # Table names sorted according to the order in the excel input spreadsheet
-    tables_temp = {
-        't1':[],'t2':[],'t3':[],'t4':[],'t5':[],'t5a':[],'t6':[],'t9':[],
-        't12':[],'t13':[],'t7':[],'t8':[],'t11':[],'t10':[],'t14':[]   
-        }
-    startmarker = '\['
-    startidx = tabledf[tabledf.apply(lambda row: row.astype(str).str.contains(\
-                    startmarker,case=False).any(), axis=1)]
-        
-    endmarker = '\]'
-    endidx = tabledf[tabledf.apply(lambda row: row.astype(str).str.contains(\
-                    endmarker,case=False).any(), axis=1)]
-        
-
-    count=0
-    for key in tables_temp:
-        #print(startidx.index[count], endidx.index[count])
-        tablepart = tabledf.loc[list(range(startidx.index[count]+1,endidx.index[count]))]
-        tablepart = tablepart.drop(columns =0 )
-        tablepart = tablepart.dropna(axis=1).reset_index(drop=True).values.tolist()
-        tables_temp[key].append(tablepart)
-        count+=1
-
-    tables = tables_temp
-
-    #If values are zero for industrial and commercial buildings
-    if numb_com ==0:
-        print('The number of commercial buildings cannot be zero.')
-    if numb_ind == 0:
-        print('The number of industrial buildings cannot be zero.')
-
-
-    #%% Function definition: dist2vector
-    def dist2vector(d_value, d_number,d_limit,shuffle_or_not):
-        # d_value, d_number = vectors of samelength (numpy array)
-        # d_limit = single integer which indicates the sum of all values
-        #           in d_number. 
-        # shuffle_or_not = 'shuffle' will return a randomly shuffled list otherwise
-        #     by default or with 'DoNotShuffle' the list will not be shuffled
-        # Output: insert_vector is a list
-        # Calculate cumulative sum and typecast to integer
-        d_number = np.cumsum(d_number).astype('int32')
-        d_number[-1] = d_limit #To prevent array broadcast mismatch
-        d_number_temp = np.insert(d_number,0,0)
-        d_number_round = np.diff(d_number_temp)
-        insert_vector_df= pd.DataFrame(np.nan,index=range(d_number[-1]),columns=['iv'])
-        a=0
-        icount= 0
-        for value in d_value:
-            b = d_number[icount]  
-            subvector = [str(value)]*d_number_round[icount]
-            insert_vector_df.loc[range(a,b),'iv'] = subvector
-            a = b   
-            icount+=1
-            
-        insert_vector = insert_vector_df['iv'].values.tolist() 
-        if shuffle_or_not == 'shuffle':
-            random.shuffle(insert_vector)
-
-        return insert_vector 
-
-    #%% The data generation process begins here____________________________________
-
-    #%% Step 1: Calculate maximum population (nPeople)
-    nPeople = round(landuse['densityCap']*landuse['area']-landuse['population'])
-    nPeople[nPeople<0]=0
-
-    #%% Step 2: Calculate the number of households (nHouse), hhID
-    # Assumption 1: Household size distribution is same for different income types
-    # Question: How to ensure that there are no NaNs while assigning zone type?
-
-    # Convert Table 1 to numpy array
-    t1_list = tables['t1'][0]
-    # No. of individuals
-    t1_l1 = np.array(t1_list[0], dtype=int) 
-    t1_l2 = np.array(t1_list[1], dtype=float) # Probabilities
-
-    # Compute the probability of X number of people living in a household 
-    household_prop = t1_l2/sum(t1_l2) 
-    # Total number of households for all zones
-    nHouse_all = round(nPeople/(sum(household_prop*t1_l1)))
-    nHouse_all = nHouse_all.astype('int32')
-    nHouse = nHouse_all[nHouse_all>0] # Exclude zones with zero households
-    nHouseidx = nHouse.index
-    #Preallocate a dataframe with nan to hold the household layer
-    household_df = pd.DataFrame(np.nan, index = range(sum(nHouse)),
-                                columns=['bldID','hhID','income','nIND','CommFacID',
-                                        'income_numb','zoneType','zoneID',
-                                        'approxFootprint'])
-    #Calculate a list of cumulative sum of nHouse
-    nHouse_cuml = np.cumsum(nHouse)
-    
-    #  Assign household id (hhID) 
-    a = 0
-    for i in nHouseidx:
-        b =  nHouse_cuml[i]
-        household_df.loc[range(a,b),'hhID'] = range(a+1,b+1) # First hhID index =1
-        household_df.loc[range(a,b),'zoneID'] = landuse.loc[i,'zoneID']
-        household_df.loc[range(a,b),'zoneType'] = landuse.loc[i,'avgIncome']
-        a = b
-
-    del a,b
-    household_df['hhID'] = household_df['hhID'].astype(int)
-
-        
-    #%% Step 3: Identify the household size and assign "nInd" values to each household
-    a_g = 0
-    for i in nHouseidx:
-        b_g = nHouse_cuml[i]
-        # Find Total of every different nInd number for households
-        household_num = nHouse[i] * household_prop
-        # Round the household numbers for various numbers of individuals 
-        # without exceeding total household number
-        cumsum_household_num = np.round_(np.cumsum(household_num)).astype('int32')
-        cumsum_household_num_diff = np.diff(cumsum_household_num)
-        first_val = nHouse[i] - sum(cumsum_household_num_diff)
-        household_num_round = np.insert(cumsum_household_num_diff,0,first_val)
-        
-        #Generate a column vector     
-        d_value = t1_l1
-        d_number = cumsum_household_num
-        insert_vector = np.ones(d_number[-1])
-        a, count =0, 0
-        for value in d_value:
-            b = d_number[count]
-            #This works for numbers but not for strings
-            subvector = np.empty(household_num_round[count]) #
-            subvector.fill(value) #
-            insert_vector[a:b] = subvector #
-            a = b
-            count+=1
-        del a,b  
-        insert_vector = np.random.permutation(insert_vector)
-        
-        household_df.loc[range(a_g,b_g), 'nIND'] = insert_vector 
-        a_g = b_g
-
-    del a_g, b_g, count,insert_vector,subvector
-
-    household_df['nIND'] = household_df['nIND'].astype(int)
-
-
-    #%% Step 4: Identify and assign income type of the households
-    # Table 2 states the % of various income groups in different income zones
-    # Convert Table 2 to numpy array
-    # for row in range((len(tables['t2'][0]))):
-    #     tables['t2'][0][row]=np.fromstring(tables['t2'][0][row],dtype=float,sep=',') 
-
-    t2 = np.array(tables['t2'][0])
-    # avg_income_types = ['lowIncomeA','lowIncomeB','midIncome','highIncome']
-
-    count = 0
-
-    for inc in avg_income_types:
-        #Find indices corresponding to a zone type
-        itidx = household_df['zoneType'] == inc
-        if sum(itidx) ==0: #i.e. this income zone doesn't exist in the landuse data
-            continue
-        income_entries = t2[count]*sum(itidx)    
-        d_limit = sum(itidx) # Size of array to match after rounding off
-        d_value = avg_income_types[income_entries!=0]
-        d_number = income_entries[income_entries!=0] #ip
-        
-        insert_vector = dist2vector(d_value, d_number,d_limit,'shuffle') 
-        count+=1    
-        household_df.loc[itidx, 'income'] = insert_vector 
-
-    del count,insert_vector
-
-        
-
-    #%% Step 5: Identify and assign a unique ID for each  individual
-
-    #Asumption 2: Gender distribution is same for different income types 
-
-    #Preallocate a dataframe with nan to hold the individual layer
-    nindiv = int(sum(household_df['nIND'])) # Total number of individuals
-    individual_df = pd.DataFrame(np.nan, index = range(nindiv),
-                            columns=['hhID', 'indivID', 'gender', 'age','head',
-                                    'eduAttStat','indivFacID_1','indivFacID_2',
-                                    'schoolEnrollment','labourForce','employed'])
-    individual_df.loc[range(nindiv),'indivID'] = [range(1,nindiv+1)]
-    individual_df['indivID'].astype('int')
-
-    #%% Step 6: Identify and assign gender for each individual
-    # Convert the gender distribution table 3 to numpy array
-    tables['t3'][0] = np.array(tables['t3'][0][0],dtype=float) 
-    female_p = tables['t3'][0][0]
-    male_p = 1-female_p
-    gender_value = np.array([1,2], dtype=int) # 1=Female, 2=Male
-    gender_number = np.array([female_p, male_p])*nindiv
-
-    d_limit = nindiv # Size of array to match after rounding off
-    d_value = gender_value
-    d_number = gender_number 
-
-    insert_vector = dist2vector(d_value, d_number,d_limit,'shuffle')
-    individual_df.loc[range(nindiv),'gender'] = insert_vector
-    individual_df['gender'] = individual_df['gender'].astype('int')
-
-    #%% Step 7: Identify and assign age for each individual
-    #Assumption 3: Age profile is same for different income types
-    #Convert the age profile wrt gender distribution table 4 to numpy array
-    ageprofile_value = np.array([1,2,3,4,5,6,7,8,9,10], dtype=int)
-    t4_l1_f = np.array(tables['t4'][0][0], dtype=float) #For female
-    t4_l2_m = np.array(tables['t4'][0][1], dtype=float) #For male
-    t4 = np.array([t4_l1_f, t4_l2_m])
-
-    for i in range(len(gender_value)):
-        gidx = individual_df['gender'] == gender_value[i]    
-        d_limit = sum(gidx)
-        d_value = ageprofile_value
-        d_number = t4[i]*sum(gidx)    
-        insert_vector = dist2vector(d_value, d_number,d_limit,'shuffle')
-        individual_df.loc[gidx,'age'] = insert_vector
-
-    individual_df['age'] = individual_df['age'].astype(int) 
-
-
-    #%% Step 8: Identify and assign education attainment status for each individual
-
-    # Assumption 4: Education Attainment status is same for different income types 
-    # Education Attainment Status (Meta Data)
-    # 1 - Only literate
-    # 2 - Primary school
-    # 3 - Elementary sch.
-    # 4 - High school
-    # 5 - University and above
-    #Convert the educational status distribution table 5 to numpy array
-    education_value = np.array([1,2,3,4,5], dtype=int)
-    t5_l1_f = np.array(tables['t5'][0][0], dtype=float) #For female
-    t5_l2_m = np.array(tables['t5'][0][1], dtype=float) #For male
-    t5 = np.array([t5_l1_f, t5_l2_m])
-
-    for i in range(len(gender_value)):
-        gidx = individual_df['gender'] == gender_value[i]    
-        d_limit = sum(gidx)
-        d_value = education_value
-        d_number = t5[i]*sum(gidx)    
-        insert_vector = dist2vector(d_value, d_number,d_limit,'shuffle')
-        individual_df.loc[gidx,'eduAttStat'] = insert_vector
-
-    individual_df['eduAttStat'] = individual_df['eduAttStat'].astype(int)
-
-    #%% Step 9: Identify and assign the head of household to corresponding hhID
-
-    # Assumption 5: Head of household is dependent on gender
-    # Assumption 6: Only (age>20) can be head of households
-    #Convert the head of houseold distribution table 6 to numpy array
-    tables['t6'][0] = np.array(tables['t6'][0][0],dtype=float) 
-    female_hh = tables['t6'][0][0]
-    male_hh = 1-female_hh
-
-    # Calculate the number of household heads by gender
-    hh_number= np.array([female_hh, male_hh])*sum(nHouse)
-    hh_number= hh_number.astype(int)
-    hh_number[0] = sum(nHouse) - hh_number[1]
-
-    for i in range(len(gender_value)): #Assign female and male candidates
-        gaidx= (individual_df['gender'] == gender_value[i]) & \
-                (individual_df['age']>4) # '>4' denotes above age group '18-20'    
-        #Index of household head candidates in individual_df
-        hh_candidate_idx =  list(individual_df.loc[gaidx,'gender'].index)            
-        # Take a random permutation sample to obtain household head indices from 
-        # the index of possible household candidates in individual_df
-        ga_hh_idx = random.sample(hh_candidate_idx, hh_number[i])                                         
-        #print('gaidx=',sum(gaidx), 'ga_hh_idx', len(ga_hh_idx))
-        
-        individual_df.loc[ga_hh_idx,'head'] = 1
-        
-
-
-    # 1= household head, 2= household members other than the head    
-    individual_df.loc[individual_df['head'] != 1,'head'] =0
-
-    #Assign household ID (hhID) randomly
-    hhid_temp = household_df['hhID'].tolist()
-    random.shuffle(hhid_temp)
-    individual_df.loc[individual_df['head'] == 1,'hhID'] = hhid_temp
-
-    #%% Step 10: Identify and assign the household that each individual belongs to
-    # In relation with Assumption 6, no individuals under 20 years of age can live
-    # alone in an household
-    individual_df_temp = individual_df[individual_df['head']==0]
-    individual_df_temp_idx = list(individual_df_temp.index)
-    #hhidlist = household_df['hhID'].tolist()
-    for i in range(1,len(t1_l1)): #Loop through household numbers >1
-        hh_nind = t1_l1[i] # Number of individuals in households
-        # Find hhID corresponding to household numbers
-        hh_df_idx = household_df['nIND']== hh_nind
-        hhidx = household_df.loc[hh_df_idx,'hhID'].tolist()
-        #Random shuffle hhidx here
-        amph = hh_nind -1 # additional member per household
-        for j in range(amph):
-            # Randomly select len(hhidx) number of indices from individual_df_temp_idx
-            idtidx = random.sample(individual_df_temp_idx, len(hhidx))
-            individual_df.loc[idtidx,'hhID'] = hhidx
-            #Remove idtidx before next iteration
-            individual_df_temp = individual_df_temp.drop(index=idtidx)
-            individual_df_temp_idx = list(individual_df_temp.index)
-            
-    individual_df['hhID'] = individual_df['hhID'].astype(int)
-
-    #%% Step 10a: Identify school enrollment for each individual
-    # Final output 0 = not enrolled in school, 1 = enrolled in school 
-    # Assumption 16: Schooling age limits- AP2 and AP3 ( 5 to 18 years old) 
-    # can go to school
-    # Convert distribution table 5a to numpy array
-    # Table 5a contains school enrollment probability
-    for row in range((len(tables['t5a'][0]))):
-        tables['t5a'][0][row]=np.array(tables['t5a'][0][row],dtype=float) 
-    t5a = np.array(tables['t5a'][0]) # Table 5a
-    # Find individuals with age between 5-18 (these are students)
-    # Also find individual Id of students and household Id of students
-    agemask = (individual_df['age'] == 2) | (individual_df['age']==3) 
-    school_df = pd.DataFrame(np.nan, index = range(sum(agemask)),
-                    columns=['indivID','hhID','eduAttStatH','income','enrollment'])
-    school_df_idx = individual_df.loc[agemask,'indivID'].index
-    school_df.set_index(school_df_idx, inplace=True)
-    school_df['indivID'] = individual_df.loc[agemask,'indivID']
-    school_df['hhID'] = individual_df.loc[agemask,'hhID']
-    # Then, pick a slice of individual_df corresponding to the household a student
-    # belongs to. From there, Pick eduAtt status of head of household. To expedite
-    # computation, dataframe columns have been converted to list
-    school_df_hhid_list = list(school_df['hhID'])
-    temp_df = individual_df[individual_df['hhID'].isin(school_df_hhid_list)]
-    head4school_df = temp_df[temp_df['head'] == 1]
-    head4school_df_hhID_list = list(head4school_df['hhID'])
-    head4school_df_edus_list = list(head4school_df['eduAttStat'])
-    school_df_edu_list = np.ones(len(school_df_hhid_list))*np.nan
-
-    # Label 'lowIncomeA' and 'lowIncomeB' = 1, 'midIncome' =2, 'highIncome' =3
-    household_df_hhid_list = list(household_df['hhID'])
-    #Use .copy() to avoid SettingwithCopyWarning
-    income4school_df=household_df[household_df['hhID'].\
-                                  isin(school_df_hhid_list)].copy()
-    li_mask = (income4school_df['income'] == avg_income_types[0]) |\
-              (income4school_df['income'] == avg_income_types[1]) 
-    lm_mask = income4school_df['income'] == avg_income_types[2]
-    lh_mask = income4school_df['income'] == avg_income_types[3]
-    income4school_df.loc[li_mask,'income'] = 1
-    income4school_df.loc[lm_mask,'income'] = 2
-    income4school_df.loc[lh_mask,'income'] = 3
-    income4school_df_income_list = list(income4school_df['income'])
-    income4school_df_hhID_list = list(income4school_df['hhID'])
-    school_df_income_list = np.ones(len(school_df_hhid_list))*np.nan
-
-    count=0
-    # NOTE: If the operation inside this for loop can be replaced with indexing
-    # operation the computation time for this code can be further reduced.
-    for hhid in school_df_hhid_list:
-        #assign education attained by head of household to school_df
-        hhid_temp = [i for i, value in enumerate(head4school_df_hhID_list)\
-                    if value == hhid ]
-        school_df_edu_list[count] = head4school_df_edus_list[hhid_temp[0]]
-        #assign income type of household to school_df
-        hhid_temp2 = [i for i, value in enumerate(income4school_df_hhID_list)\
-                    if value == hhid ]
-        school_df_income_list[count] = income4school_df_income_list[hhid_temp[0]]
-        count+=1
-        
-    school_df.loc[school_df.index, 'eduAttStatH'] = school_df_edu_list 
-    school_df['eduAttStatH'] = school_df['eduAttStatH'].astype(int)
-    school_df['income'] = school_df_income_list
-    school_df['income'] = school_df['income'].astype(int)
-      
-    #assign school enrollment (1 = enrolled, 0 = not enrolled)
-    for incomeclass in range(1,4): # Income class 1,2,3
-        for head_eduAttStat in range(1,6): # Education attainment category 1 to 5
-            enrmask = (school_df['income'] == incomeclass) &\
-                      (school_df['eduAttStatH'] == head_eduAttStat)
-            no_of_pstudents = sum(enrmask) # Number of potential students
-            if no_of_pstudents ==0: #continue if no students exist for given case
-                continue
-            i,j = incomeclass-1, head_eduAttStat-1 # indices to access table 5a
-            d_limit = no_of_pstudents # Size of array to match after rounding off
-            d_value = [1,0] #1= enrolled, 0 = not enrolled
-            d_number = np.array([t5a[i,j], 1-t5a[i,j]])*no_of_pstudents        
-            insert_vector = dist2vector(d_value, d_number,d_limit,'shuffle') 
-            school_df.loc[enrmask,'enrollment'] = insert_vector
-            
-    school_df['enrollment']= school_df['enrollment'].astype(int)
-    # Substitute the enrollment status back to individual_df dataframe
-    individual_df.loc[school_df.index,'schoolEnrollment']=  school_df['enrollment']   
-
-
-    #%% Step 11: Identify approximate total residential building area needed
-    # (approxDwellingAreaNeeded_sqm) 
-    # Assumption 7a: Average dwelling area (sqm) wrt income type (44 for LI, 
-    # 54 for MI, 67 for HI in Tomorrovwille)
-    # The output is stored in the column 'totalbldarea_res' in landuse_res_df,
-    # which represents the total buildable area
-
-    #Sub dataframe of landuse type containing only residential areas
-    landuse_res_df = landuse.loc[nHouse.index].copy()
-    landuse_res_df.loc[nHouse.index,'nHousehold'] = nHouse
-    hh_temp_df = household_df.copy()
-
-    for i in range(0,len(avg_income_types)):
-        hh_temp_df['income'] = hh_temp_df['income'].replace(avg_income_types[i],\
-                                                        average_dwelling_area[i])
-    for index in landuse_res_df.index: # Loop through each residential zone
-        zoneID = landuse_res_df['zoneID'][index]
-        sum_part = hh_temp_df.loc[hh_temp_df['zoneID']==zoneID,'income'].sum()
-        landuse_res_df.loc[index, 'approxDwellingAreaNeeded_sqm'] = sum_part
-        
-    # Zones where no households live i.e. potential commercial or industrial zones    
-    noHH = nHouse_all[nHouse_all<=0].index
-    landuse_ic_df = landuse.loc[noHH].copy()
-    landuse_ic_df['area'] = landuse_ic_df['area']*10000 # Convert hectare to sq m
-        
-    #%% Note on Land use types (LUT), load resisting system (LRS) and storey height
-    # Land Use Type 
-    # 1 - 'AGRICULTURE'                     
-    # 2 - 'CITY CENTER'                     
-    # 3 - 'COMMERCIAL AND RESIDENTIAL'      
-    # 4 - 'HISTORICAL PRESERVATION AREA'    
-    # 5 - 'INDUSTRY'                        
-    # 6 - 'NEW DEVELOPMENT'                 
-    # 7 - 'NEW PLANNING'                    
-    # 8 - 'RECREATION AREA'                 
-    # 9 - 'RESIDENTIAL (GATED NEIGHBORHOOD)'
-    # 10- 'RESIDENTIAL (HIGH DENSITY)'      
-    # 11- 'RESIDENTIAL (LOW DENSITY)'       
-    # 12- 'RESIDENTIAL (MODERATE DENSITY)'
-
-    # Storey definition:
-    # 1 - Low rise (LR) 1-4
-    # 2 - Mid rise (MR) 5-8
-    # 3 - High rise (HR) 9-19
-
-    # LRS Types
-    # 1 - BrCfl: brick and cement with flexible floor;		
-    # 2 - BrCri: brick and cement with rigid floor;		
-    # 3 - BrM: brick and mud		
-    # 4 - Adb: Adobe		
-    # 5 - RCi : Reinforced Concrete infill
-
-    # Code Compliance Levels (Low, Medium, High): 1 - LC, 2 - MC, 3 - HC
-
-    # Occupancy types: Residential (Res), Industrial (Ind), Commercial (Com)
-    # Residential and commercial mixed (ResCom)
-
-    #%% Steps 12,13,14,15: 
-    #    Identify number of residential buildings and generate building layer 
-    # Asumption 7: Range of footprint area (sqm) wrt. Income type (32-66 for LI, 
-    # 32-78 for MI and 70-132 for HI in Tomorrowville)
-
-    # Table 7 contains Number of storeys distribution for various LRS and LUT
-    # Table 11 contains code compliance distribution for various LRS and LUT
-    t7= tables['t7'][0]
-    t11 = tables['t11'][0]
-
-    # Convert Table 8 to numpy array
-    # Table8 contains LRS distribution with respect to various LUT
-    for row in range((len(tables['t8'][0]))):
-        tables['t8'][0][row]=np.array(tables['t8'][0][row],dtype=float) 
-    t8 = np.array(tables['t8'][0]) # Table 8
-
-    # Determine the number of buildings in each zone based on average income class 
-    # building footprint range for each landuse zone and Tables 7 and 8
-    no_of_resbldg = 0 # Total residential buildings in all zones
-    footprint_base_sum = 0 # footprint at base, not multiplied by storeys
-    footprint_base_L,storey_L,lrs_L,zoneid_L,codelevel_L = [],[],[],[],[]
-
-    for i in landuse_res_df.index: #Loop through zones   
-        zoneid = landuse_res_df['zoneID'][i]
-        #totalbldarea_res = landuse_res_df['totalbldarea_res'][i]
-        #totalbldarea_res is the total residential area that needs to be built
-        totalbldarea_res = landuse_res_df.loc[i,'approxDwellingAreaNeeded_sqm']
-        avgincome = landuse_res_df['avgIncome'][i]
-        lut_zone = landuse_res_df['LuF'][i]
-        fpt_range = fpt_area[avgincome]
-        # Generate a vector of footprints such that sum of all the footprints in
-        # lenmax equals maximum possible length of vector of building footprints
-        lenmax = int(totalbldarea_res/np.min(fpt_range))
-        footprints_temp = np.random.uniform(np.min(fpt_range),\
-                                        np.max(fpt_range), size=(lenmax,1))
-        footprints_temp = footprints_temp.reshape(len(footprints_temp),)
-        # Select LRS using multinomial distribution and Table 8
-        lrs_number=multinomial(len(footprints_temp), t8[lutidx[lut_zone]],size=1) 
-        lrs_vector=np.array(dist2vector(lrs_types,lrs_number,\
-                                                np.sum(lrs_number),'shuffle')) 
-
-        # Select storeys in a zone for various LRS using multinomial distribution
-        #storey_vector = np.array([],dtype=int)
-        storey_vector = np.array(np.zeros(len(lrs_vector),dtype=int)) #must be assigned after loop
-        for lrs in lrs_types: # Loop through LRS types in a zone
-            t7row = t7[lutidx[lut_zone]] #Extract row for LUT
-            #Extract storey distribution in row for LRS
-            t7dist = np.fromstring(t7row[lrsidx[lrs]],dtype=float, sep=',')
-            lrs_pos = lrs_vector==lrs
-            storey_number = multinomial(sum(lrs_pos),t7dist,size=1)
-            storey_vector_part = np.array([],dtype=int)
-            for idx,st_range in storey_range.items(): #Loop through storey classes
-                sv_temp = \
-                    randint(st_range[0],st_range[1]+1,storey_number[0][idx])
-                storey_vector_part = \
-                    np.concatenate((storey_vector_part,sv_temp),axis =0)
-            # Need to shuffle storey_vector before multiplying and deleting
-            #extra values, otherwise 100% of storeys will be low rise, resulting in 
-            #larger number of buildings        
-            np.random.shuffle(storey_vector_part)         
-            storey_vector[lrs_pos] =storey_vector_part
-        # Select code compliance level for various LRS using multinomial dist
-        cc_vector = [] # code compliance vector for a zone
-        for lrs in lrs_types: # for each LRS in a zone
-            t11row = t11[lutidx[lut_zone]]
-            t11dist = np.fromstring(t11row[lrsidx[lrs]],dtype=float, sep=',')
-            lrs_pos = lrs_vector==lrs
-            cc_number = multinomial(sum(lrs_pos),t11dist,size=1)
-            cc_part = dist2vector(code_level, cc_number,sum(lrs_pos),'shuffle')
-            cc_vector += cc_part
-        random.shuffle(cc_vector)
-        
-        #If it is necessary to equalize number of storeys = number of households
-        storey_vector_cs = np.cumsum(storey_vector)
-        stmask = storey_vector_cs <= landuse_res_df.loc[i,'nHousehold']
-        stlimit_idx = np.max(np.where(stmask))+1
-        stlimit_idx_range = range(stlimit_idx+1,len(footprints_temp))
-        
-        #If it is necessary to equalize required footprint = provided footprint
-        footprints_base = footprints_temp   #Footprints without storey  
-        dwellingArea_temp= footprints_temp*storey_vector
-        dwellingArea_temp_cs = np.cumsum(dwellingArea_temp)
-        #OPTIONAL:Here, introduce a method to match total buildable area (dwelling)
-        fpmask = dwellingArea_temp_cs <= totalbldarea_res
-        #Indices of footprints whose sum <= dwelling area needed in a zone
-        # '+ 1' provides slightly more dwelling area than needed
-        footprints_idx = np.max(np.where(fpmask)) + 1 
-        
-        # Delete additional entries in the vectors for footprint, lrs and storeys
-        # which do not fit into total buildable area
-        #ftrange = range(footprints_idx+1,len(dwellingArea_temp))
-        ftrange = stlimit_idx_range
-        
-        dwellingArea = np.delete(dwellingArea_temp,ftrange)
-        footprints_base = np.delete(footprints_base,ftrange)
-        lrs_vector_final = np.delete(lrs_vector,ftrange)
-        storey_vector_final = np.delete(storey_vector,ftrange)
-        cc_vector = np.array(cc_vector)
-        cc_vector_final = np.delete(cc_vector,ftrange)
-        no_of_resbldg += len(dwellingArea) 
-        
-        #footprint_base_sum+=np.sum(footprints_base)    
-        # Store the vectors in lists for substitution in dataframe 
-        footprint_base_L +=  list(footprints_base)
-        storey_L += list(storey_vector_final)
-        lrs_L += list(lrs_vector_final)
-        zoneid_L += [zoneid]*len(dwellingArea) 
-        codelevel_L += list(cc_vector_final)
-        
-        landuse_res_df.loc[i,'footprint_sqm'] = np.sum(footprints_base)
-        landuse_res_df.loc[i,'dwellingAreaProvided_sqm'] = np.sum(dwellingArea)
-        
-        landuse_res_df.loc[i, 'Storey_units'] = sum(storey_vector_final)
-        #'No_of_res_buildings' denotes total residential + ResCom buildings
-        landuse_res_df.loc[i, 'No_of_res_buildings'] = len(footprints_base)
-        # Check distribution after deletion (for debugging) by counting LR
-        #print(sum(storey_vector_final<5)/len(storey_vector_final))
-
-    # landuse_res_df['area'] denotes the total buildable area   
-    landuse_res_df['area'] *= 10000 # Convert hectares to sq m, 1ha =10^4 sqm
-
-    # landuse_res_df['builtArea_percent'] denotes the percentage of total 
-    # buildable area that needs to be built to accomodate the projected population
-    landuse_res_df['builtArea_percent'] =\
-        landuse_res_df['footprint_sqm']/landuse_res_df['area']*100
-
-    #ADD HERE : EXCEPTION HANDLING for built area exceeding available area
-
-    #print(no_of_resbldg) 
-
-    #ADD: Check if calculated footprint exceeds total buildable area (landuse.area)  
-
-    #Create and populate the building layer, with unassigned values as NaN
-    resbld_df = pd.DataFrame(np.nan, index = range(0, no_of_resbldg),
-                            columns=['zoneID', 'bldID', 'specialFac', 'repValue',
-                                      'nHouse', 'residents', 'expStr','fptarea',
-                                      'OccBld','lrstype','CodeLevel',
-                                      'nstoreys'])
-    resbld_range = range(0,no_of_resbldg)
-    #resbld_df.loc[resbld_range,'bldID'] = list(range(1,no_of_resbldg+1))
-    resbld_df.loc[resbld_range,'zoneID'] = zoneid_L
-    resbld_df['zoneID'] = resbld_df['zoneID'].astype('int')
-    resbld_df.loc[resbld_range,'OccBld'] = 'Res'
-    resbld_df.loc[resbld_range,'specialFac'] = 0
-    resbld_df.loc[resbld_range,'fptarea'] = footprint_base_L
-    resbld_df.loc[resbld_range,'nstoreys'] = storey_L
-    resbld_df.loc[resbld_range,'lrstype'] = lrs_L
-    resbld_df.loc[resbld_range,'CodeLevel'] = codelevel_L
-
-
-    #%% Assign zoneIDs and building IDs for Res and ResCom
-    # Assign 'ResCom' status based on Table 9
-    # Assumption: Total residential buildings = Res + ResCom
-    # Convert Table 9 to numpy array
-    # Table 9 contains occupancy type with respect to various LUT
-    # Occupancy types: Residential (Res), Industrial (Ind), Commercial (Com)
-    # Residential and commercial mixed (ResCom)
-    for row in range((len(tables['t9'][0]))):
-        tables['t9'][0][row]=np.array(tables['t9'][0][row],dtype=float) 
-    t9 = np.array(tables['t9'][0]) # Table 9
-
-    #available_LUT = list(set(landuse_res_df['LuF']))
-    available_zoneID = list(set(resbld_df['zoneID']))
-    for zoneID in available_zoneID: #Loop through zones
-        zonemask = resbld_df['zoneID'] == zoneID
-        zone_idx = list(zonemask.index.values[zonemask])
-        lutlrdidx=landuse_res_df[landuse_res_df['zoneID']==zoneID].index.values[0]
-        #Occupancy type distribution for a zone
-        occtypedist = t9[lutidx[ landuse_res_df['LuF'][lutlrdidx]]]
-        no_of_resbld = sum(zonemask) # Number of residential buildings in a zone
-        if occtypedist[3] !=0: # if mixed residential+commercial buildings exist
-            # nrc = number of mixed res+com buildings in a zone
-            nrc = int(occtypedist[3]/occtypedist[0]*no_of_resbld)
-        else: # if only residential buildings exist
-            continue
-        nrc_idx = sample(zone_idx,nrc)
-        resbld_df.loc[nrc_idx,'OccBld'] = 'ResCom'
-
-    #Assign building Ids for res and rescom buildings
-    lenresbld = len(resbld_df)
-    resbld_df.loc[range(0,lenresbld),'bldID'] = list(range(1,lenresbld+1))
-    resbld_df['bldID'] = resbld_df['bldID'].astype('int')
-
-
-    #%% STEP16: Identify and assign number of households and residents for each 
-    #residential building
-    #Assign nHouse, residents. All the households and residents must be assigned
-    #to this layer.
-
-    dwellings_str=dist2vector(resbld_df['bldID'],np.array(storey_L),\
-                                        np.sum(np.array(storey_L)),'DoNotShuffle')
-    dwellings = list(map(int,dwellings_str))
-    #dwellings.sort()
-    dwellings_selected = dwellings[0:len(household_df)]
-    random.shuffle(dwellings_selected)
-    #Assign building IDs to all households
-    household_df.loc[:,'bldID'] = dwellings_selected
-
-    # The number of residential  buildings are slightly more than that needed by 
-    # the total population. After the IDs are sorted, some of the buildings towards
-    # the end of the list will receive no population, and will be deleted from the 
-    # building dataframe.
-    # QUESTION: What will happen if the household_df zoneType and ZoneIDs are 
-    # modified to inherit the zoneType and zoneIDs of the building they are
-    # assigned to at this step? ANSWER: It could conflict with Table 2, but it 
-    # eliminates the inconsistency between building income zone and income level
-    # of its inhabitants.
-
-    # Assign number of households and residents to residential buildings resbld_df
-    # This loop must be optimized for speed
-    count =0
-    for bldid in resbld_df['bldID']:
-        bldidmask = household_df['bldID'] == bldid
-        resbld_df.loc[count,'nHouse'] = sum(bldidmask)
-        resbld_df.loc[count,'residents'] =sum(household_df['nIND'][bldidmask])
-        count+=1
-        
-    # Remove rows in resbld_df which contains no residents
-    to_del = resbld_df['nHouse']  ==0
-    resbld_df = resbld_df.drop(index=resbld_df.index[to_del])    
-
-
-    #%% Step 17,18: Identify and generate commercial and industrial buildings
-    # No household or individual lives in com, ind, hosp, sch zones
-    # Assumption 10 and 11: Assume a certain number of commercial and industrial
-    # buildings per 1000 individuals 
-        
-    # No commercial and industrial buildings in:recreational areas,agriculture,
-    # residential (gated neighbourhood), residential (low-density)
-    # But com an ind build can occur in any zone where permitted by table 9
-    ncom = round(nindiv/1000*numb_com)
-    nind = round(nindiv/1000*numb_ind)
-    nci = np.array([ncom,nind])
-    occbld_label = ['Com','Ind']
-    nci_cs = np.cumsum(nci)
-    indcom_df = pd.DataFrame(np.nan, index = range(0, ncom+nind),
-                            columns=['zoneID', 'bldID', 'specialFac', 'repValue',
-                                      'nHouse', 'residents', 'expStr','fptarea',
-                                      'lut_number','OccBld','lrstype','CodeLevel',
-                                      'nstoreys'])
-
-    t10= tables['t10'][0] # Extract Table 10
-    a = 0
-    for i in range(0,len(nci)): # First commercial, then industrial
-        attr = t10[i]
-        #Extract distributions for footprint, storeys, code compliance and LRS
-        fpt_ic = np.fromstring(attr[0], dtype=float, sep=',')
-        nstorey_ic = np.fromstring(attr[1], dtype=int, sep=',')
-        codelevel_ic = np.fromstring(attr[2], dtype=float, sep=',')
-        lrs_ic = np.fromstring(attr[3], dtype=float, sep=',')
-        range_ic = range(a,nci_cs[i])
-        a = nci_cs[i]
-        # Generate footprints
-        indcom_df.loc[range_ic,'fptarea'] = np.random.uniform(\
-                np.min(fpt_ic),np.max(fpt_ic), size=(nci[i],1)).reshape(nci[i],)
-        # Generate number of storeys
-        indcom_df.loc[range_ic,'nstoreys'] =randint(np.min(nstorey_ic),\
-                  np.max(nstorey_ic)+1,size=(nci[i],1)).reshape(nci[i],)
-        # Generate code compliance
-        cc_number_ic = multinomial(nci[i],codelevel_ic,size=1)
-        indcom_df.loc[range_ic,'CodeLevel'] =\
-                          dist2vector(code_level, cc_number_ic,nci[i],'shuffle')
-        # Generate LRS
-        lrs_number_ic = multinomial(nci[i],lrs_ic,size=1)
-        indcom_df.loc[range_ic,'lrstype'] =\
-                          dist2vector(lrs_types,lrs_number_ic,nci[i],'shuffle')
-        indcom_df.loc[range_ic,'OccBld']= occbld_label[i]                     
-
-    # Assign number of households, Residents, special facility label
-    range_all_ic = range(0,len(indcom_df))
-    indcom_df.loc[range_all_ic,'nHouse'] = 0
-    indcom_df.loc[range_all_ic,'residents'] = 0
-    indcom_df.loc[range_all_ic,'specialFac'] = 0
-
-    ind_df = indcom_df[indcom_df['OccBld'] == 'Ind'].copy()
-    com_df = indcom_df[indcom_df['OccBld'] == 'Com'].copy()
-    ind_df.reset_index(drop=True,inplace=True)
-    com_df.reset_index(drop=True,inplace=True)
-            
-        
-    #%% Step 19,20 Generate school and hospitals along with their attributes
-
-    # Assumption 14 and 15: For example : 1 school per 10000 individuals,
-    # 1 hospital per 25000 individuals
-    nsch = round(nindiv/nsch_pi) # Number of schools
-    nhsp = round(nindiv/nhsp_pi) # Number of hospitals
-
-    if nsch == 0:
-        print("WARNING: Total population",nindiv,"is less than the user-specified "\
-              "number of individuals per school",nsch_pi,". So, total school for "\
-              "this population = 1 (by default) ")
-        nsch = 1
-
-    if nhsp == 0:
-        print("WARNING: Total population",nindiv,"is less than the user-specified "\
-              "number of individuals per hospital",nhsp_pi,". So, total hospital for "\
-              "this population = 1 (by default) ")
-        nhsp = 1
-
-    nsh = np.array([nsch,nhsp])
-    nsh_cs = np.cumsum(nsh)
-    occbld_label_sh = ['Edu','Hea']
-    specialFac = [1,2] # Special facility label
-    schhsp_df = pd.DataFrame(np.nan, index = range(0, nsch+nhsp),
-                            columns=['zoneID', 'bldID', 'specialFac', 'repValue',
-                                      'nHouse', 'residents', 'expStr','fptarea',
-                                      'lut_number','OccBld','lrstype','CodeLevel',
-                                      'nstoreys'])
-    t14= tables['t14'][0] # Extract Table 14
-    a=0
-    for i in range(0,len(t14)): # First school, then hospital
-        attr_sh = t14[i]
-        #Extract distributions for footprint, storeys, code compliance and LRS
-        fpt_sh = np.fromstring(attr_sh[0], dtype=float, sep=',')
-        nstorey_sh = np.fromstring(attr_sh[1], dtype=int, sep=',')
-        codelevel_sh = np.fromstring(attr_sh[2], dtype=float, sep=',')
-        lrs_sh = np.fromstring(attr_sh[3], dtype=float, sep=',')
-        range_sh = range(a,nsh_cs[i])
-        a = nsh_cs[i]
-        # Generate footprints
-        schhsp_df.loc[range_sh,'fptarea'] = np.random.uniform(\
-                np.min(fpt_sh),np.max(fpt_sh), size=(nsh[i],1)).reshape(nsh[i],)
-        # Generate number of storeys
-        schhsp_df.loc[range_sh,'nstoreys'] =randint(np.min(nstorey_sh),\
-                  np.max(nstorey_sh)+1,size=(nsh[i],1)).reshape(nsh[i],)
-        # Generate code compliance
-        cc_number_sh = multinomial(nsh[i],codelevel_sh,size=1)
-        schhsp_df.loc[range_sh,'CodeLevel'] =\
-                          dist2vector(code_level, cc_number_sh,nsh[i],'shuffle')
-        # Generate LRS
-        lrs_number_sh = multinomial(nsh[i],lrs_sh,size=1)
-        schhsp_df.loc[range_sh,'lrstype'] =\
-                          dist2vector(lrs_types,lrs_number_sh,nsh[i],'shuffle')
-        schhsp_df.loc[range_sh,'OccBld']= occbld_label_sh[i] 
-
-        # Assign special facility label  
-        schhsp_df.loc[range_sh,'specialFac'] = specialFac[i]                 
-
-    # Assign number of households, Residents, 
-    range_all_sh = range(0,len(schhsp_df))
-    schhsp_df.loc[range_all_sh,'nHouse'] = 0
-    schhsp_df.loc[range_all_sh,'residents'] = 0
-
-
-    #%% Assign zoneIds for Industrial and Commercial buildings
-
-    # The number of industrial and commercial buildings are estimated using the
-    # following 2 methods:
-    # Method 1: Assumption of number of industrial or commercial building per
-    #           1000 individuals. (Done in steps 17,18)
-    # Method 2: Table 9 specifies what the occupancy type distribution should be 
-    #           in different land use types. This gives a different estimate of the
-    #           number of the buiildings as compared to Method 1. (Done here)
-    # To make these two Methods compatible, the value from Method 1 is treated as 
-    # the actual value of the buildings, and Method 2 is used to ensure that
-    # these buildings are distributed in such a way that they follow Table 9.
-    # 
-    # The following method of assigning the ZoneIDs treats the mixed used zones
-    # (residential, residential+commercial) and purely industrial or commercial
-    # zones as 2 separate cases.
-    #
-    # For each of the following 2 cases, we need to first find the number of
-    # industrial and commercial buildings in each zone
-
-    # Case 1: For industrial/commercial buildings in residential areas_____________
-    for i in landuse_res_df.index:
-        #Occupancy type distribution for a zone
-        otd = t9[lutidx[landuse_res_df.loc[i,'LuF']]]
-        if otd[1]==0 and otd[2]==0: 
-            # If neither industrial nor commercial buildings exist
-            landuse_res_df.loc[i,'ind_weightage'] = 0
-            landuse_res_df.loc[i,'com_weightage'] = 0
-            continue
-        # Number of residential + rescom building
-        Nrc = landuse_res_df.loc[i, 'No_of_res_buildings']
-        
-        # Tb = total possible number of buildings in a zone (all accupancy types)
-        #      This is used as weightage factor to distribute the buildings 
-        #      according to Method 2. 
-        if otd[0] == 0 and otd[3]==0:
-            Tb = Nrc # If neither residential nor res+com exist
-            print('If population exists, but neither residential nor '\
-                  'residential+commercial buildings are allowed, there is '\
-                  'inconsistency between population and current row in table 9.'\
-                  'Therefore, it is assumed that total number of buildings in '\
-                  'zoneID', landuse_res_df.loc[i,'zoneID'],\
-                  '= no. of residential buildings in this zone.')
-            print('Also, consider allowing residential and/or res+com building '\
-                  'to this zone in Table 9, if it is assigned population.')
-        else:  
-            Tb = Nrc/(otd[0]+otd[3]) # If either residential or res+com exist  
-
-        #Calculate the number of industrial buildings using Table 9   
-        if otd[1]>0:
-            landuse_res_df.loc[i,'ind_weightage'] = ceil(Tb * otd[1])
-            #landuse_res_df.loc[i,'No_of_ind_buildings'] = ceil(Tb * otd[1])
-        else:
-          # landuse_res_df.loc[i,'No_of_ind_buildings'] = 0
-          landuse_res_df.loc[i,'ind_weightage'] = 0
-            
-        #Calculate the number of commercial buildings using Table 9     
-        if otd[2]>0:
-            landuse_res_df.loc[i,'com_weightage'] = ceil(Tb * otd[2])
-            #landuse_res_df.loc[i,'No_of_com_buildings'] = ceil(Tb * otd[2])
-        else:
-            landuse_res_df.loc[i,'com_weightage'] = 0
-            #landuse_res_df.loc[i,'No_of_com_buildings'] = 0
-
-            
-    # If number of buildings (industrial/commercial) estimated from Method 2(in the
-    # above steps of Case 1) exceeds the number of buildings estimated from 
-    # Method 1, treat the value from Method 1 as the upper limit. 
-    # Then, using the number of buildings from Method 2 as weightage factor,
-    # distribute the number of  buildings from Method 1 proportionally to
-    # all the mixed use zones. This situation arises if the number of 
-    # industrial/commercial buildings per 1000 people is low.
-    #
-    # Otherwise, if the number of industrial/commercial buildings estimated from
-    # Method 1 is larger than that estimated  from Method 2, it is assumed that the
-    # number of buildings is large enough not to fit into the mixed use zones
-    # being considered under Case 1, and the additional buildings not assigned into
-    # mixed use zones is assigned under case 2 in the following section.
-    # 
-    # This method requires the area of industrial/commercial buildings in the 
-    # mixed use zones to be checked separately to see if they fit into these zones.
-
-    com_wt = landuse_res_df['com_weightage'].copy()   
-    if com_wt.sum() > ncom:
-        landuse_res_df['No_of_com_buildings'] = np.floor(ncom*com_wt/com_wt.sum())
-    else:
-        landuse_res_df['No_of_com_buildings'] = com_wt
-
-    ind_wt = landuse_res_df['ind_weightage'].copy()   
-    if ind_wt.sum() > nind:
-        landuse_res_df['No_of_ind_buildings'] = np.floor(nind*ind_wt/ind_wt.sum())
-    else:
-        landuse_res_df['No_of_ind_buildings'] = ind_wt    
-
-          
-    landuse_res_df['No_of_ind_buildings'] =\
-                        landuse_res_df['No_of_ind_buildings'].astype('int')
-    landuse_res_df['No_of_com_buildings'] =\
-                        landuse_res_df['No_of_com_buildings'].astype('int')
-                        
-    # Number and area of commercial buildings to be assigned    
-    nCom_asgn = landuse_res_df['No_of_com_buildings'].sum()
-    nCom_asgn_area = com_df.loc[range(0, nCom_asgn),'fptarea'].sum() 
-    # Number and area of industrial buildings to be assigned
-    nInd_asgn = landuse_res_df['No_of_ind_buildings'].sum()
-    nInd_asgn_area = ind_df.loc[range(0,nInd_asgn),'fptarea'].sum()
-
-
-    # Assign zoneID to industrial buildings (if any) in residential areas
-    zoneID_r_i = dist2vector(list(landuse_res_df['zoneID']),\
-                list(landuse_res_df['No_of_ind_buildings']),nInd_asgn,'shuffle')
-    ind_df.loc[range(0,nInd_asgn),'zoneID'] = list(map(int,zoneID_r_i))
-
-    # Assign zoneID to commercial buildings (if any) in residential areas
-    zoneID_r_c = dist2vector(list(landuse_res_df['zoneID']),\
-                list(landuse_res_df['No_of_com_buildings']),nCom_asgn,'shuffle')
-    com_df.loc[range(0,nCom_asgn),'zoneID'] = list(map(int,zoneID_r_c))
-
-
-    # Back-calculated number of commercial buildings per 1000 people        
-    #nCom_asgn/(len(individual_df)/1000)
-
-    # Case 2 For industrial/commercial buildings in non-residential areas__________
-
-    # Number of industrial buildings that have not been assigned
-    nInd_tba = int(len(ind_df) - nInd_asgn)
-    # Number of commercial buildings that have not been assigned
-    nCom_tba = int(len(com_df) - nCom_asgn)
-
-    # Before assigning zones to buildings, find out the area available for buildings
-    # in each zones. Since no population is assigned to residential and commercial
-    # buildings, the number of buildings in a zone is controlled solely by area.
-    for i in landuse_ic_df.index:
-        #Occupancy type distribution for a zone
-        otd = t9[lutidx[landuse_ic_df.loc[i,'LuF']]]
-        if otd[1]>0:
-            landuse_ic_df.loc[i,'AreaAvailableForInd']=\
-                                            AC_ind/100*landuse_ic_df.loc[i,'area']
-        else:
-            landuse_ic_df.loc[i,'AreaAvailableForInd']=0
-    
-        if otd[2]>0:
-            landuse_ic_df.loc[i,'AreaAvailableForCom']=\
-                                            AC_com/100*landuse_ic_df.loc[i,'area']
-        else:
-            landuse_ic_df.loc[i,'AreaAvailableForCom']=0
-            
-    # Check how many of the generated com/ind buildings fit into the available area
-    ind_fptarea_cs = list(np.cumsum(ind_df['fptarea']))
-    com_fptarea_cs = list(np.cumsum(com_df['fptarea']))
-
-    # Total areas available for commercial and industrial buildings in all zones
-    At_c= landuse_ic_df['AreaAvailableForCom'].sum()
-    At_i = landuse_ic_df['AreaAvailableForInd'].sum()
-    licidx = landuse_ic_df.index
-
-    unassigned_ind_area = ind_fptarea_cs[-1]-nInd_asgn_area # Total - assigned
-    if unassigned_ind_area <= At_i:
-        landuse_ic_df.loc[licidx,'No_of_ind_buildings'] =\
-            landuse_ic_df['AreaAvailableForInd']/At_i*nInd_tba
-        landuse_ic_df['No_of_ind_buildings']=\
-            landuse_ic_df['No_of_ind_buildings'].astype('int')
-    else:
-        print('Required industrial buildings do not fit into available land area.')
-        sys.exit(1)
-
-    unassigned_com_area = com_fptarea_cs[-1]-nCom_asgn_area
-    if unassigned_com_area <= At_c:
-        landuse_ic_df.loc[licidx,'No_of_com_buildings'] =\
-            landuse_ic_df['AreaAvailableForCom']/At_c*nCom_tba
-        landuse_ic_df['No_of_com_buildings']=\
-            landuse_ic_df['No_of_com_buildings'].astype('int')
-    else:
-        print('Required commercial buildings do not fit into available land area.')
-        sys.exit(1)
-        
-    # Begin assigning buildings to zones 
-    # Assign zoneID to industrial buildings (if any) in industrial areas
-    zoneID_ic_i = dist2vector(list(landuse_ic_df['zoneID']),\
-                list(landuse_ic_df['No_of_ind_buildings']),nInd_tba,'shuffle')
-    ind_df.loc[range(nInd_asgn,nInd_asgn+nInd_tba),'zoneID']=list(map(int,zoneID_ic_i))
-
-    # Assign zoneID to commercial buildings (if any) in commercial areas
-    zoneID_ic_c = dist2vector(list(landuse_ic_df['zoneID']),\
-                list(landuse_ic_df['No_of_com_buildings']),nCom_tba,'shuffle')
-    com_df.loc[range(nCom_asgn,nCom_asgn+nCom_tba),'zoneID']=list(map(int,zoneID_ic_c))
-
-
-    #%% Find populations in each zones and assign it back to landuse layer
-    for i in landuse.index:
-        zidmask = resbld_df['zoneID'] == landuse.loc[i,'zoneID']
-        if sum(zidmask) == 0: # if no population has been added to the zone
-            landuse.loc[i,'populationAdded'] = 0
-            continue
-        else: # if new population has been added to the zone
-            zone_nInd = resbld_df['residents'][zidmask]
-            landuse.loc[i,'populationAdded'] = int(zone_nInd.sum())
-    # population=Existing population, populationAdded=Projected future population
-    # populationFinal = existing + future projected population
-    landuse['populationFinal'] = landuse['population']+landuse['populationAdded']
-    landuse['populationFinal'] = landuse['populationFinal'].astype('int')
-
-
-
-    #%% Assign zoneIds for schools and hospitals
-    # Assign schools and hospitals to zones starting from the highest 
-    # population until the number of schools and hospitals are reached
-    landuse_sorted = landuse.sort_values(by=['populationFinal'],\
-                                                    ascending=False).copy()
-    landuse_sorted.reset_index(inplace=True, drop=True)
-    #Remove zones without population
-    no_popl_zones = landuse_sorted['populationFinal']==0
-    landuse_sorted =landuse_sorted.drop(index=landuse_sorted.index[no_popl_zones])
-
-    sch_df = schhsp_df[schhsp_df['OccBld']=='Edu'].copy() #Educational institutions
-    hsp_df = schhsp_df[schhsp_df['OccBld']=='Hea'].copy() #Health institutions
-
-    sch_df.reset_index(drop=True,inplace=True)
-    hsp_df.reset_index(drop=True,inplace=True)
-
-    # Assign zoneIDs for schools/educational institutions
-    sch_range = range(0,len(sch_df))
-    if len(sch_df) <= len(landuse_sorted):
-        sch_df.loc[sch_range, 'zoneID'] = landuse_sorted.loc[sch_range,'zoneID']
-    else:
-        iterations_s = ceil(len(sch_df)/len(landuse_sorted))
-        a1_s= list(repeat(landuse_sorted['zoneID'].tolist(),iterations_s))
-        a_s = list(chain(*a1_s))
-        sch_df.loc[sch_range, 'zoneID'] = a_s[0:len(sch_df)]
-            
-    # Assign zoneIDs for hospitals/health institutions
-    hsp_range= range(0,len(hsp_df))
-    if len(hsp_df) <= len(landuse_sorted):
-        hsp_range = range(0,len(hsp_df))
-        hsp_df.loc[hsp_range, 'zoneID'] = landuse_sorted.loc[hsp_range,'zoneID']
-    else:
-        iterations_h = ceil(len(hsp_df)/len(landuse_sorted))
-        a1_h= list(repeat(landuse_sorted['zoneID'].tolist(),iterations_h))
-        a_h = list(chain(*a1_h))
-        hsp_df.loc[hsp_range, 'zoneID'] = a_h[0:len(hsp_df)]
-
-
-    #%% Concatenate the residential, industrial/commercial and special facilities
-    # dataframes to obtain the complete building dataframe
-    building_df=pd.concat([resbld_df,ind_df,com_df,sch_df,\
-                            hsp_df]).reset_index(drop=True)
-    building_df['nstoreys'] = building_df['nstoreys'].astype(int)
-
-    #Assign exposure string
-    building_df['expStr'] = building_df['lrstype'].astype(str)+'+'+\
-                            building_df['CodeLevel'].astype(str)+'+'+\
-                            building_df['nstoreys'].astype(str)+'s'+'+'+\
-                            building_df['OccBld'].astype(str)
-    # Assign building ids
-    # lenbdf = len(building_df)
-    # building_df.loc[range(0,lenbdf),'bldID'] = list(range(1,lenbdf+1))
-    building_df.loc[range(len(resbld_df),len(building_df)),'bldID'] =\
-                        list(range(len(resbld_df)+1,len(building_df)+1))
-    building_df['bldID'] = building_df['bldID'].astype('int')
-
-
-    #%% Step 21 Employment status of the individuals
-    # Assumption 9: Only 20-65 years old individuals can work
-    # Extract Tables 12 and 13
-    t12 = np.array(tables['t12'][0][0],dtype=float) #[Female, Male]
-
-    t13_f = np.array(tables['t13'][0][0],dtype=float) #Female
-    t13_m = np.array(tables['t13'][0][1],dtype=float) #Male
-    t13 = [t13_f,t13_m]
-
-    # Identify individuals who can work
-    working_females_mask = (individual_df['gender']==1) & \
-                (individual_df['age']>=5) & (individual_df['age']<=9)
-    working_males_mask = (individual_df['gender']==2) & \
-                (individual_df['age']>=5) & (individual_df['age']<=9)
-    potential_female_workers = individual_df.index[working_females_mask]
-    potential_male_workers = individual_df.index[working_males_mask]
-        
-    # But according to Table 12, not all individuals who can work are employed,
-    # so the labour force is less than 100%
-    labourforce_female = sample(list(potential_female_workers),\
-                                    int(t12[0]*len(potential_female_workers)))
-    labourforce_male = sample(list(potential_male_workers),\
-                                    int(t12[1]*len(potential_male_workers))) 
-    # labourForce = 1 indicates that an individual is a part of labour force, but 
-    # not necessarily employed.
-    individual_df.loc[labourforce_female,'labourForce'] =1
-    individual_df.loc[labourforce_male,'labourForce'] =1  
-
-    # According to Table 13, the employment probability for labourforce differs
-    # based on educational attainment status   
-    for epd_array in t13: #Employment probability distribution for female and male
-        count = 0
-        ind_employed_idx =[]
-        for epd in epd_array: # EPD for various educational attainment status
-            # Individuals in labour force that belong to current EPD
-            eamask = (individual_df['eduAttStat'] == education_value[count]) & \
-                    (individual_df['labourForce']==1)
-            nInd_in_epd = sum(eamask)
-            if nInd_in_epd == 0:
-                continue
-            
-            nInd_employed = int(epd*nInd_in_epd)
-            if nInd_employed == 0:
-                continue
-            ind_ea_labourforce = list(individual_df.index[eamask])
-            ind_employed_idx = sample(ind_ea_labourforce, nInd_employed)
-            individual_df.loc[ind_employed_idx,'employed'] = 1
-            
-            #Check ouput epd (for debugging)
-            #print(epd,':',len(ind_employed_idx)/len(ind_ea_labourforce))
-            
-            count+=1
-        
-    #%% Step 22 Assign IndividualFacID
-    # bld_ID of the building that the individual regularly visits 
-    # (can be workplace, school, etc.)
-    # Assumption 13: Each individual is working within the total study area extent.
-    # Assumption 17: Each individual (within schooling age limits) goes to 
-    #                school within the total study area extent.
-
-    # indivFacID_1 denotes bldID of the schools
-    # students (schoolEnrollment=1) go to, whereas, indivFacID_2 denotes bldID of
-    # com, ind and rescom buildings where working people go to (workplace bldID).
-
-    # Assign working places to employed people in indivFacID_2_________________
-    # Working places are defined as occupancy types 'Ind','Com' and 'ResCom'
-    workplacemask=(building_df['OccBld']=='Ind') | (building_df['OccBld']=='Com')\
-                    | (building_df['OccBld'] == 'ResCom')
-    workplaceidx = building_df.index[workplacemask]
-    workplace_bldID = building_df['bldID'][workplaceidx].tolist()
-
-    employedmask = individual_df['employed'] ==1
-    employedidx = individual_df.index[employedmask]
-    if len(employedidx)>len(workplaceidx):
-        repetition = ceil(len(employedidx)/len(workplaceidx))
-        workplace_sample_temp = list(repeat(workplace_bldID,repetition))
-        workplace_sample = list(chain(*workplace_sample_temp))
-    else:
-        workplace_sample = workplace_bldID
-    random.shuffle(workplace_sample)
-
-    individual_df.loc[employedidx,'indivFacID_2'] = \
-                                  workplace_sample[0:sum(employedmask)]
-
-    # Assign school bldIDs to enrolled students in indivFacID_1________________
-    schoolmask = building_df['OccBld']=='Edu'            
-    schoolidx = building_df.index[schoolmask]
-    school_bldID = building_df['bldID'][schoolidx].tolist()
-
-    studentmask = individual_df['schoolEnrollment'] ==1
-    studentidx = individual_df.index[studentmask]
-    if len(studentidx)>len(schoolidx):
-        repetition = ceil(len(studentidx)/len(schoolidx))
-        school_sample_temp = list(repeat(school_bldID,repetition))
-        school_sample = list(chain(*school_sample_temp))
-    else:
-        school_sample = school_bldID
-    random.shuffle(school_sample)
-
-    individual_df.loc[studentidx,'indivFacID_1'] = \
-                                  school_sample[0:sum(studentmask)]  
-
-    # Replace missing values with -1 instead of NaN
-    individual_df['indivFacID_1'] = individual_df['indivFacID_1'].fillna(-1)
-    individual_df['indivFacID_2'] = individual_df['indivFacID_2'].fillna(-1)  
-
-
-    #%% Step 23 Assign community facility ID (CommFacID) to household layer
-    # CommFacID denotes the bldID of the hospital the households usually go to.
-
-    # In this case, randomly assign bldID of hospitals to the households, but in 
-    # next version, households must be assigned hospitals closest to their location
-    hospitalmask = building_df['OccBld']=='Hea'
-    hospitalidx = building_df.index[hospitalmask]
-    hospital_bldID = building_df['bldID'][hospitalidx].tolist()
-    repetition = ceil(len(household_df)/len(hospitalidx))
-    hospital_sample_temp = list(repeat(hospital_bldID,repetition))
-    hospital_sample = list(chain(*hospital_sample_temp))
-    random.shuffle(hospital_sample)
-
-    household_df.loc[household_df.index,'CommFacID'] =\
-                                    hospital_sample[0:len(household_df)]
-
-    #%% Step 24 Assign repValue
-    # Assumption 12: Unit price for replacement wrt occupation type and 
-    # special facility status of the building
-
-    # Assign unit price
-    for occtype in Unit_price:
-        occmask = building_df['OccBld'] == occtype
-        occidx = building_df.index[occmask]
-        building_df.loc[occidx, 'unit_price'] = Unit_price[occtype]
-        
-    building_df['repValue'] = building_df['fptarea'] *\
-                            building_df['nstoreys']* building_df['unit_price']
-
-
-    #%% Remove unnecessary columns and save the results 
-    building_df = building_df.drop(columns=\
-            ['lut_number','lrstype','CodeLevel','nstoreys','OccBld','unit_price'])
-    household_df = household_df.drop(columns=\
-            ['income_numb','zoneType','zoneID','approxFootprint'])
-    individual_df = individual_df.drop(columns=\
-                        ['schoolEnrollment','labourForce','employed'])
-        
-    # Rename indices to convert all header names to lowercase
-    building_df.rename(columns={'zoneID':'zoneid','bldID':'bldid','expStr':'expstr',\
-      'specialFac':'specialfac','repValue':'repvalue','nHouse':'nhouse'},\
-                                                              inplace=True)
-    household_df.rename(columns={'bldID':'bldid','hhID':'hhid','nIND':'nind',\
-                                'CommFacID':'commfacid'}, inplace=True)
-    individual_df.rename(columns={'hhID':'hhid','indivID':'individ',\
-      'eduAttStat':'eduattstat','indivFacID_1':'indivfacid_1',\
-      'indivFacID_2':'indivfacid_2'}, inplace=True)
-    landuse_shp.rename(columns={'zoneID':'zoneid','LuF':'luf',\
-      'densityCap':'densitycap','floorAreaR':'floorarear',\
-      'avgIncome':'avgincome'}, inplace=True)                                                                                                     
-
-    #%% Generate building centroid coordinates
-
-    histo = building_df.groupby(['zoneid'])['zoneid'].count()
-    max_val = building_df.groupby(['zoneid'])['fptarea'].max()
-    landuse_layer = landuse_shp
-    building_layer = building_df
-    final_list = []
-
-    for i in range(len(histo)):
-        df = landuse_layer[landuse_layer['zoneid'] == histo.index[i]].copy()
-        bui_indx = building_layer['zoneid'] == histo.index[i]
-        bui_attr = building_layer.loc[bui_indx].copy()
-        
-        rot_a = random.randint(10, 40)
-        rot_a_rad = rot_a*math.pi/180
-
-        separation_val = math.sqrt(max_val.values[i])/abs(math.cos(rot_a_rad))
-        separation_val = round(separation_val, 2)
-        boundary_approach =  (math.sqrt(max_val.values[i])/2)*math.sqrt(2)
-        boundary_approach = round(boundary_approach, 2)
-        
-        df2 = df.buffer(-boundary_approach)
-        df2 = gpd.GeoDataFrame(gpd.GeoSeries(df2))
-        df2 = df2.rename(columns={0:'geometry'}).set_geometry('geometry')
-        
-        xmin, ymin, xmax, ymax = df2.total_bounds    
-        xcoords = [ii for ii in np.arange(xmin, xmax, separation_val)]
-        ycoords = [ii for ii in np.arange(ymin, ymax, separation_val)]
-        
-        pointcoords = np.array(np.meshgrid(xcoords, ycoords)).T.reshape(-1, 2)
-        points = gpd.points_from_xy(x=pointcoords[:,0], y=pointcoords[:,1])
-        grid = gpd.GeoSeries(points, crs=df.crs)
-        grid.name = 'geometry'
-        
-        gridinside = gpd.sjoin(gpd.GeoDataFrame(grid), df2[['geometry']], how="inner")
-        
-        def buff(row):
-            return row.geometry.buffer(row.buff_val, cap_style = 3)
-        
-        if len(gridinside) >= histo.values[i]:
-            gridinside = gridinside.sample(min(len(gridinside), histo.values[i]))
-            gridinside['xcoord'] = gridinside.geometry.x
-            gridinside['ycoord'] = gridinside.geometry.y
-            
-            buffer_val = np.sqrt(list(bui_attr.fptarea))/2
-            buffered = gridinside.copy()
-            buffered['buff_val'] = buffer_val[0:len(gridinside)]
-            
-            buffered['geometry'] = buffered.apply(buff, axis=1)
-            polyinside = buffered.rotate(rot_a, origin='centroid')
-            
-            polyinside2 = gpd.GeoDataFrame(gpd.GeoSeries(polyinside))
-            polyinside2 = polyinside2.rename(columns={0:'geometry'}).set_geometry('geometry')
-            polyinside2['fid'] = list(range(1,len(polyinside2)+1))
-            
-            bui_attr['fid'] = list(range(1,len(bui_attr)+1))
-            bui_joined = polyinside2.merge(bui_attr, on='fid')
-            bui_joined = bui_joined.drop(columns=['fid'])
-            
-            bui_joined['xcoord'] = list(round(gridinside.geometry.x, 3))
-            bui_joined['ycoord'] = list(round(gridinside.geometry.y, 3))
-            
-        elif len(gridinside) < histo.values[i]:
-            separation_val = math.sqrt(max_val.values[i])
-            separation_val = round(separation_val, 2)
-            boundary_approach =  (math.sqrt(max_val.values[i])/2)*math.sqrt(2)
-            boundary_approach = round(boundary_approach, 2)
-            
-            df2 = df.buffer(-boundary_approach, 200)
-            df2 = gpd.GeoDataFrame(gpd.GeoSeries(df2))
-            df2 = df2.rename(columns={0:'geometry'}).set_geometry('geometry')
-            
-            xmin, ymin, xmax, ymax = df2.total_bounds    
-            xcoords = [ii for ii in np.arange(xmin, xmax, separation_val)]
-            ycoords = [ii for ii in np.arange(ymin, ymax, separation_val)]
-            
-            pointcoords = np.array(np.meshgrid(xcoords, ycoords)).T.reshape(-1, 2)
-            points = gpd.points_from_xy(x=pointcoords[:,0], y=pointcoords[:,1])
-            grid = gpd.GeoSeries(points, crs=df.crs)
-            grid.name = 'geometry'
-            
-            gridinside = gpd.sjoin(gpd.GeoDataFrame(grid), df2[['geometry']], how="inner")
-            
-            gridinside = gridinside.sample(min(len(gridinside), histo.values[i]))
-            gridinside['xcoord'] = gridinside.geometry.x
-            gridinside['ycoord'] = gridinside.geometry.y
-            
-            buffer_val = np.sqrt(list(bui_attr.fptarea))/2
-            buffered = gridinside.copy()
-            buffered['buff_val'] = buffer_val[0:len(gridinside)]
-            
-            buffered['geometry'] = buffered.apply(buff, axis=1)
-            polyinside = buffered.rotate(0, origin='centroid')
-            
-            polyinside2 = gpd.GeoDataFrame(gpd.GeoSeries(polyinside))
-            polyinside2 = polyinside2.rename(columns={0:'geometry'}).set_geometry('geometry')
-            polyinside2['fid'] = list(range(1,len(polyinside2)+1))
-            
-            bui_attr['fid'] = list(range(1,len(bui_attr)+1))
-            bui_joined = polyinside2.merge(bui_attr, on='fid')
-            bui_joined = bui_joined.drop(columns=['fid'])
-            
-            bui_joined['xcoord'] = list(round(gridinside.geometry.x, 3))
-            bui_joined['ycoord'] = list(round(gridinside.geometry.y, 3))
-
-        final_list.append(bui_joined)
-
-    final = pd.concat(final_list)
-    temp_cols = final.columns.tolist()
-    new_cols = temp_cols[1:] + temp_cols[0:1]
-    final = final[new_cols]
-
-    temp_cols2 = landuse_shp.columns.tolist()
-    new_cols2 = temp_cols2[1:] + temp_cols2[0:1]
-    landuse_shp = landuse_shp[new_cols2]   
-
-    return final, household_df, individual_df, landuse_shp

src/tomorrowcities/utils.py

@@ -1,10 +0,0 @@
-import io
-import fiona
-import geopandas as gpd
-
-def read_zipshp(file):
-  zipshp = io.BytesIO(open(file, 'rb').read())
-  with fiona.BytesCollection(zipshp.read()) as src:
-    crs = src.crs
-    gdf = gpd.GeoDataFrame.from_features(src, crs=crs)
-  return gdf

tomorrowcities/__init__.py

@@ -0,0 +1,3 @@
+"""Tomorrow's Cities Decision Support Environment"""
+__title__ = "Tomorrow's Cities Decision Support Environment"
+__version__ = "0.0.1"

{src/gui → tomorrowcities/backend}/engine.py

@@ -20,21 +20,21 @@ def compute_power_infra(nodes,edges,intensity,fragility):
     print(fragility.head())
     print(intensity.head())
 
-    eq_vuln = fragility.rename(columns={"med_Slight": "med_ds1", 
-                        "med_Moderate": "med_ds2",
-                        "med_Extensive": "med_ds3",
-                        "med_Complete": "med_ds4",
-                        "beta_Slight": "beta_ds1",
-                        "beta_Moderate": "beta_ds2",
-                        "beta_Extensive": "beta_ds3",
-                        "beta_Complete": "beta_ds4"})
+    eq_vuln = fragility.rename(columns={"med_slight": "med_ds1", 
+                        "med_moderate": "med_ds2",
+                        "med_extensive": "med_ds3",
+                        "med_complete": "med_ds4",
+                        "beta_slight": "beta_ds1",
+                        "beta_moderate": "beta_ds2",
+                        "beta_extensive": "beta_ds3",
+                        "beta_complete": "beta_ds4"})
     
     G_power = nx.Graph()
     for _, node in nodes.iterrows():
-        G_power.add_node(node.NODE_ID, pos=(node.x_coord, node.y_coord))
+        G_power.add_node(node.node_id, pos=(node.x_coord, node.y_coord))
         
     for _, edge in edges.iterrows():
-        G_power.add_edge(*(edge.FROM_NODE, edge.TO_NODE))  
+        G_power.add_edge(*(edge.from_node, edge.to_node))  
 
     nodes = geopandas.sjoin_nearest(nodes,intensity, 
                 how='left', rsuffix='intensity',distance_col='distance')
@@ -69,16 +69,16 @@ def compute_power_infra(nodes,edges,intensity,fragility):
     threshold = DS_MODERATE 
 
     # All Nodes
-    all_nodes = set(nodes['NODE_ID'])
+    all_nodes = set(nodes['node_id'])
 
     # Power Plants (generators)
-    power_plants = set(nodes[nodes['pwr_plant'] == 1]['NODE_ID'])
+    power_plants = set(nodes[nodes['pwr_plant'] == 1]['node_id'])
 
     # Server Nodes 
-    server_nodes = set(nodes[nodes['n_bldgs'] > 0]['NODE_ID'])
+    server_nodes = set(nodes[nodes['n_bldgs'] > 0]['node_id'])
 
     # Nodes directly affected by earthquake. Thresholding takes place.
-    damaged_nodes = set(nodes[nodes['eq_ds'] > threshold]['NODE_ID'])
+    damaged_nodes = set(nodes[nodes['eq_ds'] > threshold]['node_id'])
 
     # Damaged Server Nodes
     damaged_server_nodes = damaged_nodes.intersection(server_nodes)
@@ -126,8 +126,8 @@ def compute_power_infra(nodes,edges,intensity,fragility):
         
     is_damaged_mapper     = {id:id in damaged_nodes   for id in all_nodes}
     is_operational_mapper = {id:id in operating_nodes for id in all_nodes}
-    nodes['is_damaged'] = nodes['NODE_ID'].map(is_damaged_mapper)
-    nodes['is_operational'] = nodes['NODE_ID'].map(is_operational_mapper)
+    nodes['is_damaged'] = nodes['node_id'].map(is_damaged_mapper)
+    nodes['is_operational'] = nodes['node_id'].map(is_operational_mapper)
 
     return nodes['eq_ds'], nodes['is_damaged'], nodes['is_operational']
 

tomorrowcities/components/__init__.py

@@ -0,0 +1,2 @@
+from .header import Header  # noqa
+from .layout import Layout  # noqa

tomorrowcities/components/article.py

@@ -0,0 +1,25 @@
+import reacton.ipyvuetify as rv
+import solara
+
+from ..data import articles
+
+@solara.component
+def ArticleCard(name):
+    article = articles[name]
+    with rv.Card(max_width="400px") as main:
+        rv.CardTitle(children=[article.title])
+        with rv.CardText():
+            solara.Markdown(article.description)
+            with solara.Link(f"/docs/{name}"):
+                solara.Button("Read article", text=True, icon_name="mdi-book-open")
+    return main
+
+
+@solara.component
+def Overview():
+    with solara.ColumnsResponsive(12) as main:
+        with solara.Card():
+            with solara.ColumnsResponsive(12, small=6, large=4):
+                for name in articles:
+                    ArticleCard(name)
+    return main

tomorrowcities/components/header.py

@@ -0,0 +1,6 @@
+import solara
+
+
+@solara.component
+def Header():
+    pass

tomorrowcities/components/layout.py

@@ -0,0 +1,6 @@
+import solara
+
+
+@solara.component
+def Layout(children=[]):
+    return solara.VBox(children=children)

tomorrowcities/content/articles/data_formats.md

@@ -0,0 +1,53 @@
+---
+author: huseyin.kaya
+title: Data Formats 
+description: Description of the data formats used in web application
+alt: "Data Formats"
+createdAt: 2023-10-10
+duration: 6 min read
+category:
+  - general
+---
+
+## Data Structures
+Tomorrow's Cities Decision Support Environment (TCDSE) is capable of conducting different hazard scenarios on different infrastructures, hence it needs to use several data input/output formats. 
+
+There are may different possible strategies and data formats to describe and store data. 
+In TCDSE, we generally use tabular data where each row corresponds to a unique object whereas the columns corresponds to the features of that object. Object here can refer to a building, individual, etc. Full list of the objects for which we use a dedicated data file is as follows:
+
+* landuse 
+* building
+* household
+* individual
+* intensity
+* fragility
+* vulnerability
+* power nodes
+* power edges
+
+**Storage Format:** The tabular data can be stored in different formats such as Comma-Separeted Values or spreadsheets. If the data does not contain geographic coordinates or the coordinates are defined with longitude and latitude pairs, spreadsheet formats 
+
+In this way, building data can be joined with other type of data that we will mention in the coming section via relational databases.
+
+### Format
+
+
+## Layers
+### Buildings
+Buildings are the core component of visioning scenarios. The features of the building with some example data are shown below:
+
+|zoneID| bldID | nHouse | residents | specialFac | expStr          | fptarea | geometry     | 
+|------|-------|--------|-----------|------------|-----------------|---------|--------------|
+|4     | 17    | 41     | 178       | 0          |RCi+HC+18s+ResCom| 111     | MultiPolygon |
+
+
+where
+
+* **zoneID (integer)** refers to the unique identitifer of the zone that building is located in. The features of the corresponding zone is described in a dedicated zone table.
+* **bldID (integer)** is a unique building identifier.
+* **nHouse (integer)** is the number of household in that building.
+* **residents (integer)** stores the number of individual live in the building.
+* **expStr (string)** 
+
+
+

tomorrowcities/content/articles/power_network_analysis copy.md

@@ -0,0 +1,14 @@
+---
+author: huseyin.kaya
+title: Power Network Analysis
+description: How to conduct power network analysis in Tomorrowville
+image: https://images.unsplash.com/photo-1429041966141-44d228a42775?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=2500&q=80
+thumbnail: https://images.unsplash.com/photo-1429041966141-44d228a42775?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=350&q=80
+alt: "Power Network Analysis"
+createdAt: 2023-10-10
+duration: 6 min read
+category:
+  - general
+---
+
+## Power Infrastructure Analysis

tomorrowcities/content/articles/welcome.md

@@ -0,0 +1,78 @@
+---
+author: huseyin.kaya
+title: Welcome!
+description: A Brief Introduction to Tomorrow's Cities Decision Support Environment (TCDSE)
+image: https://images.unsplash.com/photo-1429041966141-44d228a42775?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=2500&q=80
+thumbnail: https://images.unsplash.com/photo-1429041966141-44d228a42775?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=350&q=80
+alt: "Welcome!"
+createdAt: 2023-10-10
+duration: 6 min read
+category:
+  - general
+---
+
+## Tomorrow's Cities Decision Support Environment (TCDSE)
+TCDSE is a web application designed to conduct computational tasks to generate information needed for decision mechanisms in designing future cities. The web application, which will be referred as TCDSE for short, contains a computational engine capable of executing several hazard scenarios on different exposure datasets and infrastructures. 
+
+## Features
+General capabilities/features of the web application can be summarized as follows:
+
+
+*Hazard Scenarios*
+
+* Earthquake
+* Flood
+* Debris
+
+*Exposure Scenarios*
+
+* Buildings
+* Power networks
+* Transportation
+* Water networks
+
+*Impact Metrics*
+
+* Building and infrastructure-level damage states
+* Household and individual-level derived metrics
+
+*Visualization*
+
+* GIS Maps
+* Hazard and Exposure data displayers
+* Reactive metric widgets
+* Damage state classifications
+
+*Data structure*
+
+* GeoJSON format for geospatial data
+* Vanilla JSON for non-geospatioal tabular data
+
+*Software*
+
+* Pure-Python development for both backend and frontend
+* Reactive user interface via Solara
+* geospatial database via postgis
+* Leaflet backend for maps
+* Easy deployment to cloud
+
+
+## Quickstart
+* Download [Sample Dataset](https://drive.google.com/file/d/1BGPZQ2IKJHY9ExOCCHcNNrCTioYZ8D1y/view?usp=sharing) to your local environment and unzip the archieve file.
+* Go to [engine](/engine)
+* Drag/drop necessary files to the drop zone of the engine and execute the engine. A sample session is displayed below. 
+* The impact metrics will be immediately seen on the page.
+
+<video width="853" controls>
+  <source src="https://github-production-user-asset-6210df.s3.amazonaws.com/2515171/270064030-0733ad34-0a7f-445e-86fb-9a61df4e2969.mp4" type="video/mp4">
+</video>
+
+In case the file names in the video are not clearly seen, they are: 
+
+* nairobi_business_buildings.geojson
+* nairobi_business_household.json
+* nairobi_business_individual.json
+* nairobi_earthquake_fragility.json
+* nairobi_earthquake_intensity.geojson
+
+The used files above satisfy minimum requirements to run Earthquake analysis on buildings. 

docs/Makefile → tomorrowcities/content/images/tcdse_demo1.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8b6587b859607f200f116e2cb043fc358e1c3a26c326b563bf348453cfc68307
-size 634
+oid sha256:88844e0fd52f7751617e2b9fdb98a84d137ae50c13620530507fa93bbd24f6e8
+size 1949660

tomorrowcities/data.py

@@ -0,0 +1,30 @@
+import dataclasses
+from pathlib import Path
+from typing import Any, Dict
+import solara
+
+import yaml
+
+
+HERE = Path(__file__)
+
+
+@dataclasses.dataclass
+class Article:
+    markdown: str
+    title: str
+    description: str
+
+
+articles: Dict[str, Article] = {}
+
+for file in (HERE.parent / "content/articles").glob("*.md"):
+    content = file.read_text()
+    lines = [k.strip() for k in content.split("\n")]
+    frontmatter_start = lines.index("---", 0)
+    frontmatter_end = lines.index("---", frontmatter_start + 1)
+    yamltext = "\n".join(lines[frontmatter_start + 1 : frontmatter_end - 2])
+    metadata = yaml.safe_load(yamltext)
+    markdown = "\n".join(lines[frontmatter_end + 1 :])
+    articles[file.stem] = Article(markdown=markdown, title=metadata["title"], description=metadata["description"])
+

tomorrowcities/pages/__init__.py

@@ -0,0 +1,121 @@
+from typing import Optional, cast
+import solara
+from solara.alias import rv
+import dataclasses
+
+from ..data import articles
+
+route_order = ["/", "docs","engine","settings","account"]
+
+def check_auth(route, children):
+    # This can be replaced by a custom function that checks if the user is
+    # logged in and has the required permissions.
+
+    # routes that are public or only for admin
+    # the rest only requires login
+    public_paths = ["/","docs","engine","account"]
+    admin_paths = ["settings"]
+
+
+    if route.path in public_paths:
+        children_auth = children
+    else:
+        if user.value is None:
+            children_auth = [LoginForm()]
+        else:
+            if route.path in admin_paths and not user.value.admin:
+                children_auth = [solara.Error("You are not an admin")]
+            else:
+                children_auth = children
+    return children_auth
+
+
+@dataclasses.dataclass
+class User:
+    username: str
+    admin: bool = False
+
+
+user = solara.reactive(cast(Optional[User], None))
+login_failed = solara.reactive(False)
+
+
+def login_control(username: str, password: str):
+    # this function can be replace by a custom username/password check
+    if username == "test" and password == "test":
+        user.value = User(username, admin=False)
+        login_failed.value = False
+    elif username == "admin" and password == "admin":
+        user.value = User(username, admin=True)
+        login_failed.value = False
+    else:
+        login_failed.value = True
+
+
+@solara.component
+def LoginForm():
+    username = solara.use_reactive("")
+    password = solara.use_reactive("")
+    with solara.Card("Login"):
+        solara.Markdown(
+            """
+        This is an example login form.
+
+          * use admin/admin to login as admin.
+          * use test/test to login as a normal user.
+        """
+        )
+        solara.InputText(label="Username", value=username)
+        solara.InputText(label="Password", password=True, value=password)
+        solara.Button(label="Login", on_click=lambda: login_control(username.value, password.value))
+        if login_failed.value:
+            solara.Error("Wrong username or password")
+
+
+
+@solara.component
+def Layout(children=[]):
+    router = solara.use_context(solara.routing.router_context)
+    route, routes = solara.use_route(peek=True)
+
+    if route is None:
+        return solara.Error("Route not found")
+    
+    children = check_auth(route, children)
+
+
+    with solara.AppLayout(children=children, title="TomorrowCities Decision Support Environment", navigation=True) as main:
+        with solara.AppBar():
+            with solara.lab.Tabs(align="center"):
+                for route in routes:
+                    name = route.path if route.path != "/" else "Welcome"
+                    is_admin = user.value and user.value.admin
+                    # we could skip the admin tab if the user is not an admin
+                    if route.path == "settings" and not is_admin:
+                         continue
+                    if user.value is not None and route.path == "logon":
+                        continue
+                    # in this case we disable the tab
+                    solara.lab.Tab(name, path_or_route=route, disabled=False)
+            if user.value:
+                solara.Text(f"Logged in as {user.value.username} as {'admin' if user.value.admin else 'user'}")
+                with solara.Tooltip("Logout"):
+                    with solara.Link(f"/account"):
+                        solara.Button(icon_name="mdi-logout", icon=True, on_click=lambda: user.set(None))
+            else:
+                with solara.Link(f"/account"):
+                    solara.Button(icon_name="mdi-login",label='login', icon=True)
+
+    
+    return main
+
+
+@solara.component
+def Page():
+    with solara.VBox() as main:
+        solara.Title("TCDSE » Welcome")
+        article = articles["welcome"]
+        solara.Markdown(article.markdown)
+
+
+    return main

tomorrowcities/pages/account.py

@@ -0,0 +1,13 @@
+from typing import Optional
+import solara
+
+from . import user
+from . import LoginForm
+
+@solara.component
+def Page(name: Optional[str] = None, page: int = 0, page_size=100):
+    solara.Title("TCDSE » Account")
+    if user.value is None:
+        LoginForm()
+    else:    
+        solara.Markdown(f'Hello {user.value.username}')

tomorrowcities/pages/docs.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+import solara
+
+from .. import data
+from ..components.article import Overview
+
+
+@solara.component
+def Page(name: Optional[str] = None, page: int = 0, page_size=100):
+    if name is None:
+        with solara.Column() as main:
+            solara.Title("TCDSE» Documentation")
+            Overview()
+        return main
+    if name not in data.articles:
+        return solara.Error(f"No such article: {name!r}")
+    article = data.articles[name]
+    with solara.ColumnsResponsive(12) as main:
+        solara.Title("TCDSE » Documentation » " + article.title)
+        with solara.Link("/docs"):
+            solara.Text("« Back to documentation")
+        with solara.Card():
+            solara.Markdown(article.markdown)
+    return main

src/gui/app_engine_v2.py → tomorrowcities/pages/engine.py

@@ -10,7 +10,101 @@ from typing import Tuple, Optional
 import ipyleaflet
 from ipyleaflet import AwesomeIcon, Marker
 import numpy as np
-import engine
+import sys
+
+from ..backend.engine import compute, compute_power_infra
+
+
+layers = solara.reactive({
+    'layers' : {
+        'building': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {'ds': 0, 'metric1': 0, 'metric2': 0, 'metric3': 0,'metric4': 0, 'metric5': 0,'metric6': 0,'metric7': 0},
+            'cols': set(['residents', 'fptarea', 'repvalue', 'nhouse', 'zoneid', 'expstr', 'bldid', 'geometry', 'specialfac'])},
+        'landuse': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['geometry', 'zoneid', 'luf', 'population', 'densitycap', 'floorarat', 'setback', 'avgincome'])},
+        'household': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols':set(['hhid', 'nind', 'income', 'bldid', 'commfacid'])},
+        'individual': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['individ', 'hhid', 'gender', 'age', 'eduattstat', 'head', 'indivfacid'])},
+        'intensity': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['geometry','im'])},
+        'fragility': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4'])},
+        'vulnerability': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6'])},
+        'power nodes': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {'ds': 0, 'is_damaged': False, 'is_operational': True},
+            'cols': set(['geometry', 'fltytype', 'strctype', 'utilfcltyc', 'indpnode', 'guid', 
+                         'node_id', 'x_coord', 'y_coord', 'pwr_plant', 'serv_area', 'n_bldgs', 
+                         'income', 'eq_vuln'])},
+        'power edges': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['from_node', 'direction', 'pipetype', 'edge_id', 'guid', 'capacity', 
+                         'geometry', 'to_node', 'length'])},
+        'power fragility': {
+            'df': solara.reactive(None),
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'cols': set(['vuln_string', 'med_slight', 'med_moderate', 'med_extensive', 'med_complete', 
+                         'beta_slight', 'beta_moderate', 'beta_extensive', 'beta_complete', 'description'])}
+            },
+    'center': solara.reactive((41.01,28.98)),
+    'selected_layer' : solara.reactive(None),
+    'render_count': solara.reactive(0),
+    'bounds': solara.reactive(None),
+    'metrics': {
+        "metric1": {"desc": "Number of workers unemployed", "value": 0, "max_value": 100},
+        "metric2": {"desc": "Number of children with no access to education", "value": 0, "max_value": 100},
+        "metric3": {"desc": "Number of households with no access to hospital", "value": 0, "max_value": 100},
+        "metric4": {"desc": "Number of individuals with no access to hospital", "value": 0, "max_value": 100},
+        "metric5": {"desc": "Number of homeless households", "value": 0, "max_value": 100},
+        "metric6": {"desc": "Number of homeless individuals", "value": 0, "max_value": 100},
+        "metric7": {"desc": "Population displacement", "value": 0, "max_value":100},}})
+
 
 def building_colors(feature):
     ds_to_color = {0: 'lavender', 1:'violet',2:'fuchsia',3:'indigo',4:'darkslateblue',5:'black'}
@@ -23,17 +117,17 @@ def power_node_colors(feature):
     ds = random.randint(0,5) #feature['properties']['ds'] 
     return {'color': ds_to_color[ds], 'fillColor': ds_to_color[ds]}
 
-def create_map_layer(layers, df, name):
+def create_map_layer(df, name):
     if df is None:
         return None 
     if "geometry" not in list(df.columns):
         return None 
     
-    if name not in layers['layers'].keys():
+    if name not in layers.value['layers'].keys():
         return None
     
-    existing_map_layer = layers['layers'][name]['map_layer'].value
-    if existing_map_layer is not None and not layers['layers'][name]['force_render'].value:
+    existing_map_layer = layers.value['layers'][name]['map_layer'].value
+    if existing_map_layer is not None and not layers.value['layers'][name]['force_render'].value:
         return existing_map_layer
     
     if name == "intensity":
@@ -58,7 +152,7 @@ def create_map_layer(layers, df, name):
                         marker_color=marker_color,
                         icon_color=icon_color,
                         spin=False
-                    ),location=(y,x),title=f'{node["NODE_ID"]}')
+                    ),location=(y,x),title=f'{node["node_id"]}')
 
             markers.append(marker)
         map_layer= ipyleaflet.MarkerCluster(markers=markers,
@@ -67,8 +161,8 @@ def create_map_layer(layers, df, name):
         
     else:
         map_layer = ipyleaflet.GeoData(geo_dataframe = df)
-    layers['layers'][name]['map_layer'].set(map_layer)
-    layers['layers'][name]['force_render'].set(False)
+    layers.value['layers'][name]['map_layer'].set(map_layer)
+    layers.value['layers'][name]['force_render'].set(False)
     return map_layer
 
 @solara.component
@@ -106,7 +200,7 @@ def MetricWidget(name, description, value, max_value, render_count):
             solara.FigureEcharts(option=options, attributes={ "style": "height: 100px; width: 100px" })
 
 
-def import_data(data: Optional[bytes], layers):
+def import_data(data: Optional[bytes]):
     json_string = data.decode('utf-8')
     json_data = json.loads(json_string)
     if "features" in json_data.keys():
@@ -114,35 +208,39 @@ def import_data(data: Optional[bytes], layers):
     else:
         df = pd.read_json(json_string)
 
+    df.columns = df.columns.str.lower()
+
     name = None
-    for layer_name, layer in layers['layers'].items():
+    for layer_name, layer in layers.value['layers'].items():
         if layer['cols'] == set(df.columns):
             name = layer_name
             break
 
     # Inject columns
     if name is not None:
-        for col, val in layers['layers'][name]['extra_cols'].items():
+        for col, val in layers.value['layers'][name]['extra_cols'].items():
             df[col] = val
     return (name, df)
 
 
 @solara.component
-def FileDropZone(layers):
+def FileDropZone():
     total_progress, set_total_progress = solara.use_state(-1)
     fileinfo, set_fileinfo = solara.use_state(None)
     result, set_result = solara.use_state(solara.Result(True))
-    layers, set_layers = solara.use_state_or_update(layers)
 
     def load():
         if fileinfo is not None:
             print('processing file')
-            name, df = import_data(fileinfo['data'], layers)
+            name, df = import_data(fileinfo['data'])
             if name is not None and df is not None:
-                layers['layers'][name]['df'].set(df)
-                layers['selected_layer'].set(name)
-                layers['layers'][name]['visible'].set(True)
-                layers['layers'][name]['force_render'].set(True)
+                layers.value['layers'][name]['df'].set(df)
+                layers.value['selected_layer'].set(name)
+                layers.value['layers'][name]['visible'].set(True)
+                layers.value['layers'][name]['force_render'].set(True)
+                if  "geometry" in list(df.columns):
+                    center = (df.geometry.centroid.y.mean(), df.geometry.centroid.x.mean())
+                    layers.value['center'].set(center)
             else:
                 return False
         return True
@@ -179,15 +277,13 @@ def FileDropZone(layers):
             solara.ProgressLinear(value=True)
 
 @solara.component
-def LayerDisplayer(layers):
-
-    layers, set_layers = solara.use_state(layers)
+def LayerDisplayer():
 
-    nonempty_layers = {name: layer for name, layer in layers['layers'].items() if layer['df'].value is not None}
+    nonempty_layers = {name: layer for name, layer in layers.value['layers'].items() if layer['df'].value is not None}
     nonempty_layer_names = list(nonempty_layers.keys())
-    selected = layers['selected_layer'].value
+    selected = layers.value['selected_layer'].value
     def set_selected(s):
-        layers['selected_layer'].set(s)
+        layers.value['selected_layer'].set(s)
 
     solara.ToggleButtonsSingle(value=selected, on_value=set_selected, 
                                values=nonempty_layer_names)
@@ -195,61 +291,58 @@ def LayerDisplayer(layers):
         set_selected(nonempty_layer_names[0])
     if selected is not None:
         DataframeDisplayer(nonempty_layers[selected]['df'].value, 
-                           layers['render_count'].value,
-                           layers['bounds'].value)
+                           layers.value['render_count'].value,
+                           layers.value['bounds'].value)
 
 @solara.component
-def MetricPanel(layers):
-    layers, set_layers = solara.use_state(layers)
-    building = layers['layers']['building']['df'].value
-    filtered_metrics = {name: 0 for name in layers['metrics'].keys()}
-    if building is not None and layers['bounds'].value is not None:
-        ((ymin,xmin),(ymax,xmax)) = layers['bounds'].value
+def MetricPanel():
+    building = layers.value['layers']['building']['df'].value
+    filtered_metrics = {name: 0 for name in layers.value['metrics'].keys()}
+    if building is not None and layers.value['bounds'].value is not None:
+        ((ymin,xmin),(ymax,xmax)) = layers.value['bounds'].value
         filtered = building.cx[xmin:xmax,ymin:ymax]
         for metric in filtered_metrics.keys():
             filtered_metrics[metric] = int(filtered.cx[xmin:xmax,ymin:ymax][metric].sum())
     
     with solara.Row():
-        for name, metric in layers['metrics'].items():
+        for name, metric in layers.value['metrics'].items():
             MetricWidget(name, metric['desc'], 
                          filtered_metrics[name], 
                          metric['max_value'],
-                         layers['render_count'].value)
+                         layers.value['render_count'].value)
   
 
 @solara.component
-def LayerController(layers):
-    layers, set_layers = solara.use_state(layers)
+def LayerController():
     with solara.Row(gap="0px"):
-        for layer_name, layer in layers['layers'].items():
+        for layer_name, layer in layers.value['layers'].items():
             if layer['map_layer'].value is not None:
                 solara.Checkbox(label=layer_name, 
                                 value=layer['visible'])
 
                     
 @solara.component
-def MapViewer(layers):
+def MapViewer():
     print('rendering mapviewer')
     default_zoom = 14
-    default_center = (-1.3, 36.80)
-    layers, set_layers = solara.use_state(layers)
+    #default_center = (-1.3, 36.80)
     zoom, set_zoom = solara.use_state(default_zoom)
-    center, set_center = solara.use_state(default_center)
+    #center, set_center = solara.use_state(default_center)
 
     def set_bounds(bounds):
-        layers['bounds'].set(bounds)
+        layers.value['bounds'].set(bounds)
 
     base_map = ipyleaflet.basemaps["Stamen"]["Watercolor"]
     base_layer = ipyleaflet.TileLayer.element(url=base_map.build_url())
     map_layers = [base_layer]
 
-    for layer_name, layer in layers['layers'].items():
+    for layer_name, layer in layers.value['layers'].items():
         df = layer['df'].value
         if df is None:
             continue
         # we have something to display on map
         if  "geometry" in list(df.columns) and layer['visible'].value:
-            map_layer = create_map_layer(layers, df, layer_name)
+            map_layer = create_map_layer(df, layer_name)
             if map_layer is not None:
                 map_layers.append(map_layer)
 
@@ -258,8 +351,8 @@ def MapViewer(layers):
         zoom=zoom,
         on_zoom=set_zoom,
         on_bounds=set_bounds,
-        center=center,
-        on_center=set_center,
+        center=layers.value['center'].value,
+        on_center=layers.value['center'].set,
         scroll_wheel_zoom=True,
         dragging=True,
         double_click_zoom=True,
@@ -280,8 +373,7 @@ def DataframeDisplayer(df, render_count, bounds):
         solara.DataFrame(df)
     
 @solara.component
-def ExecutePanel(layers):
-    layers, set_layers = solara.use_state_or_update(layers)
+def ExecutePanel():
     infra, set_infra = solara.use_state(["power"])
     hazard, set_hazard = solara.use_state("earthquake")
 
@@ -294,8 +386,8 @@ def ExecutePanel(layers):
         set_execute_counter(execute_counter + 1)
         execute_error.set("")
 
-    def is_ready_to_run(layers, infra, hazard):
-        existing_layers = set([name for name, l in layers['layers'].items() if l['df'].value is not None])
+    def is_ready_to_run(infra, hazard):
+        existing_layers = set([name for name, l in layers.value['layers'].items() if l['df'].value is not None])
         missing = []
 
         if hazard == "earthquake":
@@ -316,63 +408,70 @@ def ExecutePanel(layers):
 
 
     def execute_engine():
-        if execute_counter > 0 :
-            is_ready, missing = is_ready_to_run(layers, infra, hazard)
-            if not is_ready:
-                raise Exception(f'Missing {missing}')
-                return
-            
-            if 'power' in infra:
-                nodes = layers['layers']['power nodes']['df'].value
-                edges = layers['layers']['power edges']['df'].value
-                intensity = layers['layers']['intensity']['df'].value
-                power_fragility = layers['layers']['power fragility']['df'].value
 
 
-                eq_ds, is_damaged, is_operational = engine.compute_power_infra(nodes, 
-                                        edges,
-                                        intensity,
-                                        power_fragility)
-                
-                #power_node_df =  dfs['Power Nodes'].copy()                         
-                nodes['ds'] = list(eq_ds)
-                nodes['is_damaged'] = list(is_damaged)
-                nodes['is_operational'] = list(is_operational)
+        def execute_infra():
+            nodes = layers.value['layers']['power nodes']['df'].value
+            edges = layers.value['layers']['power edges']['df'].value
+            intensity = layers.value['layers']['intensity']['df'].value
+            power_fragility = layers.value['layers']['power fragility']['df'].value
 
-                layers['layers']['power nodes']['df'].set(nodes)
 
+            eq_ds, is_damaged, is_operational = compute_power_infra(nodes, 
+                                    edges,
+                                    intensity,
+                                    power_fragility)
+            
+            #power_node_df =  dfs['Power Nodes'].copy()                         
+            nodes['ds'] = list(eq_ds)
+            nodes['is_damaged'] = list(is_damaged)
+            nodes['is_operational'] = list(is_operational)
+            return nodes
+
+        def execute_building():
+            buildings = layers.value['layers']['building']['df'].value
+            household = layers.value['layers']['household']['df'].value
+            individual = layers.value['layers']['individual']['df'].value
+            intensity = layers.value['layers']['intensity']['df'].value
+
+            fragility = layers.value['layers']['fragility']['df'].value
+            vulnerability = layers.value['layers']['vulnerability']['df'].value
+            computed_metrics, df_metrics, df_bld_hazard = compute(
+                buildings, 
+                household, 
+                individual,
+                intensity,
+                fragility if hazard == "earthquake" else vulnerability, 
+                hazard)
+
+            print(computed_metrics)
+            for metric in df_metrics.keys():
+                buildings[metric] = list(df_metrics[metric][metric])
+                layers.value['metrics'][metric]['value'] = computed_metrics[metric]['value']
+                layers.value['metrics'][metric]['max_value'] = computed_metrics[metric]['max_value']
+            buildings['ds'] = list(df_bld_hazard['ds'])
+            return buildings
 
-                layers['render_count'].set(layers['render_count'].value + 1)
-                layers['layers']['power nodes']['force_render'].set(True)
+        if execute_counter > 0 :
+            is_ready, missing = is_ready_to_run(infra, hazard)
+            if not is_ready:
+                raise Exception(f'Missing {missing}')
+            
+            if 'power' in infra:
+                nodes = execute_infra()
+                layers.value['layers']['power nodes']['df'].set(nodes)
+            if 'building' in infra:
+                buildings = execute_building()
+                layers.value['layers']['building']['df'].set(buildings)
 
+            # trigger render event
+            layers.value['render_count'].set(layers.value['render_count'].value + 1)
+            if 'power' in infra:
+                layers.value['layers']['power nodes']['force_render'].set(True)
             if 'building' in infra:
-                buildings = layers['layers']['building']['df'].value
-                household = layers['layers']['household']['df'].value
-                individual = layers['layers']['individual']['df'].value
-                intensity = layers['layers']['intensity']['df'].value
-
-                fragility = layers['layers']['fragility']['df'].value
-                vulnerability = layers['layers']['vulnerability']['df'].value
-                computed_metrics, df_metrics, df_bld_hazard = engine.compute(
-                    buildings, 
-                    household, 
-                    individual,
-                    intensity,
-                    fragility if hazard == "earthquake" else vulnerability, 
-                    hazard)
-
-                print(computed_metrics)
-                for metric in df_metrics.keys():
-                    buildings[metric] = list(df_metrics[metric][metric])
-                    layers['metrics'][metric]['value'] = computed_metrics[metric]['value']
-                    layers['metrics'][metric]['max_value'] = computed_metrics[metric]['max_value']
-                buildings['ds'] = list(df_bld_hazard['ds'])
-                
-                layers['layers']['building']['df'].set(buildings)
-
-                layers['render_count'].set(layers['render_count'].value + 1)
-                layers['layers']['building']['force_render'].set(True)
+                layers.value['layers']['building']['force_render'].set(True)
 
+            
 
     # Execute the thread only when the depencency is changed
     result = solara.use_thread(execute_engine, dependencies=[execute_counter])
@@ -403,106 +502,22 @@ def ExecutePanel(layers):
 
 @solara.component
 def WebApp():
-    layers, set_layers = solara.use_state({
-        'layers' : {
-            'building': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {'ds': 0, 'metric1': 0, 'metric2': 0, 'metric3': 0,'metric4': 0, 'metric5': 0,'metric6': 0,'metric7': 0},
-                'cols': set(['geometry','zoneID', 'bldID', 'nHouse', 'residents', 'specialFac', 'expStr', 'fptarea', 'repValue'])},
-            'landuse': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['geometry', 'zoneID', 'LuF', 'population', 'densityCap', 'floorARat', 'setback', 'avgIncome'])},
-            'household': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols':set(['hhID', 'nInd', 'income', 'bldID', 'CommFacID'])},
-            'individual': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['indivId', 'hhID', 'gender', 'age', 'eduAttStat', 'head', 'indivFacID'])},
-            'intensity': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['geometry','im'])},
-            'fragility': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4'])},
-            'vulnerability': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6'])},
-            'power nodes': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {'ds': 0, 'is_damaged': False, 'is_operational': True},
-                'cols': set(['geometry', 'FLTYTYPE', 'STRCTYPE', 'UTILFCLTYC', 'INDPNODE', 'guid',
-                    'NODE_ID', 'x_coord', 'y_coord', 'pwr_plant', 'serv_area', 'n_bldgs',
-                    'income', 'eq_vuln'])},
-            'power edges': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['FROM_NODE', 'direction', 'pipetype', 'EDGE_ID', 'guid', 'capacity', 'geometry', 'TO_NODE', 'length'])},
-            'power fragility': {
-                'df': solara.reactive(None),
-                'map_layer': solara.reactive(None),
-                'force_render': solara.reactive(False),
-                'visible': solara.reactive(False),
-                'extra_cols': {},
-                'cols': set(['vuln_string', 'med_Slight', 'med_Moderate', 'med_Extensive', 'med_Complete', 'beta_Slight', 'beta_Moderate', 'beta_Extensive', 'beta_Complete', 'description'])}
-                },
-        'selected_layer' : solara.reactive(None),
-        'render_count': solara.reactive(0),
-        'bounds': solara.reactive(None),
-        'metrics': {
-            "metric1": {"desc": "Number of workers unemployed", "value": 0, "max_value": 100},
-            "metric2": {"desc": "Number of children with no access to education", "value": 0, "max_value": 100},
-            "metric3": {"desc": "Number of households with no access to hospital", "value": 0, "max_value": 100},
-            "metric4": {"desc": "Number of individuals with no access to hospital", "value": 0, "max_value": 100},
-            "metric5": {"desc": "Number of homeless households", "value": 0, "max_value": 100},
-            "metric6": {"desc": "Number of homeless individuals", "value": 0, "max_value": 100},
-            "metric7": {"desc": "Population displacement", "value": 0, "max_value":100},}})
 
     with solara.Columns([30,60]):
         with solara.Column():
-            FileDropZone(layers)
-            ExecutePanel(layers)
+
+            solara.Markdown('[Download Sample Dataset](https://drive.google.com/file/d/1BGPZQ2IKJHY9ExOCCHcNNrCTioYZ8D1y/view?usp=sharing)')
+            FileDropZone()
+            ExecutePanel()
         with solara.Column():
-            LayerController(layers)
-            MapViewer(layers)
-            MetricPanel(layers)
+            LayerController()
+            MapViewer()
+            MetricPanel()
             
-    LayerDisplayer(layers)
+    LayerDisplayer()
 
 @solara.component
-def Page():
+def Page(name: Optional[str] = None, page: int = 0, page_size=100):
     css = """
     .v-input {
         height: 10px;
@@ -516,9 +531,6 @@ def Page():
 
     """
     solara.Style(value=css)
+    solara.Title("TCDSE » Engine")
 
     WebApp()
-
-Page()
-
-    

tomorrowcities/pages/settings.py

@@ -0,0 +1,8 @@
+import solara
+
+from . import user
+
+@solara.component
+def Page():
+    assert user.value is not None
+    solara.Markdown(f"Hi {user.value.username}, you are an admin")