def setUpClass(cls): assets = [ asset('a1', 101), asset('a2', 151), asset('a3', 91), asset('a4', 81) ] asset_refs = [a.id for a in assets] outputs = [] weights = [0.3, 0.7] baselosses = numpy.array([.10, .14, .17, .20, .21]) for i, w in enumerate(weights): lc = loss_curves(assets, baselosses, i) out = scientific.Output(asset_refs, 'structural', weight=w, loss_curves=lc, insured_curves=None, average_losses=[.1, .12, .13, .9], average_insured_losses=None) outputs.append(out) cls.builder = scientific.StatsBuilder( quantiles=[0.1, 0.9], conditional_loss_poes=[0.35, 0.24, 0.13], poes_disagg=[], curve_resolution=len(baselosses)) cls.stats = cls.builder.build(outputs)
def __call__(self, loss_type, assets, hazard_curve, _epsilons=None, _eids=None): """ :param loss_type: the loss type :param assets: a list of N assets of the same taxonomy :param hazard_curve: an hazard curve array :returns: an array of N assets and an array of N x D elements where N is the number of points and D the number of damage states. """ ffl = self.risk_functions[loss_type] hazard_imls = self.hazard_imtls[ffl.imt] damage = scientific.classical_damage( ffl, hazard_imls, hazard_curve, investigation_time=self.investigation_time, risk_investigation_time=self.risk_investigation_time) return scientific.Output(assets, loss_type, damages=[a.number * damage for a in assets])
def __call__(self, loss_type, assets, gmfs, epsilons, event_ids): self.assets = assets original_loss_curves = utils.numpy_map( self.curves, self.vf_orig[loss_type].apply_to(gmfs, epsilons)) retrofitted_loss_curves = utils.numpy_map( self.curves, self.vf_retro[loss_type].apply_to(gmfs, epsilons)) eal_original = utils.numpy_map(scientific.average_loss, original_loss_curves) eal_retrofitted = utils.numpy_map(scientific.average_loss, retrofitted_loss_curves) bcr_results = [ scientific.bcr(eal_original[i], eal_retrofitted[i], self.interest_rate, self.asset_life_expectancy, asset.value(loss_type), asset.retrofitted(loss_type)) for i, asset in enumerate(assets) ] return scientific.Output(assets, loss_type, data=list( zip(eal_original, eal_retrofitted, bcr_results)))
def _collect_all_data(self): # return a list of list of outputs if 'rcurves-rlzs' not in self.datastore: return [] all_data = [] assets = self.assetcol['asset_ref'] rlzs = self.rlzs_assoc.realizations avg_losses = self.datastore['avg_losses-rlzs'].value r_curves = self.datastore['rcurves-rlzs'].value insured_losses = self.oqparam.insured_losses i_curves = (self.datastore['icurves-rlzs'].value if insured_losses else None) for loss_type, cbuilder in zip(self.riskmodel.loss_types, self.riskmodel.curve_builders): avglosses = avg_losses[loss_type] rcurves = r_curves[loss_type] asset_values = self.assetcol[loss_type] data = [] for rlz in rlzs: average_losses = avglosses[:, rlz.ordinal] out = scientific.Output( assets, loss_type, rlz.ordinal, rlz.weight, loss_curves=old_loss_curves(asset_values, rcurves, rlz.ordinal, cbuilder.ratios), insured_curves=old_loss_curves( asset_values, i_curves[loss_type], rlz.ordinal, cbuilder.ratios) if i_curves else None, average_losses=average_losses[:, 0], average_insured_losses=average_losses[:, 1]) data.append(out) all_data.append(data) return all_data
def __call__(self, loss_type, assets, hazard, _eps=None, _tags=None): self.assets = assets original_loss_curves = utils.numpy_map(self.curves_orig[loss_type], hazard) retrofitted_loss_curves = utils.numpy_map(self.curves_retro[loss_type], hazard) eal_original = utils.numpy_map(scientific.average_loss, original_loss_curves) eal_retrofitted = utils.numpy_map(scientific.average_loss, retrofitted_loss_curves) bcr_results = [ scientific.bcr(eal_original[i], eal_retrofitted[i], self.interest_rate, self.asset_life_expectancy, asset.value(loss_type), asset.retrofitted(loss_type)) for i, asset in enumerate(assets) ] return scientific.Output(assets, loss_type, data=list( zip(eal_original, eal_retrofitted, bcr_results)))
def build_stats(self, loss_curve_key): """ Compute all statistics for the specified assets starting from the stored loss curves. Yield a statistical output object for each loss type. """ oq = self.oqparam rlzs = self.rlzs_assoc.realizations stats = scientific.StatsBuilder( oq.quantile_loss_curves, oq.conditional_loss_poes, [], scientific.normalize_curves_eb) # NB: should we encounter memory issues in the future, the easy # solution is to split the specific assets in blocks and perform # the computation one block at the time for loss_type in self.riskmodel.get_loss_types(): outputs = [] for rlz in rlzs: key = '%s-rlzs/%s' % (loss_curve_key, rlz.uid) lcs = self.datastore[key][loss_type] assets = [None] if key.startswith('agg') else self.assets losses_poes = numpy.array( # -> shape (N, 2, C) [lcs['losses'], lcs['poes']]).transpose(1, 0, 2) out = scientific.Output( assets, loss_type, rlz.ordinal, rlz.weight, loss_curves=losses_poes, insured_curves=None) outputs.append(out) yield stats.build(outputs)
def __call__(self, loss_type, assets, ground_motion_values, epsilons, event_ids): """ :param str loss_type: the loss type considered :param assets: assets is an iterator over :class:`openquake.risklib.scientific.Asset` instances :param ground_motion_values: a numpy array with ground_motion_values of shape N x R :param epsilons: a numpy array with stochastic values of shape N x R :param event_ids: a numpy array of R event ID (integer) :returns: a :class: `openquake.risklib.scientific.ProbabilisticEventBased.Output` instance. """ n = len(assets) loss_matrix = self.risk_functions[loss_type].apply_to( ground_motion_values, epsilons) # sum on ruptures; compute the fractional losses average_losses = loss_matrix.sum(axis=1) * self.ses_ratio values = get_values(loss_type, assets) ela = loss_matrix.T * values # matrix with T x N elements cb = self.riskmodel.curve_builders[self.riskmodel.lti[loss_type]] # FIXME: ugly workaround for qa_tests.event_based_test; in Ubuntu 12.04 # MagicMock does not work well, so len(cb.ratios) gives an error nratios = 1 if isinstance(cb, mock.Mock) else len(cb.ratios) if self.insured_losses and loss_type != 'fatalities': deductibles = numpy.array( [a.deductible(loss_type) for a in assets]) limits = numpy.array( [a.insurance_limit(loss_type) for a in assets]) ilm = utils.numpy_map(scientific.insured_losses, loss_matrix, deductibles, limits) icounts = cb.build_counts(ilm) else: # build a NaN matrix of size N x T T = len(ground_motion_values[0]) ilm = numpy.empty((n, T)) ilm.fill(numpy.nan) icounts = numpy.empty((n, nratios)) icounts.fill(numpy.nan) ila = ilm.T * values average_insured_losses = ilm.sum(axis=1) * self.ses_ratio return scientific.Output(assets, loss_type, event_loss_per_asset=ela, insured_loss_per_asset=ila, average_losses=average_losses, average_insured_losses=average_insured_losses, counts_matrix=cb.build_counts(loss_matrix), insured_counts_matrix=icounts, tags=event_ids)
def __call__(self, loss_type, assets, hazard_curve, _epsilons=None, _eids=None): """ :param str loss_type: the loss type considered :param assets: assets is an iterator over N :class:`openquake.risklib.scientific.Asset` instances :param hazard_curve: an array of poes :param _epsilons: ignored, here only for API compatibility with other calculators :returns: a :class:`openquake.risklib.scientific.Classical.Output` instance. """ n = len(assets) vf = self.risk_functions[loss_type] imls = self.hazard_imtls[vf.imt] curves = [ scientific.classical(vf, imls, hazard_curve, self.lrem_steps_per_interval) ] * n average_losses = utils.numpy_map(scientific.average_loss, curves) maps = scientific.loss_map_matrix(self.conditional_loss_poes, curves) values = get_values(loss_type, assets) if self.insured_losses and loss_type != 'occupants': deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] insured_curves = rescale( utils.numpy_map(scientific.insured_loss_curve, curves, deductibles, limits), values) average_insured_losses = utils.numpy_map(scientific.average_loss, insured_curves) else: insured_curves = None average_insured_losses = None return scientific.Output(assets, loss_type, loss_curves=rescale(numpy.array(curves), values), average_losses=values * average_losses, insured_curves=insured_curves, average_insured_losses=average_insured_losses, loss_maps=values * maps)
def __call__(self, loss_type, assets, ground_motion_values, epsilons, eids): """ :param str loss_type: the loss type considered :param assets: a list with a single asset :param ground_motion_values: an array of E ground_motion_values :param epsilons: a list with a single array of E stochastic values :param eids: a numpy array of E rupture IDs :returns: a :class: `openquake.risklib.scientific.ProbabilisticEventBased.Output` instance. """ E = len(eids) I = self.insured_losses + 1 loss_ratios = numpy.zeros((E, I), F32) asset = assets[0] # the only one loss_ratios[:, 0] = ratios = self.risk_functions[loss_type].apply_to( [ground_motion_values], epsilons)[0] # shape E cb = self.compositemodel.curve_builders[ self.compositemodel.lti[loss_type]] if self.insured_losses and loss_type != 'occupants': deductible = asset.deductible(loss_type) limit = asset.insurance_limit(loss_type) ilm = scientific.insured_losses(ratios, deductible, limit) loss_ratios[:, 1] = ilm icounts = cb.build_counts(ilm) else: # FIXME: ugly workaround for qa_tests.event_based_test; in Ubuntu # 12.04 MagicMock does not work well, so len(cb.ratios) gives error nratios = 1 if isinstance(cb, mock.Mock) else len(cb.ratios) icounts = numpy.empty(nratios) icounts.fill(numpy.nan) return scientific.Output(assets, loss_type, losses=loss_ratios * asset.value(loss_type), average_loss=loss_ratios.sum(axis=0) * self.ses_ratio, counts_matrix=cb.build_counts(loss_ratios), insured_counts_matrix=icounts, eids=eids)
def __call__(self, loss_type, assets, gmfs, _epsilons=None, _tags=None): """ :param loss_type: the loss type :param assets: a list of N assets of the same taxonomy :param gmfs: an array of N x E elements :returns: an array of N assets and an array of N x E x D elements where N is the number of points, E the number of events and D the number of damage states. """ ffs = self.risk_functions[loss_type] damages = numpy.array( [[scientific.scenario_damage(ffs, gmv) for gmv in gmvs] for gmvs in gmfs]) return scientific.Output(assets, loss_type, damages=damages)
def build_agg_curve_stats(self, builder, agg_curve, loss_curve_dt): """ Build and save `agg_curve-stats` in the HDF5 file. :param builder: :class:`openquake.risklib.scientific.StatsBuilder` instance :param agg_curve: array of aggregate curves, one per realization :param loss_curve_dt: numpy dtype for loss curves """ rlzs = self.datastore['csm_info'].get_rlzs_assoc().realizations Q1 = len(builder.mean_quantiles) agg_curve_stats = numpy.zeros(Q1, loss_curve_dt) for l, loss_type in enumerate(self.riskmodel.loss_types): agg_curve_lt = agg_curve[loss_type] outputs = [] for rlz in rlzs: curve = agg_curve_lt[rlz.ordinal] average_loss = curve['avg'] loss_curve = (curve['losses'], curve['poes']) if self.oqparam.insured_losses: average_insured_loss = curve['avg_ins'] insured_curves = [(curve['losses_ins'], curve['poes_ins'])] else: average_insured_loss = None insured_curves = None out = scientific.Output( [None], loss_type, rlz.ordinal, rlz.weight, loss_curves=[loss_curve], insured_curves=insured_curves, average_losses=[average_loss], average_insured_losses=[average_insured_loss]) outputs.append(out) stats = builder.build(outputs) curves, _maps = builder.get_curves_maps(stats) # shape (Q1, 1) acs = agg_curve_stats[loss_type] for i, statname in enumerate(builder.mean_quantiles): for name in acs.dtype.names: acs[name][i] = curves[name][i] # saving agg_curve_stats self.datastore['agg_curve-stats'] = agg_curve_stats self.datastore['agg_curve-stats'].attrs['nbytes'] = ( agg_curve_stats.nbytes)
def __call__(self, loss_type, assets, gmvs, _eps=None): """ :param loss_type: the loss type :param assets: a list of N assets of the same taxonomy :param gmvs: an array of E elements :param _eps: dummy parameter, unused :returns: an array of N assets and an array of N x E x D elements where N is the number of points, E the number of events and D the number of damage states. """ n = len(assets) ffs = self.risk_functions[loss_type] damages = numpy.array( [scientific.scenario_damage(ffs, gmv) for gmv in gmvs]) return scientific.Output(assets, loss_type, damages=[damages] * n)
def __call__(self, loss_type, assets, ground_motion_values, epsilons, _eids=None): values = get_values(loss_type, assets, self.time_event) ok = ~numpy.isnan(values) if not ok.any(): # there are no assets with a value return # there may be assets without a value missing_value = not ok.all() if missing_value: assets = assets[ok] epsilons = epsilons[ok] # a matrix of N x E elements loss_ratio_matrix = self.risk_functions[loss_type].apply_to( [ground_motion_values] * len(assets), epsilons) # another matrix of N x E elements loss_matrix = (loss_ratio_matrix.T * values).T # an array of E elements aggregate_losses = loss_matrix.sum(axis=0) if self.insured_losses and loss_type != "occupants": deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] insured_loss_ratio_matrix = utils.numpy_map( scientific.insured_losses, loss_ratio_matrix, deductibles, limits) insured_loss_matrix = (insured_loss_ratio_matrix.T * values).T else: insured_loss_matrix = numpy.empty_like(loss_ratio_matrix) insured_loss_matrix.fill(numpy.nan) # aggregating per asset, getting a vector of E elements insured_losses = insured_loss_matrix.sum(axis=0) return scientific.Output(assets, loss_type, loss_matrix=loss_matrix, loss_ratio_matrix=loss_ratio_matrix, aggregate_losses=aggregate_losses, insured_loss_matrix=insured_loss_matrix, insured_losses=insured_losses)
def __call__(self, loss_type, assets, hazard, _eps=None, _eids=None): """ :param loss_type: the loss type :param assets: a list of N assets of the same taxonomy :param hazard: an hazard curve :param _eps: dummy parameter, unused :param _eids: dummy parameter, unused :returns: a :class:`openquake.risklib.scientific.Output` instance """ n = len(assets) self.assets = assets vf = self.risk_functions[loss_type] imls = self.hazard_imtls[vf.imt] vf_retro = self.retro_functions[loss_type] curves_orig = functools.partial(scientific.classical, vf, imls, steps=self.lrem_steps_per_interval) curves_retro = functools.partial(scientific.classical, vf_retro, imls, steps=self.lrem_steps_per_interval) original_loss_curves = utils.numpy_map(curves_orig, [hazard] * n) retrofitted_loss_curves = utils.numpy_map(curves_retro, [hazard] * n) eal_original = utils.numpy_map(scientific.average_loss, original_loss_curves) eal_retrofitted = utils.numpy_map(scientific.average_loss, retrofitted_loss_curves) bcr_results = [ scientific.bcr(eal_original[i], eal_retrofitted[i], self.interest_rate, self.asset_life_expectancy, asset.value(loss_type), asset.retrofitted(loss_type)) for i, asset in enumerate(assets) ] return scientific.Output(assets, loss_type, data=list( zip(eal_original, eal_retrofitted, bcr_results)))
def __call__(self, loss_type, assets, ground_motion_values, epsgetter): epsilons = epsgetter() values = get_values(loss_type, assets, self.time_event) ok = ~numpy.isnan(values) if not ok.any(): # there are no assets with a value return # there may be assets without a value missing_value = not ok.all() if missing_value: assets = assets[ok] epsilons = epsilons[ok] # a matrix of N x E elements vf = self.risk_functions[loss_type] means, covs, idxs = vf.interpolate(ground_motion_values) loss_ratio_matrix = numpy.zeros((len(assets), len(epsilons[0]))) for i, eps in enumerate(epsilons): loss_ratio_matrix[i, idxs] = vf.sample(means, covs, idxs, eps) # another matrix of N x E elements loss_matrix = (loss_ratio_matrix.T * values).T # an array of E elements aggregate_losses = loss_matrix.sum(axis=0) if self.insured_losses and loss_type != "occupants": deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] insured_loss_ratio_matrix = utils.numpy_map( scientific.insured_losses, loss_ratio_matrix, deductibles, limits) insured_loss_matrix = (insured_loss_ratio_matrix.T * values).T else: insured_loss_matrix = numpy.empty_like(loss_ratio_matrix) insured_loss_matrix.fill(numpy.nan) # aggregating per asset, getting a vector of E elements insured_losses = insured_loss_matrix.sum(axis=0) return scientific.Output(assets, loss_type, loss_matrix=loss_matrix, loss_ratio_matrix=loss_ratio_matrix, aggregate_losses=aggregate_losses, insured_loss_matrix=insured_loss_matrix, insured_losses=insured_losses)
def __call__(self, loss_type, assets, hazard_curves, _epsilons=None, _tags=None): """ :param str loss_type: the loss type considered :param assets: assets is an iterator over N :class:`openquake.risklib.scientific.Asset` instances :param hazard_curves: an iterator over N arrays with the poes :param _epsilons: ignored, here only for API compatibility with other calculators :returns: a :class:`openquake.risklib.scientific.Classical.Output` instance. """ curves = utils.numpy_map(self.curves[loss_type], hazard_curves) average_losses = utils.numpy_map(scientific.average_loss, curves) maps = scientific.loss_map_matrix(self.conditional_loss_poes, curves) fractions = scientific.loss_map_matrix(self.poes_disagg, curves) if self.insured_losses and loss_type != 'fatalities': deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] insured_curves = utils.numpy_map(scientific.insured_loss_curve, curves, deductibles, limits) average_insured_losses = utils.numpy_map(scientific.average_loss, insured_curves) else: insured_curves = None average_insured_losses = None return scientific.Output(assets, loss_type, loss_curves=curves, average_losses=average_losses, insured_curves=insured_curves, average_insured_losses=average_insured_losses, loss_maps=maps, loss_fractions=fractions)
def __call__(self, loss_type, assets, hazard_curves, _epsilons=None, _tags=None): """ :param loss_type: the string 'damage' :param assets: a list of N assets of the same taxonomy :param hazard_curves: an array of N x E elements :returns: an array of N assets and an array of N x D elements where N is the number of points and D the number of damage states. """ fractions = utils.numpy_map(self.curves, hazard_curves) damages = [ asset.number * fraction for asset, fraction in zip(assets, fractions) ] return scientific.Output(assets, 'damage', damages=damages)
def _collect_all_data(self): # return a list of list of outputs if 'rcurves-rlzs' not in self.datastore: return [] all_data = [] assets = self.datastore['asset_refs'].value[self.assetcol.array['idx']] rlzs = self.rlzs_assoc.realizations insured = self.oqparam.insured_losses if self.oqparam.avg_losses: avg_losses = self.datastore['avg_losses-rlzs'].value else: avg_losses = self.avg_losses r_curves = self.datastore['rcurves-rlzs'].value for loss_type, cbuilder in zip(self.riskmodel.loss_types, self.riskmodel.curve_builders): rcurves = r_curves[loss_type] asset_values = self.vals[loss_type] data = [] for rlz in rlzs: average_losses = avg_losses[loss_type][:, rlz.ordinal] average_insured_losses = (avg_losses[loss_type + '_ins'][:, rlz.ordinal] if insured else None) loss_curves = _old_loss_curves(asset_values, rcurves[:, rlz.ordinal, 0], cbuilder.ratios) insured_curves = _old_loss_curves( asset_values, rcurves[:, rlz.ordinal, 1], cbuilder.ratios) if insured else None out = scientific.Output( assets, loss_type, rlz.ordinal, rlz.weight, loss_curves=loss_curves, insured_curves=insured_curves, average_losses=average_losses, average_insured_losses=average_insured_losses) data.append(out) all_data.append(data) return all_data
def build_specific_stats(self, builder): """ Compute all statistics for the specified assets starting from the stored loss curves. Yield a statistical output object for each loss type. """ if not self.oqparam.specific_assets: return [] specific_assets = set(self.oqparam.specific_assets) assetcol = self.assetcol specific_ids = [] for i, a in enumerate(self.assetcol): if a['asset_ref'] in specific_assets: specific_ids.append(i) assets = assetcol['asset_ref'] rlzs = self.rlzs_assoc.realizations stats = [] for loss_type in self.riskmodel.loss_types: group = self.datastore['/specific-loss_curves-rlzs/%s' % loss_type] data = [] for rlz, dataset in zip(rlzs, group.values()): dkey = 'avg_losses-rlzs/%s/%s' % (loss_type, rlz.uid) average_losses = self.datastore[dkey][specific_ids] lcs = dataset.value losses_poes = numpy.array( # -> shape (N, 2, C) [lcs['losses'], lcs['poes']]).transpose(1, 0, 2) out = scientific.Output( assets, loss_type, rlz.ordinal, rlz.weight, loss_curves=losses_poes, insured_curves=None, average_losses=average_losses[:, 0], average_insured_losses=average_losses[:, 1]) data.append(out) stats.append(builder.build(data, prefix='specific-')) return stats
def __call__(self, loss_type, assets, ground_motion_values, epsilons, _tags=None): # FIXME: remove this when the engine calculator will be removed engine = hasattr(assets[0], 'asset_ref') values = get_values(loss_type, assets, self.time_event) # a matrix of N x E elements loss_ratio_matrix = self.risk_functions[loss_type].apply_to( ground_motion_values, epsilons) # another matrix of N x E elements loss_matrix = (loss_ratio_matrix.T * values).T # an array of E elements aggregate_losses = loss_matrix.sum(axis=0) if self.insured_losses and loss_type != "fatalities": deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] insured_loss_ratio_matrix = utils.numpy_map( scientific.insured_losses, loss_ratio_matrix, deductibles, limits) insured_loss_matrix = (insured_loss_ratio_matrix.T * values).T else: insured_loss_matrix = numpy.empty_like(loss_ratio_matrix) insured_loss_matrix.fill(numpy.nan) # aggregating per asset, getting a vector of E elements insured_losses = insured_loss_matrix.sum(axis=0) return scientific.Output(assets, loss_type, loss_matrix=loss_matrix, loss_ratio_matrix=loss_ratio_matrix, aggregate_losses=aggregate_losses, insured_loss_matrix=NoneOr( engine, insured_loss_matrix), insured_losses=NoneOr(engine, insured_losses))
def build_stats(self, builder): """ Compute all statistics for all assets starting from the stored loss curves. Yield a statistical output object for each loss type. """ if 'rcurves-rlzs' not in self.datastore: return [] stats = [] # NB: should we encounter memory issues in the future, the easy # solution is to split the assets in blocks and perform # the computation one block at the time assets = self.assetcol['asset_ref'] rlzs = self.rlzs_assoc.realizations for loss_type in self.riskmodel.loss_types: group = self.datastore['rcurves-rlzs/%s' % loss_type] asset_values = self.assetcol[loss_type] data = [] for rlz, dataset in zip(rlzs, group.values()): dkey = 'avg_losses-rlzs/%s/%s' % (loss_type, rlz.uid) average_losses = self.datastore[dkey].value ratios = group.attrs['loss_ratios'] lcs = [] for avalue, poes in zip(asset_values, dataset['poes']): lcs.append((avalue * ratios, poes)) losses_poes = numpy.array(lcs) # -> shape (N, 2, C) out = scientific.Output( assets, loss_type, rlz.ordinal, rlz.weight, loss_curves=losses_poes, insured_curves=None, average_losses=average_losses[:, 0], average_insured_losses=average_losses[:, 1]) data.append(out) stats.append(builder.build(data)) return stats
def __call__(self, loss_type, assets, gmvs_eids, epsgetter): """ :param str loss_type: the loss type considered :param assets: a list of assets on the same site and with the same taxonomy :param gmvs_eids: a pair of arrays of E elements :param epsgetter: a callable returning the correct epsilons for the given gmvs :returns: a :class: `openquake.risklib.scientific.ProbabilisticEventBased.Output` instance. """ gmvs, eids = gmvs_eids E = len(gmvs) I = self.insured_losses + 1 N = len(assets) loss_ratios = numpy.zeros((N, E, I), F32) vf = self.risk_functions[loss_type] means, covs, idxs = vf.interpolate(gmvs) for i, asset in enumerate(assets): epsilons = epsgetter(asset.ordinal, eids) if epsilons is not None: ratios = vf.sample(means, covs, idxs, epsilons) else: ratios = means loss_ratios[i, idxs, 0] = ratios if self.insured_losses and loss_type != 'occupants': loss_ratios[i, idxs, 1] = scientific.insured_losses( ratios, asset.deductible(loss_type), asset.insurance_limit(loss_type)) return scientific.Output(assets, loss_type, loss_ratios=loss_ratios, eids=eids)
def _collect_specific_data(self): # return a list of list of outputs if not self.oqparam.specific_assets: return [] specific_assets = set(self.oqparam.specific_assets) assetcol = self.assetcol specific_ids = [] for i, a in enumerate(self.assetcol): if a['asset_ref'] in specific_assets: specific_ids.append(i) assets = assetcol['asset_ref'] rlzs = self.rlzs_assoc.realizations specific_data = [] avglosses = self.datastore['avg_losses-rlzs'][specific_ids] for loss_type in self.riskmodel.loss_types: group = self.datastore['/specific-loss_curves-rlzs/%s' % loss_type] data = [] avglosses_lt = avglosses[loss_type] for rlz, dataset in zip(rlzs, group.values()): average_losses = avglosses_lt[:, rlz.ordinal] lcs = dataset.value losses_poes = numpy.array( # -> shape (N, 2, C) [lcs['losses'], lcs['poes']]).transpose(1, 0, 2) out = scientific.Output( assets, loss_type, rlz.ordinal, rlz.weight, loss_curves=losses_poes, insured_curves=None, # FIXME: why None? average_losses=average_losses[:, 0], average_insured_losses=average_losses[:, 1]) data.append(out) specific_data.append(data) return specific_data
def __call__(self, loss_type, assets, hazard_curves, _epsilons=None, _tags=None): """ :param loss_type: the loss type :param assets: a list of N assets of the same taxonomy :param hazard_curves: an array of N x E elements :returns: an array of N assets and an array of N x D elements where N is the number of points and D the number of damage states. """ damages = [ asset.number * scientific.classical_damage( self.risk_functions[loss_type], self.hazard_imls, curve, investigation_time=self.investigation_time, risk_investigation_time=self.risk_investigation_time) for asset, curve in zip(assets, hazard_curves) ] return scientific.Output(assets, loss_type, damages=damages)
def __call__(self, loss_type, assets, ground_motion_values, epsilons, _tags=None): values = get_values(loss_type, assets, self.time_event) # a matrix of N x R elements loss_ratio_matrix = self.risk_functions[loss_type].apply_to( ground_motion_values, epsilons) # another matrix of N x R elements loss_matrix = (loss_ratio_matrix.T * values).T # an array of R elements aggregate_losses = loss_matrix.sum(axis=0) if self.insured_losses and loss_type != "fatalities": deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] insured_loss_ratio_matrix = utils.numpy_map( scientific.insured_losses, loss_ratio_matrix, deductibles, limits) insured_loss_matrix = (insured_loss_ratio_matrix.T * values).T # aggregating per asset, getting a vector of R elements insured_losses = insured_loss_matrix.sum(axis=0) else: insured_loss_matrix = None insured_losses = None return scientific.Output(assets, loss_type, loss_matrix=loss_matrix, loss_ratio_matrix=loss_ratio_matrix, aggregate_losses=aggregate_losses, insured_loss_matrix=insured_loss_matrix, insured_losses=insured_losses)
def __call__(self, loss_type, assets, ground_motion_values, epsilons, event_ids): """ :param str loss_type: the loss type considered :param assets: assets is an iterator over :class:`openquake.risklib.scientific.Asset` instances :param ground_motion_values: a numpy array with ground_motion_values of shape N x R :param epsilons: a numpy array with stochastic values of shape N x R :param event_ids: a numpy array of R event ID (integer) :returns: a :class: `openquake.risklib.scientific.ProbabilisticEventBased.Output` instance. """ loss_matrix = self.risk_functions[loss_type].apply_to( ground_motion_values, epsilons) values = get_values(loss_type, assets) ela = loss_matrix.T * values # matrix with T x N elements if self.insured_losses and loss_type != 'fatalities': deductibles = [a.deductible(loss_type) for a in assets] limits = [a.insurance_limit(loss_type) for a in assets] ila = utils.numpy_map(scientific.insured_losses, loss_matrix, deductibles, limits) else: # build a zero matrix of size T x N ila = numpy.zeros((len(ground_motion_values[0]), len(assets))) if isinstance(assets[0].id, str): # in oq-lite return early, with just the losses per asset cb = self.riskmodel.curve_builders[self.riskmodel.lti[loss_type]] return scientific.Output( assets, loss_type, event_loss_per_asset=ela, insured_loss_per_asset=ila, counts_matrix=cb.build_counts(loss_matrix), insured_counts_matrix=cb.build_counts(ila), tags=event_ids) # in the engine, compute more stuff on the workers curves = utils.numpy_map(self.curves, loss_matrix) average_losses = utils.numpy_map(scientific.average_loss, curves) stddev_losses = numpy.std(loss_matrix, axis=1) maps = scientific.loss_map_matrix(self.conditional_loss_poes, curves) elt = self.event_loss(ela, event_ids) if self.insured_losses and loss_type != 'fatalities': insured_curves = utils.numpy_map(self.curves, ila) average_insured_losses = utils.numpy_map(scientific.average_loss, insured_curves) stddev_insured_losses = numpy.std(ila, axis=1) else: insured_curves = None average_insured_losses = None stddev_insured_losses = None return scientific.Output( assets, loss_type, loss_matrix=loss_matrix if self.return_loss_matrix else None, loss_curves=curves, average_losses=average_losses, stddev_losses=stddev_losses, insured_curves=insured_curves, average_insured_losses=average_insured_losses, stddev_insured_losses=stddev_insured_losses, loss_maps=maps, event_loss_table=elt)