def scenario_damage(job_id, risk_model, getters, outputdict, params):
"""
Celery task for the scenario damage risk calculator.
:param int job_id:
ID of the currently running job
:param risk_model:
A :class:`openquake.risklib.workflows.RiskModel` instance
:param getters:
A list of callable hazard getters
:param outputdict:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `LossMap`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
:returns:
A matrix of fractions and a taxonomy string
"""
monitor = EnginePerformanceMonitor(
None, job_id, scenario_damage, tracing=True)
# in scenario damage calculation the only loss_type is 'damage'
[getter] = getters
[ffs] = risk_model.vulnerability_functions
# and NO containes
assert len(outputdict) == 0
with db.transaction.commit_on_success(using='job_init'):
with monitor.copy('getting hazard'):
ground_motion_values = getter.get_data(ffs.imt)
with monitor.copy('computing risk'):
fractions = risk_model.workflow(ground_motion_values)
aggfractions = sum(fractions[i] * asset.number_of_units
for i, asset in enumerate(getter.assets))
with monitor.copy('saving damage per assets'):
writers.damage_distribution(
getter.assets, fractions, params.damage_state_ids)
return aggfractions, risk_model.taxonomy
def event_based_fr(job_id, sites, rc, risk_models,
getter_builders, outputdict, params):
"""
:param int job_id:
ID of the currently running job
:param rc:
a :class:`openquake.engine.db.models.RiskCalculation` instance
:param risk_models:
a list of RiskModel instances corresponding to the taxonomy
:param getter_builders:
a list of GetterBuilder instances associated to the risk models
:param outputdict:
an instance of :class:`..writers.OutputDict` containing
output container instances (e.g. a LossCurve)
:param params:
an instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
hc = rc.hazard_calculation
site_ids = set(sites.complete.sids)
truncation_level = hc.truncation_level
sorted_imts = sorted(map(from_string, hc.intensity_measure_types))
# init the Epsilon Provider only once
for builder in getter_builders:
builder.init_epsilon_provider(asset_correlation=0)
# TODO: the following monitors should be replaced by LightMonitors,
# since they write a lot on the database, once per asset
getdata_mon = EnginePerformanceMonitor(
'getting hazard', job_id, event_based_fr)
getters_mon = getdata_mon.copy('building getters')
assocs = models.AssocLtRlzTrtModel.objects.filter(
trt_model__lt_model__hazard_calculation=hc).order_by('rlz')
# mapping realization -> [(trt_model, gsim)]
rlz2gsims = {
rlz: [(a.trt_model, GSIM[a.gsim]()) for a in group]
for rlz, group in itertools.groupby(
assocs, operator.attrgetter('rlz'))}
# building the getters, i.e. initialize .gmv_dict and .hid
with getters_mon:
for builder in getter_builders:
builder.init_getters(sorted_imts, rlz2gsims)
for builder in getter_builders:
for getter in builder.getters:
for gsim, trt_model in zip(getter.gsims, getter.trt_models):
# read the ruptures from the db
with getdata_mon.copy('reading ruptures'):
ses_ruptures = models.SESRupture.objects.filter(
rupture__trt_model=trt_model)
with getdata_mon.copy('generating gmf'):
# NB: the ruptures are already ordered by tag
# and therefore by '.rupture'
for rupture, group in itertools.groupby(
ses_ruptures, operator.attrgetter('rupture')):
if rupture.site_indices is None:
r_sites = sites
else:
r_sites = FilteredSiteCollection(
rupture.site_indices, sites.complete)
if not site_ids.intersection(r_sites.sids):
continue # skip ruptures not contributing
# populating the gmv_dicts for each getter
getter.build_data(
rupture, r_sites, [(r.id, r.seed) for r in group],
truncation_level)
# computing risk
elt = {} # event loss table
with db.transaction.commit_on_success(using='job_init'):
for risk_model, builder in zip(risk_models, getter_builders):
elt.update(
core.do_event_based(
risk_model, builder.getters,
outputdict, params, getdata_mon))
return elt
