Added support for reading GEM XML format

pyproject.toml

@@ -19,7 +19,9 @@ dependencies = [
     "pandas",
     "networkx",
     "openpyxl",
-    "rasterio"
+    "rasterio",
+    "xml"
+
 ]
 
 [tool.hatch.version]

requirements.txt

@@ -7,4 +7,5 @@ matplotlib
 psycopg2-binary 
 scipy
 pandas
-rasterio
+rasterio
+xml

tomorrowcities/components/article.py

@@ -7,6 +7,8 @@ from ..data import articles
 def ArticleCard(name):
     article = articles[name]
     with rv.Card(max_width="400px") as main:
+        with solara.Link(f"/docs/{name}"):
+            rv.Img(height="250", src=article.image_url)
         rv.CardTitle(children=[article.title])
         with rv.CardText():
             solara.Markdown(article.description)

tomorrowcities/content/articles/{data_formats.md → data.md}

@@ -2,6 +2,8 @@
 author: huseyin.kaya
 title: Data Formats 
 description: Description of the data formats used in web application
+image: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/data.png?raw=true
+thumbnail: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/data.png?raw=true
 alt: "Data Formats"
 createdAt: 2023-10-10
 duration: 6 min read
@@ -9,13 +11,34 @@ category:
   - general
 ---
 
+[TOC]
+
 ## 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. 
+Tomorrow's Cities Decision Support Environment (TCDSE) is capable of conducting different hazard scenarios on different infrastructures, hence it needs to use several layers with different data input/output formats.
+
+## Storage Formats
+**Tabular**
+If the data does not contain geo-spatial information, then spreadsheet formats such as
+Comma-Separated Values (*.csv) or Microsoft Excel (*.xlsx) can be used to store the data.
+
+**GeoGSON**
+The primary choice of the webapp to store geo-spatial information is GeoJSON for couple of reasons. 
+First, unlike SHP format, it doesn't require auxillary files so it is easy to transfer or load
+a GeoJSON file. Secondly, it is supported by QGIS and geopandas Python libraries. Another advantage is
+that every GeoJSON is a text file and you can always look at the content by any text editor.
+
+**GeoTIFF**
+When the intensity measures are given as a mesh of rectangular grid, then the number of points to store 
+can become very large. In those cases, the size of the GeoJSON files will be very large because GeoJSON is 
+a text file and there will be redundant information. It is possible to compress a GeoJSON but a better 
+approach is to use GeoTIFF files. GeoTIFF is useful because it is a raster file and moreover geo-spatial
+context is already built-in in the format. Additionally GeoTIFF files are lot smaller than GeoJSON files.
+Please note that GeoTIFF is only advised to represent intensity measures on a mesh grid. 
 
-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:
+## Layers
+The layers supported by tomorrowcities are listed below.  In this section, we will cover all of them and provide information so that the users are able to generate data compatible to web application.
 
-* landuse 
+* land use 
 * building
 * household
 * individual
@@ -25,14 +48,6 @@ In TCDSE, we generally use tabular data where each row corresponds to a unique o
 * 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:
 
@@ -54,3 +69,33 @@ Whether it is flood, debris or earthquake, every hazard map should contain at le
 information so that the engine could map the coordinates to a common CRS to conduct calculations.
 
 
+### Vulnerability
+The engine has a built-in support for [Global Vulnerability Model (GVM)](https://github.com/gem/global_vulnerability_model) used in [Global Earthquake Model (GEM)](https://github.com/gem). 
+GVM uses an XML format in which one can define several vulnerability functons. There are almost a thousand XML files in [GVM repository](https://github.com/gem/global_vulnerability_model) precomputed for hundred cities from all continents. When a user uploads an XML file conforming to GVM, the engine can parse, display and use it in the calculations.
+
+The GVM's XML format is very simple. For demonstration purposes, we provide a short but structurally-complete one below. Please note that the values do not represent a real vulnerability function:
+
+~~~xml
+<?xml version="1.0" encoding="UTF-8"?>
+<nrml xmlns="http://openquake.org/xmlns/nrml/0.5">
+<vulnerabilityModel id="vulnerability_model" 
+                    assetCategory="buildings" 
+                    lossCategory="structural">
+  <description>Example vulnerability model</description>
+
+  <vulnerabilityFunction id="CR/LDUAL+CDL+DUM/H12/COM" dist="BT">
+    <imls imt="SA(1.0)">0.05 0.1 1.2 2.3 5.2 6.6 8.38 15</imls>
+    <meanLRs>1e-08 0.0001 0.002 0.06 0.14 0.19 0.6 0.99</meanLRs>
+    <covLRs>1e-08 1e-08 1e-08 1e-08 0.62 0.53 1e-08 1e-08 </covLRs>
+  </vulnerabilityFunction>
+
+  <vulnerabilityFunction id="MUR+CLBRS/LWAL+DNO/H1/RES" dist="BT">
+    <imls imt="SA(1.0)">0.04 0.2 1.2 2.3 5.2 6.4 9.38 15</imls>
+    <meanLRs>1e-08 0.001 0.003 0.06 0.15 0.18 0.7 0.99</meanLRs>
+    <covLRs>1e-08 1e-08 1e-08 1e-08 0.2 0.6 1e-08 1e-08 </covLRs>
+  </vulnerabilityFunction>
+
+  </vulnerabilityModel>
+</nrml>
+~~~
+

tomorrowcities/content/articles/flood.md

@@ -1,9 +1,9 @@
 ---
 author: huseyin.kaya
-title: Flood Vulnerability Analysis
-description: Methodologies in flood damage assessment
-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
+title: Flood
+description: How to define flood vulnerabiities and conduct damage assessment 
+image: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/flood.png?raw=true
+thumbnail: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/flood.png?raw=true
 alt: "Flood vulnerability analysis"
 createdAt: 2023-10-10
 duration: 6 min read
@@ -11,6 +11,8 @@ category:
   - general
 ---
 
+[TOC]
+
 The core component used in flood vulnerability analysis is to generate a mapping between water levels and relative damage on the structure. The shape of the curve depends on the typology of the structure, material type, height, code levels and many other features.
 
 The Joint Research Centre (JRC) led by the European Commission provides technical reports and guidelines to generate damage curves [1]. It is also always possible to make minor modification for special cases such as single storey adobe buildings in Africa [2]. 

tomorrowcities/content/articles/metrics.md

@@ -1,9 +1,9 @@
 ---
 author: huseyin.kaya
 title: Metrics
-description: A brief introduction to metrics
-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
+description: A brief introduction to impact metrics and implementation strategies
+image: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/metrics.jpg?raw=true
+thumbnail: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/metrics.jpg?raw=true
 alt: "Metrics"
 createdAt: 2023-10-10
 duration: 6 min read
@@ -11,6 +11,8 @@ category:
   - general
 ---
 
+[TOC]
+
 ## Metrics
 There are seven fundamental impact metrics displayed in the web application. For each them there is an associcated threhold but for the sake of simplicity, it is not explicitly stated.
 

tomorrowcities/content/articles/policies.md

@@ -1,9 +1,9 @@
 ---
 author: huseyin.kaya
-title: Policies in a nutshell
-description: A brief introduction to policies
-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
+title: Policies
+description: How to describe policies and their effect on impact metrics
+image: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/policies.png?raw=true
+thumbnail: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/policies.png?raw=true
 alt: "Policies"
 createdAt: 2023-10-10
 duration: 6 min read
@@ -11,6 +11,8 @@ category:
   - general
 ---
 
+[TOC]
+
 ### Policy 1: Land and tenure security program
 When this policy applied, the code levels of the residential buildings are set to higher standards 
 which effectively reduces the damage states during hazard simulations. Since this policy only changes

tomorrowcities/content/articles/power.md

@@ -2,8 +2,8 @@
 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
+image: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/power.png?raw=true
+thumbnail: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/power.png?raw=true
 alt: "Power Network Analysis"
 createdAt: 2023-10-10
 duration: 6 min read
@@ -11,4 +11,6 @@ category:
   - general
 ---
 
-## Power Infrastructure Analysis
+[TOC]
+
+## Power Infrastructure Analysis

tomorrowcities/content/articles/welcome.md

@@ -2,8 +2,8 @@
 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
+image: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/welcome.jpg?raw=true
+thumbnail: https://github.com/TomorrowsCities/tomorrowcities/blob/main/tomorrowcities/content/images/welcome.jpg?raw=true
 alt: "Welcome!"
 createdAt: 2023-10-10
 duration: 6 min read
@@ -11,10 +11,13 @@ category:
   - general
 ---
 
+[TOC]
+
 ## 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. 
 
 ## What is New?
+* **New** The engine now can parse, display vulnerability curves located on [Global Vulnerability Model Reposity](https://github.com/gem/global_vulnerability_model) maintained by [Global Earthquake Model Foundation)](https://www.globalquakemodel.org/gem). To see the new fatures, download one of the XML files in  [Global Vulnerability Model Reposity](https://github.com/gem/global_vulnerability_model) and drag and drop to [Engine](/engine). The engine will read all the vulnerability functions defined in the XML file and display them. 
 * basemap is changed to ESri.WorldImagery to see the landscapes especially rivers.
 * utilities page is added.
 * Excel to GeoJSON converted is added to utilities page.

tomorrowcities/data.py

@@ -14,6 +14,7 @@ class Article:
     markdown: str
     title: str
     description: str
+    image_url: str
 
 
 articles: Dict[str, Article] = {}
@@ -26,5 +27,8 @@ for file in (HERE.parent / "content/articles").glob("*.md"):
     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"])
+    articles[file.stem] = Article(markdown=markdown, 
+                                  title=metadata["title"], 
+                                  description=metadata["description"],
+                                  image_url=metadata["image"])
 

tomorrowcities/pages/docs.py

@@ -12,6 +12,7 @@ def Page(name: Optional[str] = None, page: int = 0, page_size=100):
         with solara.Column() as main:
             solara.Title("TCDSE» Documentation")
             Overview()
+            solara.Text('Images by rawpixel.com')
         return main
     if name not in data.articles:
         return solara.Error(f"No such article: {name!r}")

tomorrowcities/pages/engine.py

@@ -13,6 +13,7 @@ import numpy as np
 import rasterio 
 from rasterio.warp import calculate_default_transform, reproject, Resampling
 import io
+import xml
 import logging, sys
 #logging.basicConfig(stream=sys.stderr, level=logging.INFO)
 
@@ -24,107 +25,118 @@ layers = solara.reactive({
         'building': {
             'render_order': 50,
             'map_info_tooltip': 'Number of buildings',
-            'df': solara.reactive(None),
+            'data': 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_required': set(['residents', 'fptarea', 'repvalue', 'nhouse', 'zoneid', 'expstr', 'bldid', 'geometry', 'specialfac']),
-            'cols': set(['residents', 'fptarea', 'repvalue', 'nhouse', 'zoneid', 'expstr', 'bldid', 'geometry', 'specialfac'])},
+            'attributes_required': set(['residents', 'fptarea', 'repvalue', 'nhouse', 'zoneid', 'expstr', 'bldid', 'geometry', 'specialfac']),
+            'attributes': set(['residents', 'fptarea', 'repvalue', 'nhouse', 'zoneid', 'expstr', 'bldid', 'geometry', 'specialfac'])},
         'landuse': {
             'render_order': 20,
             'map_info_tooltip': 'Number of landuse zones',
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['geometry', 'zoneid', 'luf', 'population', 'densitycap', 'avgincome']),
-            'cols': set(['geometry', 'zoneid', 'luf', 'population', 'densitycap', 'floorarat', 'setback', 'avgincome'])},
+            'attributes_required': set(['geometry', 'zoneid', 'luf', 'population', 'densitycap', 'avgincome']),
+            'attributes': set(['geometry', 'zoneid', 'luf', 'population', 'densitycap', 'floorarat', 'setback', 'avgincome'])},
         'household': {
             'render_order': 0,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of households',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required':set(['hhid', 'nind', 'income', 'bldid', 'commfacid']),
-            'cols':set(['hhid', 'nind', 'income', 'bldid', 'commfacid'])},
+            'attributes_required':set(['hhid', 'nind', 'income', 'bldid', 'commfacid']),
+            'attributes':set(['hhid', 'nind', 'income', 'bldid', 'commfacid'])},
         'individual': {
             'render_order': 0,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of individuals',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['individ', 'hhid', 'gender', 'age', 'eduattstat', 'head', 'indivfacid']),
-            'cols': set(['individ', 'hhid', 'gender', 'age', 'eduattstat', 'head', 'indivfacid'])},
+            'attributes_required': set(['individ', 'hhid', 'gender', 'age', 'eduattstat', 'head', 'indivfacid']),
+            'attributes': set(['individ', 'hhid', 'gender', 'age', 'eduattstat', 'head', 'indivfacid'])},
         'intensity': {
             'render_order': 0,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of intensity measurements',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['geometry','im']),
-            'cols': set(['geometry','im'])},
+            'attributes_required': set(['geometry','im']),
+            'attributes': set(['geometry','im'])},
         'fragility': {
             'render_order': 0,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of records in fragility configuration',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4']),
-            'cols': set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4'])},
+            'attributes_required': set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4']),
+            'attributes': set(['expstr','muds1_g','muds2_g','muds3_g','muds4_g','sigmads1','sigmads2','sigmads3','sigmads4'])},
         'vulnerability': {
             'render_order': 0,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of records in vulnerabilty configuration',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6']),
-            'cols': set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6'])},
+            'attributes_required': set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6']),
+            'attributes': set(['expstr', 'hw0', 'hw0_5', 'hw1', 'hw1_5', 'hw2', 'hw3', 'hw4', 'hw5','hw6'])},
+        'gem_vulnerability': {
+            'render_order': 0,
+            'data': solara.reactive(None),
+            'map_info_tooltip': 'Number of functions in gem vulnerabilty',
+            'map_layer': solara.reactive(None),
+            'force_render': solara.reactive(False),
+            'visible': solara.reactive(False),
+            'extra_cols': {},
+            'attributes_required': set(['id', 'assetCategory', 'lossCategory', 'description', 'vulnerabilityFunctions']),
+            'attributes': set(['id', 'assetCategory', 'lossCategory', 'description', 'vulnerabilityFunctions']),
+        },
         'power nodes': {
             'render_order': 90,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of electrical power nodes',
             '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_required': set(['geometry', 'node_id', 'pwr_plant', 'n_bldgs', 'eq_vuln']),
-            'cols': set(['geometry', 'fltytype', 'strctype', 'utilfcltyc', 'indpnode', 'guid', 
+            'attributes_required': set(['geometry', 'node_id', 'pwr_plant', 'n_bldgs', 'eq_vuln']),
+            'attributes': set(['geometry', 'fltytype', 'strctype', 'utilfcltyc', 'indpnode', 'guid', 
                          'node_id', 'x_coord', 'y_coord', 'pwr_plant', 'serv_area', 'n_bldgs', 
                          'income', 'eq_vuln'])},
         'power edges': {
             'render_order': 80,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of connections in power grid',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['geometry','from_node','to_node', 'edge_id']),
-            'cols': set(['from_node', 'direction', 'pipetype', 'edge_id', 'guid', 'capacity', 
+            'attributes_required': set(['geometry','from_node','to_node', 'edge_id']),
+            'attributes': set(['from_node', 'direction', 'pipetype', 'edge_id', 'guid', 'capacity', 
                          'geometry', 'to_node', 'length'])},
         'power fragility': {
             'render_order': 0,
-            'df': solara.reactive(None),
+            'data': solara.reactive(None),
             'map_info_tooltip': 'Number of records in fragility configuration for power',
             'map_layer': solara.reactive(None),
             'force_render': solara.reactive(False),
             'visible': solara.reactive(False),
             'extra_cols': {},
-            'cols_required': set(['vuln_string', 'med_slight', 'med_moderate', 'med_extensive', 'med_complete', 
+            'attributes_required': set(['vuln_string', 'med_slight', 'med_moderate', 'med_extensive', 'med_complete', 
                          'beta_slight', 'beta_moderate', 'beta_extensive', 'beta_complete']),
-            'cols': set(['vuln_string', 'med_slight', 'med_moderate', 'med_extensive', 'med_complete', 
+            'attributes': 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)),
@@ -350,6 +362,138 @@ def read_tiff(file_bytes):
     return gdf[gdf['im'] > 0]
     #return gdf.sort_values(by='im',ascending=False).head(10000)
 
+
+def read_gem_xml(data: [bytes]):
+    content_as_string = data.decode('utf-8')
+    content_as_string = content_as_string.replace('\n','')
+    dom = xml.dom.minidom.parseString(content_as_string)
+
+    def getText(node):
+        nodelist = node.childNodes
+        rc = []
+        for node in nodelist:
+            if node.nodeType == node.TEXT_NODE:
+                rc.append(node.data)
+        return ''.join(rc)
+
+    d = dict()
+    node = dom.getElementsByTagName('vulnerabilityModel')[0]
+    for i in range(node.attributes.length):
+        d[node.attributes.item(i).name] = node.attributes.item(i).value 
+
+    d['description'] = getText(dom.getElementsByTagName('description')[0])
+
+
+    d['vulnerabilityFunctions'] = []
+    for node in dom.getElementsByTagName('vulnerabilityFunction'):
+        v = dict()
+        for i in range(node.attributes.length):
+            v[node.attributes.item(i).name] = node.attributes.item(i).value 
+        imls = node.getElementsByTagName('imls')[0]
+        v['imt'] = imls.getAttribute('imt')
+        v['imls'] = np.fromstring(getText(imls),dtype=float, sep=' ')
+        v['meanLRs'] = np.fromstring(getText(node.getElementsByTagName('meanLRs')[0]),dtype=float, sep=' ')
+        v['covLRs'] = np.fromstring(getText(node.getElementsByTagName('covLRs')[0]),dtype=float, sep=' ')
+        d['vulnerabilityFunctions'].append(v)
+
+    return d
+
+
+@solara.component
+def VulnerabilityFunctionDisplayer(vuln_func):
+    vuln_func, _ = solara.use_state_or_update(vuln_func)
+
+    x = vuln_func['imls']
+    y = vuln_func['meanLRs']
+    s = vuln_func['covLRs']
+    xlabel = vuln_func['imt']
+   
+    options = { 
+        'title': {
+            'text': vuln_func['id'],
+            'left': 'center'},
+        'tooltip': {
+            'trigger': 'axis',
+            'axisPointer': {
+                'type': 'cross'
+            }
+        },
+        #'legend': {'data': ['Covariance','Mean']},
+        'xAxis': {
+            'axisTick': {
+                'alignWithLabel': True
+            },
+            'data': list(x),
+            'name': xlabel,
+            'nameLocation': 'middle',
+            'nameTextStyle': {'verticalAlign': 'top','padding': [10, 0, 0, 0]}
+        },
+        'yAxis': [
+            {
+                'type': 'value',
+                'name': "Covariance",
+                'position': 'left',
+                'alignTicks': True,
+                'axisLine': {
+                    'show': True,
+                    'lineStyle': {'color': 'green'}}
+            },
+            {
+                'type': 'value',
+                'name': "Mean",
+                'position': 'right',
+                'alignTicks': True,
+                'axisLine': {
+                    'show': True,
+                    'lineStyle': {'color': 'blue'}}
+            },
+
+        ],
+        'series': [
+            {
+            'name': 'Mean',
+            'data': list(y),
+            'type': 'line',
+            'yAxisIndex': 1
+            },
+            {
+            'name': 'Covariance',
+            'data': list(s),
+            'type': 'line',
+            'yAxisIndex': 0
+            },
+        ],
+    }
+    solara.FigureEcharts(option=options) 
+
+@solara.component
+def VulnerabiliyDisplayer(vuln_xml: dict):
+    vuln_xml, set_vuln_xml = solara.use_state_or_update(vuln_xml)
+
+    func_labels = [f'{v["imt"]}---{v["id"]}' for v in vuln_xml['vulnerabilityFunctions']]
+    func_label, set_func_label  = solara.use_state_or_update(func_labels[0])
+
+    with solara.GridFixed(columns=2):
+        with solara.Column(gap="1px"):
+            solara.Text('Description:',style={'fontWeight': 'bold'})
+            with solara.Row(justify="left"):
+                solara.Text(f'{vuln_xml["description"]}')   
+            with solara.GridFixed(columns=2,row_gap="1px"):
+                solara.Text('Asset Category:',style={'fontWeight': 'bold'})
+                with solara.Row(justify="right"):
+                    solara.Text(f'{vuln_xml["assetCategory"]}')
+                solara.Text('Loss Category:',style={'fontWeight': 'bold'})
+                with solara.Row(justify="right"):
+                    solara.Text(f'{vuln_xml["lossCategory"]}')
+                solara.Text('# of vulnerability functions:',style={'fontWeight': 'bold'})
+                with solara.Row(justify="right"):
+                    solara.Text(f'{len(vuln_xml["vulnerabilityFunctions"])}')      
+            solara.Text('Select vulnerability function:',style={'fontWeight': 'bold'})
+            solara.Select(label='',value=func_label, values=func_labels,
+                        on_value=set_func_label)
+        with solara.Column():
+            VulnerabilityFunctionDisplayer(vuln_xml['vulnerabilityFunctions'][func_labels.index(func_label)])
+
 @solara.component
 def MetricWidget(name, description, value, max_value, render_count):
     value, set_value = solara.use_state_or_update(value)
@@ -386,42 +530,51 @@ def MetricWidget(name, description, value, max_value, render_count):
 
 
 def import_data(fileinfo: solara.components.file_drop.FileInfo):
-    data = fileinfo['data']
+    data_array = fileinfo['data']
     extension = fileinfo['name'].split('.')[-1]
     if extension == 'xlsx':
-        df = pd.read_excel(data)
+        data = pd.read_excel(data_array)
     elif extension in ['tiff','tif']:
-        df = read_tiff(data) 
+        data = read_tiff(data_array)
+    elif extension.lower() in ['xml']:
+        data = read_gem_xml(data_array)
     else:
-        json_string = data.decode('utf-8')
+        json_string = data_array.decode('utf-8')
         json_data = json.loads(json_string)
         if "features" in json_data.keys():
-            df = gpd.GeoDataFrame.from_features(json_data['features'])
+            data = gpd.GeoDataFrame.from_features(json_data['features'])
         else:
-            df = pd.read_json(json_string)
+            data = pd.read_json(json_string)
+
+    if isinstance(data, gpd.GeoDataFrame) or isinstance(data, pd.DataFrame):
+        data.columns = data.columns.str.lower()
+        attributes = set(data.columns)
+    elif isinstance(data, dict):
+        attributes = set(data.keys())
+    else:
+        return (None, None)
 
-    df.columns = df.columns.str.lower()
 
     # in the first pass, look for exact column match
     name = None
     for layer_name, layer in layers.value['layers'].items():
-        if layer['cols'] == set(df.columns):
+        if layer['attributes'] == attributes:
             name = layer_name
             break
     # if not, check only the required columns
     if name is None:
         for layer_name, layer in layers.value['layers'].items():
-            if layer['cols_required'].issubset(set(df.columns)):
+            if layer['attributes_required'].issubset(attributes):
                 name = layer_name
-                logging.debug('There are extra columns', set(df.columns) - layer['cols_required'])
+                logging.debug('There are extra columns', attributes - layer['attributes_required'])
                 break
     
 
     # Inject columns
-    if name is not None:
+    if name is not None and (isinstance(data, gpd.GeoDataFrame) or isinstance(data, pd.DataFrame)):
         for col, val in layers.value['layers'][name]['extra_cols'].items():
-            df[col] = val
-    return (name, df)
+            data[col] = val
+    return (name, data)
 
 
 @solara.component
@@ -433,15 +586,21 @@ def FileDropZone():
     def load():
         if fileinfo is not None:
             print('processing file')
-            name, df = import_data(fileinfo)
-            if name is not None and df is not None:
-                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)
+            name, data = import_data(fileinfo)
+            if name is not None and data is not None:
+                if isinstance(data, gpd.GeoDataFrame) or isinstance(data, pd.DataFrame):
+                    layers.value['layers'][name]['data'].set(data)
+                    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(data.columns):
+                        center = (data.geometry.centroid.y.mean(), data.geometry.centroid.x.mean())
+                        layers.value['center'].set(center)
+                elif isinstance(data, dict):
+                    layers.value['layers'][name]['data'].set(data)
+                    layers.value['selected_layer'].set(name)
+                    layers.value['layers'][name]['visible'].set(True)
+                    layers.value['layers'][name]['force_render'].set(True)
             else:
                 return False
         return True
@@ -480,7 +639,7 @@ def FileDropZone():
 @solara.component
 def LayerDisplayer():
     print(f'{layers.value["bounds"].value}')
-    nonempty_layers = {name: layer for name, layer in layers.value['layers'].items() if layer['df'].value is not None}
+    nonempty_layers = {name: layer for name, layer in layers.value['layers'].items() if layer['data'].value is not None}
     nonempty_layer_names = list(nonempty_layers.keys())
     selected = layers.value['selected_layer'].value
     def set_selected(s):
@@ -491,22 +650,24 @@ def LayerDisplayer():
     if selected is None and len(nonempty_layer_names) > 0:
         set_selected(nonempty_layer_names[0])
     if selected is not None:
-        df = nonempty_layers[selected]['df'].value
-        if "geometry" in df.columns:
-            ((ymin,xmin),(ymax,xmax)) = layers.value['bounds'].value
-            df_filtered = df.cx[xmin:xmax,ymin:ymax].drop(columns='geometry')
-            solara.DataFrame(df_filtered)
-        else:
-            solara.DataFrame(df)
-        if selected == "building":
-            file_object = df.to_json()
-            with solara.FileDownload(file_object, "building_export.geojson", mime_type="application/geo+json"):
-                solara.Button("Download GeoJSON", icon_name="mdi-cloud-download-outline", color="primary")
-
+        data = nonempty_layers[selected]['data'].value
+        if isinstance(data, gpd.GeoDataFrame) or isinstance(data, pd.DataFrame):
+            if "geometry" in data.columns:
+                ((ymin,xmin),(ymax,xmax)) = layers.value['bounds'].value
+                df_filtered = data.cx[xmin:xmax,ymin:ymax].drop(columns='geometry')
+                solara.DataFrame(df_filtered)
+            else:
+                solara.DataFrame(data)
+            if selected == "building":
+                file_object = data.to_json()
+                with solara.FileDownload(file_object, "building_export.geojson", mime_type="application/geo+json"):
+                    solara.Button("Download GeoJSON", icon_name="mdi-cloud-download-outline", color="primary")
+        if selected == 'gem_vulnerability':
+            VulnerabiliyDisplayer(data)
 
 @solara.component
 def MetricPanel():
-    building = layers.value['layers']['building']['df'].value
+    building = layers.value['layers']['building']['data'].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
@@ -547,14 +708,13 @@ def MapViewer():
 
     render_order = [l['render_order'] for _, l in layers.value['layers'].items()]
     for _, (layer_name, layer) in sorted(zip(render_order,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(df, layer_name)
-            if map_layer is not None:
-                map_layers.append(map_layer)
+        df = layer['data'].value
+        if isinstance(df, gpd.GeoDataFrame):
+            # we have something to display on map
+            if  "geometry" in list(df.columns) and layer['visible'].value:
+                map_layer = create_map_layer(df, layer_name)
+                if map_layer is not None:
+                    map_layers.append(map_layer)
 
      
     ipyleaflet.Map.element(
@@ -587,7 +747,7 @@ def ExecutePanel():
         execute_error.set("")
 
     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])
+        existing_layers = set([name for name, l in layers.value['layers'].items() if l['data'].value is not None])
         missing = []
 
         if hazard == "earthquake":
@@ -611,10 +771,10 @@ def ExecutePanel():
 
 
         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
+            nodes = layers.value['layers']['power nodes']['data'].value
+            edges = layers.value['layers']['power edges']['data'].value
+            intensity = layers.value['layers']['intensity']['data'].value
+            power_fragility = layers.value['layers']['power fragility']['data'].value
 
 
             eq_ds, is_damaged, is_operational = compute_power_infra(nodes, 
@@ -629,14 +789,14 @@ def ExecutePanel():
             return nodes
 
         def execute_building():
-            landuse = layers.value['layers']['landuse']['df'].value
-            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
+            landuse = layers.value['layers']['landuse']['data'].value
+            buildings = layers.value['layers']['building']['data'].value
+            household = layers.value['layers']['household']['data'].value
+            individual = layers.value['layers']['individual']['data'].value
+            intensity = layers.value['layers']['intensity']['data'].value
 
-            fragility = layers.value['layers']['fragility']['df'].value
-            vulnerability = layers.value['layers']['vulnerability']['df'].value
+            fragility = layers.value['layers']['fragility']['data'].value
+            vulnerability = layers.value['layers']['vulnerability']['data'].value
 
             policies = [p['id'] for id, p in layers.value['policies'].items() if p['applied'].value]
 
@@ -676,10 +836,10 @@ def ExecutePanel():
             
             if 'power' in infra:
                 nodes = execute_infra()
-                layers.value['layers']['power nodes']['df'].set(nodes)
+                layers.value['layers']['power nodes']['data'].set(nodes)
             if 'building' in infra:
                 buildings = execute_building()
-                layers.value['layers']['building']['df'].set(buildings)
+                layers.value['layers']['building']['data'].set(buildings)
 
             # trigger render event
             layers.value['render_count'].set(layers.value['render_count'].value + 1)
@@ -751,13 +911,17 @@ def MapInfo():
     if layers.value['map_info_button'].value == "summary":
         with solara.GridFixed(columns=2,row_gap="1px"):
             for layer_name,layer in layers.value['layers'].items():
+                data = layer['data'].value
                 with solara.Tooltip(layer['map_info_tooltip']):
                     solara.Text(f'{layer_name}')
                 with solara.Row(justify="right"):
-                    if layer['df'].value is None:
+                    if data is None:
                         solara.Text('0')
                     else:
-                        solara.Text(f"{len(layer['df'].value)}")
+                        if isinstance(data, gpd.GeoDataFrame) or isinstance(data, pd.DataFrame):
+                            solara.Text(f"{len(data)}")
+                        elif isinstance(data, dict) and layer_name == 'gem_vulnerability':
+                            solara.Text(f"{len(data['vulnerabilityFunctions'])}")
     else:
         with solara.GridFixed(columns=2,row_gap="1px"):
             for key, value in layers.value['map_info_detail'].value.items():