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 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()