def get_risk_job(cfg, username=None, hazard_calculation_id=None,
hazard_output_id=None):
"""
Given a path to a config file and a hazard_calculation_id
(or, alternatively, a hazard_output_id, create a
:class:`openquake.engine.db.models.OqJob` object for a risk calculation.
"""
username = username if username is not None else default_user().user_name
# You can't specify both a hazard output and hazard calculation
# Pick one
assert not (hazard_calculation_id is not None
and hazard_output_id is not None)
job = engine.prepare_job(username)
params, files = engine.parse_config(open(cfg, 'r'))
params.update(
dict(hazard_output_id=hazard_output_id,
hazard_calculation_id=hazard_calculation_id)
)
risk_calc = engine.create_risk_calculation(
job.owner, params, files)
risk_calc = models.RiskCalculation.objects.get(id=risk_calc.id)
job.risk_calculation = risk_calc
job.save()
return job
def test_create_risk_calculation(self):
# we need an hazard output to create a risk calculation
hazard_cfg = helpers.get_data_path('simple_fault_demo_hazard/job.ini')
hazard_job = helpers.get_hazard_job(hazard_cfg, 'openquake')
hc = hazard_job.hazard_calculation
rlz = models.LtRealization.objects.create(
hazard_calculation=hazard_job.hazard_calculation,
ordinal=1, seed=1, weight=None,
sm_lt_path="test_sm", gsim_lt_path="test_gsim",
is_complete=False, total_items=1, completed_items=1)
hazard_output = models.HazardCurve.objects.create(
lt_realization=rlz,
output=models.Output.objects.create_output(
hazard_job, "Test Hazard output", "hazard_curve"),
investigation_time=hc.investigation_time,
imt="PGA", imls=[0.1, 0.2, 0.3])
params = {
'hazard_output_id': hazard_output.output.id,
'base_path': 'path/to/job.ini',
'export_dir': '/tmp/xxx',
'calculation_mode': 'classical',
# just some sample params
'lrem_steps_per_interval': 5,
'conditional_loss_poes': '0.01, 0.02, 0.05',
'region_constraint': '-0.5 0.5, 0.5 0.5, 0.5 -0.5, -0.5, -0.5',
}
owner = helpers.default_user()
vuln_file = models.Input(digest='123', path='/foo/bar', size=0,
input_type='structural_vulnerability',
owner=owner)
vuln_file.save()
exposure_file = models.Input(digest='456', path='/foo/baz', size=0,
input_type='exposure', owner=owner)
exposure_file.save()
files = [vuln_file, exposure_file]
rc = engine.create_risk_calculation(owner, params, files)
# Normalize/clean fields by fetching a fresh copy from the db.
rc = models.RiskCalculation.objects.get(id=rc.id)
self.assertEqual(rc.calculation_mode, 'classical')
self.assertEqual(rc.lrem_steps_per_interval, 5)
self.assertEqual(rc.conditional_loss_poes, [0.01, 0.02, 0.05])
self.assertEqual(
rc.region_constraint.wkt,
('POLYGON ((-0.5000000000000000 0.5000000000000000, '
'0.5000000000000000 0.5000000000000000, '
'0.5000000000000000 -0.5000000000000000, '
'-0.5000000000000000 -0.5000000000000000, '
'-0.5000000000000000 0.5000000000000000))'))
def get_fake_risk_job(risk_cfg, hazard_cfg, output_type="curve",
username=None):
"""
Takes in input the paths to a risk job config file and a hazard job config
file.
Creates fake hazard outputs suitable to be used by a risk
calculation and then creates a :class:`openquake.engine.db.models.OqJob`
object for a risk calculation. It also returns the input files
referenced by the risk config file.
:param output_type: gmf, gmf_scenario, or curve
"""
username = username if username is not None else default_user().user_name
hazard_job = get_hazard_job(hazard_cfg, username)
hc = hazard_job.hazard_calculation
rlz = models.LtRealization.objects.create(
hazard_calculation=hazard_job.hazard_calculation,
ordinal=1, seed=1, weight=None,
sm_lt_path="test_sm", gsim_lt_path="test_gsim",
is_complete=False, total_items=1, completed_items=1)
if output_type == "curve":
models.HazardCurve.objects.create(
lt_realization=rlz,
output=models.Output.objects.create_output(
hazard_job, "Test Hazard output", "hazard_curve_multi"),
investigation_time=hc.investigation_time)
hazard_output = models.HazardCurve.objects.create(
lt_realization=rlz,
output=models.Output.objects.create_output(
hazard_job, "Test Hazard output", "hazard_curve"),
investigation_time=hc.investigation_time,
imt="PGA", imls=[0.1, 0.2, 0.3])
for point in ["POINT(-1.01 1.01)", "POINT(0.9 1.01)",
"POINT(0.01 0.01)", "POINT(0.9 0.9)"]:
models.HazardCurveData.objects.create(
hazard_curve=hazard_output,
poes=[0.1, 0.2, 0.3],
location="%s" % point)
elif output_type == "gmf_scenario":
hazard_output = models.Gmf.objects.create(
output=models.Output.objects.create_output(
hazard_job, "Test gmf scenario output", "gmf_scenario"))
site_ids = hazard_job.hazard_calculation.save_sites(
[(15.48, 38.0900001), (15.565, 38.17), (15.481, 38.25)])
for site_id in site_ids:
models.GmfData.objects.create(
gmf=hazard_output,
imt="PGA",
site_id=site_id,
gmvs=[0.1, 0.2, 0.3])
else:
hazard_output = create_gmf_data_records(
hazard_job, rlz)[0].gmf
hazard_job.status = "complete"
hazard_job.save()
job = engine.prepare_job(username)
params, files = engine.parse_config(open(risk_cfg, 'r'))
params.update(dict(hazard_output_id=hazard_output.output.id))
risk_calc = engine.create_risk_calculation(job.owner, params, files)
job.risk_calculation = risk_calc
job.save()
error_message = validate(job, 'risk', params, files, [])
# reload risk calculation to have all the types converted properly
job.risk_calculation = models.RiskCalculation.objects.get(id=risk_calc.id)
if error_message:
raise RuntimeError(error_message)
return job, files
