def classical_risk(riskinputs, riskmodel, rlzs_assoc, monitor): """ Compute and return the average losses for each asset. :param riskinputs: a list of :class:`openquake.risklib.riskinput.RiskInput` objects :param riskmodel: a :class:`openquake.risklib.riskinput.RiskModel` instance :param rlzs_assoc: associations (trt_id, gsim) -> realizations :param monitor: :class:`openquake.baselib.performance.PerformanceMonitor` instance """ result = general.AccumDict({rlz.ordinal: general.AccumDict() for rlz in rlzs_assoc.realizations}) for out_by_rlz in riskmodel.gen_outputs(riskinputs, rlzs_assoc, monitor): for out in out_by_rlz: values = workflows.get_values(out.loss_type, out.assets) for i, asset in enumerate(out.assets): if out.average_insured_losses is not None: ins = out.average_insured_losses[i] * values[i] else: ins = numpy.nan result[out.hid][out.loss_type, asset.id] = ( out.average_losses[i] * values[i], ins) return result
def classical_risk(riskinputs, riskmodel, rlzs_assoc, monitor): """ Compute and return the average losses for each asset. :param riskinputs: a list of :class:`openquake.risklib.riskinput.RiskInput` objects :param riskmodel: a :class:`openquake.risklib.riskinput.RiskModel` instance :param rlzs_assoc: associations (trt_id, gsim) -> realizations :param monitor: :class:`openquake.commonlib.parallel.PerformanceMonitor` instance """ result = general.AccumDict( {rlz.ordinal: general.AccumDict() for rlz in rlzs_assoc.realizations}) for out_by_rlz in riskmodel.gen_outputs(riskinputs, rlzs_assoc, monitor): for out in out_by_rlz: values = workflows.get_values(out.loss_type, out.assets) for i, asset in enumerate(out.assets): if out.average_insured_losses is not None: ins = out.average_insured_losses[i] * values[i] else: ins = numpy.nan result[out.hid][out.loss_type, asset.id] = (out.average_losses[i] * values[i], ins) return result
def classical_risk(riskinputs, riskmodel, rlzs_assoc, monitor): """ Compute and return the average losses for each asset. :param riskinputs: a list of :class:`openquake.risklib.riskinput.RiskInput` objects :param riskmodel: a :class:`openquake.risklib.riskinput.RiskModel` instance :param rlzs_assoc: associations (trt_id, gsim) -> realizations :param monitor: :class:`openquake.baselib.performance.PerformanceMonitor` instance """ lti = riskmodel.lti oq = monitor.oqparam ins = oq.insured_losses result = dict(loss_curves=[], loss_maps=[], stat_curves=[], stat_maps=[]) for out_by_rlz in riskmodel.gen_outputs(riskinputs, rlzs_assoc, monitor): l = lti[out_by_rlz.loss_type] values = workflows.get_values(out_by_rlz.loss_type, out_by_rlz.assets) for out in out_by_rlz: r = out.hid for i, asset in enumerate(out.assets): aid = asset.idx val = values[i] avg = out.average_losses[i] * val avg_ins = (out.average_insured_losses[i] * val if ins else numpy.nan) lcurve = (out.loss_curves[i, 0] * val, out.loss_curves[i, 1], avg) if ins: lcurve += (out.insured_curves[i, 0] * val, out.insured_curves[i, 1], avg_ins) else: lcurve += (None, None, None) result['loss_curves'].append((l, r, aid, lcurve)) # no insured, shape (P, N) result['loss_maps'].append( (l, r, aid, out.loss_maps[:, i] * val)) # compute statistics if len(out_by_rlz) > 1: cb = riskmodel.curve_builders[l] statsbuilder = scientific.StatsBuilder( oq.quantile_loss_curves, oq.conditional_loss_poes, oq.poes_disagg, cb.curve_resolution, insured_losses=oq.insured_losses) stats = statsbuilder.build(out_by_rlz) stat_curves, stat_maps = statsbuilder.get_curves_maps(stats) for asset, stat_curve, stat_map in zip(out_by_rlz.assets, stat_curves, stat_maps): result['stat_curves'].append((l, asset.idx, stat_curve)) result['stat_maps'].append((l, asset.idx, stat_map)) return result
def post_execute(self, result): """ Extract from the result dictionary rlz.ordinal -> (loss_type, tag) -> [(asset.id, loss), ...] several interesting outputs. """ oq = self.oqparam # take the cached self.rlzs_assoc and write it on the datastore self.rlzs_assoc = self.rlzs_assoc rlzs = self.rlzs_assoc.realizations loss_types = self.riskmodel.get_loss_types() C = oq.loss_curve_resolution self.loss_curve_dt = numpy.dtype( [('losses', (float, C)), ('poes', (float, C)), ('avg', float)]) if oq.conditional_loss_poes: lm_names = _loss_map_names(oq.conditional_loss_poes) self.loss_map_dt = numpy.dtype([(f, float) for f in lm_names]) self.assets = assets = riskinput.sorted_assets(self.assets_by_site) self.specific_assets = specific_assets = [ a for a in assets if a.id in self.oqparam.specific_assets] specific_asset_refs = set(self.oqparam.specific_assets) N = len(assets) event_loss_asset = [{} for rlz in rlzs] event_loss = [{} for rlz in rlzs] loss_curves = self.zeros(N, self.loss_curve_dt) ins_curves = self.zeros(N, self.loss_curve_dt) if oq.conditional_loss_poes: loss_maps = self.zeros(N, self.loss_map_dt) agg_loss_curve = self.zeros(1, self.loss_curve_dt) for i in sorted(result): rlz = rlzs[i] data_by_lt_tag = result[i] # (loss_type, asset_id) -> [(tag, loss, ins_loss), ...] elass = {(loss_type, asset.id): [] for asset in assets for loss_type in loss_types} elagg = [] # aggregate event loss nonzero = total = 0 for loss_type, tag in data_by_lt_tag: d = data_by_lt_tag[loss_type, tag] if tag == 'counts_matrix': assets, counts = d.keys(), d.values() indices = numpy.array([asset.idx for asset in assets]) asset_values = workflows.get_values(loss_type, assets) poes = scientific.build_poes( counts, oq.ses_per_logic_tree_path) cb = scientific.CurveBuilder( loss_type, numpy.linspace(0, 1, C)) lcurves = cb.build_loss_curves( poes, asset_values, indices, N) self.store('lcurves/' + loss_type, rlz, lcurves) continue for aid, loss, ins_loss in d['data']: elass[loss_type, aid].append((tag, loss, ins_loss)) # aggregates elagg.append((loss_type, tag, d['loss'], d['ins_loss'])) nonzero += d['nonzero'] total += d['total'] logging.info('rlz=%d: %d/%d nonzero losses', i, nonzero, total) if elass: data_by_lt = collections.defaultdict(list) for (loss_type, asset_id), rows in elass.items(): for tag, loss, ins_loss in rows: data_by_lt[loss_type].append( (tag, asset_id, loss, ins_loss)) for loss_type, data in data_by_lt.items(): event_loss_asset[i][loss_type] = sorted( # data contains rows (tag, asset, loss, ins_loss) (t, a, l, i) for t, a, l, i in data if a in specific_asset_refs) # build the loss curves per asset lc = self.build_loss_curves(elass, loss_type, 1) loss_curves[loss_type] = lc if oq.insured_losses: # build the insured loss curves per asset ic = self.build_loss_curves(elass, loss_type, 2) ins_curves[loss_type] = ic if oq.conditional_loss_poes: # build the loss maps per asset, array of shape (N, P) losses_poes = numpy.array( # shape (N, 2, C) [lc['losses'], lc['poes']]).transpose(1, 0, 2) lmaps = scientific.loss_map_matrix( oq.conditional_loss_poes, losses_poes) # (P, N) for lm, lmap in zip(lm_names, lmaps): loss_maps[loss_type][lm] = lmap self.store('loss_curves', rlz, loss_curves) if oq.insured_losses: self.store('ins_curves', rlz, ins_curves) if oq.conditional_loss_poes: self.store('loss_maps', rlz, loss_maps) if elagg: for loss_type, rows in groupby( elagg, operator.itemgetter(0)).items(): event_loss[i][loss_type] = [row[1:] for row in rows] # aggregate loss curve for all tags losses, poes, avg, _ = self.build_agg_loss_curve_and_map( [loss for _lt, _tag, loss, _ins_loss in rows]) # NB: there is no aggregate insured loss curve agg_loss_curve[loss_type][0] = (losses, poes, avg) # NB: the aggregated loss_map is not stored self.store('agg_loss_curve', rlz, agg_loss_curve) if specific_assets: self.event_loss_asset = event_loss_asset self.event_loss = event_loss # store statistics (i.e. mean and quantiles) for curves and maps if len(self.rlzs_assoc.realizations) > 1: self.compute_store_stats('loss_curves') self.compute_store_stats('agg_loss_curve')