def test_compute_mean_curve_invalid_weights(self):
curves = [
[1.0, 0.85, 0.67, 0.3],
[0.87, 0.76, 0.59, 0.21],
[0.62, 0.41, 0.37, 0.0],
]
weights = [0.6, None, 0.4]
with self.assertRaises(TypeError):
# None is not a valid weight
scientific.mean_curve(curves, weights)
def test_compute_mean_curve(self):
curves = [
[1.0, 0.85, 0.67, 0.3],
[0.87, 0.76, 0.59, 0.21],
[0.62, 0.41, 0.37, 0.0],
]
expected_mean_curve = numpy.array([0.83, 0.67333333, 0.54333333, 0.17])
numpy.testing.assert_allclose(
expected_mean_curve, scientific.mean_curve(curves))
def test_compute_mean_curve_weighted(self):
curves = [
[1.0, 0.85, 0.67, 0.3],
[0.87, 0.76, 0.59, 0.21],
[0.62, 0.41, 0.37, 0.0],
]
weights = [0.5, 0.3, 0.2]
expected_mean_curve = numpy.array([0.885, 0.735, 0.586, 0.213])
numpy.testing.assert_allclose(
expected_mean_curve,
scientific.mean_curve(curves, weights=weights))
def test_compute_mean_curve_weights_None(self):
# If all weight values are None, ignore the weights altogether
curves = [
[1.0, 0.85, 0.67, 0.3],
[0.87, 0.76, 0.59, 0.21],
[0.62, 0.41, 0.37, 0.0],
]
weights = None
expected_mean_curve = numpy.array([0.83, 0.67333333, 0.54333333, 0.17])
numpy.testing.assert_allclose(
expected_mean_curve,
scientific.mean_curve(curves, weights=weights))
def combined_curves(dstore):
"""
:param dstore: a DataStore instance
:returns: curves_by_rlz, mean_curves
"""
no_curves = all(len(c) == 0 for c in dstore['curves_by_trt_gsim'].values())
if no_curves:
raise Exception('Could not find hazard curves in %s' % dstore)
curves_by_rlz = dstore['rlzs_assoc'].combine(dstore['curves_by_trt_gsim'])
rlzs = sorted(curves_by_rlz)
weights = [rlz.weight for rlz in rlzs]
return curves_by_rlz, scientific.mean_curve(
[curves_by_rlz[rlz] for rlz in rlzs], weights)
def combined_curves(dstore):
"""
:param dstore: a DataStore instance
:returns: curves_by_rlz, mean_curves
"""
no_curves = all(len(c) == 0 for c in dstore['curves_by_trt_gsim'].values())
if no_curves:
raise Exception('Could not find hazard curves in %s' % dstore)
curves_by_rlz = dstore['rlzs_assoc'].combine(dstore['curves_by_trt_gsim'])
rlzs = sorted(curves_by_rlz)
weights = [rlz.weight for rlz in rlzs]
return curves_by_rlz, scientific.mean_curve(
[curves_by_rlz[rlz] for rlz in rlzs], weights)
def post_execute(self, curves_by_trt_gsim):
"""
Collect the hazard curves by realization and export them.
:param curves_by_trt_gsim:
a dictionary (trt_id, gsim) -> hazard curves
"""
self.curves_by_trt_gsim = curves_by_trt_gsim
oq = self.oqparam
zc = zero_curves(len(self.sitecol), oq.imtls)
curves_by_rlz = self.rlzs_assoc.combine_curves(
curves_by_trt_gsim, agg_curves, zc)
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
for rlz, curves in curves_by_rlz.iteritems():
self.store_curves('rlz-%d' % rlz.ordinal, curves)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
weights = (None if oq.number_of_logic_tree_samples
else [rlz.weight for rlz in rlzs])
mean = oq.mean_hazard_curves
if mean:
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(
curves, q, weights).reshape((nsites, -1))
if mean:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def get_hcurves_and_means(dstore):
"""
Extract hcurves from the datastore and compute their means.
:returns: curves_by_rlz, mean_curves
"""
oq = dstore['oqparam']
hcurves = dstore['hcurves']
realizations = dstore['csm_info'].get_rlzs_assoc().realizations
weights = [rlz.weight for rlz in realizations]
curves_by_rlz = {rlz: hcurves['rlz-%03d' % rlz.ordinal]
for rlz in realizations}
N = len(dstore['sitemesh'])
mean_curves = zero_curves(N, oq.imtls)
for imt in oq.imtls:
mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in sorted(curves_by_rlz)],
weights)
return curves_by_rlz, mean_curves
def get_hcurves_and_means(dstore):
"""
Extract hcurves from the datastore and compute their means.
:returns: curves_by_rlz, mean_curves
"""
oq = dstore['oqparam']
hcurves = dstore['hcurves']
realizations = dstore['csm_info'].get_rlzs_assoc().realizations
weights = [rlz.weight for rlz in realizations]
curves_by_rlz = {rlz: hcurves['rlz-%03d' % rlz.ordinal]
for rlz in realizations}
N = len(dstore['sitecol'])
mean_curves = zero_curves(N, oq.imtls)
for imt in oq.imtls:
mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in sorted(curves_by_rlz)],
weights)
return curves_by_rlz, mean_curves
def save_curves(self, curves_by_rlz):
"""
Save the dictionary curves_by_rlz
"""
oq = self.oqparam
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
with self.monitor('save curves_by_rlz', autoflush=True):
for rlz, curves in curves_by_rlz.items():
self.store_curves('rlz-%03d' % rlz.ordinal, curves, rlz)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
with self.monitor('compute and save statistics', autoflush=True):
weights = (None if oq.number_of_logic_tree_samples else
[rlz.weight for rlz in rlzs])
# mean curves are always computed but stored only on request
zc = zero_curves(nsites, oq.imtls)
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz.get(rlz, zc)[imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(curves, q,
weights).reshape(
(nsites, -1))
if oq.mean_hazard_curves:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def save_curves(self, curves_by_rlz):
"""
Save the dictionary curves_by_rlz
"""
oq = self.oqparam
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
with self.monitor('save curves_by_rlz', autoflush=True):
for rlz, curves in curves_by_rlz.items():
self.store_curves('rlz-%03d' % rlz.ordinal, curves, rlz)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
with self.monitor('compute and save statistics', autoflush=True):
weights = (None if oq.number_of_logic_tree_samples
else [rlz.weight for rlz in rlzs])
# mean curves are always computed but stored only on request
zc = zero_curves(nsites, oq.imtls)
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz.get(rlz, zc)[imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(
curves, q, weights).reshape((nsites, -1))
if oq.mean_hazard_curves:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def post_execute(self, curves_by_trt_gsim):
"""
Collect the hazard curves by realization and export them.
:param curves_by_trt_gsim:
a dictionary (trt_id, gsim) -> hazard curves
"""
# save calculation time per source
try:
calc_times = curves_by_trt_gsim.pop('calc_times')
except KeyError:
pass
else:
sources = self.csm.get_sources()
info = []
for i, dt in calc_times:
src = sources[i]
info.append((src.trt_model_id, src.source_id, dt))
info.sort(key=operator.itemgetter(2), reverse=True)
self.source_info = numpy.array(info, source_info_dt)
# save curves_by_trt_gsim
for sm in self.rlzs_assoc.csm_info.source_models:
group = self.datastore.hdf5.create_group(
'curves_by_sm/' + '_'.join(sm.path))
group.attrs['source_model'] = sm.name
for tm in sm.trt_models:
for gsim in tm.gsims:
try:
curves = curves_by_trt_gsim[tm.id, gsim]
except KeyError: # no data for the trt_model
pass
else:
ts = '%03d-%s' % (tm.id, gsim)
group[ts] = curves
group[ts].attrs['trt'] = tm.trt
oq = self.oqparam
zc = zero_curves(len(self.sitecol.complete), oq.imtls)
curves_by_rlz = self.rlzs_assoc.combine_curves(
curves_by_trt_gsim, agg_curves, zc)
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
for rlz, curves in curves_by_rlz.items():
self.store_curves('rlz-%03d' % rlz.ordinal, curves, rlz)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
weights = (None if oq.number_of_logic_tree_samples
else [rlz.weight for rlz in rlzs])
mean = oq.mean_hazard_curves
if mean:
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(
curves, q, weights).reshape((nsites, -1))
if mean:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def post_execute(self, curves_by_trt_gsim):
"""
Collect the hazard curves by realization and export them.
:param curves_by_trt_gsim:
a dictionary (trt_id, gsim) -> hazard curves
"""
# save calculation time per source
calc_times = getattr(curves_by_trt_gsim, 'calc_times', [])
sources = self.csm.get_sources()
infodict = collections.defaultdict(float)
weight = {}
for src_idx, dt in calc_times:
src = sources[src_idx]
weight[src.trt_model_id, src.source_id] = src.weight
infodict[src.trt_model_id, src.source_id] += dt
infolist = [key + (dt, weight[key]) for key, dt in infodict.items()]
infolist.sort(key=operator.itemgetter(1), reverse=True)
if infolist:
self.source_info = numpy.array(infolist, source_info_dt)
with self.monitor('save curves_by_trt_gsim', autoflush=True):
for sm in self.rlzs_assoc.csm_info.source_models:
group = self.datastore.hdf5.create_group(
'curves_by_sm/' + '_'.join(sm.path))
group.attrs['source_model'] = sm.name
for tm in sm.trt_models:
for i, gsim in enumerate(tm.gsims):
try:
curves = curves_by_trt_gsim[tm.id, gsim]
except KeyError: # no data for the trt_model
pass
else:
ts = '%03d-%d' % (tm.id, i)
if nonzero(curves):
group[ts] = curves
group[ts].attrs['trt'] = tm.trt
group[ts].attrs['nbytes'] = curves.nbytes
group[ts].attrs['gsim'] = str(gsim)
self.datastore.set_nbytes(group.name)
self.datastore.set_nbytes('curves_by_sm')
oq = self.oqparam
with self.monitor('combine and save curves_by_rlz', autoflush=True):
zc = zero_curves(len(self.sitecol.complete), oq.imtls)
curves_by_rlz = self.rlzs_assoc.combine_curves(
curves_by_trt_gsim, agg_curves, zc)
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
for rlz, curves in curves_by_rlz.items():
self.store_curves('rlz-%03d' % rlz.ordinal, curves, rlz)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
with self.monitor('compute and save statistics', autoflush=True):
weights = (None if oq.number_of_logic_tree_samples
else [rlz.weight for rlz in rlzs])
mean = oq.mean_hazard_curves
if mean:
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(
curves, q, weights).reshape((nsites, -1))
if mean:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def post_execute(self, curves_by_trt_gsim):
"""
Collect the hazard curves by realization and export them.
:param curves_by_trt_gsim:
a dictionary (trt_id, gsim) -> hazard curves
"""
with self.monitor('save curves_by_trt_gsim', autoflush=True):
for sm in self.rlzs_assoc.csm_info.source_models:
group = self.datastore.hdf5.create_group('curves_by_sm/' +
'_'.join(sm.path))
group.attrs['source_model'] = sm.name
for tm in sm.trt_models:
for i, gsim in enumerate(tm.gsims):
try:
curves = curves_by_trt_gsim[tm.id, gsim]
except KeyError: # no data for the trt_model
pass
else:
ts = '%03d-%d' % (tm.id, i)
if nonzero(curves):
group[ts] = curves
group[ts].attrs['trt'] = tm.trt
group[ts].attrs['nbytes'] = curves.nbytes
group[ts].attrs['gsim'] = str(gsim)
self.datastore.set_nbytes(group.name)
self.datastore.set_nbytes('curves_by_sm')
oq = self.oqparam
with self.monitor('combine and save curves_by_rlz', autoflush=True):
zc = zero_curves(len(self.sitecol.complete), oq.imtls)
curves_by_rlz = self.rlzs_assoc.combine_curves(
curves_by_trt_gsim, agg_curves, zc)
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
for rlz, curves in curves_by_rlz.items():
self.store_curves('rlz-%03d' % rlz.ordinal, curves, rlz)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
with self.monitor('compute and save statistics', autoflush=True):
weights = (None if oq.number_of_logic_tree_samples else
[rlz.weight for rlz in rlzs])
# mean curves are always computed but stored only on request
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(curves, q,
weights).reshape(
(nsites, -1))
if oq.mean_hazard_curves:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def post_execute(self, curves_by_trt_gsim):
"""
Collect the hazard curves by realization and export them.
:param curves_by_trt_gsim:
a dictionary (trt_id, gsim) -> hazard curves
"""
with self.monitor('save curves_by_trt_gsim', autoflush=True):
for sm in self.rlzs_assoc.csm_info.source_models:
group = self.datastore.hdf5.create_group(
'curves_by_sm/' + '_'.join(sm.path))
group.attrs['source_model'] = sm.name
for tm in sm.trt_models:
for i, gsim in enumerate(tm.gsims):
try:
curves = curves_by_trt_gsim[tm.id, gsim]
except KeyError: # no data for the trt_model
pass
else:
ts = '%03d-%d' % (tm.id, i)
if nonzero(curves):
group[ts] = curves
group[ts].attrs['trt'] = tm.trt
group[ts].attrs['nbytes'] = curves.nbytes
group[ts].attrs['gsim'] = str(gsim)
self.datastore.set_nbytes(group.name)
self.datastore.set_nbytes('curves_by_sm')
oq = self.oqparam
with self.monitor('combine and save curves_by_rlz', autoflush=True):
zc = zero_curves(len(self.sitecol.complete), oq.imtls)
curves_by_rlz = self.rlzs_assoc.combine_curves(
curves_by_trt_gsim, agg_curves, zc)
rlzs = self.rlzs_assoc.realizations
nsites = len(self.sitecol)
if oq.individual_curves:
for rlz, curves in curves_by_rlz.items():
self.store_curves('rlz-%03d' % rlz.ordinal, curves, rlz)
if len(rlzs) == 1: # cannot compute statistics
[self.mean_curves] = curves_by_rlz.values()
return
with self.monitor('compute and save statistics', autoflush=True):
weights = (None if oq.number_of_logic_tree_samples
else [rlz.weight for rlz in rlzs])
# mean curves are always computed but stored only on request
self.mean_curves = numpy.array(zc)
for imt in oq.imtls:
self.mean_curves[imt] = scientific.mean_curve(
[curves_by_rlz[rlz][imt] for rlz in rlzs], weights)
self.quantile = {}
for q in oq.quantile_hazard_curves:
self.quantile[q] = qc = numpy.array(zc)
for imt in oq.imtls:
curves = [curves_by_rlz[rlz][imt] for rlz in rlzs]
qc[imt] = scientific.quantile_curve(
curves, q, weights).reshape((nsites, -1))
if oq.mean_hazard_curves:
self.store_curves('mean', self.mean_curves)
for q in self.quantile:
self.store_curves('quantile-%s' % q, self.quantile[q])
def do_aggregate_post_proc(self):
"""
Grab hazard data for all realizations and sites from the database and
compute mean and/or quantile aggregates (depending on which options are
enabled in the calculation).
Post-processing results will be stored directly into the database.
"""
num_rlzs = len(self._realizations)
if not num_rlzs:
logs.LOG.warn('No realizations for hazard_calculation_id=%d',
self.job.id)
return
elif num_rlzs == 1 and self.quantile_hazard_curves:
logs.LOG.warn(
'There is only one realization, the configuration parameter '
'quantile_hazard_curves should not be set')
return
weights = (None if self.oqparam.number_of_logic_tree_samples
else [rlz.weight for rlz in self._realizations])
if self.oqparam.mean_hazard_curves:
# create a new `HazardCurve` 'container' record for mean
# curves (virtual container for multiple imts)
models.HazardCurve.objects.create(
output=models.Output.objects.create_output(
self.job, "mean-curves-multi-imt",
"hazard_curve_multi"),
statistics="mean",
imt=None,
investigation_time=self.oqparam.investigation_time)
for quantile in self.quantile_hazard_curves:
# create a new `HazardCurve` 'container' record for quantile
# curves (virtual container for multiple imts)
models.HazardCurve.objects.create(
output=models.Output.objects.create_output(
self.job, 'quantile(%s)-curves' % quantile,
"hazard_curve_multi"),
statistics="quantile",
imt=None,
quantile=quantile,
investigation_time=self.oqparam.investigation_time)
for imt, imls in self.oqparam.imtls.items():
im_type, sa_period, sa_damping = from_string(imt)
# prepare `output` and `hazard_curve` containers in the DB:
container_ids = dict()
if self.oqparam.mean_hazard_curves:
mean_output = self.job.get_or_create_output(
display_name='Mean Hazard Curves %s' % imt,
output_type='hazard_curve'
)
mean_hc = models.HazardCurve.objects.create(
output=mean_output,
investigation_time=self.oqparam.investigation_time,
imt=im_type,
imls=imls,
sa_period=sa_period,
sa_damping=sa_damping,
statistics='mean'
)
self._hazard_curves.append(mean_hc)
container_ids['mean'] = mean_hc.id
for quantile in self.quantile_hazard_curves:
q_output = self.job.get_or_create_output(
display_name=(
'%s quantile Hazard Curves %s' % (quantile, imt)),
output_type='hazard_curve')
q_hc = models.HazardCurve.objects.create(
output=q_output,
investigation_time=self.oqparam.investigation_time,
imt=im_type,
imls=imls,
sa_period=sa_period,
sa_damping=sa_damping,
statistics='quantile',
quantile=quantile
)
self._hazard_curves.append(q_hc)
container_ids['q%s' % quantile] = q_hc.id
# num_rlzs * num_sites * num_levels
# NB: different IMTs can have different num_levels
all_curves_for_imt = numpy.array(self.curves_by_imt[imt])
del self.curves_by_imt[imt] # save memory
inserter = writer.CacheInserter(
models.HazardCurveData, max_cache_size=10000)
# curve_poes below is an array num_rlzs * num_levels
for i, site in enumerate(self.site_collection):
wkt = site.location.wkt2d
curve_poes = numpy.array(
[c_by_rlz[i] for c_by_rlz in all_curves_for_imt])
# calc quantiles first
for quantile in self.quantile_hazard_curves:
q_curve = scientific.quantile_curve(
curve_poes, quantile, weights)
inserter.add(
models.HazardCurveData(
hazard_curve_id=(
container_ids['q%s' % quantile]),
poes=q_curve.tolist(),
location=wkt))
# then means
if self.mean_hazard_curves and len(curve_poes):
m_curve = scientific.mean_curve(curve_poes, weights)
inserter.add(
models.HazardCurveData(
hazard_curve_id=container_ids['mean'],
poes=m_curve.tolist(),
location=wkt))
inserter.flush()
def do_aggregate_post_proc(self):
"""
Grab hazard data for all realizations and sites from the database and
compute mean and/or quantile aggregates (depending on which options are
enabled in the calculation).
Post-processing results will be stored directly into the database.
"""
num_rlzs = len(self._realizations)
if not num_rlzs:
logs.LOG.warn('No realizations for hazard_calculation_id=%d',
self.job.id)
return
elif num_rlzs == 1 and self.quantile_hazard_curves:
logs.LOG.warn(
'There is only one realization, the configuration parameter '
'quantile_hazard_curves should not be set')
return
weights = (None if self.oqparam.number_of_logic_tree_samples else
[rlz.weight for rlz in self._realizations])
if self.oqparam.mean_hazard_curves:
# create a new `HazardCurve` 'container' record for mean
# curves (virtual container for multiple imts)
models.HazardCurve.objects.create(
output=models.Output.objects.create_output(
self.job, "mean-curves-multi-imt", "hazard_curve_multi"),
statistics="mean",
imt=None,
investigation_time=self.oqparam.investigation_time)
for quantile in self.quantile_hazard_curves:
# create a new `HazardCurve` 'container' record for quantile
# curves (virtual container for multiple imts)
models.HazardCurve.objects.create(
output=models.Output.objects.create_output(
self.job, 'quantile(%s)-curves' % quantile,
"hazard_curve_multi"),
statistics="quantile",
imt=None,
quantile=quantile,
investigation_time=self.oqparam.investigation_time)
for imt, imls in self.oqparam.imtls.items():
im_type, sa_period, sa_damping = from_string(imt)
# prepare `output` and `hazard_curve` containers in the DB:
container_ids = dict()
if self.oqparam.mean_hazard_curves:
mean_output = self.job.get_or_create_output(
display_name='Mean Hazard Curves %s' % imt,
output_type='hazard_curve')
mean_hc = models.HazardCurve.objects.create(
output=mean_output,
investigation_time=self.oqparam.investigation_time,
imt=im_type,
imls=imls,
sa_period=sa_period,
sa_damping=sa_damping,
statistics='mean')
self._hazard_curves.append(mean_hc)
container_ids['mean'] = mean_hc.id
for quantile in self.quantile_hazard_curves:
q_output = self.job.get_or_create_output(
display_name=('%s quantile Hazard Curves %s' %
(quantile, imt)),
output_type='hazard_curve')
q_hc = models.HazardCurve.objects.create(
output=q_output,
investigation_time=self.oqparam.investigation_time,
imt=im_type,
imls=imls,
sa_period=sa_period,
sa_damping=sa_damping,
statistics='quantile',
quantile=quantile)
self._hazard_curves.append(q_hc)
container_ids['q%s' % quantile] = q_hc.id
# num_rlzs * num_sites * num_levels
# NB: different IMTs can have different num_levels
all_curves_for_imt = numpy.array(self.curves_by_imt[imt])
del self.curves_by_imt[imt] # save memory
inserter = writer.CacheInserter(models.HazardCurveData,
max_cache_size=10000)
# curve_poes below is an array num_rlzs * num_levels
for i, site in enumerate(self.site_collection):
wkt = site.location.wkt2d
curve_poes = numpy.array(
[c_by_rlz[i] for c_by_rlz in all_curves_for_imt])
# calc quantiles first
for quantile in self.quantile_hazard_curves:
q_curve = scientific.quantile_curve(
curve_poes, quantile, weights)
inserter.add(
models.HazardCurveData(
hazard_curve_id=(container_ids['q%s' % quantile]),
poes=q_curve.tolist(),
location=wkt))
# then means
if self.mean_hazard_curves:
m_curve = scientific.mean_curve(curve_poes, weights)
inserter.add(
models.HazardCurveData(
hazard_curve_id=container_ids['mean'],
poes=m_curve.tolist(),
location=wkt))
inserter.flush()