def __init__(self, calc_id):
[smlt_input] = models.inputs4hcalc(calc_id, input_type='lt_source')
smlt_content = smlt_input.model_content.raw_content
[gmpelt_input] = models.inputs4hcalc(calc_id, input_type='lt_gsim')
gmpelt_content = gmpelt_input.model_content.raw_content
self.source_model_lt = SourceModelLogicTree(
smlt_content, basepath=None, filename=None, validate=False
)
self.gmpe_lt = GMPELogicTree(
tectonic_region_types=[], content=gmpelt_content,
basepath=None, filename=None, validate=False
)
def test_initialize_site_model(self):
# we need a slightly different config file for this test
cfg = helpers.demo_file(
'simple_fault_demo_hazard/job_with_site_model.ini')
self.job = helpers.get_hazard_job(cfg)
self.calc = core.ClassicalHazardCalculator(self.job)
self.calc.initialize_site_model()
# If the site model isn't valid for the calculation geometry, a
# `RuntimeError` should be raised here
# Okay, it's all good. Now check the count of the site model records.
[site_model_inp] = models.inputs4hcalc(
self.job.hazard_calculation.id, input_type='site_model')
sm_nodes = models.SiteModel.objects.filter(input=site_model_inp)
self.assertEqual(2601, len(sm_nodes))
num_pts_to_compute = len(
self.job.hazard_calculation.points_to_compute())
[site_data] = models.SiteData.objects.filter(
hazard_calculation=self.job.hazard_calculation.id)
# The site model is good. Now test that `site_data` was computed.
# For now, just test the lengths of the site data collections:
self.assertEqual(num_pts_to_compute, len(site_data.lons))
self.assertEqual(num_pts_to_compute, len(site_data.lats))
self.assertEqual(num_pts_to_compute, len(site_data.vs30s))
self.assertEqual(num_pts_to_compute, len(site_data.vs30_measured))
self.assertEqual(num_pts_to_compute, len(site_data.z1pt0s))
self.assertEqual(num_pts_to_compute, len(site_data.z2pt5s))
def test_initalize_sources(self):
self.calc.initialize_sources()
# The source model logic tree for this configuration has only 1 source
# model:
[source] = models.inputs4hcalc(
self.job.hazard_calculation.id, input_type='source')
parsed_sources = models.ParsedSource.objects.filter(input=source)
# This source model contains 118 sources:
self.assertEqual(118, len(parsed_sources))
# Finally, check the Src2ltsrc linkage:
[smlt] = models.inputs4hcalc(
self.job.hazard_calculation.id, input_type='lt_source')
[src2ltsrc] = models.Src2ltsrc.objects.filter(
hzrd_src=source, lt_src=smlt)
# Make sure the `filename` is exactly as it apprears in the logic tree.
# This is import for the logic tree processing we need to do later on.
self.assertEqual('dissFaultModel.xml', src2ltsrc.filename)
def initialize_sources(self):
"""
Parse and validation logic trees (source and gsim). Then get all
sources referenced in the the source model logic tree, create
:class:`~openquake.db.models.Input` records for all of them, parse
then, and save the parsed sources to the `parsed_source` table
(see :class:`openquake.db.models.ParsedSource`).
"""
logs.log_progress("initializing sources", 2)
hc = self.job.hazard_calculation
[smlt] = models.inputs4hcalc(hc.id, input_type='lt_source')
[gsimlt] = models.inputs4hcalc(hc.id, input_type='lt_gsim')
source_paths = logictree.read_logic_trees(
hc.base_path, smlt.path, gsimlt.path)
src_inputs = []
for src_path in source_paths:
full_path = os.path.join(hc.base_path, src_path)
# Get or reuse the 'source' Input:
inp = engine2.get_input(
full_path, 'source', hc.owner, hc.force_inputs)
src_inputs.append(inp)
# Associate the source input to the calculation:
models.Input2hcalc.objects.get_or_create(
input=inp, hazard_calculation=hc)
# Associate the source input to the source model logic tree input:
models.Src2ltsrc.objects.get_or_create(
hzrd_src=inp, lt_src=smlt, filename=src_path)
# Now parse the source models and store `pared_source` records:
for src_inp in src_inputs:
src_content = StringIO.StringIO(src_inp.model_content.raw_content)
sm_parser = nrml_parsers.SourceModelParser(src_content)
src_db_writer = source.SourceDBWriter(
src_inp, sm_parser.parse(), hc.rupture_mesh_spacing,
hc.width_of_mfd_bin, hc.area_source_discretization)
src_db_writer.serialize()
def test_a_few_inputs(self):
cfg = helpers.demo_file('simple_fault_demo_hazard/job.ini')
params, files = engine2.parse_config(open(cfg, 'r'), force_inputs=True)
owner = helpers.default_user()
hc = engine2.create_hazard_calculation(owner, params, files.values())
expected_ids = sorted([x.id for x in files.values()])
inputs = models.inputs4hcalc(hc.id)
actual_ids = sorted([x.id for x in inputs])
self.assertEqual(expected_ids, actual_ids)
def test_with_input_type(self):
cfg = helpers.demo_file('simple_fault_demo_hazard/job.ini')
params, files = engine2.parse_config(open(cfg, 'r'), force_inputs=True)
owner = helpers.default_user()
hc = engine2.create_hazard_calculation(owner, params, files.values())
# It should only be 1 id, actually.
expected_ids = [x.id for x in files.values()
if x.input_type == 'lt_source']
inputs = models.inputs4hcalc(hc.id, input_type='lt_source')
actual_ids = sorted([x.id for x in inputs])
self.assertEqual(expected_ids, actual_ids)
def _initialize_realizations_enumeration(self, rlz_callbacks=None):
"""
Perform full paths enumeration of logic trees and populate
lt_realization table.
:param rlz_callbacks:
See :meth:`initialize_realizations` for more info.
"""
hc = self.job.hazard_calculation
[smlt] = models.inputs4hcalc(hc.id, input_type='lt_source')
ltp = logictree.LogicTreeProcessor(hc.id)
hzrd_src_cache = {}
for i, path_info in enumerate(ltp.enumerate_paths()):
sm_name, weight, sm_lt_path, gsim_lt_path = path_info
lt_rlz = models.LtRealization(
hazard_calculation=hc,
ordinal=i,
seed=None,
weight=weight,
sm_lt_path=sm_lt_path,
gsim_lt_path=gsim_lt_path,
# we will update total_sources in initialize_source_progress()
total_sources=-1)
lt_rlz.save()
if not sm_name in hzrd_src_cache:
# Get the source model for this sample:
hzrd_src = models.Src2ltsrc.objects.get(
lt_src=smlt.id, filename=sm_name).hzrd_src
# and cache it
hzrd_src_cache[sm_name] = hzrd_src
else:
hzrd_src = hzrd_src_cache[sm_name]
# Create source_progress objects
self.initialize_source_progress(lt_rlz, hzrd_src)
# Run realization callback (if any) to do additional initialization
# for each realization:
if rlz_callbacks is not None:
for cb in rlz_callbacks:
cb(lt_rlz)
def get_site_model(hc_id):
"""Get the site model :class:`~openquake.db.models.Input` record for the
given job id.
:param int hc_id:
The id of a :class:`~openquake.db.models.HazardCalculation`.
:returns:
The site model :class:`~openquake.db.models.Input` record for this job.
:raises:
:exc:`RuntimeError` if the job has more than 1 site model.
"""
site_model = models.inputs4hcalc(hc_id, input_type='site_model')
if len(site_model) == 0:
return None
elif len(site_model) > 1:
# Multiple site models for 1 job are not allowed.
raise RuntimeError("Only 1 site model per job is allowed, found %s."
% len(site_model))
# There's only one site model.
return site_model[0]
def test_no_inputs(self):
self.assertEqual([], list(models.inputs4hcalc(-1)))
def _initialize_realizations_montecarlo(self, rlz_callbacks=None):
"""
Perform random sampling of both logic trees and populate lt_realization
table.
:param rlz_callbacks:
See :meth:`initialize_realizations` for more info.
"""
hc = self.job.hazard_calculation
# Each realization will have two seeds:
# One for source model logic tree, one for GSIM logic tree.
rnd = random.Random()
seed = hc.random_seed
rnd.seed(seed)
[smlt] = models.inputs4hcalc(hc.id, input_type='lt_source')
ltp = logictree.LogicTreeProcessor(hc.id)
hzrd_src_cache = {}
# The first realization gets the seed we specified in the config file.
for i in xrange(hc.number_of_logic_tree_samples):
# Sample source model logic tree branch paths:
sm_name, sm_lt_path = ltp.sample_source_model_logictree(
rnd.randint(MIN_SINT_32, MAX_SINT_32))
# Sample GSIM logic tree branch paths:
gsim_lt_path = ltp.sample_gmpe_logictree(
rnd.randint(MIN_SINT_32, MAX_SINT_32))
lt_rlz = models.LtRealization(
hazard_calculation=hc,
ordinal=i,
seed=seed,
weight=None,
sm_lt_path=sm_lt_path,
gsim_lt_path=gsim_lt_path,
# we will update total_sources in initialize_source_progress()
total_sources=-1
)
lt_rlz.save()
if not sm_name in hzrd_src_cache:
# Get the source model for this sample:
hzrd_src = models.Src2ltsrc.objects.get(
lt_src=smlt.id, filename=sm_name).hzrd_src
# and cache it
hzrd_src_cache[sm_name] = hzrd_src
else:
hzrd_src = hzrd_src_cache[sm_name]
# Create source_progress objects
self.initialize_source_progress(lt_rlz, hzrd_src)
# Run realization callback (if any) to do additional initialization
# for each realization:
if rlz_callbacks is not None:
for cb in rlz_callbacks:
cb(lt_rlz)
# update the seed for the next realization
seed = rnd.randint(MIN_SINT_32, MAX_SINT_32)
rnd.seed(seed)
