def get_eid(self, events_npz):
self.events_npz = events_npz
events = events_npz['array']
self.eid = -1 # assuming events start from 0
if 'GEM_QGIS_TEST' in os.environ:
self.eid = self.get_closest_element(self.eid, events['id'])
ok = True
elif 'scenario' in self.calculation_mode:
range_width = self.oqparam['number_of_ground_motion_fields']
ranges = {}
for gsim_idx, gsim in enumerate(self.gsims):
ranges[gsim] = (gsim_idx * range_width,
gsim_idx * range_width + range_width - 1)
ranges_str = ''
for gsim in ranges:
ranges_str += '\n%s: %s' % (gsim, ranges[gsim])
input_msg = "Ranges:%s" % ranges_str
else:
input_msg = "Range (%s - %s)" % (events[0]['id'], events[-1]['id'])
if 'GEM_QGIS_TEST' not in os.environ:
while self.eid not in events['id']:
if self.eid == -1:
is_first_iteration = True
self.eid = self.get_closest_element(self.eid, events['id'])
if is_first_iteration:
msg = 'The first relevant event id is %s' % self.eid
level = 'I'
else:
msg = 'The closest relevant event id is %s' % self.eid
level = 'W'
log_msg(msg, level=level, message_bar=self.iface.messageBar())
self.eid, ok = QInputDialog.getInt(self.drive_engine_dlg,
'Select an event ID',
input_msg, self.eid,
events[0]['id'],
events[-1]['id'])
if not ok:
self.reject()
return
if not ok:
self.reject()
return
log_msg(
'Extracting ground motion fields.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract ground motion fields',
QgsTask.CanCancel,
self.session,
self.hostname,
self.calc_id,
self.output_type,
self.finalize_init,
self.on_extract_error,
params={'event_id': self.eid})
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self,
drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=None,
path=None,
mode=None,
zonal_layer_path=None,
engine_version=None,
calculation_mode=None):
assert output_type in ('avg_losses-rlzs', 'avg_losses-stats')
super().__init__(drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=output_type,
path=path,
mode=mode,
zonal_layer_path=zonal_layer_path,
engine_version=engine_version,
calculation_mode=calculation_mode)
if self.output_type == 'avg_losses-rlzs':
self.setWindowTitle(
'Load losses by asset, aggregated by location, as layer')
elif self.output_type == 'avg_losses-stats':
self.setWindowTitle('Load average asset losses (statistics),'
' aggregated by location, as layer')
else:
raise NotImplementedError(output_type)
self.create_load_selected_only_ckb()
self.create_num_sites_indicator()
self.create_rlz_or_stat_selector()
self.create_taxonomy_selector()
self.create_loss_type_selector()
self.create_zonal_layer_selector()
# NOTE: it's correct to use 'avg_losses-rlzs' instead of output_type,
# both in case of avg_losses-rlzs and in case of avg_losses-stats
log_msg('Extracting output data.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract losses by asset',
QgsTask.CanCancel, self.session,
self.hostname, self.calc_id,
'losses_by_asset',
self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def accept(self):
log_msg('Loading output started. Watch progress in QGIS task bar',
level='I', message_bar=self.iface.messageBar())
self.hide()
min_mag = self.min_mag_dsb.value()
self.extract_npz_task = ExtractNpzTask(
'Extract ruptures', QgsTask.CanCancel, self.session,
self.hostname, self.calc_id, 'rupture_info',
self.on_ruptures_extracted,
self.on_extract_error, params={'min_mag': min_mag})
QgsApplication.taskManager().addTask(self.extract_npz_task)
def download_asset_risk(self, extract_params):
self.extract_npz_task = ExtractNpzTask('Extract asset_risk',
QgsTask.CanCancel,
self.session,
self.hostname,
self.calc_id,
'asset_risk',
self.on_asset_risk_downloaded,
self.on_extract_error,
params=extract_params)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self,
drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type='hmaps',
path=None,
mode=None,
engine_version=None,
calculation_mode=None):
assert output_type == 'hmaps'
super().__init__(drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=output_type,
path=path,
mode=mode,
engine_version=engine_version,
calculation_mode=calculation_mode)
self.setWindowTitle('Load hazard maps as layer')
self.create_num_sites_indicator()
self.create_single_layer_ckb()
self.create_load_one_layer_per_stat_ckb()
self.create_rlz_or_stat_selector(all_ckb=True)
self.create_imt_selector(all_ckb=True)
self.create_poe_selector(all_ckb=True)
self.create_show_return_period_ckb()
self.load_single_layer_ckb.stateChanged[int].connect(
self.on_load_single_layer_ckb_stateChanged)
self.load_one_layer_per_stat_ckb.stateChanged[int].connect(
self.on_load_one_layer_per_stat_ckb_stateChanged)
log_msg('Extracting hazard maps.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract hazard maps',
QgsTask.CanCancel, self.session,
self.hostname, self.calc_id,
self.output_type,
self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self,
drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type='gmf_data',
path=None,
mode=None,
engine_version=None,
calculation_mode=None):
assert output_type == 'gmf_data'
super().__init__(drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=output_type,
path=path,
mode=mode,
engine_version=engine_version,
calculation_mode=calculation_mode)
self.setWindowTitle('Load ground motion fields as layer')
self.create_num_sites_indicator()
# NOTE: gmpe and gsim are synonyms
self.create_rlz_or_stat_selector(
label='Ground Motion Prediction Equation')
# NOTE: we do not display the selector for realizations, but we can
# still update and use its contents (e.g. to display the gmpe
# corresponding to the chosen event)
self.rlz_or_stat_cbx.setVisible(False)
self.create_imt_selector()
self.extract_realizations()
log_msg('Extracting events. Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract events',
QgsTask.CanCancel, self.session,
self.hostname, self.calc_id,
'events', self.get_eid,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self,
drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type='hcurves',
path=None,
mode=None,
engine_version=None,
calculation_mode=None):
assert output_type == 'hcurves'
super().__init__(drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=output_type,
path=path,
mode=mode,
engine_version=engine_version,
calculation_mode=calculation_mode)
self.setWindowTitle('Load hazard curves as layer')
self.create_num_sites_indicator()
self.create_rlz_or_stat_selector(all_ckb=True)
self.create_imt_selector(all_ckb=True)
self.load_all_rlzs_or_stats_chk.setChecked(True)
self.load_all_imts_chk.setChecked(True)
log_msg('Extracting hazard curves.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract hazard curves',
QgsTask.CanCancel, self.session,
self.hostname, self.calc_id,
self.output_type,
self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self, drive_engine_dlg, iface, viewer_dock, session, hostname,
calc_id, output_type='disagg', path=None, mode=None,
engine_version=None, calculation_mode=None):
assert output_type == 'disagg'
super().__init__(
drive_engine_dlg, iface, viewer_dock, session, hostname,
calc_id, output_type=output_type, path=path, mode=mode,
engine_version=engine_version, calculation_mode=calculation_mode)
self.disagg = None
# self.setWindowTitle('Load disaggregation as layer')
# self.populate_out_dep_widgets()
# self.adjustSize()
self.ok_button.setEnabled(True)
log_msg('Extracting disagg. Watch progress in QGIS task bar',
level='I', message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask(
'Extract disagg', QgsTask.CanCancel, self.session,
self.hostname, self.calc_id, 'disagg_layer', self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self,
drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type='asset_risk',
path=None,
mode=None,
engine_version=None,
calculation_mode=None):
assert output_type == 'asset_risk'
super().__init__(drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=output_type,
path=path,
mode=mode,
engine_version=engine_version,
calculation_mode=calculation_mode)
self.setWindowTitle('Load Exposure/Risk as layer')
log_msg(
'Extracting exposure metadata.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract exposure metadata',
QgsTask.CanCancel, self.session,
self.hostname, self.calc_id,
'exposure_metadata',
self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def __init__(self, drive_engine_dlg, iface, viewer_dock, session, hostname,
calc_id, output_type='uhs', path=None, mode=None,
engine_version=None, calculation_mode=None):
assert output_type == 'uhs'
super().__init__(
drive_engine_dlg, iface, viewer_dock, session, hostname,
calc_id, output_type=output_type, path=path, mode=mode,
engine_version=engine_version, calculation_mode=calculation_mode)
self.setWindowTitle(
'Load uniform hazard spectra as layer')
self.create_num_sites_indicator()
self.create_load_selected_only_ckb()
self.create_poe_selector()
log_msg('Extracting uniform hazard spectra.'
' Watch progress in QGIS task bar',
level='I', message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask(
'Extract uniform hazard spectra', QgsTask.CanCancel, self.session,
self.hostname, self.calc_id, self.output_type, self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)