def post_execute(self, result):
"""
Saving loss curves in the datastore.
:param result: aggregated result of the task classical_risk
"""
loss_ratios = {
cb.loss_type: cb.curve_resolution
for cb in self.riskmodel.curve_builder if cb.user_provided
}
self.loss_curve_dt, _ = scientific.build_loss_dtypes(
loss_ratios, self.oqparam.conditional_loss_poes, self.I)
ltypes = self.riskmodel.loss_types
loss_curves = numpy.zeros((self.N, self.R), self.loss_curve_dt)
for l, r, aid, lcurve in result['loss_curves']:
loss_curves_lt = loss_curves[ltypes[l]]
for i, name in enumerate(loss_curves_lt.dtype.names):
if name.startswith('avg'):
loss_curves_lt[name][aid, r] = lcurve[i]
else: # 'losses', 'poes'
base.set_array(loss_curves_lt[name][aid, r], lcurve[i])
self.datastore['loss_curves-rlzs'] = loss_curves
self.datastore.set_nbytes('loss_curves-rlzs')
# loss curves stats
if self.R > 1:
stat_curves = numpy.zeros((self.N, self.S), self.loss_curve_dt)
for l, aid, losses, statpoes, statloss in result['stat_curves']:
stat_curves_lt = stat_curves[ltypes[l]]
for s in range(self.S):
stat_curves_lt['avg'][aid, s] = statloss[s]
base.set_array(stat_curves_lt['poes'][aid, s], statpoes[s])
base.set_array(stat_curves_lt['losses'][aid, s], losses)
self.datastore['loss_curves-stats'] = stat_curves
self.datastore.set_nbytes('loss_curves-stats')
def get_loss_maps(dstore, kind):
"""
:param dstore: a DataStore instance
:param kind: 'rlzs' or 'stats'
"""
oq = dstore['oqparam']
name = 'rcurves-%s' % kind
if name in dstore: # event_based risk
values = dstore['assetcol'].values()
_, loss_maps_dt = scientific.build_loss_dtypes(
{lt: len(oq.loss_ratios[lt]) for lt in oq.loss_ratios},
oq.conditional_loss_poes, oq.insured_losses)
rcurves = dstore[name].value # to support Ubuntu 14
A, R, I = rcurves.shape
ins = ['', '_ins']
loss_maps = numpy.zeros((A, R), loss_maps_dt)
for ltype, lratios in oq.loss_ratios.items():
for (a, r, i) in indices(A, R, I):
rcurve = rcurves[ltype][a, r, i]
losses = numpy.array(lratios) * values[ltype][a]
tup = tuple(
scientific.conditional_loss_ratio(losses, rcurve, poe)
for poe in oq.conditional_loss_poes)
loss_maps[ltype + ins[i]][a, r] = tup
return loss_maps
name = 'loss_curves-%s' % kind
if name in dstore: # classical_risk
loss_curves = dstore[name]
loss_maps = scientific.broadcast(
scientific.loss_maps, loss_curves, oq.conditional_loss_poes)
return loss_maps
def post_execute(self, result):
"""
Save the losses in a compact form.
"""
loss_ratios = {cb.loss_type: cb.curve_resolution
for cb in self.riskmodel.curve_builders
if cb.user_provided}
self.loss_curve_dt, self.loss_maps_dt = scientific.build_loss_dtypes(
loss_ratios, self.oqparam.conditional_loss_poes, self.I)
self.save_loss_curves(result)
def build_agg_curve(self):
"""
Build a single loss curve per realization. It is NOT obtained
by aggregating the loss curves; instead, it is obtained without
generating the loss curves, directly from the the aggregate losses.
"""
oq = self.oqparam
cr = {
cb.loss_type: cb.curve_resolution
for cb in self.riskmodel.curve_builder
}
loss_curve_dt, _ = scientific.build_loss_dtypes(
cr, oq.conditional_loss_poes)
lts = self.riskmodel.loss_types
cb_inputs = self.cb_inputs('agg_loss_table')
I = oq.insured_losses + 1
R = len(self.rlzs_assoc.realizations)
# NB: using the Processmap since celery is hanging; the computation
# is fast anyway and this part will likely be removed in the future
result = parallel.Processmap.apply(
build_agg_curve, (cb_inputs, self.monitor('')),
concurrent_tasks=self.oqparam.concurrent_tasks).reduce()
agg_curve = numpy.zeros((I, R), loss_curve_dt)
for l, r, i in result:
agg_curve[lts[l]][i, r] = result[l, r, i]
self.datastore['agg_curve-rlzs'] = agg_curve
if R > 1: # save stats too
statnames, stats = zip(*oq.risk_stats())
weights = self.datastore['realizations']['weight']
agg_curve_stats = numpy.zeros((I, len(stats)), agg_curve.dtype)
for l, loss_type in enumerate(agg_curve.dtype.names):
acs = agg_curve_stats[loss_type]
data = agg_curve[loss_type]
for i in range(I):
avg = data['avg'][i]
losses, all_poes = scientific.normalize_curves_eb([
(c['losses'], c['poes']) for c in data[i]
])
acs['losses'][i] = losses
acs['poes'][i] = compute_stats(all_poes, stats, weights)
acs['avg'][i] = compute_stats(avg, stats, weights)
self.datastore['agg_curve-stats'] = agg_curve_stats
def build_agg_curve(self):
"""
Build a single loss curve per realization. It is NOT obtained
by aggregating the loss curves; instead, it is obtained without
generating the loss curves, directly from the the aggregate losses.
"""
oq = self.oqparam
cr = {cb.loss_type: cb.curve_resolution
for cb in self.riskmodel.curve_builders}
loss_curve_dt, _ = scientific.build_loss_dtypes(
cr, oq.conditional_loss_poes)
lts = self.riskmodel.loss_types
cb_inputs = self.cb_inputs('agg_loss_table')
I = oq.insured_losses + 1
R = len(self.rlzs_assoc.realizations)
result = parallel.apply(
build_agg_curve, (cb_inputs, self.monitor('')),
concurrent_tasks=self.oqparam.concurrent_tasks).reduce()
agg_curve = numpy.zeros((I, R), loss_curve_dt)
for l, r, i in result:
agg_curve[lts[l]][i, r] = result[l, r, i]
self.datastore['agg_curve-rlzs'] = agg_curve
if R > 1: # save stats too
weights = self.datastore['realizations']['weight']
Q1 = len(oq.quantile_loss_curves) + 1
agg_curve_stats = numpy.zeros((I, Q1), agg_curve.dtype)
for l, loss_type in enumerate(agg_curve.dtype.names):
acs = agg_curve_stats[loss_type]
data = agg_curve[loss_type]
for i in range(I):
losses, all_poes = scientific.normalize_curves_eb(
[(c['losses'], c['poes']) for c in data[i]])
acs['losses'][i] = losses
acs['poes'][i] = compute_stats(
all_poes, oq.quantile_loss_curves, weights)
acs['avg'][i] = compute_stats(
data['avg'][i], oq.quantile_loss_curves, weights)
self.datastore['agg_curve-stats'] = agg_curve_stats
