def test_quantile_hazard_maps_computation(self):
self.params[self.poes_levels] = "0.10"
self.params[self.quantiles_levels] = "0.25 0.50 0.75"
curve_1 = {"site_lon": 3.0, "site_lat": 3.0,
"curve": classical_psha._reconstruct_curve_list_from(
[9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01,
8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01,
2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02,
7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06])}
curve_2 = {"site_lon": 3.5, "site_lat": 3.5,
"curve": classical_psha._reconstruct_curve_list_from(
[9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01,
8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01,
2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02,
7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06])}
# keys for shapes.Site(3.0, 3.0)
key_1 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.0, 3.0), 0.25)
key_2 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.0, 3.0), 0.50)
key_3 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.0, 3.0), 0.75)
# keys for shapes.Site(3.5, 3.5)
key_4 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.5, 3.5), 0.25)
key_5 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.5, 3.5), 0.50)
key_6 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.5, 3.5), 0.75)
# setting values in kvs
kvs.set_value_json_encoded(key_1, curve_1)
kvs.set_value_json_encoded(key_2, curve_1)
kvs.set_value_json_encoded(key_3, curve_1)
kvs.set_value_json_encoded(key_4, curve_2)
kvs.set_value_json_encoded(key_5, curve_2)
kvs.set_value_json_encoded(key_6, curve_2)
classical_psha.compute_quantile_hazard_maps(self.engine)
# asserting imls have been produced for all poes and quantiles
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.0, 3.0), 0.10, 0.25)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.0, 3.0), 0.10, 0.50)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.0, 3.0), 0.10, 0.75)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.5, 3.5), 0.10, 0.25)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.5, 3.5), 0.10, 0.50)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.5, 3.5), 0.10, 0.75)))
def test_quantile_hazard_maps_computation(self):
self.params[self.poes_levels] = "0.10"
self.params[self.quantiles_levels] = "0.25 0.50 0.75"
curve_1 = {"site_lon": 3.0, "site_lat": 3.0,
"curve": classical_psha._reconstruct_curve_list_from(
[9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01,
8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01,
2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02,
7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06])}
curve_2 = {"site_lon": 3.5, "site_lat": 3.5,
"curve": classical_psha._reconstruct_curve_list_from(
[9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01,
8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01,
2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02,
7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06])}
# keys for shapes.Site(3.0, 3.0)
key_1 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.0, 3.0), 0.25)
key_2 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.0, 3.0), 0.50)
key_3 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.0, 3.0), 0.75)
# keys for shapes.Site(3.5, 3.5)
key_4 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.5, 3.5), 0.25)
key_5 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.5, 3.5), 0.50)
key_6 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, shapes.Site(3.5, 3.5), 0.75)
# setting values in kvs
kvs.set_value_json_encoded(key_1, curve_1)
kvs.set_value_json_encoded(key_2, curve_1)
kvs.set_value_json_encoded(key_3, curve_1)
kvs.set_value_json_encoded(key_4, curve_2)
kvs.set_value_json_encoded(key_5, curve_2)
kvs.set_value_json_encoded(key_6, curve_2)
classical_psha.compute_quantile_hazard_maps(self.engine)
# asserting imls have been produced for all poes and quantiles
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.0, 3.0), 0.10, 0.25)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.0, 3.0), 0.10, 0.50)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.0, 3.0), 0.10, 0.75)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.5, 3.5), 0.10, 0.25)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.5, 3.5), 0.10, 0.50)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, shapes.Site(3.5, 3.5), 0.10, 0.75)))
def test_quantile_hazard_maps_computation(self):
self.params[classical_psha.POES_PARAM_NAME] = "0.10"
self.params[classical_psha.QUANTILE_PARAM_NAME] = "0.25 0.50 0.75"
curve_1 = [9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01,
8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01,
2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02,
7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06]
curve_2 = [9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01,
8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01,
2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02,
7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06]
sites = [shapes.Site(3.0, 3.0), shapes.Site(3.5, 3.5)]
# keys for sites[0]
key_1 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, sites[0], 0.25)
key_2 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, sites[0], 0.50)
key_3 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, sites[0], 0.75)
# keys for sites[1]
key_4 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, sites[1], 0.25)
key_5 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, sites[1], 0.50)
key_6 = kvs.tokens.quantile_hazard_curve_key(
self.job_id, sites[1], 0.75)
# setting values in kvs
kvs.set_value_json_encoded(key_1, curve_1)
kvs.set_value_json_encoded(key_2, curve_1)
kvs.set_value_json_encoded(key_3, curve_1)
kvs.set_value_json_encoded(key_4, curve_2)
kvs.set_value_json_encoded(key_5, curve_2)
kvs.set_value_json_encoded(key_6, curve_2)
classical_psha.compute_quantile_hazard_maps(self.job.job_id, sites,
[0.25, 0.50, 0.75], self.imls, [0.10])
# asserting imls have been produced for all poes and quantiles
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, sites[0], 0.10, 0.25)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, sites[0], 0.10, 0.50)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, sites[0], 0.10, 0.75)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, sites[1], 0.10, 0.25)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, sites[1], 0.10, 0.50)))
self.assertTrue(kvs.get(kvs.tokens.quantile_hazard_map_key(
self.job_id, sites[1], 0.10, 0.75)))
def execute(self):
results = []
source_model_generator = random.Random()
source_model_generator.seed(
self.params.get('SOURCE_MODEL_LT_RANDOM_SEED', None))
gmpe_generator = random.Random()
gmpe_generator.seed(self.params.get('GMPE_LT_RANDOM_SEED', None))
realizations = int(self.params['NUMBER_OF_LOGIC_TREE_SAMPLES'])
site_list = self.sites_for_region()
LOG.info('Going to run classical PSHA hazard for %s realizations '\
'and %s sites' % (realizations, len(site_list)))
for realization in xrange(0, realizations):
LOG.info('Calculating hazard curves for realization %s'
% realization)
pending_tasks = []
results_per_realization = []
self.store_source_model(source_model_generator.getrandbits(32))
self.store_gmpe_map(source_model_generator.getrandbits(32))
pending_tasks.append(
tasks.compute_hazard_curve.delay(self.id, site_list,
realization))
for task in pending_tasks:
task.wait()
if task.status != 'SUCCESS':
raise Exception(task.result)
results_per_realization.extend(task.result)
self.write_hazardcurve_file(results_per_realization)
results.extend(results_per_realization)
del results_per_realization
# compute and serialize mean and quantile hazard curves
pending_tasks_mean = []
results_mean = []
pending_tasks_quantile = []
results_quantile = []
LOG.info('Computing mean and quantile hazard curves')
pending_tasks_quantile.append(
tasks.compute_quantile_curves.delay(self.id, site_list))
if self.params['COMPUTE_MEAN_HAZARD_CURVE'].lower() == 'true':
pending_tasks_mean.append(
tasks.compute_mean_curves.delay(self.id, site_list))
for task in pending_tasks_mean:
task.wait()
if task.status != 'SUCCESS':
raise Exception(task.result)
results_mean.extend(task.result)
for task in pending_tasks_quantile:
task.wait()
if task.status != 'SUCCESS':
raise Exception(task.result)
results_quantile.extend(task.result)
if self.params['COMPUTE_MEAN_HAZARD_CURVE'].lower() == 'true':
LOG.info('Serializing mean hazard curves')
self.write_hazardcurve_file(results_mean)
del results_mean
if self.params[classical_psha.POES_PARAM_NAME] != '':
LOG.info('Computing/serializing mean hazard maps')
results_mean_maps = classical_psha.compute_mean_hazard_maps(
self)
self.write_hazardmap_file(results_mean_maps)
del results_mean_maps
# collect hazard curve keys per quantile value
quantile_values = _collect_curve_keys_per_quantile(results_quantile)
LOG.info('Serializing quantile hazard curves for %s quantile values' \
% len(quantile_values))
for key_list in quantile_values.values():
self.write_hazardcurve_file(key_list)
# compute quantile hazard maps
if (self.params[classical_psha.POES_PARAM_NAME] != '' and
len(quantile_values) > 0):
LOG.info('Computing quantile hazard maps')
results_quantile_maps = \
classical_psha.compute_quantile_hazard_maps(self)
quantile_values = _collect_map_keys_per_quantile(
results_quantile_maps)
LOG.info(
"Serializing quantile hazard maps for %s quantile values"
% len(quantile_values))
for key_list in quantile_values.values():
self.write_hazardmap_file(key_list)
return results
def execute(self):
results = []
source_model_generator = random.Random()
source_model_generator.seed(
self.params.get('SOURCE_MODEL_LT_RANDOM_SEED', None))
gmpe_generator = random.Random()
gmpe_generator.seed(self.params.get('GMPE_LT_RANDOM_SEED', None))
realizations = int(self.params['NUMBER_OF_LOGIC_TREE_SAMPLES'])
site_list = self.sites_for_region()
LOG.info('Going to run classical PSHA hazard for %s realizations '\
'and %s sites' % (realizations, len(site_list)))
for realization in xrange(0, realizations):
LOG.info('Calculating hazard curves for realization %s' %
realization)
pending_tasks = []
results_per_realization = []
self.store_source_model(source_model_generator.getrandbits(32))
self.store_gmpe_map(source_model_generator.getrandbits(32))
pending_tasks.append(
tasks.compute_hazard_curve.delay(self.id, site_list,
realization))
for task in pending_tasks:
task.wait()
if task.status != 'SUCCESS':
raise Exception(task.result)
results_per_realization.extend(task.result)
self.write_hazardcurve_file(results_per_realization)
results.extend(results_per_realization)
del results_per_realization
# compute and serialize mean and quantile hazard curves
pending_tasks_mean = []
results_mean = []
pending_tasks_quantile = []
results_quantile = []
LOG.info('Computing mean and quantile hazard curves')
pending_tasks_quantile.append(
tasks.compute_quantile_curves.delay(self.id, site_list))
if self.params['COMPUTE_MEAN_HAZARD_CURVE'].lower() == 'true':
pending_tasks_mean.append(
tasks.compute_mean_curves.delay(self.id, site_list))
for task in pending_tasks_mean:
task.wait()
if task.status != 'SUCCESS':
raise Exception(task.result)
results_mean.extend(task.result)
for task in pending_tasks_quantile:
task.wait()
if task.status != 'SUCCESS':
raise Exception(task.result)
results_quantile.extend(task.result)
if self.params['COMPUTE_MEAN_HAZARD_CURVE'].lower() == 'true':
LOG.info('Serializing mean hazard curves')
self.write_hazardcurve_file(results_mean)
del results_mean
if self.params[classical_psha.POES_PARAM_NAME] != '':
LOG.info('Computing/serializing mean hazard maps')
results_mean_maps = classical_psha.compute_mean_hazard_maps(
self)
self.write_hazardmap_file(results_mean_maps)
del results_mean_maps
# collect hazard curve keys per quantile value
quantile_values = _collect_curve_keys_per_quantile(results_quantile)
LOG.info('Serializing quantile hazard curves for %s quantile values' \
% len(quantile_values))
for key_list in quantile_values.values():
self.write_hazardcurve_file(key_list)
# compute quantile hazard maps
if (self.params[classical_psha.POES_PARAM_NAME] != ''
and len(quantile_values) > 0):
LOG.info('Computing quantile hazard maps')
results_quantile_maps = \
classical_psha.compute_quantile_hazard_maps(self)
quantile_values = _collect_map_keys_per_quantile(
results_quantile_maps)
LOG.info(
"Serializing quantile hazard maps for %s quantile values" %
len(quantile_values))
for key_list in quantile_values.values():
self.write_hazardmap_file(key_list)
return results
