def test_volcano_circle_population_impact(self):
"""Volcano function runs circular evacuation zone."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/Merapi_alert.shp' % TESTDATA
exposure_filename = ('%s/glp10ag.asc' % EXPDATA)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'Volcano Polygon Hazard Population'
impact_function = get_plugin(plugin_name)
impact_layer = calculate_impact(
layers=[hazard_layer, exposure_layer], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
print keywords
# This is the expected number of people affected
# Distance [km] Total Cumulative
# 3 15.800 15.800
# 5 17.300 33.100
# 10 125.000 158.000
message = 'Result not as expected'
impact_summary = keywords['impact_summary']
self.assertTrue(format_int(15800) in impact_summary, message)
self.assertTrue(format_int(17300) in impact_summary, message)
self.assertTrue(format_int(125000) in impact_summary, message)
def test_run(self):
function = AshRasterPopulationFunction.instance()
hazard_path = standard_data_path('hazard', 'ash_raster_wgs84.tif')
exposure_path = standard_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
# We need clipping for both layers to be in the same dimension
clipped_hazard, clipped_exposure = clip_layers(
hazard_path, exposure_path)
hazard_layer = read_layer(clipped_hazard.source())
exposure_layer = read_layer(clipped_exposure.source())
# Let's set the extent to the hazard extent
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.run()
impact = function.impact
expected = [
[u'Population in very low hazard zone', 0],
[u'Population in medium hazard zone', 1374],
[u'Population in high hazard zone', 20],
[u'Population in very high hazard zone', 0],
[u'Population in low hazard zone', 8443],
[u'Total affected population', 9837],
[u'Unaffected population', 0],
[u'Total population', 9837],
[u'Population needing evacuation <sup>1</sup>', 9837]
]
self.assertListEqual(
expected, impact.impact_data['impact summary']['fields'])
def test_run(self):
impact_function = TsunamiRasterBuildingFunction.instance()
hazard_path = test_data_path("hazard", "continuous_flood_20_20.asc")
exposure_path = test_data_path("exposure", "buildings.shp")
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
impact_function.hazard = SafeLayer(hazard_layer)
impact_function.exposure = SafeLayer(exposure_layer)
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
self.assertEqual(len(impact_data), 181)
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {0: 1, 1: 116, 2: 64, 3: 0, 4: 0}
result = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
for feature in impact_data:
inundated_status = feature[impact_function.target_field]
result[inundated_status] += 1
message = "Expecting %s, but it returns %s" % (expected_result, result)
self.assertEqual(expected_result, result, message)
def test_earthquake_building_impact_function(self):
"""Earthquake Building Impact Function works as expected."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/eq_yogya_2006.asc' % HAZDATA
exposure_filename = '%s/OSM_building_polygons_20110905.shp' % TESTDATA
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'Earthquake Building Impact Function'
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
# calculated_result = I.get_data()
# print calculated_result.shape
keywords = impact_layer.get_keywords()
impact_summary = keywords['impact_summary']
# This is the expected number of building might be affected
# Hazard Level - Buildings Affected
# Low - 845
# Medium - 15524
# High - 122
message = 'Result not as expected'
self.assertTrue(format_int(845) in impact_summary, message)
self.assertTrue(format_int(15524) in impact_summary, message)
self.assertTrue(format_int(122) in impact_summary, message)
def test_run(self):
"""TestVolcanoPolygonPopulationFunction: Test running the IF."""
merapi_krb_path = test_data_path('hazard', 'volcano_krb.shp')
population_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
merapi_krb_layer = read_layer(merapi_krb_path)
population_layer = read_layer(population_path)
impact_function = VolcanoPolygonPopulationFunction.instance()
# 2. Run merapi krb
impact_function.hazard = SafeLayer(merapi_krb_layer)
impact_function.exposure = SafeLayer(population_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of volcano krb how many population '
'might need evacuation')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand
expected_affected_population = 181
result = numpy.nansum(impact_layer.get_data())
self.assertEqual(expected_affected_population, result, message)
def test_run(self):
impact_function = FloodRasterBuildingFunction.instance()
hazard_path = standard_data_path('hazard',
'continuous_flood_20_20.asc')
exposure_path = standard_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
impact_function.hazard = SafeLayer(hazard_layer)
impact_function.exposure = SafeLayer(exposure_layer)
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
self.assertEqual(len(impact_data), 181)
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {1: 64, 2: 117, 3: 0}
result = {1: 0, 2: 0, 3: 0}
for feature in impact_data:
inundated_status = feature[impact_function.target_field]
result[inundated_status] += 1
message = 'Expecting %s, but it returns %s' % (expected_result, result)
self.assertEqual(expected_result, result, message)
def test_run(self):
"""TestVolcanoPolygonBuildingFunction: Test running the IF."""
volcano_path = test_data_path('hazard', 'volcano_krb.shp')
building_path = test_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(volcano_path)
exposure_layer = read_layer(building_path)
impact_function = VolcanoPolygonBuildingFunction.instance()
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of volcano krb how many buildings '
'might be affected')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# The buildings should all be categorised into 5000 zone
zone_sum = impact_layer.get_data(attribute='zone')
krb3_zone_count = zone_sum.count('Kawasan Rawan Bencana III')
krb2_zone_count = zone_sum.count('Kawasan Rawan Bencana II')
# The result (counted by hand)
expected_krb3_count = 11
expected_krb2_count = 161
message = 'Expecting %s for KRB III zone, but it returns %s' % (
krb3_zone_count, expected_krb3_count)
self.assertEqual(krb3_zone_count, expected_krb3_count, message)
message = 'Expecting %s for KRB II zone, but it returns %s' % (
krb2_zone_count, expected_krb2_count)
self.assertEqual(krb2_zone_count, expected_krb2_count, message)
def test_run(self):
function = ContinuousHazardPopulationFunction.instance()
hazard_path = test_data_path('hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path('exposure',
'pop_binary_raster_20_20.asc')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.run()
impact = function.impact
# print "keywords", keywords
keywords = impact.get_keywords()
total_needs_full = keywords['total_needs']
total_needs_weekly = OrderedDict([[x['table name'], x['amount']]
for x in total_needs_full['weekly']])
total_needs_single = OrderedDict([[x['table name'], x['amount']]
for x in total_needs_full['single']])
self.assertEqual(total_needs_weekly['Rice [kg]'], 336)
self.assertEqual(total_needs_weekly['Drinking Water [l]'], 2100)
self.assertEqual(total_needs_weekly['Clean Water [l]'], 8040)
self.assertEqual(total_needs_weekly['Family Kits'], 24)
self.assertEqual(total_needs_single['Toilets'], 6)
def test_run(self):
"""TestVolcanoPolygonPopulationFunction: Test running the IF."""
merapi_krb_path = test_data_path('hazard', 'volcano_krb.shp')
population_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
merapi_krb_layer = read_layer(merapi_krb_path)
population_layer = read_layer(population_path)
impact_function = VolcanoPolygonPopulationFunction.instance()
# 2. Run merapi krb
impact_function.hazard = SafeLayer(merapi_krb_layer)
impact_function.exposure = SafeLayer(population_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of volcano krb how many population '
'might need evacuation')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand
expected_affected_population = 181
result = numpy.nansum(impact_layer.get_data())
self.assertEqual(expected_affected_population, result, message)
def test_volcano_building_impact(self):
"""Building impact from volcanic hazard is computed correctly."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = os.path.join(TESTDATA, 'donut.shp')
exposure_filename = test_data_path('exposure', 'bangunan.shp')
# Calculate impact using API
hazard = read_layer(hazard_filename)
exposure = read_layer(exposure_filename)
plugin_name = 'Volcano Building Impact'
impact_function = get_plugin(plugin_name)
impact_function.parameters['name attribute'] = 'GUNUNG'
print 'Calculating'
# Call calculation engine
impact_layer = calculate_impact(
layers=[hazard, exposure], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact = read_layer(impact_filename)
keywords = impact.get_keywords()
# Check for expected results:
for value in ['Merapi', 5, 86, 91, 1, 21, 22, 6, 107, 113]:
if isinstance(value, int):
x = format_int(value)
else:
x = value
summary = keywords['impact_summary']
message = (
'Did not find expected value %s in summary %s' % (x, summary))
self.assertIn(x, summary, message)
def test_flood_population_evacuation_polygon(self):
"""Flood population evacuation (flood is polygon)
"""
population = 'pop_clip_flood_test.tif'
flood_data = 'flood_poly_clip_flood_test.shp'
plugin_name = 'FloodEvacuationFunctionVectorHazard'
hazard_filename = os.path.join(TESTDATA, flood_data)
exposure_filename = os.path.join(TESTDATA, population)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
# print "keywords", keywords
affected_population = float(keywords['affected_population'])
total_population = keywords['total_population']
self.assertEqual(affected_population, 134000)
self.assertEqual(total_population, 163000)
def test_run(self):
function = ClassifiedRasterHazardBuildingFunction.instance()
hazard_path = test_data_path('hazard', 'classified_flood_20_20.asc')
exposure_path = test_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.run()
impact_layer = function.impact
impact_data = impact_layer.get_data()
# Count
expected_impact = {1.0: 67, 2.0: 49, 3.0: 64}
result_impact = {1.0: 0, 2.0: 0, 3.0: 0}
for impact_feature in impact_data:
level = impact_feature['level']
if not math.isnan(level):
result_impact[level] += 1
message = 'Expecting %s, but it returns %s' % (expected_impact,
result_impact)
self.assertEqual(expected_impact, result_impact, message)
def test_flood_raster_building_impact_function(self):
"""Flood raster building impact function works
This test also exercises interpolation of hazard level (raster) to
building locations (vector data).
"""
for haz_filename in ['Flood_Current_Depth_Jakarta_geographic.asc',
'Flood_Design_Depth_Jakarta_geographic.asc']:
# Name file names for hazard level and exposure
hazard_filename = '%s/%s' % (HAZDATA, haz_filename)
exposure_filename = ('%s/OSM_building_polygons_20110905.shp'
% TESTDATA)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'FloodRasterBuildingImpactFunction'
impact_function = get_plugin(plugin_name)
impact_vector = calculate_impact(
layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
# Extract calculated result
icoordinates = impact_vector.get_geometry()
iattributes = impact_vector.get_data()
# Check
assert len(icoordinates) == 34960
assert len(iattributes) == 34960
def test_aggregate(self):
"""Aggregation by boundaries works
"""
# Name file names for hazard level and exposure
boundary_filename = ('%s/kecamatan_jakarta_osm.shp' % TESTDATA)
#data_filename = ('%s/Population_Jakarta_geographic.asc' % TESTDATA)
# Get reference building impact data
building_filename = ('%s/building_impact_scenario.shp' % TESTDATA)
boundary_layer = read_layer(boundary_filename)
building_layer = read_layer(building_filename)
res = aggregate(data=building_layer,
boundaries=boundary_layer,
attribute_name='AFFECTED',
aggregation_function='count')
#print res, len(res)
#print boundary_layer, len(boundary_layer)
msg = ('Number of aggregations %i should be the same as the '
'number of specified boundaries %i' %
(len(res), len(boundary_layer)))
assert len(res) == len(boundary_layer), msg
def test_run(self):
"""TestVolcanoPointPopulationFunction: Test running the IF."""
merapi_point_path = test_data_path('hazard', 'volcano_point.shp')
population_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
merapi_point_layer = read_layer(merapi_point_path)
population_layer = read_layer(population_path)
impact_function = VolcanoPointPopulationFunction.instance()
# Run merapi point
impact_function.hazard = merapi_point_layer
impact_function.exposure = population_layer
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = (
'In the event of a volcano point how many '
'people might be impacted')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand
expected_affected_population = 200
result = numpy.nansum(impact_layer.get_data())
message = 'Expecting %s, but it returns %s' % (
expected_affected_population, result)
self.assertEqual(expected_affected_population, result, message)
def test_run(self):
function = ClassifiedRasterHazardBuildingFunction.instance()
hazard_path = test_data_path('hazard', 'classified_flood_20_20.asc')
exposure_path = test_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = hazard_layer
function.exposure = exposure_layer
function.run()
impact_layer = function.impact
impact_data = impact_layer.get_data()
# Count
expected_impact = {
1.0: 67,
2.0: 49,
3.0: 64
}
result_impact = {
1.0: 0,
2.0: 0,
3.0: 0
}
for impact_feature in impact_data:
level = impact_feature['level']
if not math.isnan(level):
result_impact[level] += 1
message = 'Expecting %s, but it returns %s' % (
expected_impact, result_impact)
self.assertEqual(expected_impact, result_impact, message)
def test_pager_earthquake_fatality_estimation(self):
"""Fatalities from ground shaking can be computed correctly
using the Pager fatality model."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/itb_test_mmi.asc' % TESTDATA
exposure_filename = '%s/itb_test_pop.asc' % TESTDATA
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'PAG Fatality Function'
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
population = keywords['total_population']
fatalities = keywords['total_fatalities']
# Check aggregated values
expected_population = 85425000.0
msg = ('Expected population was %f, I got %f' %
(expected_population, population))
self.assertEqual(population, expected_population, msg)
expected_fatalities = 410000.0
msg = ('Expected fatalities was %f, I got %f' %
(expected_fatalities, fatalities))
assert numpy.allclose(fatalities, expected_fatalities,
rtol=1.0e-5), msg
def test_run(self):
function = FloodEvacuationRasterHazardFunction.instance()
hazard_path = test_data_path('hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = hazard_layer
function.exposure = exposure_layer
function.run()
impact = function.impact
# Count of flooded objects is calculated "by the hands"
# print "keywords", keywords
keywords = impact.get_keywords()
evacuated = float(keywords['evacuated'])
total_needs_full = keywords['total_needs']
total_needs_weekly = OrderedDict([
[x['table name'], x['amount']] for x in
total_needs_full['weekly']
])
total_needs_single = OrderedDict([
[x['table name'], x['amount']] for x in
total_needs_full['single']
])
expected_evacuated = 100
self.assertEqual(evacuated, expected_evacuated)
self.assertEqual(total_needs_weekly['Rice [kg]'], 280)
self.assertEqual(total_needs_weekly['Family Kits'], 20)
self.assertEqual(total_needs_weekly['Drinking Water [l]'], 1750)
self.assertEqual(total_needs_weekly['Clean Water [l]'], 6700)
self.assertEqual(total_needs_single['Toilets'], 5)
def test_run(self):
"""TestVolcanoPointPopulationFunction: Test running the IF."""
merapi_point_path = test_data_path('hazard', 'volcano_point.shp')
population_path = test_data_path('exposure',
'pop_binary_raster_20_20.asc')
merapi_point_layer = read_layer(merapi_point_path)
population_layer = read_layer(population_path)
impact_function = VolcanoPointPopulationFunction.instance()
# Run merapi point
impact_function.hazard = SafeLayer(merapi_point_layer)
impact_function.exposure = SafeLayer(population_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of a volcano point how many '
'people might be impacted')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand
expected_affected_population = 200
result = numpy.nansum(impact_layer.get_data())
message = 'Expecting %s, but it returns %s' % (
expected_affected_population, result)
self.assertEqual(expected_affected_population, result, message)
def test_run(self):
function = ClassifiedRasterHazardBuildingFunction.instance()
hazard_path = standard_data_path(
'hazard', 'classified_hazard.tif')
exposure_path = standard_data_path('exposure', 'small_building.shp')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.run_analysis()
impact_layer = function.impact
impact_data = impact_layer.get_data()
# Count
expected_impact = {
'Not affected': 5,
'Low hazard zone': 2,
'Medium hazard zone': 9,
'High hazard zone': 5
}
result_impact = {}
for impact_feature in impact_data:
hazard_class = impact_feature[function.target_field]
if hazard_class in result_impact:
result_impact[hazard_class] += 1
else:
result_impact[hazard_class] = 1
self.assertDictEqual(expected_impact, result_impact)
def test_run(self):
"""TestVolcanoPointPopulationFunction: Test running the IF."""
merapi_point_path = standard_data_path('hazard', 'volcano_point.shp')
population_path = standard_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
merapi_point_layer = read_layer(merapi_point_path)
population_layer = read_layer(population_path)
impact_function = VolcanoPointPopulationFunction.instance()
# Run merapi point
impact_function.hazard = SafeLayer(merapi_point_layer)
impact_function.exposure = SafeLayer(population_layer)
impact_function._prepare()
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = (
'In the event of a volcano point how many people might be '
'impacted?')
self.assertEqual(expected_question, impact_function.question)
# Count by hand
expected_affected_population = 200
result = numpy.nansum(impact_layer.get_data())
self.assertEqual(expected_affected_population, result)
def test_run(self):
"""TestClassifiedPolygonPopulationFunction: Test running the IF."""
generic_polygon_path = test_data_path(
'hazard', 'classified_generic_polygon.shp')
population_path = test_data_path('exposure',
'pop_binary_raster_20_20.asc')
generic_polygon_layer = read_layer(generic_polygon_path)
population_layer = read_layer(population_path)
impact_function = ClassifiedPolygonHazardPopulationFunction.instance()
impact_function.hazard = generic_polygon_layer
impact_function.exposure = population_layer
impact_function.parameters['hazard zone attribute'] = 'h_zone'
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In each of the hazard zones how many people '
'might be impacted.')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand
expected_affected_population = 181
result = numpy.nansum(impact_layer.get_data())
self.assertEqual(expected_affected_population, result, message)
def test_flood_vector_building_impact_function(self):
"""Test flood building impact function works (flood is polygon)."""
building = 'test_flood_building_impact_exposure.shp'
flood_data = 'test_flood_building_impact_hazard.shp'
plugin_name = 'FloodVectorBuildingImpactFunction'
hazard_filename = os.path.join(TESTDATA, flood_data)
exposure_filename = os.path.join(TESTDATA, building)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(
layers=[hazard_layer, exposure_layer], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
buildings_total = keywords['buildings_total']
buildings_affected = keywords['buildings_affected']
self.assertEqual(buildings_total, 67)
self.assertEqual(buildings_affected, 41)
def test_run(self):
function = FloodEvacuationRasterHazardFunction.instance()
hazard_path = test_data_path('hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path('exposure',
'pop_binary_raster_20_20.asc')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = hazard_layer
function.exposure = exposure_layer
function.run()
impact = function.impact
# Count of flooded objects is calculated "by the hands"
# print "keywords", keywords
keywords = impact.get_keywords()
evacuated = float(keywords['evacuated'])
total_needs_full = keywords['total_needs']
total_needs_weekly = OrderedDict([[x['table name'], x['amount']]
for x in total_needs_full['weekly']])
total_needs_single = OrderedDict([[x['table name'], x['amount']]
for x in total_needs_full['single']])
expected_evacuated = 100
self.assertEqual(evacuated, expected_evacuated)
self.assertEqual(total_needs_weekly['Rice [kg]'], 280)
self.assertEqual(total_needs_weekly['Family Kits'], 20)
self.assertEqual(total_needs_weekly['Drinking Water [l]'], 1750)
self.assertEqual(total_needs_weekly['Clean Water [l]'], 6700)
self.assertEqual(total_needs_single['Toilets'], 5)
def test_pager_earthquake_fatality_estimation(self):
"""Fatalities from ground shaking can be computed correctly
using the Pager fatality model."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/itb_test_mmi.asc' % TESTDATA
exposure_filename = '%s/itb_test_pop.asc' % TESTDATA
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'PAG Fatality Function'
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(
layers=[hazard_layer, exposure_layer], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
population = keywords['total_population']
fatalities = keywords['total_fatalities']
# Check aggregated values
expected_population = 85425000.0
msg = ('Expected population was %f, I got %f'
% (expected_population, population))
self.assertEqual(population, expected_population, msg)
expected_fatalities = 410000.0
msg = ('Expected fatalities was %f, I got %f'
% (expected_fatalities, fatalities))
assert numpy.allclose(
fatalities, expected_fatalities, rtol=1.0e-5), msg
def test_run(self):
"""TestEarthquakeBuildingFunction: Test running the IF."""
eq_path = test_data_path('hazard', 'earthquake.tif')
building_path = test_data_path('exposure', 'buildings.shp')
eq_layer = read_layer(eq_path)
building_layer = read_layer(building_path)
impact_function = EarthquakeBuildingFunction.instance()
impact_function.hazard = eq_layer
impact_function.exposure = building_layer
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of earthquake how many '
'buildings might be affected')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand,
# 1 = low, 2 = medium, 3 = high
impact = {1: 0, 2: 181, 3: 0}
result = {1: 0, 2: 0, 3: 0}
impact_features = impact_layer.get_data()
for i in range(len(impact_features)):
impact_feature = impact_features[i]
level = impact_feature.get('Shake_cls')
result[level] += 1
message = 'Expecting %s, but it returns %s' % (impact, result)
self.assertEqual(impact, result, message)
def test_run(self):
function = ContinuousHazardPopulationFunction.instance()
hazard_path = test_data_path(
'hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.run()
impact = function.impact
# print "keywords", keywords
keywords = impact.get_keywords()
total_needs_full = keywords['total_needs']
total_needs_weekly = OrderedDict([
[x['table name'], x['amount']] for x in
total_needs_full['weekly']
])
total_needs_single = OrderedDict([
[x['table name'], x['amount']] for x in
total_needs_full['single']
])
self.assertEqual(total_needs_weekly['Rice [kg]'], 336)
self.assertEqual(total_needs_weekly['Drinking Water [l]'], 2100)
self.assertEqual(total_needs_weekly['Clean Water [l]'], 8040)
self.assertEqual(total_needs_weekly['Family Kits'], 24)
self.assertEqual(total_needs_single['Toilets'], 6)
def test_aggregate(self):
"""Aggregation by boundaries works
"""
# Name file names for hazard level and exposure
boundary_filename = ('%s/kecamatan_jakarta_osm.shp' % TESTDATA)
#data_filename = ('%s/Population_Jakarta_geographic.asc' % TESTDATA)
# Get reference building impact data
building_filename = ('%s/building_impact_scenario.shp' % TESTDATA)
boundary_layer = read_layer(boundary_filename)
building_layer = read_layer(building_filename)
res = aggregate(data=building_layer,
boundaries=boundary_layer,
attribute_name='AFFECTED',
aggregation_function='count')
#print res, len(res)
#print boundary_layer, len(boundary_layer)
msg = ('Number of aggregations %i should be the same as the '
'number of specified boundaries %i' % (len(res),
len(boundary_layer)))
assert len(res) == len(boundary_layer), msg
def test_run(self):
"""TestVolcanoPolygonBuildingFunction: Test running the IF."""
volcano_path = test_data_path('hazard', 'volcano_krb.shp')
building_path = test_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(volcano_path)
exposure_layer = read_layer(building_path)
impact_function = VolcanoPolygonBuildingFunction.instance()
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of volcano krb how many buildings '
'might be affected')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# The buildings should all be categorised into 5000 zone
zone_sum = impact_layer.get_data(attribute='zone')
krb3_zone_count = zone_sum.count('Kawasan Rawan Bencana III')
krb2_zone_count = zone_sum.count('Kawasan Rawan Bencana II')
# The result (counted by hand)
expected_krb3_count = 11
expected_krb2_count = 161
message = 'Expecting %s for KRB III zone, but it returns %s' % (
krb3_zone_count, expected_krb3_count)
self.assertEqual(krb3_zone_count, expected_krb3_count, message)
message = 'Expecting %s for KRB II zone, but it returns %s' % (
krb2_zone_count, expected_krb2_count)
self.assertEqual(krb2_zone_count, expected_krb2_count, message)
def test_run(self):
"""TestVolcanoPointBuildingFunction: Test running the IF."""
volcano_path = standard_data_path('hazard', 'volcano_point.shp')
building_path = standard_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(volcano_path)
exposure_layer = read_layer(building_path)
impact_function = VolcanoPointBuildingFunction.instance()
impact_function.hazard = SafeLayer(hazard_layer)
impact_function.exposure = SafeLayer(exposure_layer)
impact_function._prepare()
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = (
'In the event of volcano point how many buildings might be '
'affected?')
self.assertEqual(expected_question, impact_function.question)
# The buildings should all be categorised into 3000 zone
zone_sum = sum(
impact_layer.get_data(attribute=impact_function.target_field))
expected_sum = 3 * 181
message = 'Expecting %s, but it returns %s' % (expected_sum, zone_sum)
self.assertEqual(zone_sum, expected_sum, message)
def test_run(self):
impact_function = FloodRasterBuildingFunction.instance()
hazard_path = test_data_path('hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(hazard_path)
exposure_layer = read_layer(exposure_path)
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
self.assertEqual(len(impact_data), 181)
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {
1: 64,
2: 117,
3: 0
}
result = {
1: 0,
2: 0,
3: 0
}
for feature in impact_data:
inundated_status = feature['INUNDATED']
result[inundated_status] += 1
message = 'Expecting %s, but it returns %s' % (expected_result, result)
self.assertEqual(expected_result, result, message)
def test_run(self):
"""TestVolcanoPointBuildingFunction: Test running the IF."""
volcano_path = test_data_path('hazard', 'volcano_point.shp')
building_path = test_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(volcano_path)
exposure_layer = read_layer(building_path)
impact_function = VolcanoPointBuildingFunction.instance()
impact_function.hazard = SafeLayer(hazard_layer)
impact_function.exposure = SafeLayer(exposure_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = (
'In the event of volcano point how many buildings might be '
'affected')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# The buildings should all be categorised into 3000 zone
zone_sum = sum(impact_layer.get_data(
attribute=impact_function.target_field))
expected_sum = 3000 * 181
message = 'Expecting %s, but it returns %s' % (expected_sum, zone_sum)
self.assertEqual(zone_sum, expected_sum, message)
def test_run(self):
"""TestVolcanoPolygonBuildingFunction: Test running the IF."""
volcano_path = standard_data_path('hazard', 'volcano_krb.shp')
building_path = standard_data_path('exposure', 'buildings.shp')
hazard_layer = read_layer(volcano_path)
exposure_layer = read_layer(building_path)
impact_function = VolcanoPolygonBuildingFunction.instance()
impact_function.hazard = SafeLayer(hazard_layer)
impact_function.exposure = SafeLayer(exposure_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = (
'In the event of volcano krb how many buildings might be '
'affected?')
self.assertEqual(expected_question, impact_function.question)
# The buildings should all be categorised into 5000 zone
zone_sum = impact_layer.get_data(
attribute=impact_function.target_field)
krb3_zone_count = zone_sum.count('High Hazard Zone')
krb2_zone_count = zone_sum.count('Medium Hazard Zone')
# The result (counted by hand)
expected_krb3_count = 11
expected_krb2_count = 161
message = 'Expecting %s for KRB III zone, but it returns %s' % (
krb3_zone_count, expected_krb3_count)
self.assertEqual(krb3_zone_count, expected_krb3_count, message)
message = 'Expecting %s for KRB II zone, but it returns %s' % (
krb2_zone_count, expected_krb2_count)
self.assertEqual(krb2_zone_count, expected_krb2_count, message)
def test_earthquake_building_impact_function(self):
"""Earthquake Building Impact Function works as expected."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/eq_yogya_2006.asc' % HAZDATA
exposure_filename = '%s/OSM_building_polygons_20110905.shp' % TESTDATA
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'Earthquake Building Impact Function'
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(
layers=[hazard_layer, exposure_layer], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
# calculated_result = I.get_data()
# print calculated_result.shape
keywords = impact_layer.get_keywords()
impact_summary = keywords['impact_summary']
# This is the expected number of building might be affected
# Hazard Level - Buildings Affected
# Low - 845
# Medium - 15524
# High - 122
message = 'Result not as expected'
self.assertTrue(format_int(845) in impact_summary, message)
self.assertTrue(format_int(15524) in impact_summary, message)
self.assertTrue(format_int(122) in impact_summary, message)
def test_run(self):
"""TestClassifiedPolygonPopulationFunction: Test running the IF."""
generic_polygon_path = test_data_path(
'hazard', 'classified_generic_polygon.shp')
population_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
generic_polygon_layer = read_layer(generic_polygon_path)
population_layer = read_layer(population_path)
impact_function = ClassifiedPolygonHazardPopulationFunction.instance()
impact_function.hazard = SafeLayer(generic_polygon_layer)
impact_function.exposure = SafeLayer(population_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In each of the hazard zones how many people '
'might be impacted.')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand
expected_affected_population = 181
result = numpy.nansum(impact_layer.get_data())
self.assertEqual(expected_affected_population, result, message)
def test_volcano_population_evacuation_impact(self):
"""Population impact from volcanic hazard is computed correctly."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/donut.shp' % TESTDATA
exposure_filename = ('%s/pop_merapi_clip.tif' % TESTDATA)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'Volcano Polygon Hazard Population'
impact_function = get_plugin(plugin_name)
impact_layer = calculate_impact(
layers=[hazard_layer, exposure_layer], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
# Check for expected results:
for value in ['Merapi', 192055, 56514, 68568, 66971]:
if isinstance(value, int):
x = format_int(population_rounding(value))
else:
x = value
summary = keywords['impact_summary']
msg = ('Did not find expected value %s in summary %s'
% (x, summary))
assert x in summary, msg
def test_run(self):
"""TestEarthquakeBuildingFunction: Test running the IF."""
eq_path = test_data_path("hazard", "earthquake.tif")
building_path = test_data_path("exposure", "buildings.shp")
eq_layer = read_layer(eq_path)
building_layer = read_layer(building_path)
impact_function = EarthquakeBuildingFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(building_layer)
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = "In the event of earthquake how many buildings might be affected"
message = "The question should be %s, but it returns %s" % (expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
# Count by hand,
# 1 = low, 2 = medium, 3 = high
impact = {1: 0, 2: 181, 3: 0}
result = {1: 0, 2: 0, 3: 0}
impact_features = impact_layer.get_data()
for i in range(len(impact_features)):
impact_feature = impact_features[i]
level = impact_feature.get(impact_function.target_field)
result[level] += 1
message = "Expecting %s, but it returns %s" % (impact, result)
self.assertEqual(impact, result, message)
def test_volcano_circle_population_impact(self):
"""Volcano function runs circular evacuation zone."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/Merapi_alert.shp' % TESTDATA
exposure_filename = ('%s/glp10ag.asc' % EXPDATA)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'Volcano Polygon Hazard Population'
impact_function = get_plugin(plugin_name)
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
print keywords
# This is the expected number of people affected
# Distance [km] Total Cumulative
# 3 15.800 15.800
# 5 17.300 33.100
# 10 125.000 158.000
message = 'Result not as expected'
impact_summary = keywords['impact_summary']
self.assertTrue(format_int(15800) in impact_summary, message)
self.assertTrue(format_int(17300) in impact_summary, message)
self.assertTrue(format_int(125000) in impact_summary, message)
def test_volcano_population_evacuation_impact(self):
"""Population impact from volcanic hazard is computed correctly."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/donut.shp' % TESTDATA
exposure_filename = ('%s/pop_merapi_clip.tif' % TESTDATA)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'Volcano Polygon Hazard Population'
impact_function = get_plugin(plugin_name)
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
# Check for expected results:
for value in ['Merapi', 192055, 56514, 68568, 66971]:
if isinstance(value, int):
x = format_int(population_rounding(value))
else:
x = value
summary = keywords['impact_summary']
msg = ('Did not find expected value %s in summary %s' %
(x, summary))
assert x in summary, msg
def test_flood_vector_building_impact_function(self):
"""Test flood building impact function works (flood is polygon)."""
building = 'test_flood_building_impact_exposure.shp'
flood_data = 'test_flood_building_impact_hazard.shp'
plugin_name = 'FloodVectorBuildingImpactFunction'
hazard_filename = os.path.join(TESTDATA, flood_data)
exposure_filename = os.path.join(TESTDATA, building)
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
keywords = impact_layer.get_keywords()
buildings_total = keywords['buildings_total']
buildings_affected = keywords['buildings_affected']
self.assertEqual(buildings_total, 67)
self.assertEqual(buildings_affected, 41)
def test_itb_earthquake_fatality_estimation(self):
"""Fatalities from ground shaking can be computed correctly using the
ITB fatality model (Test data from Hadi Ghasemi)."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/itb_test_mmi.asc' % TESTDATA
exposure_filename = '%s/itb_test_pop.asc' % TESTDATA
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'ITB Fatality Function'
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(
layers=[hazard_layer, exposure_layer], impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
# calculated_result = I.get_data()
# print calculated_result.shape
keywords = impact_layer.get_keywords()
# print "keywords", keywords
population = float(keywords['total_population'])
fatalities = float(keywords['total_fatalities'])
# Check aggregated values
expected_population = population_rounding(85424650.0)
msg = ('Expected population was %f, I got %f'
% (expected_population, population))
assert population == expected_population, msg
expected_fatalities = population_rounding(40871.3028)
msg = ('Expected fatalities was %f, I got %f'
% (expected_fatalities, fatalities))
assert numpy.allclose(fatalities, expected_fatalities,
rtol=1.0e-5), msg
# Check that aggregated number of fatilites is as expected
all_numbers = int(numpy.sum([31.8937368131,
2539.26369372,
1688.72362573,
17174.9261705,
19436.834531]))
msg = ('Aggregated number of fatalities not as expected: %i'
% all_numbers)
assert all_numbers == 40871, msg
x = population_rounding(all_numbers)
msg = ('Did not find expected fatality value %i in summary %s'
% (x, keywords['impact_summary']))
assert format_int(x) in keywords['impact_summary'], msg
def test_itb_earthquake_fatality_estimation(self):
"""Fatalities from ground shaking can be computed correctly using the
ITB fatality model (Test data from Hadi Ghasemi)."""
# Name file names for hazard level, exposure and expected fatalities
hazard_filename = '%s/itb_test_mmi.asc' % TESTDATA
exposure_filename = '%s/itb_test_pop.asc' % TESTDATA
# Calculate impact using API
hazard_layer = read_layer(hazard_filename)
exposure_layer = read_layer(exposure_filename)
plugin_name = 'ITB Fatality Function'
impact_function = get_plugin(plugin_name)
# Call calculation engine
impact_layer = calculate_impact(layers=[hazard_layer, exposure_layer],
impact_fcn=impact_function)
impact_filename = impact_layer.get_filename()
impact_layer = read_layer(impact_filename)
# calculated_result = I.get_data()
# print calculated_result.shape
keywords = impact_layer.get_keywords()
# print "keywords", keywords
population = float(keywords['total_population'])
fatalities = float(keywords['total_fatalities'])
# Check aggregated values
expected_population = population_rounding(85424650.0)
msg = ('Expected population was %f, I got %f' %
(expected_population, population))
assert population == expected_population, msg
expected_fatalities = population_rounding(40871.3028)
msg = ('Expected fatalities was %f, I got %f' %
(expected_fatalities, fatalities))
assert numpy.allclose(fatalities, expected_fatalities,
rtol=1.0e-5), msg
# Check that aggregated number of fatilites is as expected
all_numbers = int(
numpy.sum([
31.8937368131, 2539.26369372, 1688.72362573, 17174.9261705,
19436.834531
]))
msg = ('Aggregated number of fatalities not as expected: %i' %
all_numbers)
assert all_numbers == 40871, msg
x = population_rounding(all_numbers)
msg = ('Did not find expected fatality value %i in summary %s' %
(x, keywords['impact_summary']))
assert format_int(x) in keywords['impact_summary'], msg
def test_run(self):
"""TestPagerEarthquakeFatalityFunction: Test running the IF."""
eq_path = test_data_path('hazard', 'earthquake.tif')
population_path = test_data_path(
'exposure', 'pop_binary_raster_20_20.asc')
# For EQ on Pops we need to clip the hazard and exposure first to the
# same dimension
clipped_hazard, clipped_exposure = clip_layers(eq_path,
population_path)
# noinspection PyUnresolvedReferences
eq_layer = read_layer(
str(clipped_hazard.source()))
# noinspection PyUnresolvedReferences
population_layer = read_layer(
str(clipped_exposure.source()))
impact_function = PAGFatalityFunction.instance()
impact_function.hazard = eq_layer
impact_function.exposure = population_layer
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of earthquake how many '
'population might die or be displaced according '
'pager model')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
expected_exposed_per_mmi = {
2.0: 0,
2.5: 0,
3.0: 0,
3.5: 0,
4.0: 0,
4.5: 0,
5.0: 0,
5.5: 0,
6.5: 0,
6.0: 0,
7.0: 0,
7.5: 60,
8.0: 140,
8.5: 0,
9.0: 0,
9.5: 0}
result = impact_layer.get_keywords('exposed_per_mmi')
message = 'Expecting %s, but it returns %s' % (
expected_exposed_per_mmi, result)
self.assertEqual(expected_exposed_per_mmi, result, message)
def analysis_execution():
from safe.test.utilities import get_qgis_app
# get_qgis_app must be called before importing Analysis
QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app()
from safe.utilities.analysis import Analysis
from safe.utilities.keyword_io import KeywordIO
analysis = Analysis()
arg = AnalysisArguments.read_arguments()
register_impact_functions()
registry = ImpactFunctionManager().registry
function = registry.get_instance(arg.impact_function_name)
hazard_layer = safe_to_qgis_layer(read_layer(arg.hazard_filename))
exposure_layer = safe_to_qgis_layer(read_layer(arg.exposure_filename))
if arg.aggregation_filename:
aggregation_layer = safe_to_qgis_layer(read_layer(
arg.aggregation_filename))
keywords_io = KeywordIO()
try:
analysis.map_canvas = IFACE.mapCanvas()
analysis.hazard_layer = hazard_layer
analysis.hazard_keyword = keywords_io.read_keywords(hazard_layer)
analysis.exposure_layer = exposure_layer
analysis.exposure_keyword = keywords_io.read_keywords(exposure_layer)
if aggregation_layer:
analysis.aggregation_layer = aggregation_layer
analysis.aggregation_keyword = keywords_io.read_keywords(
aggregation_layer)
analysis.impact_function = function
analysis.setup_analysis()
print 'Setup analysis done'
analysis.run_analysis()
print 'Analysis done'
except Exception as e:
print e.message
impact = analysis.impact_layer
qgis_impact = safe_to_qgis_layer(impact)
generate_styles(impact, qgis_impact)
copy_impact_layer(impact, arg.impact_filename)
def analysis_execution():
from safe.test.utilities import get_qgis_app
# get_qgis_app must be called before importing Analysis
QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app()
from safe.utilities.analysis import Analysis
from safe.utilities.keyword_io import KeywordIO
analysis = Analysis()
arg = AnalysisArguments.read_arguments()
register_impact_functions()
registry = ImpactFunctionManager().registry
function = registry.get_instance(arg.impact_function_name)
hazard_layer = safe_to_qgis_layer(read_layer(arg.hazard_filename))
exposure_layer = safe_to_qgis_layer(read_layer(arg.exposure_filename))
if arg.aggregation_filename:
aggregation_layer = safe_to_qgis_layer(
read_layer(arg.aggregation_filename))
keywords_io = KeywordIO()
try:
analysis.map_canvas = IFACE.mapCanvas()
analysis.hazard_layer = hazard_layer
analysis.hazard_keyword = keywords_io.read_keywords(hazard_layer)
analysis.exposure_layer = exposure_layer
analysis.exposure_keyword = keywords_io.read_keywords(exposure_layer)
if aggregation_layer:
analysis.aggregation_layer = aggregation_layer
analysis.aggregation_keyword = keywords_io.read_keywords(
aggregation_layer)
analysis.impact_function = function
analysis.setup_analysis()
print 'Setup analysis done'
analysis.run_analysis()
print 'Analysis done'
except Exception as e:
print e.message
impact = analysis.impact_layer
qgis_impact = safe_to_qgis_layer(impact)
generate_styles(impact, qgis_impact)
copy_impact_layer(impact, arg.impact_filename)
def test_run(self):
"""TestPagerEarthquakeFatalityFunction: Test running the IF."""
eq_path = test_data_path('hazard', 'earthquake.tif')
population_path = test_data_path('exposure',
'pop_binary_raster_20_20.asc')
# For EQ on Pops we need to clip the hazard and exposure first to the
# same dimension
clipped_hazard, clipped_exposure = clip_layers(eq_path,
population_path)
# noinspection PyUnresolvedReferences
eq_layer = read_layer(str(clipped_hazard.source()))
# noinspection PyUnresolvedReferences
population_layer = read_layer(str(clipped_exposure.source()))
impact_function = PAGFatalityFunction.instance()
impact_function.hazard = eq_layer
impact_function.exposure = population_layer
impact_function.run()
impact_layer = impact_function.impact
# Check the question
expected_question = ('In the event of earthquake how many '
'population might die or be displaced according '
'pager model')
message = 'The question should be %s, but it returns %s' % (
expected_question, impact_function.question)
self.assertEqual(expected_question, impact_function.question, message)
expected_exposed_per_mmi = {
2.0: 0,
2.5: 0,
3.0: 0,
3.5: 0,
4.0: 0,
4.5: 0,
5.0: 0,
5.5: 0,
6.5: 0,
6.0: 0,
7.0: 0,
7.5: 60,
8.0: 140,
8.5: 0,
9.0: 0,
9.5: 0
}
result = impact_layer.get_keywords('exposed_per_mmi')
message = 'Expecting %s, but it returns %s' % (
expected_exposed_per_mmi, result)
self.assertEqual(expected_exposed_per_mmi, result, message)
def test_calculate_impact(self):
"""Test calculating impact."""
eq_path = test_data_path('hazard', 'earthquake.tif')
building_path = test_data_path('exposure', 'buildings.shp')
eq_layer = read_layer(eq_path)
building_layer = read_layer(building_path)
impact_function = EarthquakeBuildingFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(building_layer)
impact_layer = calculate_impact(impact_function)
self.assertIsNotNone(impact_layer)
def test_calculate_impact(self):
"""Test calculating impact."""
eq_path = test_data_path('hazard', 'earthquake.tif')
building_path = test_data_path('exposure', 'buildings.shp')
eq_layer = read_layer(eq_path)
building_layer = read_layer(building_path)
impact_function = EarthquakeBuildingFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(building_layer)
impact_layer = calculate_impact(impact_function)
self.assertIsNotNone(impact_layer)
def test_clip_points_by_polygons(self):
"""Points can be clipped by polygons (real data)
"""
# Name input files
point_name = join(TESTDATA, 'population_5x5_jakarta_points.shp')
point_layer = read_layer(point_name)
points = numpy.array(point_layer.get_geometry())
attrs = point_layer.get_data()
# Loop through polygons
for filename in ['polygon_0.shp', 'polygon_1.shp', 'polygon_2.shp',
'polygon_3.shp', 'polygon_4.shp',
'polygon_5.shp', 'polygon_6.shp']:
polygon_layer = read_layer(join(TESTDATA, filename))
polygon = polygon_layer.get_geometry()[0]
# Clip
indices = inside_polygon(points, polygon)
# Sanity
for point in points[indices, :]:
assert is_inside_polygon(point, polygon)
# Explicit tests
if filename == 'polygon_0.shp':
assert len(indices) == 6
elif filename == 'polygon_1.shp':
assert len(indices) == 2
assert numpy.allclose(points[indices[0], :],
[106.8125, -6.1875])
assert numpy.allclose(points[indices[1], :],
[106.8541667, -6.1875])
assert numpy.allclose(attrs[indices[0]]['value'],
331941.6875)
assert numpy.allclose(attrs[indices[1]]['value'],
496445.8125)
elif filename == 'polygon_2.shp':
assert len(indices) == 7
elif filename == 'polygon_3.shp':
assert len(indices) == 0 # Degenerate
elif filename == 'polygon_4.shp':
assert len(indices) == 0 # Degenerate
elif filename == 'polygon_5.shp':
assert len(indices) == 8
elif filename == 'polygon_6.shp':
assert len(indices) == 6
def test_clip_points_by_polygons_with_holes0(self):
"""Points can be clipped by polygons with holes
"""
# Define an outer ring
outer_ring = numpy.array([[106.79, -6.233], [106.80, -6.24],
[106.78, -6.23], [106.77, -6.21],
[106.79, -6.233]])
# Define inner rings
inner_rings = [
numpy.array([[106.77827, -6.2252], [106.77775, -6.22378],
[106.78, -6.22311], [106.78017, -6.22530],
[106.77827, -6.2252]])[::-1],
numpy.array([[106.78652, -6.23215], [106.78642, -6.23075],
[106.78746, -6.23143], [106.78831, -6.23307],
[106.78652, -6.23215]])[::-1]
]
v = Vector(
geometry=[Polygon(outer_ring=outer_ring, inner_rings=inner_rings)])
assert v.is_polygon_data
# Write it to file
tmp_filename = unique_filename(suffix='.shp')
v.write_to_file(tmp_filename)
# Read polygon it back
L = read_layer(tmp_filename)
P = L.get_geometry(as_geometry_objects=True)[0]
outer_ring = P.outer_ring
inner_ring0 = P.inner_rings[0]
inner_ring1 = P.inner_rings[1]
# Make some test points
points = generate_random_points_in_bbox(outer_ring, 1000, seed=13)
# Clip to outer ring, excluding holes
indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)
# Sanity
for point in points[indices, :]:
# Must be inside outer ring
assert is_inside_polygon(point, outer_ring)
# But not in any of the inner rings
assert not is_inside_polygon(point, inner_ring0)
assert not is_inside_polygon(point, inner_ring1)
if False:
# Store for visual check
pol = Vector(geometry=[P])
tmp_filename = unique_filename(suffix='.shp')
pol.write_to_file(tmp_filename)
# print 'Polygon with holes written to %s' % tmp_filename
pts = Vector(geometry=points[indices, :])
tmp_filename = unique_filename(suffix='.shp')
pts.write_to_file(tmp_filename)
def accept(self):
"""Process the layer and field and generate a new layer.
.. note:: This is called on ok click.
"""
myIndex = self.cboFields.currentIndex()
myFieldName = self.cboFields.itemData(
myIndex, QtCore.Qt.UserRole).toString()
myIndex = self.cboPolygonLayers.currentIndex()
myLayerId = self.cboPolygonLayers.itemData(
myIndex, QtCore.Qt.UserRole).toString()
myLayer = QgsMapLayerRegistry.instance().mapLayer(myLayerId)
myFileName = str(myLayer.source())
myInputLayer = read_layer(myFileName)
try:
myOutputLayer = self.minimum_needs(myInputLayer, str(myFieldName))
except ValueError:
return
myNewFile = myFileName[:-4] + '_perka7' + '.shp'
myOutputLayer.write_to_file(myNewFile)
myNewLayer = QgsVectorLayer(myNewFile, 'Minimum Needs', 'ogr')
QgsMapLayerRegistry.instance().addMapLayers([myNewLayer])
self.done(QtGui.QDialog.Accepted)
def calculate_impact(self):
if_manager = ImpactFunctionManager()
function_id = self.function_id
impact_function = if_manager.get_instance(function_id)
impact_function.hazard = SafeLayer(self.hazard_layer)
impact_function.exposure = SafeLayer(self.exposure_layer)
try:
self.impact_layer = safe_calculate_impact(impact_function)
self.set_style()
except ZeroImpactException as e:
# in case zero impact, just return
LOGGER.info('No impact detected')
LOGGER.info(e.message)
return
# copy results of impact to report_path directory
base_name, _ = os.path.splitext(self.impact_layer.filename)
dir_name = os.path.dirname(self.impact_layer.filename)
for (root, dirs, files) in os.walk(dir_name):
for f in files:
source_filename = os.path.join(root, f)
if source_filename.find(base_name) >= 0:
extensions = source_filename.replace(base_name, '')
new_path = os.path.join(self.report_path,
'impact' + extensions)
shutil.copy(source_filename, new_path)
self.impact_layer = read_layer(self.impact_path)
def test_osm2padang(self):
"""OSM structure types maps to Padang vulnerability curves
"""
# hazard_filename = '%s/Shakemap_Padang_2009.asc' % HAZDATA
exposure_filename = ('%s/jakarta_OSM_building.shp'
% EXPDATA)
# Calculate impact using API
E = read_layer(exposure_filename)
# Map from OSM attributes to the padang building classes
Emap = osm2padang(E)
for i, feature in enumerate(E.get_data()):
vclass = int(Emap.get_data('VCLASS', i))
levels = feature['building_l']
structure = feature['building_s']
msg = ('Unexpected VCLASS %i. '
'I have levels == %s and structure == %s.'
% (vclass, levels, structure))
if levels is None or structure is None:
assert vclass == 2, msg
continue
# Map string variable levels to integer
if levels.endswith('+'):
levels = 100
try:
levels = int(levels)
except ValueError:
# E.g. 'ILP jalan'
assert vclass == 2, msg
continue
levels = int(levels)
# Check the main cases
if levels >= 10:
assert vclass == 6, msg
elif 4 <= levels < 10:
assert vclass == 4, msg
elif 1 <= levels < 4:
if structure in ['plastered',
'reinforced masonry',
'reinforced_masonry']:
assert vclass == 7, msg
elif structure == 'confined_masonry':
assert vclass == 8, msg
elif 'kayu' in structure or 'wood' in structure:
assert vclass == 9, msg
else:
assert vclass == 2, msg
else:
assert vclass == 2, msg
def test_run_failed(self):
"""Test run IF with missing keywords."""
merapi_krb_path = standard_data_path('hazard', 'volcano_krb.shp')
population_path = standard_data_path('exposure',
'pop_binary_raster_20_20.asc')
merapi_krb_layer = read_layer(merapi_krb_path)
population_layer = read_layer(population_path)
impact_function = VolcanoPolygonPopulationFunction.instance()
# 2. Run merapi krb
layer = SafeLayer(merapi_krb_layer)
layer.keywords = {}
impact_function.hazard = layer
impact_function.exposure = SafeLayer(population_layer)
self.assertRaises(KeywordNotFoundError, impact_function.run)