Create Local Hazards#

This tutorial provides examples of how to create local hazards for tornadoes, earthquakes, tsunamis, floods, and hurricanes, respectively.

import os
import json
from pyincore import Hurricane, Flood, Earthquake, Tornado
from pyincore.models.hazard.tsunami import Tsunami

You will need to indicate the local data path initially.

dir = "files"

Create Tornadoes#

Inputs: JSON representation of a dataset describing a tornado. Each available dataset in Shapefile format.

with open(os.path.join(dir, "tornado_dataset.json"), 'r') as file:
    tornado_dataset_json = file.read()
    print(json.dumps(json.loads(tornado_dataset_json), indent=4))

{
    "name": "pytest - Joplin Tornado",
    "description": "Joplin tornado hazard",
    "tornadoType": "dataset",
    "threshold": null,
    "thresholdUnit": "mph",
    "hazardDatasets": [
        {
            "demandType": "wind",
            "demandUnits": "mph",
            "threshold": null
        }
    ]
}

# create the tornado object
tornado = Tornado.from_json_file(os.path.join(dir, "tornado_dataset.json"))

# attach dataset from local file
tornado.hazardDatasets[0].from_file((os.path.join(dir, "joplin_tornado/joplin_path_wgs84.shp")), 
                                    data_type="incore:tornadoWindfield")

payload = [
    {
        "demands": ["wind"],
        "units": ["mph"],
        "loc": "37.04, -94.37"
    }
]

values = tornado.read_hazard_values(payload, seed=1234) # removing the seed will give random values
print(values)

[{'demands': ['wind'], 'units': ['mph'], 'loc': '37.04, -94.37', 'hazardValues': [102.62435891472981]}]

Create Earthquakes#

Inputs: JSON representation of a dataset describing an earthquake. Each available dataset in TIF format.

with open(os.path.join(dir, "eq-dataset.json"), 'r') as file:
    earthquake_dataset_json = file.read()
    print(json.dumps(json.loads(earthquake_dataset_json), indent=4))

{
    "name": "pytest - Memphis Deterministic EQ",
    "description": "Memphis dataset based deterministic hazard - Pytest",
    "eqType": "dataset",
    "hazardDatasets": [
        {
            "hazardType": "deterministic",
            "demandType": "SA",
            "demandUnits": "g",
            "period": "0.2",
            "eqParameters": {
                "srcLatitude": "35.927",
                "srcLongitude": "-89.919",
                "magnitude": "7.9",
                "depth": "10.0"
            }
        },
        {
            "hazardType": "deterministic",
            "demandType": "PGA",
            "demandUnits": "g",
            "period": "0.0",
            "eqParameters": {
                "srcLatitude": "35.927",
                "srcLongitude": "-89.919",
                "magnitude": "7.9",
                "depth": "10.0"
            }
        }
    ]
}

# create the earthquake object
eq = Earthquake.from_json_file(os.path.join(dir, "eq-dataset.json"))

# attach datasets from local files
eq.hazardDatasets[0].from_file((os.path.join(dir, "eq-dataset-SA.tif")),
                               data_type="ergo:probabilisticEarthquakeRaster")
eq.hazardDatasets[1].from_file((os.path.join(dir, "eq-dataset-PGA.tif")),
                               data_type="ergo:probabilisticEarthquakeRaster")

payload = [
    {
        "demands": ["PGA", "0.2 SA"],
        "units": ["g", "g"],
        "loc": "35.03,-89.93"
    }
]

values = eq.read_hazard_values(payload)
print(values)

[{'demands': ['PGA', '0.2 SA'], 'units': ['g', 'g'], 'loc': '35.03,-89.93', 'hazardValues': [0.3149999976158142, 0.4729999899864197]}]

Create Tsunamis#

Inputs: JSON representation of a dataset describing a tsunami. Each available dataset in TIF format.

with open(os.path.join(dir, "tsunami.json"), 'r') as file:
    tsunami_dataset_json = file.read()
    print(json.dumps(json.loads(tsunami_dataset_json), indent=4))

{
    "name": "pytest - Seaside Probabilistic Tsunami - 100 yr",
    "description": "pytest - Seaside dataset based probabilistic tsunami hazard. This is just a test!",
    "tsunamiType": "dataset",
    "hazardDatasets": [
        {
            "hazardType": "probabilistic",
            "demandType": "Vmax",
            "demandUnits": "m/s",
            "recurrenceInterval": "100",
            "recurrenceUnit": "years"
        },
        {
            "hazardType": "probabilistic",
            "demandType": "Mmax",
            "demandUnits": "m^3/s^2",
            "recurrenceInterval": "100",
            "recurrenceUnit": "years"
        },
        {
            "hazardType": "probabilistic",
            "demandType": "Hmax",
            "demandUnits": "m",
            "recurrenceInterval": "100",
            "recurrenceUnit": "years"
        }
    ]
}

# create the tsunami object
tsunami = Tsunami.from_json_file(os.path.join(dir, "tsunami.json"))

# attach datasets from local files
tsunami.hazardDatasets[0].from_file((os.path.join(dir, "Tsu_100yr_Vmax.tif")),
                                    data_type="ncsa:probabilisticTsunamiRaster")
tsunami.hazardDatasets[1].from_file((os.path.join(dir, "Tsu_100yr_Mmax.tif")),
                                    data_type="ncsa:probabilisticTsunamiRaster")
tsunami.hazardDatasets[2].from_file((os.path.join(dir, "Tsu_100yr_Hmax.tif")),
                                    data_type="ncsa:probabilisticTsunamiRaster")

payload = [
    {
        "demands": ["hmax"],
        "units": ["m"],
        "loc": "46.006,-123.935"
    }
]

values = tsunami.read_hazard_values(payload)
print(values)

[{'demands': ['hmax'], 'units': ['m'], 'loc': '46.006,-123.935', 'hazardValues': [2.9000000953674316]}]

Create Floods#

Inputs: JSON representation of a dataset describing a flood. Each available dataset in TIF format.

with open(os.path.join(dir, "flood-dataset.json"), 'r') as file:
    flood_dataset_json = file.read()
    print(json.dumps(json.loads(flood_dataset_json), indent=4))

{
    "name": "Lumberton Deterministic Flood - riverine flooding",
    "description": "Lumberton dataset based deterministic hazard - 2 datasets",
    "floodType": "dataset",
    "hazardDatasets": [
        {
            "hazardType": "deterministic",
            "demandType": "inundationDepth",
            "demandUnits": "ft",
            "floodParameters": {
                "model": "riverine flooding"
            }
        },
        {
            "hazardType": "deterministic",
            "demandType": "waterSurfaceElevation",
            "demandUnits": "ft",
            "floodParameters": {
                "model": "riverine flooding"
            }
        }
    ]
}

# create the flood object
flood = Flood.from_json_file(os.path.join(dir, "flood-dataset.json"))

# attach datasets from local files
flood.hazardDatasets[0].from_file((os.path.join(dir, "flood-inundationDepth-50ft.tif")),
                                  data_type="ncsa:probabilisticFloodRaster")
flood.hazardDatasets[1].from_file(os.path.join(dir, "flood-WSE-50ft.tif"),
                                  data_type="ncsa:probabilisticFloodRaster")

payload = [
    {
         "demands": ["waterSurfaceElevation"],
         "units": ["m"],
         "loc": "34.60,-79.16"
     }
 ]

values = flood.read_hazard_values(payload)
print(values)

[{'demands': ['waterSurfaceElevation'], 'units': ['m'], 'loc': '34.60,-79.16', 'hazardValues': [41.970442822265625]}]

Create Hurricanes#

Inputs: JSON representation of a dataset describing a hurricane. Each available dataset in TIF format.

with open(os.path.join(dir, "hurricane-dataset.json"), 'r') as file:
    hurricane_dataset_json = file.read()
    print(json.dumps(json.loads(hurricane_dataset_json), indent=4))

{
    "name": "pytest - Galveston Deterministic Hurricane - Kriging ",
    "description": "Galveston dataset based deterministic hazard - 3 datasets",
    "hurricaneType": "dataset",
    "hazardDatasets": [
        {
            "hazardType": "deterministic",
            "demandType": "waveHeight",
            "demandUnits": "m",
            "hurricaneParameters": {
                "model": "Kriging"
            }
        },
        {
            "hazardType": "deterministic",
            "demandType": "surgeLevel",
            "demandUnits": "m",
            "hurricaneParameters": {
                "model": "Kriging"
            }
        },
        {
            "hazardType": "deterministic",
            "demandType": "inundationDuration",
            "demandUnits": "hr",
            "hurricaneParameters": {
                "model": "Kriging"
            }
        }
    ]
}

# create the hurricane object
hurricane = Hurricane.from_json_file((os.path.join(dir, "hurricane-dataset.json")))

# attach datasets from local files
hurricane.hazardDatasets[0].from_file((os.path.join(dir, "Wave_Raster.tif")),
                                      data_type="ncsa:deterministicHurricaneRaster")
hurricane.hazardDatasets[1].from_file(os.path.join(dir, "Surge_Raster.tif"),
                                      data_type="ncsa:deterministicHurricaneRaster")
hurricane.hazardDatasets[2].from_file(os.path.join(dir, "Inundation_Raster.tif"),
                                      data_type="ncsa:deterministicHurricaneRaster")

payload = [
        {
            "demands": ["waveHeight", "surgeLevel"],
            "units": ["m", "m"],
            "loc": "29.22,-95.06"
        },
        {
            "demands": ["waveHeight", "surgeLevel"],
            "units": ["cm", "cm"],
            "loc": "29.23,-95.05"
        },
        {
            "demands": ["waveHeight", "inundationDuration"],
            "units": ["in", "hr"],
            "loc": "29.22,-95.06"
        }
    ]

values = hurricane.read_hazard_values(payload)
print(values)

[{'demands': ['waveHeight', 'surgeLevel'], 'units': ['m', 'm'], 'loc': '29.22,-95.06', 'hazardValues': [1.54217780024576, 3.663398872786693]}, {'demands': ['waveHeight', 'surgeLevel'], 'units': ['cm', 'cm'], 'loc': '29.23,-95.05', 'hazardValues': [162.9628933899723, 369.7690109274975]}, {'demands': ['waveHeight', 'inundationDuration'], 'units': ['in', 'hr'], 'loc': '29.22,-95.06', 'hazardValues': [60.7156942134556, 18.346923306935572]}]

IN-CORE Manual

Create Local Hazards

Contents