def test_compute_probability(self):
impact_function = ITBBayesianFatalityFunction.instance()
total_fatalities = numpy.array([
1, 9, 10, 99, 101, 999, 9999, 10000, 100001, 999999])
result = impact_function.compute_probability(total_fatalities)
expected_result = numpy.array([20., 20., 20., 10., 10., 20.])
numpy.testing.assert_allclose(expected_result, result, rtol=1.0e-3)
def test_compute_probability(self):
impact_function = ITBBayesianFatalityFunction.instance()
total_fatalities = numpy.array(
[1, 9, 10, 99, 101, 999, 9999, 10000, 100001, 999999])
result = impact_function.compute_probability(total_fatalities)
expected_result = numpy.array([20., 20., 20., 10., 10., 20.])
numpy.testing.assert_allclose(expected_result, result, rtol=1.0e-3)
def test_functions_for_constraint(self):
"""Test functions_for_constraint."""
ifm = ImpactFunctionManager()
impact_functions = ifm.functions_for_constraint(
'earthquake',
'population',
'raster',
'raster',
'continuous',
'continuous',
)
expected = [
ITBFatalityFunction.metadata().as_dict(),
ITBBayesianFatalityFunction.metadata().as_dict(),
PAGFatalityFunction.metadata().as_dict(),
ContinuousHazardPopulationFunction.metadata().as_dict()
]
for key in impact_functions[0].keys():
if key == 'parameters':
# We do not check the parameters since they are mutable.
continue
result = [x[key] for x in impact_functions]
hope = [x[key] for x in expected]
message = key
self.assertItemsEqual(result, hope, message)
def test_functions_for_constraint(self):
"""Test functions_for_constraint."""
ifm = ImpactFunctionManager()
impact_functions = ifm.functions_for_constraint(
'earthquake',
'population',
'raster',
'raster',
'continuous',
'continuous',
)
expected = [
ITBFatalityFunction.metadata().as_dict(),
ITBBayesianFatalityFunction.metadata().as_dict(),
PAGFatalityFunction.metadata().as_dict(),
ContinuousHazardPopulationFunction.metadata().as_dict()]
for key in impact_functions[0].keys():
if key == 'parameters':
# We do not check the parameters since they are mutable.
continue
result = [x[key] for x in impact_functions]
hope = [x[key] for x in expected]
message = key
self.assertItemsEqual(result, hope, message)
def test_is_valid(self):
"""Test is_valid."""
impact_functions = [
# Earthquake
EarthquakeBuildingFunction(),
ITBFatalityFunction(),
PAGFatalityFunction(),
ITBBayesianFatalityFunction(),
# Generic
ClassifiedPolygonHazardBuildingFunction(),
ClassifiedPolygonHazardLandCoverFunction(),
ClassifiedPolygonHazardPopulationFunction(),
ClassifiedPolygonHazardPolygonPeopleFunction(),
ClassifiedRasterHazardBuildingFunction(),
ClassifiedRasterHazardPopulationFunction(),
ContinuousHazardPopulationFunction(),
# Inundation
FloodEvacuationVectorHazardFunction(),
FloodPolygonRoadsFunction(),
FloodRasterBuildingFunction(),
FloodEvacuationRasterHazardFunction(),
FloodRasterRoadsFunction(),
FloodPolygonBuildingFunction(),
# Tsunami
TsunamiEvacuationFunction(),
TsunamiRasterRoadsFunction(),
TsunamiRasterLandcoverFunction(),
TsunamiRasterBuildingFunction(),
# Volcanic
VolcanoPointBuildingFunction(),
VolcanoPointPopulationFunction(),
VolcanoPolygonBuildingFunction(),
VolcanoPolygonPopulationFunction(),
# Volcanic Ash
AshRasterLandCoverFunction(),
AshRasterPlacesFunction(),
AshRasterPopulationFunction()
]
self.assertEqual(len(impact_functions), len(EXPECTED_IF))
for impact_function in impact_functions:
valid = impact_function.metadata().is_valid()
impact_function_name = impact_function.__class__.__name__
message = '%s is invalid because %s' % (impact_function_name,
valid[1])
self.assertTrue(valid[0], message)
if valid[0]:
# print '%s has a valid metadata.' % impact_function_name
continue
def test_parameter(self):
"""Test for checking parameter is carried out"""
eq_path = standard_data_path('hazard', 'earthquake.tif')
population_path = standard_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 = ITBBayesianFatalityFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(population_layer)
expected = {
'postprocessors': {
'Age': {
'Age': {
'Adult ratio': 0.659,
'Elderly ratio': 0.078,
'Youth ratio': 0.263
}
},
'Gender': {
'Gender': True
},
'MinimumNeeds': {
'MinimumNeeds': True
}
}
}
self.assertDictEqual(expected, impact_function.parameters_value())
def test_parameter(self):
"""Test for checking parameter is carried out"""
eq_path = standard_data_path('hazard', 'earthquake.tif')
population_path = standard_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 = ITBBayesianFatalityFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(population_layer)
expected = {
'postprocessors': {
'Age': {
'Age': {
'Adult ratio': 0.659,
'Elderly ratio': 0.078,
'Youth ratio': 0.263
}
},
'Gender': {'Gender': True},
'MinimumNeeds': {'MinimumNeeds': True}
}
}
self.assertDictEqual(expected, impact_function.parameters_value())
def test_run(self):
"""TestITBBayesianEarthquakeFatalityFunction: Test running the IF."""
# FIXME(Hyeuk): test requires more realistic hazard and population data
eq_path = standard_data_path('hazard', 'earthquake.tif')
population_path = standard_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 = ITBBayesianFatalityFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(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 itb bayesian model?')
self.assertEqual(expected_question, impact_function.question)
expected_result = {
'total_population': 200,
'total_fatalities': 0,
'total_displaced': 200
}
for key_ in expected_result.keys():
result = impact_layer.get_keywords(key_)
message = 'Expecting %s, but it returns %s' % (
expected_result[key_], result)
self.assertEqual(expected_result[key_], result, message)
expected_result = {}
expected_result['exposed_per_mmi'] = {
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0,
8: 200,
9: 0,
10: 0
}
expected_result['displaced_per_mmi'] = {
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0,
8: 199.6297, # FIXME should be 200.0
9: 0,
10: 0
}
for key_ in expected_result.keys():
result = impact_layer.get_keywords(key_)
for item in expected_result[key_].keys():
message = 'Expecting %s, but it returns %s' % (
expected_result[key_][item], result[item])
self.assertAlmostEqual(expected_result[key_][item],
result[item],
places=4,
msg=message)
expected_result = [100.0, 0.0, 0.0, 0.0, 0.0, 0.0]
result = impact_layer.get_keywords('prob_fatality_mag')
message = 'Expecting %s, but it returns %s' % (expected_result, result)
self.assertEqual(expected_result, result, message)
def test_run(self):
"""TestITBBayesianEarthquakeFatalityFunction: Test running the IF."""
# FIXME(Hyeuk): test requires more realistic hazard and population data
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 = ITBBayesianFatalityFunction.instance()
impact_function.hazard = SafeLayer(eq_layer)
impact_function.exposure = SafeLayer(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 itb bayesian 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_result = {
'total_population': 200,
'total_fatalities': 0,
'total_displaced': 200
}
for key_ in expected_result.keys():
result = impact_layer.get_keywords(key_)
message = 'Expecting %s, but it returns %s' % (
expected_result[key_], result)
self.assertEqual(expected_result[key_], result, message)
expected_result = {}
expected_result['exposed_per_mmi'] = {
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0,
8: 200,
9: 0,
10: 0
}
expected_result['displaced_per_mmi'] = {
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0,
8: 199.6297, # FIXME should be 200.0
9: 0,
10: 0
}
for key_ in expected_result.keys():
result = impact_layer.get_keywords(key_)
for item in expected_result[key_].keys():
message = 'Expecting %s, but it returns %s' % (
expected_result[key_][item], result[item])
self.assertAlmostEqual(
expected_result[key_][item],
result[item], places=4, msg=message)
expected_result = [
100.0, 0.0, 0.0, 0.0, 0.0, 0.0]
result = impact_layer.get_keywords('prob_fatality_mag')
message = 'Expecting %s, but it returns %s' % (
expected_result, result)
self.assertEqual(expected_result, result, message)
