def run_with_base_class():
client = IncoreClient(INCORE_API_DEV_URL)
# Memphis Earthquake damage
# New madrid earthquake using Atkinson Boore 1995
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
# Building dataset
# 5a284f0bc7d30d13bc081a28 5kb
# 5bcf2fcbf242fe047ce79dad 300kb
# 5a284f37c7d30d13bc08219c 20mb
bldg_dataset_id = "5a284f0bc7d30d13bc081a28"
bldg_dmg = BuildingDamage(client)
bldg_dmg.load_remote_input_dataset("buildings", bldg_dataset_id)
# Earthquake mapping
mapping_id = "5b47b350337d4a3629076f2c"
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bldg_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
result_name = "memphis_eq_bldg_dmg_result"
bldg_dmg.set_parameter("result_name", result_name)
bldg_dmg.set_parameter("hazard_type", hazard_type)
bldg_dmg.set_parameter("hazard_id", hazard_id)
bldg_dmg.set_parameter("num_cpu", 4)
# Run Analysis
bldg_dmg.run_analysis()
# TSUNAMI
hazard_type = "tsunami"
hazard_id = "5bc9e25ef7b08533c7e610dc"
# Seaside building dataset
bldg_dataset_id = "5bcf2fcbf242fe047ce79dad"
# Run seaside tsunami building damage
bldg_dmg = BuildingDamage(client)
bldg_dmg.load_remote_input_dataset("buildings", bldg_dataset_id)
# Tsunami mapping
mapping_id = "5b48fb1f337d4a478e7bd54d"
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bldg_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
result_name = "seaside_tsunami_dmg_result"
bldg_dmg.set_parameter("result_name", result_name)
bldg_dmg.set_parameter("hazard_type", hazard_type)
bldg_dmg.set_parameter("hazard_id", hazard_id)
bldg_dmg.set_parameter("num_cpu", 4)
bldg_dmg.run_analysis()
def run_with_base_class():
client = IncoreClient(INCORE_API_DEV_URL)
hazard_type = "earthquake"
hazard_id = "5eebcbb08f80fe3899ad6039"
epf_dataset_id = "5eebcaa17a00803abc85ec11"
# Earthquake mapping
mapping_id = "5eebcc13e7226233ce4ef0d7"
# Run epf damage
epf_dmg = EpfDamage(client)
epf_dmg.load_remote_input_dataset("epfs", epf_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
epf_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
epf_dmg.set_parameter("result_name", "earthquake_epf_dmg_result")
epf_dmg.set_parameter("hazard_type", hazard_type)
epf_dmg.set_parameter("hazard_id", hazard_id)
epf_dmg.set_parameter("num_cpu", 1)
# Run Analysis
epf_dmg.run_analysis()
hazard_type = "tsunami"
hazard_id = "5bc9eaf7f7b08533c7e610e1"
epf_dataset_id = "5eebcaa17a00803abc85ec11"
# Tsunami mapping
mapping_id = "5eebce11e7226233ce4ef305"
# Run epf damage
epf_dmg = EpfDamage(client)
epf_dmg.load_remote_input_dataset("epfs", epf_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
epf_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
epf_dmg.set_parameter("fragility_key", "Non-Retrofit inundationDepth Fragility ID Code")
epf_dmg.set_parameter("result_name", "tsunami_epf_dmg_result")
epf_dmg.set_parameter("hazard_type", hazard_type)
epf_dmg.set_parameter("hazard_id", hazard_id)
epf_dmg.set_parameter("num_cpu", 1)
# Run Analysis
epf_dmg.run_analysis()
def test_road_failure():
client = IncoreClient(INCORE_API_DEV_URL, token_file_name=".incrtesttoken")
# road inventory for Galveston island
road_dataset_id = "5f0dd5ecb922f96f4e962caf"
# distance table for Galveston island
distance_dataset_id = "5f1883abfeef2d758c4e857d"
# road damage by hurricane inundation mapping
mapping_id = "5f0cb04fe392b24d4800f316"
# Galveston Deterministic Hurricane - Kriging inundationDuration
hazard_type = "hurricane"
hazard_id = "5f10837c01d3241d77729a4f"
# Create road damage
road_failure = RoadFailure(client)
# Load input datasets
road_failure.load_remote_input_dataset("roads", road_dataset_id)
road_failure.load_remote_input_dataset("distance_table",
distance_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
road_failure.set_input_dataset('dfr3_mapping_set', mapping_set)
# Specify the result name
result_name = "road_result"
# Set analysis parameters
road_failure.set_parameter("result_name", result_name)
road_failure.set_parameter("hazard_type", hazard_type)
road_failure.set_parameter("hazard_id", hazard_id)
road_failure.set_parameter("num_cpu", 4)
# Run road damage by hurricane inundation analysis
result = road_failure.run_analysis()
assert result is True
def run_with_base_class():
client = IncoreClient(INCORE_API_DEV_URL)
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
facility_datasetid = "5a284f2ac7d30d13bc081e52"
mapping_id = "5b47c3b1337d4a387e85564b" # Hazus Potable Water Facility Fragility Mapping - Only PGA
liq_geology_dataset_id = "5a284f53c7d30d13bc08249c"
uncertainty = False
liquefaction = False
liq_fragility_key = "pgd"
wf_dmg = WaterFacilityDamage(client)
wf_dmg.load_remote_input_dataset("water_facilities", facility_datasetid)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
wf_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
result_name = "wf-dmg-results.csv"
wf_dmg.set_parameter("result_name", result_name)
wf_dmg.set_parameter("hazard_type", hazard_type)
wf_dmg.set_parameter("hazard_id", hazard_id)
wf_dmg.set_parameter("fragility_key", "pga")
wf_dmg.set_parameter("use_liquefaction", liquefaction)
wf_dmg.set_parameter("liquefaction_geology_dataset_id",
liq_geology_dataset_id)
wf_dmg.set_parameter("liquefaction_fragility_key", liq_fragility_key)
wf_dmg.set_parameter("use_hazard_uncertainty", uncertainty)
wf_dmg.set_parameter("num_cpu", 4)
wf_dmg.run_analysis()
def test_pipeline_dmg():
client = IncoreClient(service_url=INCORE_API_DEV_URL, token_file_name=".incrtesttoken")
pipeline_dmg = PipelineDamage(client)
# test tsunami pipeline
pipeline_dmg.load_remote_input_dataset("pipeline",
"5ef1171b2367ff111d082f0c")
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping("5ef11888da15730b13b84353"))
pipeline_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
pipeline_dmg.set_parameter("result_name",
"seaside_tsunami_pipeline_result")
pipeline_dmg.set_parameter("hazard_type", "tsunami")
pipeline_dmg.set_parameter("fragility_key",
"Non-Retrofit inundationDepth Fragility ID Code")
pipeline_dmg.set_parameter("hazard_id", "5bc9eaf7f7b08533c7e610e1")
pipeline_dmg.set_parameter("num_cpu", 4)
# Run pipeline damage analysis
result = pipeline_dmg.run_analysis()
assert result is True
def pytest_sessionstart(session):
"""
Called after the Session object has been created and
before performing collection and entering the run test loop.
"""
try:
with open(
os.path.join(os.path.dirname(__file__), "pyincore/.incorepw"),
'r') as f:
cred = f.read().splitlines()
except EnvironmentError:
assert False
credentials = jwt.decode(cred[0], cred[1])
monkeypatch = MonkeyPatch()
monkeypatch.setattr("builtins.input", lambda x: credentials["username"])
monkeypatch.setattr("getpass.getpass", lambda y: credentials["password"])
client = IncoreClient(service_url=pyglobals.INCORE_API_DEV_URL,
token_file_name=".incrtesttoken")
pytest.client = client
pytest.datasvc = DataService(client)
pytest.fragilitysvc = FragilityService(client)
pytest.repairsvc = RepairService(client)
pytest.restorationsvc = RestorationService(client)
pytest.hazardsvc = HazardService(client)
pytest.spacesvc = SpaceService(client)
print(
f"Successfully initialized Incore client and services. Using {pyglobals.INCORE_API_DEV_URL}"
)
def run_with_base_class():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
pipeline_dmg = PipelineDamage(client)
# test tsunami pipeline
pipeline_dmg.load_remote_input_dataset("pipeline",
"5ef1171b2367ff111d082f0c")
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(
fragility_service.get_mapping(
"60b124e01f2b7d4a916ba456")) # new format fragility curves
# mapping_set = MappingSet(fragility_service.get_mapping("5ef11888da15730b13b84353")) # legacy fragility curves
pipeline_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
pipeline_dmg.set_parameter("result_name",
"seaside_tsunami_pipeline_result")
pipeline_dmg.set_parameter("hazard_type", "tsunami")
pipeline_dmg.set_parameter(
"fragility_key", "Non-Retrofit inundationDepth Fragility ID Code")
pipeline_dmg.set_parameter("hazard_id", "5bc9eaf7f7b08533c7e610e1")
pipeline_dmg.set_parameter("num_cpu", 4)
# Run pipeline damage analysis
result = pipeline_dmg.run_analysis()
def run_with_base_class():
client = IncoreClient(INCORE_API_DEV_URL)
# EQ Road Dataset - Seaside roads
road_dataset_id = "5ee7af50772cf80008577ae3"
hazard_type = "tsunami"
liq_geology_dataset_id = None
if hazard_type == 'earthquake':
# Seaside Earthquake
hazard_id = "5ba8f379ec2309043520906f"
# Earthquake mapping
mapping_id = "5ee7b145c54361000148dcc5"
fragility_key = "pgd"
liquefaction = False
elif hazard_type == 'tsunami':
# Seaside Tsunami
hazard_id = "5bc9eaf7f7b08533c7e610e1"
# Tsunami Mapping for Seaside
mapping_id = "5ee7b2c9c54361000148de37"
fragility_key = "Non-Retrofit inundationDepth Fragility ID Code"
liquefaction = False
else:
raise ValueError(
"Earthquake and tsunami are the only testable hazards with road damage currently"
)
uncertainty = False
# Run Seaside earthquake road damage
road_dmg = RoadDamage(client)
road_dmg.load_remote_input_dataset("roads", road_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
road_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
road_dmg.set_parameter("result_name", "seaside_road_dmg_" + hazard_type)
road_dmg.set_parameter("hazard_type", hazard_type)
road_dmg.set_parameter("hazard_id", hazard_id)
if fragility_key is not None:
road_dmg.set_parameter("fragility_key", fragility_key)
road_dmg.set_parameter("num_cpu", 1)
road_dmg.set_parameter("use_liquefaction", liquefaction)
if liquefaction and liq_geology_dataset_id is not None:
road_dmg.set_parameter("liquefaction_geology_dataset_id",
liq_geology_dataset_id)
road_dmg.set_parameter("use_hazard_uncertainty", uncertainty)
# Run Analysis
road_dmg.run_analysis()
def run_with_base_class():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
# Joplin tornado building damage
bldg_dataset_id = "5df7d0de425e0b00092d0082" # joplin building v6
bldg_dmg = BuildingDamage(client)
bldg_dmg.load_remote_input_dataset("buildings", bldg_dataset_id)
mapping_id = "5e8e3a21eaa8b80001f04f1c" # 19 archetype, non-retrofit
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bldg_dmg.set_input_dataset("dfr3_mapping_set", mapping_set)
bldg_dmg.set_parameter("fragility_key", "Non-Retrofit Fragility ID Code")
# The simulated EF-5 tornado shows geographical locations and the range of wind speed
# of tornado hazard in Joplin.
hazard_type = "tornado"
hazard_id = "5dfa32bbc0601200080893fb"
result_name = "joplin_tornado_dmg_result"
bldg_dmg.set_parameter("result_name", result_name)
bldg_dmg.set_parameter("hazard_type", hazard_type)
bldg_dmg.set_parameter("hazard_id", hazard_id)
bldg_dmg.set_parameter("num_cpu", 4)
bldg_dmg.set_parameter("seed", 1000)
bldg_dmg.run_analysis()
# end of Building damage analysis
# get csv results from Building damage analysis
building_dmg_result = bldg_dmg.get_output_dataset("ds_result")
building_dmg_result.get_dataframe_from_csv()
restoration = JoplinEmpiricalRestoration(client)
# Building final target level dataset defining custom final restoration values
building_fl_id = "61a68979d5b02930aa43ae39"
restoration.load_remote_input_dataset("buildings", bldg_dataset_id)
# restoration.load_remote_input_dataset("building_dmg", building_dmg_result)
restoration.set_input_dataset("building_dmg", building_dmg_result)
restoration.load_remote_input_dataset("building_functionality_level", building_fl_id)
result_name = "Joplin_empirical_restoration_result"
restoration.set_parameter("result_name", result_name)
restoration.set_parameter("target_functionality_level", 0)
# restoration.set_parameter("seed", 1234)
# Run Analysis
restoration.run_analysis()
def run_with_base_class():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
# Memphis 7.9 AB-95
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
# Shelby County Essential Facilities
building_dataset_id = "5a284f42c7d30d13bc0821ba"
# Default Building Fragility Mapping v1.0
mapping_id = "5b47b350337d4a3629076f2c"
non_structural_building_dmg = NonStructBuildingDamage(client)
# Load input datasets
non_structural_building_dmg.load_remote_input_dataset(
"buildings", building_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
non_structural_building_dmg.set_input_dataset('dfr3_mapping_set',
mapping_set)
# Specify the result name
result_name = "non_structural_building_dmg_result"
# Set analysis parameters
non_structural_building_dmg.set_parameter("result_name", result_name)
non_structural_building_dmg.set_parameter("hazard_type", hazard_type)
non_structural_building_dmg.set_parameter("hazard_id", hazard_id)
non_structural_building_dmg.set_parameter("num_cpu", 4)
# use liquefaction (slow)
# Shelby County Liquefaction Susceptibility
use_liquefaction = True
liq_geology_dataset_id = "5a284f55c7d30d13bc0824ba"
non_structural_building_dmg.set_parameter("use_liquefaction",
use_liquefaction)
non_structural_building_dmg.set_parameter("liq_geology_dataset_id",
liq_geology_dataset_id)
# Run analysis
non_structural_building_dmg.run_analysis()
def test_pipeline_dmg_w_repair_rate():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
# This is the Memphis Water Buried Pipeline with Topology dataset the Ergo repository
pipeline_dataset_id = "5a284f28c7d30d13bc081d14"
# pipeline mapping
mapping_id = "5b47c227337d4a38464efea8"
# New madrid earthquake using Atkinson Boore 1995
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
# Geology dataset
liq_geology_dataset_id = "5a284f53c7d30d13bc08249c"
# Create pipeline damage
test_pipeline_dmg_w_rr = PipelineDamageRepairRate(client)
# Load input datasets
test_pipeline_dmg_w_rr.load_remote_input_dataset("pipeline",
pipeline_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
test_pipeline_dmg_w_rr.set_input_dataset('dfr3_mapping_set', mapping_set)
# Specify the result name
result_name = "pipeline_result"
# Set analysis parameters
test_pipeline_dmg_w_rr.set_parameter("result_name", result_name)
test_pipeline_dmg_w_rr.set_parameter("hazard_type", hazard_type)
test_pipeline_dmg_w_rr.set_parameter("hazard_id", hazard_id)
test_pipeline_dmg_w_rr.set_parameter("liquefaction_fragility_key", "pgd")
# test_pipeline_dmg_w_rr.set_parameter("use_liquefaction", False)
test_pipeline_dmg_w_rr.set_parameter(
"use_liquefaction", True) # toggle on and off to see liquefaction
test_pipeline_dmg_w_rr.set_parameter("num_cpu", 4)
test_pipeline_dmg_w_rr.set_parameter("liquefaction_geology_dataset_id",
liq_geology_dataset_id)
# Run pipeline damage analysis
result = test_pipeline_dmg_w_rr.run_analysis()
assert result is True
def __init__(self, incore_client):
# Create Hazard and Fragility service
self.hazardsvc = HazardService(incore_client)
self.fragilitysvc = FragilityService(incore_client)
super(WaterFacilityDamage, self).__init__(incore_client)
def __init__(self, incore_client):
self.hazardsvc = HazardService(incore_client)
self.fragilitysvc = FragilityService(incore_client)
super(RoadDamage, self).__init__(incore_client)
def run_with_base_class(chained):
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
if chained:
# *************************************************************
# Set up and run Building damage, Galveston, TX analysis
# *************************************************************
hazard_type = "hurricane"
# Galveston deterministic Hurricane, 3 datasets - Kriging
# hazard_id = "5fa5a228b6429615aeea4410" # prod
hazard_id = "5fa472033c1f0c73fe81461a"
# Galveston, TX Building inventory
# bldg_inv_id = "60354b6c123b4036e6837ef7" # prod 19k buildings with age_group
bldg_inv_id = "602eba8bb1db9c28aef01358"
# Hurricane building mapping (with equation)
mapping_id = "602c381a1d85547cdc9f0675" # dev & prod
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bldg_dmg = BuildingDamage(client)
bldg_dmg.load_remote_input_dataset("buildings", bldg_inv_id)
bldg_dmg.set_input_dataset("dfr3_mapping_set", mapping_set)
result_name = "Galveston_bldg_dmg_result"
bldg_dmg.set_parameter("fragility_key", "Hurricane SurgeLevel and WaveHeight Fragility ID Code")
bldg_dmg.set_parameter("result_name", result_name)
bldg_dmg.set_parameter("hazard_type", hazard_type)
bldg_dmg.set_parameter("hazard_id", hazard_id)
bldg_dmg.set_parameter("num_cpu", 4)
# Run Building damage
bldg_dmg.run_analysis()
# Retrieve result dataset
building_dmg_result = bldg_dmg.get_output_dataset("ds_result")
# Convert dataset to Pandas DataFrame
# bdmg_df = building_dmg_result.get_dataframe_from_csv(low_memory=False)
# print(bdmg_df[["guid", "DS_0", "DS_1", "DS_2", "DS_3", "haz_expose"]])
# *************************************************************
# Set up and run Housing Unit Allocation (HUA) analysis
# *************************************************************
# Housing unit inventory
# housing_unit_inv = "5fc6ab1cd2066956f49e7a03" # prod
housing_unit_inv = "5fc6a757eba0eb743dc7739f"
# Address point inventory
# address_point_inv = "5fc6aadcc38a0722f563392e"
address_point_inv = "5fc6a4ddeba0eb743dc77301"
# Create housing allocation
hua = HousingUnitAllocation(client)
# Load input dataset
hua.load_remote_input_dataset("housing_unit_inventory", housing_unit_inv)
hua.load_remote_input_dataset("address_point_inventory", address_point_inv)
hua.load_remote_input_dataset("buildings", bldg_inv_id)
# Specify the result name
result_name = "Galveston_HUA"
seed = 1238
iterations = 1
# Set analysis parameters
hua.set_parameter("result_name", result_name)
hua.set_parameter("seed", seed)
hua.set_parameter("iterations", iterations)
# Run Housing unit allocation analysis
hua.run_analysis()
# Retrieve result dataset
hua_result = hua.get_output_dataset("result")
# Convert dataset to Pandas DataFrame
# hua_df = hua_result.get_dataframe_from_csv(low_memory=False)
# Display top 5 rows of output data
# print(hua_df[["guid", "numprec", "incomegroup"]].head())
# *************************************************************
# Set up and run Population Dislocation analysis
# *************************************************************
# Block group data, IN-CORE_BGMAP_2021-01-19_GalvestonTX
# bg_data = "603545f2dcda03378087e708" # prod
bg_data = "6035445b1e456929c86094c8"
# Value loss parameters DS 0-3
# value_loss = "60354810e379f22e16560dbd"
value_loss = "613901d9ca423a005e422feb"
pop_dis = PopulationDislocation(client)
pop_dis.load_remote_input_dataset("block_group_data", bg_data)
pop_dis.load_remote_input_dataset("value_loss_param", value_loss)
pop_dis.set_input_dataset("building_dmg", building_dmg_result)
pop_dis.set_input_dataset("housing_unit_allocation", hua_result)
result_name = "galveston-pop-disl-results"
seed = 1111
pop_dis.set_parameter("result_name", result_name)
pop_dis.set_parameter("seed", seed)
pop_dis.run_analysis()
# Retrieve result dataset
pd_result = pop_dis.get_output_dataset("result")
# Convert dataset to Pandas DataFrame
# pd_df = pd_result.get_dataframe_from_csv(low_memory=False)
# Display top 5 rows of output data
# print(pd_df[["guid", "dislocated"]].head())
# *************************************************************
# Set up and run Housing Recovery analysis
# *************************************************************
# Additional inventory data (assessed damage, square area)
bldg_sqft_id = "62193c19a42a3e546ae2d9f8"
# Census block groups data (required)
census_bg_id = "62193b7ca42a3e546ae2d9f2"
# Census appraisal file; id of external Census json
census_appr_id = "6241fbd153302c512d685181" # dev
result_name = "Galveston_building_values_chained"
housing_rec = HousingRecovery(client)
housing_rec.set_input_dataset("population_dislocation", pd_result)
housing_rec.load_remote_input_dataset("building_area", bldg_sqft_id)
housing_rec.load_remote_input_dataset("census_block_groups_data", census_bg_id)
# Census appraisal data
housing_rec.load_remote_input_dataset("census_appraisal_data", census_appr_id)
housing_rec.set_parameter("result_name", result_name)
housing_rec.run_analysis()
else:
# Run Housing Recovery analysis without chaining
# Additional inventory data (assessed damage, square area)
bldg_add_id = "62193c19a42a3e546ae2d9f8"
# bldg_add_id = "6243638e89dbb809c6432501" # no dmg, uses value_loss
# Census block groups data (required)
census_bg_id = "62193b7ca42a3e546ae2d9f2"
# Census appraisal file; id of external Census json
census_appr_id = "6241fbd153302c512d685181"
result_name = "Galveston_building_values"
housing_rec = HousingRecovery(client)
pop_disl_id = "623d1e1ca42a3e546aeba25f" # dev
housing_rec.load_remote_input_dataset("population_dislocation", pop_disl_id)
housing_rec.load_remote_input_dataset("building_area", bldg_add_id)
housing_rec.load_remote_input_dataset("census_block_groups_data", census_bg_id)
# Census appraisal data
housing_rec.load_remote_input_dataset("census_appraisal_data", census_appr_id)
housing_rec.set_parameter("result_name", result_name)
housing_rec.run_analysis()
def run_with_base_class():
client = IncoreClient()
# New madrid earthquake using Atkinson Boore 1995
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
# mmsa highway bridges
highway_bridges_id_list = {
"Highway_Bridges": "60e86d6b544e944c3ce622d2"
}
# mmsa railway bridges
railway_bridges_id_list = {
"Railway_Bridges_BNSF": "60e86e6f60b3f41243fb9df3",
"Railway_Bridges_CN": "60e86e91544e944c3ce62376",
"Railway_Bridges_CSXT": "60e86eab60b3f41243fb9e44",
"Railway_Bridges_NS": "60e86ed1544e944c3ce6241a",
"Railway_Bridges_UP": "60e86ee960b3f41243fb9ee8"
}
# Default Bridge Fragility Mapping on incore-service
highway_bridge_mapping_id_list = {
"ABP": "60f89fce52e10319df8086c4",
"ABA": "60f89fd647290977c8994353",
"EBL": "60f89fd7a0c8a24d7eedf916",
"EBT": "60f89fd96fb1bc236b68d3f7",
"Col": "60f89fdc47290977c8994578",
"FBL": "60f89fdda0c8a24d7eedfa9f",
"ABT": "60f89fdf6fb1bc236b68d61c",
"FBT": "60f89fdf52e10319df808b5f"
}
railway_bridge_mapping_id_list = {
"ABT": "60f89fc947290977c8994215",
"FBL": "60f89fcba0c8a24d7eedf6a0",
"FBT": "60f89fcd6fb1bc236b68d049",
"Col": "60f89fd047290977c8994302",
"EBL": "60f89fd2a0c8a24d7eedf6f1",
"EBT": "60f89fd36fb1bc236b68d3a6",
"ABA": "60f89fd452e10319df8088e9",
"ABP": "60f89fda52e10319df808a72"
}
# Use hazard uncertainty for computing damage
use_hazard_uncertainty = False
# Use liquefaction (LIQ) column of bridges to modify fragility curve
use_liquefaction = False
# Create bridge damage
bridge_dmg = BridgeDamage(client)
# Load input datasets
for bridge_name, highway_bridge_id in highway_bridges_id_list.items():
bridge_dmg.load_remote_input_dataset("bridges", highway_bridge_id)
# Load fragility mapping
fragility_service = FragilityService(client)
for component_name, highway_bridge_mapping_id in highway_bridge_mapping_id_list.items():
mapping_set = MappingSet(fragility_service.get_mapping(highway_bridge_mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter("result_name", bridge_name + "_" + component_name)
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("num_cpu", 4)
# Run bridge damage analysis
bridge_dmg.run_analysis()
# Load input datasets
for bridge_name, railway_bridge_id in railway_bridges_id_list.items():
bridge_dmg.load_remote_input_dataset("bridges", railway_bridge_id)
# Load fragility mapping
fragility_service = FragilityService(client)
for component_name, railway_bridge_mapping_id in railway_bridge_mapping_id_list.items():
mapping_set = MappingSet(fragility_service.get_mapping(railway_bridge_mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter("result_name", bridge_name + "_" + component_name)
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("num_cpu", 4)
# Run bridge damage analysis
bridge_dmg.run_analysis()
def __init__(self, incore_client):
self.hazardsvc = HazardService(incore_client)
self.fragilitysvc = FragilityService(incore_client)
super(PipelineDamageRepairRate, self).__init__(incore_client)
def fragilitysvc(monkeypatch):
client = IncoreClient(service_url=pyglobals.INCORE_API_DEV_URL, token_file_name=".incrtesttoken")
return FragilityService(client)
def __init__(self, incore_client):
self.hazardsvc = HazardService(incore_client)
self.fragilitysvc = FragilityService(incore_client)
super(NonStructBuildingDamage, self).__init__(incore_client)
def run_with_base_class():
client = IncoreClient(INCORE_API_DEV_URL)
# New madrid earthquake using Atkinson Boore 1995
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
# NBSR bridges
bridge_dataset_id = "5a284f2dc7d30d13bc082040"
# Default Bridge Fragility Mapping on incore-service
mapping_id = "5b47bcce337d4a37755e0cb2"
# Use hazard uncertainty for computing damage
use_hazard_uncertainty = False
# Use liquefaction (LIQ) column of bridges to modify fragility curve
use_liquefaction = False
# Create bridge damage
bridge_dmg = BridgeDamage(client)
# Load input datasets
bridge_dmg.load_remote_input_dataset("bridges", bridge_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter("result_name", "bridge_result")
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("num_cpu", 4)
# Run bridge damage analysis
bridge_dmg.run_analysis()
###################################################################
# Test liquefaction
# south carolina eq damage
hazard_type = "earthquake"
hazard_id = "5ee9309bc9f1b70008fdbd26"
# south carolina bridges
bridge_dataset_id = "5ee92f884210b80008f9377e"
# Default Bridge Fragility Mapping on incore-service
mapping_id = "5b47bcce337d4a37755e0cb2"
# Use hazard uncertainty for computing damage
use_hazard_uncertainty = False
# Use liquefaction (LIQ) column of bridges to modify fragility curve
use_liquefaction = True
# Create bridge damage
bridge_dmg = BridgeDamage(client)
# Load input datasets
bridge_dmg.load_remote_input_dataset("bridges", bridge_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter("result_name", "bridge_result_w_liquefaction")
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("use_liquefaction", use_liquefaction)
bridge_dmg.set_parameter("num_cpu", 1)
# Run bridge damage analysis
bridge_dmg.run_analysis()
def __init__(self, incore_client):
self.hazardsvc = HazardService(incore_client)
self.fragilitysvc = FragilityService(incore_client)
self.datasetsvc = DataService(incore_client)
self.fragility_tower_id = '5b201b41b1cf3e336de8fa67'
self.fragility_pole_id = '5b201d91b1cf3e336de8fa68'
# this is for deciding to use indpnode field. Not using this could be safer for general dataset
self.use_indpnode = False
self.nnode = 0
self.highest_node_num = 0
self.EF = 0
self.nint = []
self.indpnode = []
self.mcost = 1435 # mean repair cost for single distribution pole
self.vcost = (0.1 * self.mcost)**2
self.sigmad = math.sqrt(math.log(
self.vcost / (self.mcost**2) +
1)) # convert to gaussian Std Deviation to be used in logncdf
self.mud = math.log(
(self.mcost**2) / math.sqrt(self.vcost + self.mcost**2))
self.mcost = 400000 # mean repair cost for single transmission pole
self.vcost = (0.1 * self.mcost)**2
self.sigmat = math.sqrt(math.log(
self.vcost / (self.mcost**2) +
1)) # convert to gaussian Std Deviation to be used in logncdf
self.mut = math.log(
(self.mcost**2) / math.sqrt(self.vcost + self.mcost**2))
self.tmut = 72 # mean repairtime for transmission tower in hrs
self.tsigmat = 36 # std dev
self.tmud = 5 # mean repairtime for poles in hrs
self.tsigmad = 2.5
self.totalcost2repairpath = []
self.totalpoles2repair = []
self.tornado_sim_field_name = 'SIMULATION'
self.tornado_ef_field_name = 'EF_RATING'
# tornado number of simulation and ef_rate
self.nmcs = 0
self.tornado_ef_rate = 0
self.pole_distance = 38.1
# node variables
self.nodenwid_fld_name = "NODENWID"
self.indpnode_fld_name = "INDPNODE"
self.guid_fldname = 'GUID'
# link variables
self.tonode_fld_name = "TONODE"
self.fromnode_fld_name = "FROMNODE"
self.linetype_fld_name = "LINETYPE"
# line type variable
self.line_transmission = "transmission"
self.line_distribution = "distribution"
super(TornadoEpnDamage, self).__init__(incore_client)
def run_with_base_class():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
# New madrid earthquake using Atkinson Boore 1995
hazard_type = "earthquake"
hazard_id = "5b902cb273c3371e1236b36b"
# NBSR bridges
bridge_dataset_id = "5a284f2dc7d30d13bc082040"
# Default Bridge Fragility Mapping on incore-service
mapping_id = "5b47bcce337d4a37755e0cb2"
# Use hazard uncertainty for computing damage
use_hazard_uncertainty = False
# Use liquefaction (LIQ) column of bridges to modify fragility curve
use_liquefaction = False
# Create bridge damage
bridge_dmg = BridgeDamage(client)
# Load input datasets
bridge_dmg.load_remote_input_dataset("bridges", bridge_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter("result_name", "bridge_result")
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("num_cpu", 4)
# Run bridge damage analysis
bridge_dmg.run_analysis()
###################################################################
# Test liquefaction
# south carolina eq damage
hazard_type = "earthquake"
hazard_id = "5ee9309bc9f1b70008fdbd26"
# south carolina bridges
bridge_dataset_id = "5ee92f884210b80008f9377e"
# Default Bridge Fragility Mapping on incore-service
mapping_id = "5b47bcce337d4a37755e0cb2"
# Use hazard uncertainty for computing damage
use_hazard_uncertainty = False
# Use liquefaction (LIQ) column of bridges to modify fragility curve
use_liquefaction = True
# Create bridge damage
bridge_dmg = BridgeDamage(client)
# Load input datasets
bridge_dmg.load_remote_input_dataset("bridges", bridge_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter("result_name", "bridge_result_w_liquefaction")
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("use_liquefaction", use_liquefaction)
bridge_dmg.set_parameter("num_cpu", 1)
# Run bridge damage analysis
bridge_dmg.run_analysis()
###################################################################
# test Galveston Bridge Damage
hazard_type = "hurricane"
hazard_id = "5f11e50cc6491311a814584c"
# Galveston bridge
bridge_dataset_id = "6062058ac57ada48e48c31e3"
# Galveston hurricane bridge mapping
refactored_mapping_id = "6062254b618178207f66226c"
# Create bridge damage
bridge_dmg = BridgeDamage(client)
# Load input datasets
bridge_dmg.load_remote_input_dataset("bridges", bridge_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
refactored_mapping_set = MappingSet(
fragility_service.get_mapping(refactored_mapping_id))
bridge_dmg.set_input_dataset('dfr3_mapping_set', refactored_mapping_set)
# Set analysis parameters
bridge_dmg.set_parameter(
"fragility_key",
"Hurricane SurgeLevel and WaveHeight Fragility ID Code")
bridge_dmg.set_parameter("result_name", "galveston_bridge_dmg_result")
bridge_dmg.set_parameter("hazard_type", hazard_type)
bridge_dmg.set_parameter("hazard_id", hazard_id)
bridge_dmg.set_parameter("num_cpu", 4)
# Run bridge damage analysis
bridge_dmg.run_analysis()
def run_with_base_class():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
# EQ Road Dataset - Seaside roads
road_dataset_id = "5ee7af50772cf80008577ae3"
hazard_type = "tsunami"
# hazard_type = "earthquake"
liq_geology_dataset_id = None
if hazard_type == 'earthquake':
# Seaside Earthquake
hazard_id = "5ba8f379ec2309043520906f"
# Earthquake mapping
mapping_id = "5d545b0bb9219c0689f1f3f4"
fragility_key = "pgd"
liquefaction = False
elif hazard_type == 'tsunami':
# Seaside Tsunami
hazard_id = "5bc9eaf7f7b08533c7e610e1"
# Tsunami Mapping for Seaside
mapping_id = "5ee7b2c9c54361000148de37"
fragility_key = "Non-Retrofit inundationDepth Fragility ID Code"
liquefaction = False
else:
raise ValueError(
"Earthquake and tsunami are the only testable hazards with road damage currently"
)
uncertainty = False
# Run road damage
road_dmg = RoadDamage(client)
road_dmg.load_remote_input_dataset("roads", road_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
road_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
road_dmg.set_parameter("result_name", "seaside_road_dmg_" + hazard_type)
road_dmg.set_parameter("hazard_type", hazard_type)
road_dmg.set_parameter("hazard_id", hazard_id)
if fragility_key is not None:
road_dmg.set_parameter("fragility_key", fragility_key)
road_dmg.set_parameter("num_cpu", 1)
road_dmg.set_parameter("use_liquefaction", liquefaction)
if liquefaction and liq_geology_dataset_id is not None:
road_dmg.set_parameter("liquefaction_geology_dataset_id",
liq_geology_dataset_id)
road_dmg.set_parameter("use_hazard_uncertainty", uncertainty)
# Run Analysis
road_dmg.run_analysis()
######################################################################
# test galveston hurricane road failure
# road inventory for Galveston island
road_dataset_id = "60ba5ee94219ee25a56b6999"
# road damage by hurricane inundation mapping
mapping_id = "60ba583b1f2b7d4a916faf03"
# Galveston Deterministic Hurricane - Kriging inundationDuration
hazard_type = "hurricane"
hazard_id = "5f10837c01d3241d77729a4f"
# Create road damage
hurr_road_dmg = RoadDamage(client)
# Load input datasets
hurr_road_dmg.load_remote_input_dataset("roads", road_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
hurr_road_dmg.set_input_dataset('dfr3_mapping_set', mapping_set)
# Specify the result name
result_name = "galveston_hurricane_road_result"
# Set analysis parameters
hurr_road_dmg.set_parameter("result_name", result_name)
hurr_road_dmg.set_parameter("hazard_type", hazard_type)
hurr_road_dmg.set_parameter(
"fragility_key", "Non-Retrofit inundationDepth Fragility ID Code")
hurr_road_dmg.set_parameter("hazard_id", hazard_id)
hurr_road_dmg.set_parameter("num_cpu", 4)
# Run road damage by hurricane inundation analysis
hurr_road_dmg.run_analysis()
def run_with_base_class():
client = IncoreClient(pyglobals.INCORE_API_DEV_URL)
# ## Memphis EPF Damage with Earthquake ##
hazard_type_eq = "earthquake"
hazard_id_eq = "5b902cb273c3371e1236b36b"
epf_dataset_id = "6189c103d5b02930aa3efc35"
# mapping_id = "61980b11e32da63f4b9d86f4"
mapping_id = "61980cf5e32da63f4b9d86f5" # PGA and PGD
use_liquefaction = True
use_hazard_uncertainty = False
liquefaction_geology_dataset_id = "5a284f53c7d30d13bc08249c"
# Run epf damage
epf_dmg_eq_memphis = EpfDamage(client)
epf_dmg_eq_memphis.load_remote_input_dataset("epfs", epf_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
epf_dmg_eq_memphis.set_input_dataset('dfr3_mapping_set', mapping_set)
epf_dmg_eq_memphis.set_parameter("result_name",
"memphis_eq_epf_dmg_result")
epf_dmg_eq_memphis.set_parameter("hazard_type", hazard_type_eq)
epf_dmg_eq_memphis.set_parameter("hazard_id", hazard_id_eq)
epf_dmg_eq_memphis.set_parameter("use_liquefaction", use_liquefaction)
epf_dmg_eq_memphis.set_parameter("use_hazard_uncertainty",
use_hazard_uncertainty)
epf_dmg_eq_memphis.set_parameter("liquefaction_geology_dataset_id",
liquefaction_geology_dataset_id)
epf_dmg_eq_memphis.set_parameter("num_cpu", 1)
# Run Analysis
epf_dmg_eq_memphis.run_analysis()
# ## Seaside EPF Damage with Earthquake ##
hazard_type_eq = "earthquake"
hazard_id_eq = "5eebcbb08f80fe3899ad6039"
epf_dataset_id = "5eebcaa17a00803abc85ec11"
# Earthquake mapping
mapping_id = "5eebcc13e7226233ce4ef0d7" # only PGA
# Run epf damage
epf_dmg_eq = EpfDamage(client)
epf_dmg_eq.load_remote_input_dataset("epfs", epf_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
epf_dmg_eq.set_input_dataset('dfr3_mapping_set', mapping_set)
epf_dmg_eq.set_parameter("result_name", "seaside_eq_epf_dmg_result")
epf_dmg_eq.set_parameter("hazard_type", hazard_type_eq)
epf_dmg_eq.set_parameter("hazard_id", hazard_id_eq)
epf_dmg_eq.set_parameter("num_cpu", 1)
epf_dmg_eq.run_analysis()
# ## Seaside Tsunami EPF Damage ##
hazard_type_tsu = "tsunami"
hazard_id_tsu = "5bc9eaf7f7b08533c7e610e1"
epf_dataset_id = "5eebcaa17a00803abc85ec11"
# Tsunami mapping
mapping_id = "605bf9e1618178207f6475c6"
# Run epf damage
epf_dmg_tsu_re = EpfDamage(client)
epf_dmg_tsu_re.load_remote_input_dataset("epfs", epf_dataset_id)
epf_dmg_eq = EpfDamage(client)
epf_dmg_eq.load_remote_input_dataset("epfs", epf_dataset_id)
# Load fragility mapping
fragility_service = FragilityService(client)
mapping_set = MappingSet(fragility_service.get_mapping(mapping_id))
epf_dmg_tsu_re.set_input_dataset('dfr3_mapping_set', mapping_set)
epf_dmg_tsu_re.set_parameter(
"fragility_key", "Non-Retrofit inundationDepth Fragility ID Code")
epf_dmg_tsu_re.set_parameter("result_name",
"seaside_tsunami_epf_dmg_result")
epf_dmg_tsu_re.set_parameter("hazard_type", hazard_type_tsu)
epf_dmg_tsu_re.set_parameter("hazard_id", hazard_id_tsu)
epf_dmg_tsu_re.set_parameter("num_cpu", 1)
epf_dmg_tsu_re.set_input_dataset('dfr3_mapping_set', mapping_set)
# Run Analysis
epf_dmg_tsu_re.run_analysis()
