本文整理汇总了Python中safe.impact_function.impact_function.ImpactFunction.run方法的典型用法代码示例。如果您正苦于以下问题:Python ImpactFunction.run方法的具体用法?Python ImpactFunction.run怎么用?Python ImpactFunction.run使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类safe.impact_function.impact_function.ImpactFunction
的用法示例。
在下文中一共展示了ImpactFunction.run方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_profiling
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_profiling(self):
"""Test running impact function on test data."""
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'classified_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'building-points.geojson')
aggregation_layer = load_test_vector_layer(
'gisv4', 'aggregation', 'small_grid.geojson')
# Set up impact function
impact_function = ImpactFunction()
impact_function.aggregation = aggregation_layer
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
status, message = impact_function.run()
self.assertEqual(ANALYSIS_FAILED_BAD_INPUT, status, message)
impact_function.prepare()
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
message = impact_function.performance_log_message().to_text()
expected_result = get_control_text(
'test-profiling-logs.txt')
for line in expected_result:
line = line.replace('\n', '')
if line == '' or line == '-':
continue
self.assertIn(line, message)
# Notes(IS): For some unknown reason I need to do this to make
# test_provenance pass
del hazard_layer
示例2: test_analysis_earthquake_summary
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_analysis_earthquake_summary(self):
"""Test we can compute summary after an EQ on population."""
hazard = load_test_raster_layer('gisv4', 'hazard', 'earthquake.asc')
exposure = load_test_raster_layer(
'gisv4', 'exposure', 'raster', 'population.asc')
aggregation = load_test_vector_layer(
'gisv4', 'aggregation', 'small_grid.geojson')
impact_function = ImpactFunction()
impact_function.hazard = hazard
impact_function.exposure = exposure
impact_function.aggregation = aggregation
status, message = impact_function.prepare()
self.assertEqual(PREPARE_SUCCESS, status, message)
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
layer = impact_function.analysis_impacted
classification = hazard.keywords['classification']
classes = definition(classification)['classes']
for hazard_class in classes:
field_name = hazard_count_field['field_name'] % hazard_class['key']
message = '%s is not found in the EQ summary layer.' % field_name
self.assertNotEqual(-1, layer.fieldNameIndex(field_name), message)
check_inasafe_fields(impact_function.analysis_impacted)
check_inasafe_fields(impact_function.aggregation_summary)
示例3: test_provenance_without_aggregation
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_provenance_without_aggregation(self):
"""Test provenance of impact function without aggregation."""
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'classified_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'building-points.geojson')
hazard = definition(hazard_layer.keywords['hazard'])
exposure = definition(exposure_layer.keywords['exposure'])
hazard_category = definition(hazard_layer.keywords['hazard_category'])
expected_provenance = {
'gdal_version': gdal.__version__,
'host_name': gethostname(),
'map_title': get_map_title(hazard, exposure, hazard_category),
'map_legend_title': exposure['layer_legend_title'],
'inasafe_version': get_version(),
'pyqt_version': PYQT_VERSION_STR,
'qgis_version': QGis.QGIS_VERSION,
'qt_version': QT_VERSION_STR,
'user': getpass.getuser(),
'os': readable_os_version(),
'aggregation_layer': None,
'aggregation_layer_id': None,
'exposure_layer': exposure_layer.source(),
'exposure_layer_id': exposure_layer.id(),
'hazard_layer': hazard_layer.source(),
'hazard_layer_id': hazard_layer.id(),
'analysis_question': get_analysis_question(hazard, exposure),
'aggregation_keywords': None,
'exposure_keywords': deepcopy(exposure_layer.keywords),
'hazard_keywords': deepcopy(hazard_layer.keywords),
}
# Set up impact function
impact_function = ImpactFunction()
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
status, message = impact_function.prepare()
self.assertEqual(PREPARE_SUCCESS, status, message)
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
self.maxDiff = None
expected_provenance.update({
'action_checklist': impact_function.action_checklist(),
'analysis_extent': impact_function.analysis_extent.exportToWkt(),
'impact_function_name': impact_function.name,
'impact_function_title': impact_function.title,
'notes': impact_function.notes(),
'requested_extent': impact_function.requested_extent,
'data_store_uri': impact_function.datastore.uri_path,
'start_datetime': impact_function.start_datetime,
'end_datetime': impact_function.end_datetime,
'duration': impact_function.duration
})
self.assertDictEqual(expected_provenance, impact_function.provenance)
示例4: test_raster_post_minimum_needs_value_generation
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_raster_post_minimum_needs_value_generation(self):
"""Test minimum needs postprocessors on raster exposure.
Minimum needs postprocessors is defined to only generate values
when exposure contains population data.
Especially important to test, since on raster exposure the population
field is generated on the fly.
The postprocessors need to expect generated population field exists.
"""
# # #
# Test with raster exposure data with population_exposure_count
# exists.
# # #
hazard_layer = load_test_raster_layer(
'hazard', 'tsunami_wgs84.tif')
exposure_layer = load_test_raster_layer(
'exposure', 'pop_binary_raster_20_20.asc')
impact_function = ImpactFunction()
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.prepare()
return_code, message = impact_function.run()
self.assertEqual(return_code, ANALYSIS_SUCCESS, message)
# minimum needs fields should exists in the results
self._check_minimum_fields_exists(impact_function)
# TODO: should include demographic postprocessor value too
expected_value = {
u'total_affected': 9.208200000039128,
u'minimum_needs__rice': 25,
u'minimum_needs__toilets': 0,
u'minimum_needs__drinking_water': 161,
u'minimum_needs__clean_water': 616,
u'male': 4,
u'female': 4,
u'youth': 2,
u'adult': 6,
u'elderly': 0,
u'total': 162.7667000000474,
u'minimum_needs__family_kits': 1,
u'total_not_affected': 153.55850000000828,
}
self._check_minimum_fields_value(expected_value, impact_function)
示例5: test_vector_post_minimum_needs_value_generation
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_vector_post_minimum_needs_value_generation(self):
"""Test minimum needs postprocessors on vector exposure.
Test with vector exposure data with population_count_field exists.
Minimum needs postprocessors is defined to only generate values when
exposure contains population data.
"""
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'tsunami_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'population.geojson')
aggregation_layer = load_test_vector_layer(
'gisv4', 'aggregation', 'small_grid.geojson')
impact_function = ImpactFunction()
impact_function.aggregation = aggregation_layer
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
status, message = impact_function.prepare()
self.assertEqual(PREPARE_SUCCESS, status, message)
return_code, message = impact_function.run()
self.assertEqual(return_code, ANALYSIS_SUCCESS, message)
# minimum needs fields should exists in the results
self._check_minimum_fields_exists(impact_function)
expected_value = {
u'population': 69,
u'total': 9.0,
u'minimum_needs__rice': 491,
u'minimum_needs__clean_water': 11763,
u'minimum_needs__toilets': 8,
u'minimum_needs__drinking_water': 3072,
u'minimum_needs__family_kits': 35,
u'male': 34,
u'female': 34,
u'youth': 17,
u'adult': 45,
u'elderly': 6,
u'total_affected': 6.0,
}
self._check_minimum_fields_value(expected_value, impact_function)
示例6: run_task
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def run_task(self, task_item, status_item, count=0, index=''):
"""Run a single task.
:param task_item: Table task_item containing task name / details.
:type task_item: QTableWidgetItem
:param status_item: Table task_item that holds the task status.
:type status_item: QTableWidgetItem
:param count: Count of scenarios that have been run already.
:type count:
:param index: The index for the table item that will be run.
:type index: int
:returns: Flag indicating if the task succeeded or not.
:rtype: bool
"""
self.enable_busy_cursor()
for layer_group in self.layer_group_container:
layer_group.setItemVisibilityChecked(False)
# set status to 'running'
status_item.setText(self.tr('Running'))
# .. see also:: :func:`appendRow` to understand the next 2 lines
variant = task_item.data(QtCore.Qt.UserRole)
value = variant[0]
result = True
if isinstance(value, str):
filename = value
# run script
try:
self.run_script(filename)
# set status to 'OK'
status_item.setText(self.tr('Script OK'))
except Exception as e: # pylint: disable=W0703
# set status to 'fail'
status_item.setText(self.tr('Script Fail'))
LOGGER.exception(
'Running macro failed. The exception: ' + str(e))
result = False
elif isinstance(value, dict):
# start in new project if toggle is active
if self.start_in_new_project:
self.iface.newProject()
# create layer group
group_name = value['scenario_name']
self.layer_group = self.root.addGroup(group_name)
self.layer_group_container.append(self.layer_group)
# Its a dict containing files for a scenario
success, parameters = self.prepare_task(value)
if not success:
# set status to 'running'
status_item.setText(self.tr('Please update scenario'))
self.disable_busy_cursor()
return False
directory = self.output_directory.text()
if self.scenario_directory_radio.isChecked():
directory = self.source_directory.text()
output_directory = os.path.join(directory, group_name)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
# If impact function parameters loaded successfully, initiate IF.
impact_function = ImpactFunction()
impact_function.datastore = Folder(output_directory)
impact_function.datastore.default_vector_format = "geojson"
impact_function.hazard = parameters[layer_purpose_hazard['key']]
impact_function.exposure = (
parameters[layer_purpose_exposure['key']])
if parameters[layer_purpose_aggregation['key']]:
impact_function.aggregation = (
parameters[layer_purpose_aggregation['key']])
elif parameters['extent']:
impact_function.requested_extent = parameters['extent']
impact_function.crs = parameters['crs']
prepare_status, prepare_message = impact_function.prepare()
if prepare_status == PREPARE_SUCCESS:
LOGGER.info('Impact function ready')
status, message = impact_function.run()
if status == ANALYSIS_SUCCESS:
status_item.setText(self.tr('Analysis Success'))
impact_layer = impact_function.impact
if impact_layer.isValid():
layer_list = [
impact_layer,
impact_function.analysis_impacted,
parameters[layer_purpose_hazard['key']],
parameters[layer_purpose_exposure['key']],
parameters[layer_purpose_aggregation['key']]]
QgsProject.instance().addMapLayers(
layer_list, False)
for layer in layer_list:
self.layer_group.addLayer(layer)
#.........这里部分代码省略.........
示例7: test_ratios_with_raster_exposure
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_ratios_with_raster_exposure(self):
"""Test if we can add defaults to a raster exposure.
See ticket #3851 how to manage ratios with a raster exposure.
"""
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'tsunami_vector.geojson')
exposure_layer = load_test_raster_layer(
'gisv4', 'exposure', 'raster', 'population.asc')
# Set up impact function
impact_function = ImpactFunction()
impact_function.debug_mode = True
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.prepare()
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
for layer in impact_function.outputs:
if layer.keywords['layer_purpose'] == (
layer_purpose_analysis_impacted['key']):
analysis = layer
if layer.keywords['layer_purpose'] == (
layer_purpose_aggregate_hazard_impacted['key']):
impact = layer
# We check in the impact layer if we have :
# female default ratio with the default value
index = impact.fieldNameIndex(female_ratio_field['field_name'])
self.assertNotEqual(-1, index)
unique_values = impact.uniqueValues(index)
self.assertEqual(1, len(unique_values))
female_ratio = unique_values[0]
# female displaced count and youth displaced count
self.assertNotEqual(
-1, impact.fieldNameIndex(
female_displaced_count_field['field_name']))
self.assertNotEqual(
-1, impact.fieldNameIndex(
youth_displaced_count_field['field_name']))
# Check that we have more than 0 female displaced in the analysis layer
index = analysis.fieldNameIndex(
female_displaced_count_field['field_name'])
female_displaced = analysis.uniqueValues(index)[0]
self.assertGreater(female_displaced, 0)
# Let's check computation
index = analysis.fieldNameIndex(
displaced_field['field_name'])
displaced_population = analysis.uniqueValues(index)[0]
self.assertEqual(
int(displaced_population * female_ratio), female_displaced)
# Check that we have more than 0 youth displaced in the analysis layer
index = analysis.fieldNameIndex(
female_displaced_count_field['field_name'])
value = analysis.uniqueValues(index)[0]
self.assertGreater(value, 0)
# Let do another test with the special aggregation layer
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'tsunami_vector.geojson')
exposure_layer = load_test_raster_layer(
'gisv4', 'exposure', 'raster', 'population.asc')
aggregation_layer = load_test_vector_layer(
'gisv4', 'aggregation', 'small_grid_ratios.geojson')
# This aggregation layer has :
# * a field for female ratio : 1, 0.5 and 0
# * use global default for youth ratio
# * do not ust for adult ratio
# * use custom 0.75 for elderly ratio
# Set up impact function
impact_function = ImpactFunction()
impact_function.debug_mode = True
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.aggregation = aggregation_layer
status, message = impact_function.prepare()
self.assertEqual(PREPARE_SUCCESS, status, message)
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
impact = impact_function.impact
# We should have a female_ratio with many values
index = impact.fieldNameIndex(female_ratio_field['field_name'])
self.assertNotEqual(-1, index)
values = impact.uniqueValues(index)
self.assertEqual(3, len(values))
# We should have a youth_ratio with global default
index = impact.fieldNameIndex(youth_ratio_field['field_name'])
self.assertNotEqual(-1, index)
values = impact.uniqueValues(index)
self.assertEqual(1, len(values))
#.........这里部分代码省略.........
示例8: test_ratios_with_vector_exposure
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_ratios_with_vector_exposure(self):
"""Test if we can add defaults to a vector exposure."""
# First test, if we do not provide an aggregation,
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'classified_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'population.geojson')
# Set up impact function
impact_function = ImpactFunction()
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.prepare()
# Let's remove one field from keywords.
# We monkey patch keywords for testing after `prepare` & before `run`.
fields = impact_function.exposure.keywords['inasafe_fields']
del fields[female_count_field['key']]
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
impact = impact_function.impact
# We check the field exist after the IF with only one value.
field = impact.fieldNameIndex(
female_ratio_field['field_name'])
self.assertNotEqual(-1, field)
unique_ratio = impact.uniqueValues(field)
self.assertEqual(1, len(unique_ratio), unique_ratio)
self.assertEqual(
unique_ratio[0], female_ratio_default_value['default_value'])
# Second test, if we provide an aggregation without a default ratio 0.2
expected_ratio = 1.0
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'classified_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'population.geojson')
aggregation_layer = load_test_vector_layer(
'gisv4', 'aggregation', 'small_grid.geojson')
# Set up impact function
impact_function = ImpactFunction()
impact_function.aggregation = aggregation_layer
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.debug_mode = True
impact_function.prepare()
# The `prepare` reads keywords from the file.
impact_function.aggregation.keywords['inasafe_default_values'] = {
elderly_ratio_field['key']: expected_ratio
}
fields = impact_function.exposure.keywords['inasafe_fields']
del fields[female_count_field['key']]
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
impact = impact_function.impact
# We check the field exist after the IF with only original values.
field = impact.fieldNameIndex(
female_ratio_field['field_name'])
self.assertNotEqual(-1, field)
unique_ratio = impact.uniqueValues(field)
self.assertEqual(3, len(unique_ratio), unique_ratio)
# We check the field exist after the IF with only one value.
field = impact.fieldNameIndex(
elderly_ratio_field['field_name'])
self.assertNotEqual(-1, field)
unique_ratio = impact.uniqueValues(field)
self.assertEqual(1, len(unique_ratio), unique_ratio)
self.assertEqual(expected_ratio, unique_ratio[0])
# Third test, if we provide an aggregation with a ratio and the
# exposure has a count, we should a have a ratio from the exposure
# count.
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'classified_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'population.geojson')
aggregation_layer = load_test_vector_layer(
'gisv4', 'aggregation', 'small_grid.geojson')
# Set up impact function
impact_function = ImpactFunction()
impact_function.debug_mode = True
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.aggregation = aggregation_layer
impact_function.prepare()
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
impact = impact_function.impact
# Check that we have don't have only one unique value since the ratio
# depends on the "population / female count" and we should have at
# least different ratios.
field = impact.fieldNameIndex(
female_ratio_field['field_name'])
self.assertNotEqual(-1, field)
#.........这里部分代码省略.........
示例9: run_scenario
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def run_scenario(scenario, use_debug=False):
"""Run scenario.
:param scenario: Dictionary of hazard, exposure, and aggregation.
:type scenario: dict
:param use_debug: If we should use debug_mode when we run the scenario.
:type use_debug: bool
:returns: Tuple(status, Flow dictionary, outputs).
:rtype: list
"""
if os.path.exists(scenario['exposure']):
exposure_path = scenario['exposure']
elif os.path.exists(standard_data_path('exposure', scenario['exposure'])):
exposure_path = standard_data_path('exposure', scenario['exposure'])
elif os.path.exists(
standard_data_path(*(scenario['exposure'].split('/')))):
exposure_path = standard_data_path(*(scenario['exposure'].split('/')))
else:
raise IOError('No exposure file')
if os.path.exists(scenario['hazard']):
hazard_path = scenario['hazard']
elif os.path.exists(standard_data_path('hazard', scenario['hazard'])):
hazard_path = standard_data_path('hazard', scenario['hazard'])
elif os.path.exists(standard_data_path(*(scenario['hazard'].split('/')))):
hazard_path = standard_data_path(*(scenario['hazard'].split('/')))
else:
raise IOError('No hazard file')
if not scenario['aggregation']:
aggregation_path = None
else:
if os.path.exists(scenario['aggregation']):
aggregation_path = scenario['aggregation']
elif os.path.exists(standard_data_path(
'aggregation', scenario['aggregation'])):
aggregation_path = standard_data_path(
'aggregation', scenario['aggregation'])
elif os.path.exists(
standard_data_path(*(scenario['aggregation'].split('/')))):
aggregation_path = standard_data_path(
*(scenario['aggregation'].split('/')))
else:
raise IOError('No aggregation file')
impact_function = ImpactFunction()
impact_function.debug_mode = use_debug
layer = QgsVectorLayer(hazard_path, 'Hazard', 'ogr')
if not layer.isValid():
layer = QgsRasterLayer(hazard_path, 'Hazard')
impact_function.hazard = layer
layer = QgsVectorLayer(exposure_path, 'Exposure', 'ogr')
if not layer.isValid():
layer = QgsRasterLayer(exposure_path, 'Exposure')
impact_function.exposure = layer
if aggregation_path:
impact_function.aggregation = QgsVectorLayer(
aggregation_path, 'Aggregation', 'ogr')
status, message = impact_function.prepare()
if status != 0:
return status, message, None
status, message = impact_function.run()
if status != 0:
return status, message, None
for layer in impact_function.outputs:
if layer.type() == QgsMapLayer.VectorLayer:
check_inasafe_fields(layer)
return status, impact_function.state, impact_function.outputs
示例10: test_provenance_without_aggregation
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_provenance_without_aggregation(self):
"""Test provenance of impact function without aggregation."""
hazard_layer = load_test_vector_layer(
'gisv4', 'hazard', 'classified_vector.geojson')
exposure_layer = load_test_vector_layer(
'gisv4', 'exposure', 'building-points.geojson')
hazard = definition(hazard_layer.keywords['hazard'])
exposure = definition(exposure_layer.keywords['exposure'])
hazard_category = definition(hazard_layer.keywords['hazard_category'])
expected_provenance = {
provenance_gdal_version['provenance_key']: gdal.__version__,
provenance_host_name['provenance_key']: gethostname(),
provenance_map_title['provenance_key']: get_map_title(
hazard, exposure, hazard_category),
provenance_map_legend_title['provenance_key']: exposure[
'layer_legend_title'],
provenance_user['provenance_key']: getpass.getuser(),
provenance_os['provenance_key']: readable_os_version(),
provenance_pyqt_version['provenance_key']: PYQT_VERSION_STR,
provenance_qgis_version['provenance_key']: QGis.QGIS_VERSION,
provenance_qt_version['provenance_key']: QT_VERSION_STR,
provenance_inasafe_version['provenance_key']: get_version(),
provenance_aggregation_layer['provenance_key']: None,
provenance_aggregation_layer_id['provenance_key']: None,
provenance_exposure_layer['provenance_key']:
exposure_layer.source(),
provenance_exposure_layer_id['provenance_key']:
exposure_layer.id(),
provenance_hazard_layer['provenance_key']: hazard_layer.source(),
provenance_hazard_layer_id['provenance_key']: hazard_layer.id(),
provenance_analysis_question['provenance_key']:
get_analysis_question(hazard, exposure),
provenance_aggregation_keywords['provenance_key']: None,
provenance_exposure_keywords['provenance_key']:
deepcopy(exposure_layer.keywords),
provenance_hazard_keywords['provenance_key']: deepcopy(
hazard_layer.keywords),
}
# Set up impact function
impact_function = ImpactFunction()
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
status, message = impact_function.prepare()
self.assertEqual(PREPARE_SUCCESS, status, message)
status, message = impact_function.run()
self.assertEqual(ANALYSIS_SUCCESS, status, message)
self.maxDiff = None
expected_provenance.update({
provenance_action_checklist['provenance_key']:
impact_function.action_checklist(),
provenance_analysis_extent['provenance_key']:
impact_function.analysis_extent.exportToWkt(),
provenance_impact_function_name['provenance_key']:
impact_function.name,
provenance_impact_function_title['provenance_key']:
impact_function.title,
provenance_notes['provenance_key']: impact_function.notes(),
provenance_requested_extent['provenance_key']: impact_function.
requested_extent,
provenance_data_store_uri['provenance_key']: impact_function.
datastore.uri_path,
provenance_start_datetime['provenance_key']: impact_function.
start_datetime,
provenance_end_datetime['provenance_key']:
impact_function.end_datetime,
provenance_duration['provenance_key']: impact_function.duration
})
self.assertDictContainsSubset(
expected_provenance, impact_function.provenance)
output_layer_provenance_keys = [
provenance_layer_exposure_summary['provenance_key'],
provenance_layer_aggregate_hazard_impacted['provenance_key'],
provenance_layer_aggregation_summary['provenance_key'],
provenance_layer_analysis_impacted['provenance_key'],
provenance_layer_exposure_summary_table['provenance_key']
]
for key in output_layer_provenance_keys:
self.assertIn(key, impact_function.provenance.keys())
示例11: test_earthquake_population_without_aggregation
# 需要导入模块: from safe.impact_function.impact_function import ImpactFunction [as 别名]
# 或者: from safe.impact_function.impact_function.ImpactFunction import run [as 别名]
def test_earthquake_population_without_aggregation(self):
"""Testing Earthquake in Population without aggregation.
.. versionadded:: 4.0
"""
output_folder = self.fixtures_dir('../output/earthquake_population')
# Classified vector with building-points
shutil.rmtree(output_folder, ignore_errors=True)
hazard_layer = load_test_raster_layer(
'hazard', 'earthquake.tif')
exposure_layer = load_test_raster_layer(
'exposure', 'pop_binary_raster_20_20.asc')
impact_function = ImpactFunction()
impact_function.exposure = exposure_layer
impact_function.hazard = hazard_layer
impact_function.prepare()
return_code, message = impact_function.run()
self.assertEqual(return_code, ANALYSIS_SUCCESS, message)
report_metadata = ReportMetadata(
metadata_dict=standard_impact_report_metadata_html)
impact_report = ImpactReport(
IFACE,
report_metadata,
impact_function=impact_function)
impact_report.output_folder = output_folder
return_code, message = impact_report.process_components()
self.assertEqual(
return_code, ImpactReport.REPORT_GENERATION_SUCCESS, message)
"""Checking generated context"""
empty_component_output_message = 'Empty component output'
# Check Analysis Summary
analysis_summary = impact_report.metadata.component_by_key(
general_report_component['key'])
""":type: safe.report.report_metadata.Jinja2ComponentsMetadata"""
expected_context = {
'table_header': (
u'Estimated Number of people affected per MMI intensity'),
'header': u'General Report',
'summary': [
{
'header_label': u'Hazard Zone',
'rows': [
{'value': 0, 'name': u'X', 'key': 'X'},
{'value': 0, 'name': u'IX', 'key': 'IX'},
{'value': '200', 'name': u'VIII', 'key': 'VIII'},
{'value': 0, 'name': u'VII', 'key': 'VII'},
{'value': 0, 'name': u'VI', 'key': 'VI'},
{'value': 0, 'name': u'V', 'key': 'V'},
{'value': 0, 'name': u'IV', 'key': 'IV'},
{'value': 0, 'name': u'III', 'key': 'III'},
{'value': 0, 'name': u'II', 'key': 'II'},
{'value': 0, 'name': u'I', 'key': 'I'},
{
'as_header': True,
'key': 'total_field',
'name': u'Total',
'value': '200'
}
],
'value_label': u'Count'
},
{
'header_label': u'Population',
'rows': [
{
'value': '200',
'name': u'Affected',
'key': 'total_affected_field',
}, {
'key': 'total_not_affected_field',
'name': u'Not Affected',
'value': '0'
}, {
'key': 'total_not_exposed_field',
'name': u'Not Exposed',
'value': '0'},
{
'value': '200',
'name': u'Displaced',
'key': 'displaced_field'
}, {
'value': '0 - 100',
'name': u'Fatalities',
'key': 'fatalities_field'
}],
'value_label': u'Count'
}
],
'notes': [
'Exposed People: People who are present in hazard zones and '
#.........这里部分代码省略.........