def test_normalize_all_trivial(self):
poes = numpy.linspace(1, 0, 11)
losses = numpy.zeros(11)
curves = [[losses, poes], [losses, poes / 2]]
exp_losses, (poes1, poes2) = scientific.normalize_curves_eb(curves)
numpy.testing.assert_allclose(exp_losses, losses)
numpy.testing.assert_allclose(poes1, poes)
numpy.testing.assert_allclose(poes2, poes / 2)
def test_normalize_one_trivial(self):
trivial = [numpy.zeros(6), numpy.linspace(1, 0, 6)]
curve = [numpy.linspace(0., 1., 6), numpy.linspace(1., 0., 6)]
with numpy.errstate(invalid='ignore', divide='ignore'):
exp_losses, (poes1, poes2) = scientific.normalize_curves_eb(
[trivial, curve])
numpy.testing.assert_allclose(exp_losses, curve[0])
numpy.testing.assert_allclose(poes1, [numpy.nan, 0., 0., 0., 0., 0.])
numpy.testing.assert_allclose(poes2, curve[1])
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
