def compute_losses(ssm, src_filter, param, riskmodel, monitor): """ Compute the losses for a single source model. Returns the ruptures as an attribute `.ruptures_by_grp` of the list of losses. :param ssm: CompositeSourceModel containing a single source model :param sitecol: a SiteCollection instance :param param: a dictionary of extra parameters :param riskmodel: a RiskModel instance :param monitor: a Monitor instance :returns: a List containing the losses by taxonomy and some attributes """ [grp] = ssm.src_groups res = List() rlzs_assoc = ssm.info.get_rlzs_assoc() rlzs_by_gsim = rlzs_assoc.get_rlzs_by_gsim(DEFAULT_TRT) hazard = compute_hazard(grp, src_filter, rlzs_by_gsim, param, monitor) [(grp_id, ebruptures)] = hazard['ruptures'].items() samples = ssm.info.get_samples_by_grp() num_rlzs = len(rlzs_assoc.realizations) rlzs_by_gsim = rlzs_assoc.get_rlzs_by_gsim(DEFAULT_TRT) getter = getters.GmfGetter(rlzs_by_gsim, ebruptures, src_filter.sitecol, param['oqparam'], param['min_iml'], samples[grp_id]) ri = riskinput.RiskInput(getter, param['assetcol'].assets_by_site()) res.append(ucerf_risk(ri, riskmodel, param, monitor)) res.sm_id = ssm.sm_id res.num_events = len(ri.hazard_getter.eids) start = res.sm_id * num_rlzs res.rlz_slice = slice(start, start + num_rlzs) res.events_by_grp = hazard.events_by_grp res.eff_ruptures = hazard.eff_ruptures return res
def ebrisk(rupgetters, srcfilter, param, monitor): """ :param rupgetters: RuptureGetters with 1 rupture each :param srcfilter: a SourceFilter :param param: dictionary of parameters coming from oqparam :param monitor: a Monitor instance :returns: a dictionary with keys elt, alt, ... """ mon_haz = monitor('getting hazard', measuremem=False) computers = [] with monitor('getting ruptures'): for rupgetter in rupgetters: gg = getters.GmfGetter(rupgetter, srcfilter, param['oqparam']) gg.init() computers.extend(gg.computers) if not computers: # all filtered out return {} rupgetters.clear() computers.sort(key=lambda c: c.rupture.ridx) hazard = dict(gmfs=[], events=[], gmf_info=[]) for c in computers: with mon_haz: data = c.compute_all(gg.min_iml, gg.rlzs_by_gsim) hazard['gmfs'].append(data) hazard['events'].append(c.rupture.get_events(gg.rlzs_by_gsim)) hazard['gmf_info'].append((c.rupture.ridx, mon_haz.task_no, len(c.sids), data.nbytes, mon_haz.dt)) computers.clear() acc = _calc_risk(hazard, param, monitor) return acc
def ebrisk(rupgetter, param, monitor): """ :param rupgetter: RuptureGetter with multiple ruptures :param param: dictionary of parameters coming from oqparam :param monitor: a Monitor instance :returns: a dictionary of arrays """ mon_rup = monitor('getting ruptures', measuremem=False) mon_haz = monitor('getting hazard', measuremem=True) alldata = general.AccumDict(accum=[]) gmf_info = [] srcfilter = monitor.read('srcfilter') param['N'] = len(srcfilter.sitecol.complete) gg = getters.GmfGetter(rupgetter, srcfilter, param['oqparam'], param['amplifier']) with mon_haz: for c in gg.gen_computers(mon_rup): data, time_by_rup = c.compute_all(gg.min_iml, gg.rlzs_by_gsim) if len(data): for key, val in data.items(): alldata[key].extend(data[key]) nbytes = len(data['sid']) * len(data) * 4 gmf_info.append((c.ebrupture.id, mon_haz.task_no, len(c.sids), nbytes, mon_haz.dt)) if not alldata: return {} for key, val in sorted(alldata.items()): if key in 'eid sid rlz': alldata[key] = U32(alldata[key]) else: alldata[key] = F32(alldata[key]) yield from event_based_risk(pandas.DataFrame(alldata), param, monitor) if gmf_info: yield {'gmf_info': numpy.array(gmf_info, gmf_info_dt)}
def ebrisk(rupgetter, param, monitor): """ :param rupgetter: RuptureGetter with multiple ruptures :param param: dictionary of parameters coming from oqparam :param monitor: a Monitor instance :returns: a dictionary with keys elt, alt, ... """ mon_rup = monitor('getting ruptures', measuremem=False) mon_haz = monitor('getting hazard', measuremem=True) gmfs = [] gmf_info = [] srcfilter = monitor.read('srcfilter') gg = getters.GmfGetter(rupgetter, srcfilter, param['oqparam'], param['amplifier']) nbytes = 0 with mon_haz: for c in gg.gen_computers(mon_rup): data, time_by_rup = c.compute_all(gg.min_iml, gg.rlzs_by_gsim) if len(data): gmfs.append(data) nbytes += data.nbytes gmf_info.append((c.ebrupture.id, mon_haz.task_no, len(c.sids), data.nbytes, mon_haz.dt)) if not gmfs: return {} res = calc_risk(numpy.concatenate(gmfs), param, monitor) if gmf_info: res['gmf_info'] = numpy.array(gmf_info, gmf_info_dt) return res
def ebrisk(rupgetter, srcfilter, param, monitor): """ :param rupgetter: RuptureGetter with multiple ruptures :param srcfilter: a SourceFilter :param param: dictionary of parameters coming from oqparam :param monitor: a Monitor instance :returns: a dictionary with keys elt, alt, ... """ mon_haz = monitor('getting hazard', measuremem=False) mon_rup = monitor('getting ruptures', measuremem=False) hazard = dict(gmfs=[], events=[], gmf_info=[]) for rg in rupgetter.split(): with mon_rup: gg = getters.GmfGetter(rg, srcfilter, param['oqparam']) gg.init() if not gg.computers: # filtered out rupture continue [c] = gg.computers with mon_haz: data = c.compute_all(gg.min_iml, gg.rlzs_by_gsim) hazard['gmfs'].append(data) hazard['events'].append(c.rupture.get_events(gg.rlzs_by_gsim)) hazard['gmf_info'].append( (c.rupture.id, mon_haz.task_no, len(c.sids), data.nbytes, mon_haz.dt)) if not hazard['gmfs']: return {} with monitor('getting assets'): assetcol = datastore.read(param['hdf5path'])['assetcol'] return calc_risk(hazard, assetcol, param, monitor)
def compute_hazard(sources, src_filter, rlzs_by_gsim, param, monitor): """ :param sources: a list with a single UCERF source :param src_filter: a SourceFilter instance :param rlzs_by_gsim: a dictionary gsim -> rlzs :param param: extra parameters :param monitor: a Monitor instance :returns: an AccumDict grp_id -> EBRuptures """ [src] = sources res = AccumDict() res.calc_times = [] serial = 1 sampl_mon = monitor('sampling ruptures', measuremem=True) filt_mon = monitor('filtering ruptures', measuremem=False) res.trt = DEFAULT_TRT ebruptures = [] background_sids = src.get_background_sids(src_filter) sitecol = src_filter.sitecol cmaker = ContextMaker(rlzs_by_gsim, src_filter.integration_distance) for sample in range(param['samples']): for ses_idx, ses_seed in param['ses_seeds']: seed = sample * TWO16 + ses_seed with sampl_mon: rups, n_occs = generate_event_set(src, background_sids, src_filter, seed) with filt_mon: for rup, n_occ in zip(rups, n_occs): rup.serial = serial try: rup.sctx, rup.dctx = cmaker.make_contexts(sitecol, rup) indices = rup.sctx.sids except FarAwayRupture: continue events = [] for _ in range(n_occ): events.append((0, src.src_group_id, ses_idx, sample)) if events: evs = numpy.array(events, stochastic.event_dt) ebruptures.append(EBRupture(rup, src.id, indices, evs)) serial += 1 res.num_events = len(stochastic.set_eids(ebruptures)) res['ruptures'] = {src.src_group_id: ebruptures} if param['save_ruptures']: res.ruptures_by_grp = {src.src_group_id: ebruptures} else: res.events_by_grp = { src.src_group_id: event_based.get_events(ebruptures) } res.eff_ruptures = {src.src_group_id: src.num_ruptures} if param.get('gmf'): getter = getters.GmfGetter(rlzs_by_gsim, ebruptures, sitecol, param['oqparam'], param['min_iml'], param['samples']) res.update(getter.compute_gmfs_curves(monitor)) return res
def compute_hazard(sources, src_filter, rlzs_by_gsim, param, monitor): """ :param sources: a list with a single UCERF source :param src_filter: a SourceFilter instance :param rlzs_by_gsim: a dictionary gsim -> rlzs :param param: extra parameters :param monitor: a Monitor instance :returns: an AccumDict grp_id -> EBRuptures """ [src] = sources res = AccumDict() res.calc_times = [] serial = 1 sampl_mon = monitor('sampling ruptures', measuremem=True) filt_mon = monitor('filtering ruptures', measuremem=False) res.trt = DEFAULT_TRT background_sids = src.get_background_sids(src_filter) sitecol = src_filter.sitecol cmaker = ContextMaker(rlzs_by_gsim, src_filter.integration_distance) num_ses = param['ses_per_logic_tree_path'] samples = getattr(src, 'samples', 1) n_occ = AccumDict(accum=numpy.zeros((samples, num_ses), numpy.uint16)) with sampl_mon: for sam_idx in range(samples): for ses_idx, ses_seed in param['ses_seeds']: seed = sam_idx * TWO16 + ses_seed rups, occs = generate_event_set(src, background_sids, src_filter, seed) for rup, occ in zip(rups, occs): n_occ[rup][sam_idx, ses_idx] = occ rup.serial = serial serial += 1 with filt_mon: rlzs = numpy.concatenate(list(rlzs_by_gsim.values())) ebruptures = stochastic.build_eb_ruptures(src, rlzs, num_ses, cmaker, sitecol, n_occ.items()) res.num_events = sum(ebr.multiplicity for ebr in ebruptures) res['ruptures'] = {src.src_group_id: ebruptures} if param['save_ruptures']: res.ruptures_by_grp = {src.src_group_id: ebruptures} else: res.events_by_grp = { src.src_group_id: event_based.get_events(ebruptures) } res.eff_ruptures = {src.src_group_id: src.num_ruptures} if param.get('gmf'): getter = getters.GmfGetter(rlzs_by_gsim, ebruptures, sitecol, param['oqparam'], param['min_iml'], samples) res.update(getter.compute_gmfs_curves(monitor)) return res
def compute_losses(ssm, src_filter, param, riskmodel, imts, trunc_level, correl_model, min_iml, monitor): """ Compute the losses for a single source model. Returns the ruptures as an attribute `.ruptures_by_grp` of the list of losses. :param ssm: CompositeSourceModel containing a single source model :param sitecol: a SiteCollection instance :param param: a dictionary of parameters :param riskmodel: a RiskModel instance :param imts: a list of Intensity Measure Types :param trunc_level: truncation level :param correl_model: correlation model :param min_iml: vector of minimum intensities, one per IMT :param monitor: a Monitor instance :returns: a List containing the losses by taxonomy and some attributes """ [grp] = ssm.src_groups res = List() gsims = ssm.gsim_lt.values[DEFAULT_TRT] ruptures_by_grp = compute_ruptures( grp, src_filter, gsims, param, monitor) [(grp_id, ebruptures)] = ruptures_by_grp.items() rlzs_assoc = ssm.info.get_rlzs_assoc() samples = ssm.info.get_samples_by_grp() num_rlzs = len(rlzs_assoc.realizations) rlzs_by_gsim = rlzs_assoc.get_rlzs_by_gsim(DEFAULT_TRT) getter = getters.GmfGetter( rlzs_by_gsim, ebruptures, src_filter.sitecol, imts, min_iml, src_filter.integration_distance, trunc_level, correl_model, samples[grp_id]) ri = riskinput.RiskInput(getter, param['assetcol'].assets_by_site()) res.append(event_based_risk(ri, riskmodel, param, monitor)) res.sm_id = ssm.sm_id res.num_events = len(ri.hazard_getter.eids) start = res.sm_id * num_rlzs res.rlz_slice = slice(start, start + num_rlzs) res.events_by_grp = ruptures_by_grp.events_by_grp res.eff_ruptures = ruptures_by_grp.eff_ruptures return res
def ebrisk(rupgetter, srcfilter, param, monitor): """ :param rupgetter: RuptureGetter with multiple ruptures :param srcfilter: a SourceFilter :param param: dictionary of parameters coming from oqparam :param monitor: a Monitor instance :returns: a dictionary with keys elt, alt, ... """ mon_rup = monitor('getting ruptures', measuremem=False) mon_haz = monitor('getting hazard', measuremem=False) gmfs = [] gmf_info = [] gg = getters.GmfGetter(rupgetter, srcfilter, param['oqparam'], param['amplifier']) nbytes = 0 for c in gg.gen_computers(mon_rup): with mon_haz: data, time_by_rup = c.compute_all(gg.min_iml, gg.rlzs_by_gsim) if len(data): gmfs.append(data) nbytes += data.nbytes gmf_info.append((c.ebrupture.id, mon_haz.task_no, len(c.sids), data.nbytes, mon_haz.dt)) if nbytes > param['ebrisk_maxsize']: msg = 'produced subtask' try: logs.dbcmd('log', monitor.calc_id, datetime.utcnow(), 'DEBUG', 'ebrisk#%d' % monitor.task_no, msg) except Exception: # for `oq run` print(msg) yield calc_risk, numpy.concatenate(gmfs), param nbytes = 0 gmfs = [] res = {} if gmfs: res.update(calc_risk(numpy.concatenate(gmfs), param, monitor)) if gmf_info: res['gmf_info'] = numpy.array(gmf_info, gmf_info_dt) yield res
def ebrisk(rupgetter, srcfilter, param, monitor): """ :param rupgetter: a RuptureGetter instance :param srcfilter: a SourceFilter instance :param param: a dictionary of parameters :param monitor: :class:`openquake.baselib.performance.Monitor` instance :returns: an ArrayWrapper with shape (E, L, T, ...) """ riskmodel = param['riskmodel'] E = rupgetter.num_events L = len(riskmodel.lti) N = len(srcfilter.sitecol.complete) e1 = rupgetter.first_event with monitor('getting assets', measuremem=False): with datastore.read(srcfilter.filename) as dstore: assetcol = dstore['assetcol'] assets_by_site = assetcol.assets_by_site() A = len(assetcol) getter = getters.GmfGetter(rupgetter, srcfilter, param['oqparam']) with monitor('getting hazard'): getter.init() # instantiate the computers hazard = getter.get_hazard_by_sid() # sid -> (sid, eid, gmv) mon_risk = monitor('computing risk', measuremem=False) mon_agg = monitor('aggregating losses', measuremem=False) events = rupgetter.get_eid_rlz() # numpy.testing.assert_equal(events['eid'], sorted(events['eid'])) eid2idx = dict(zip(events['eid'], range(e1, e1 + E))) tagnames = param['aggregate_by'] shape = assetcol.tagcol.agg_shape((E, L), tagnames) elt_dt = [('eid', U64), ('rlzi', U16), ('loss', (F32, shape[1:]))] if param['asset_loss_table']: alt = numpy.zeros((A, E, L), F32) acc = numpy.zeros(shape, F32) # shape (E, L, T...) if param['avg_losses']: losses_by_A = numpy.zeros((A, L), F32) else: losses_by_A = 0 # NB: IMT-dependent weights are not supported in ebrisk times = numpy.zeros(N) # risk time per site_id num_events_per_sid = 0 epspath = param['epspath'] gmf_nbytes = 0 for sid, haz in hazard.items(): gmf_nbytes += haz.nbytes t0 = time.time() assets_on_sid = assets_by_site[sid] if len(assets_on_sid) == 0: continue num_events_per_sid += len(haz) if param['avg_losses']: weights = getter.weights[[ getter.eid2rlz[eid] for eid in haz['eid'] ]] assets_by_taxo = get_assets_by_taxo(assets_on_sid, epspath) eidx = numpy.array([eid2idx[eid] for eid in haz['eid']]) - e1 haz['eid'] = eidx + e1 with mon_risk: out = riskmodel.get_output(assets_by_taxo, haz) with mon_agg: for a, asset in enumerate(assets_on_sid): aid = asset['ordinal'] tagi = asset[tagnames] if tagnames else () tagidxs = tuple(idx - 1 for idx in tagi) for lti, lt in enumerate(riskmodel.loss_types): lratios = out[lt][a] if lt == 'occupants': losses = lratios * asset['occupants_None'] else: losses = lratios * asset['value-' + lt] if param['asset_loss_table']: alt[aid, eidx, lti] = losses acc[(eidx, lti) + tagidxs] += losses if param['avg_losses']: losses_by_A[aid, lti] += losses @ weights times[sid] = time.time() - t0 if hazard: num_events_per_sid /= len(hazard) with monitor('building event loss table'): elt = numpy.fromiter( ((event['eid'], event['rlz'], losses) for event, losses in zip(events, acc) if losses.sum()), elt_dt) agg = general.AccumDict(accum=numpy.zeros(shape[1:], F32)) # rlz->agg for rec in elt: agg[rec['rlzi']] += rec['loss'] * param['ses_ratio'] res = { 'elt': elt, 'agg_losses': agg, 'times': times, 'events_per_sid': num_events_per_sid, 'gmf_nbytes': gmf_nbytes } if param['avg_losses']: res['losses_by_A'] = losses_by_A * param['ses_ratio'] if param['asset_loss_table']: eidx = numpy.array([eid2idx[eid] for eid in events['eid']]) res['alt_eidx'] = alt, eidx return res
def ebrisk(rupgetter, srcfilter, param, monitor): """ :param rupgetter: a RuptureGetter instance :param srcfilter: a SourceFilter instance :param param: a dictionary of parameters :param monitor: :class:`openquake.baselib.performance.Monitor` instance :returns: an ArrayWrapper with shape (E, L, T, ...) """ riskmodel = param['riskmodel'] L = len(riskmodel.lti) N = len(srcfilter.sitecol.complete) mon = monitor('getting assets', measuremem=False) with datastore.read(srcfilter.filename) as dstore: assgetter = getters.AssetGetter(dstore) getter = getters.GmfGetter(rupgetter, srcfilter, param['oqparam']) with monitor('getting hazard'): getter.init() # instantiate the computers hazard = getter.get_hazard() # sid -> (rlzi, sid, eid, gmv) mon_risk = monitor('computing losses', measuremem=False) mon_agg = monitor('aggregating losses', measuremem=False) imts = getter.imts events = rupgetter.get_eid_rlz() eid2idx = {eid: idx for idx, eid in enumerate(events['eid'])} tagnames = param['aggregate_by'] shape = assgetter.tagcol.agg_shape((len(events), L), tagnames) elt_dt = [('eid', U64), ('rlzi', U16), ('loss', (F32, shape[1:]))] acc = numpy.zeros(shape, F32) # shape (E, L, T...) if param['avg_losses']: losses_by_A = numpy.zeros((assgetter.num_assets, L), F32) else: losses_by_A = 0 times = numpy.zeros(N) # risk time per site_id for sid, haz in hazard.items(): t0 = time.time() weights = getter.weights[haz['rlzi']] assets_on_sid, tagidxs = assgetter.get(sid, tagnames) eidx = [eid2idx[eid] for eid in haz['eid']] mon.duration += time.time() - t0 mon.counts += 1 with mon_risk: assets_ratios = riskmodel.get_assets_ratios( assets_on_sid, haz['gmv'], imts) with mon_agg: for assets, ratios in assets_ratios: taxo = assets[0].taxonomy ws_by_lti = [ weights[vf.imt] for vf in riskmodel[taxo].risk_functions.values() ] for lti, loss_ratios in enumerate(ratios): ws = ws_by_lti[lti] lt = riskmodel.loss_types[lti] for asset in assets: aid = asset.ordinal losses = loss_ratios * asset.value(lt) acc[(eidx, lti) + tagidxs[aid]] += losses if param['avg_losses']: losses_by_A[aid, lti] += losses @ ws times[sid] = time.time() - t0 with monitor('building event loss table'): elt = numpy.fromiter( ((event['eid'], event['rlz'], losses) for event, losses in zip(events, acc) if losses.sum()), elt_dt) agg = general.AccumDict(accum=numpy.zeros(shape[1:], F32)) # rlz->agg for rec in elt: agg[rec['rlzi']] += rec['loss'] * param['ses_ratio'] res = {'elt': elt, 'agg_losses': agg, 'times': times} if param['avg_losses']: res['losses_by_A'] = losses_by_A * param['ses_ratio'] return res
def start_tasks(self, sm_id, sitecol, assetcol, riskmodel, imtls, trunc_level, correl_model, min_iml): """ :param sm_id: source model ordinal :param sitecol: a SiteCollection instance :param assetcol: an AssetCollection instance :param riskmodel: a RiskModel instance :param imtls: Intensity Measure Types and Levels :param trunc_level: truncation level :param correl_model: correlation model :param min_iml: vector of minimum intensities, one per IMT :returns: an IterResult instance """ sm_info = self.csm_info.get_info(sm_id) grp_ids = sorted(sm_info.get_sm_by_grp()) rlzs_assoc = sm_info.get_rlzs_assoc() # prepare the risk inputs allargs = [] ruptures_per_block = self.oqparam.ruptures_per_block try: csm_info = self.csm.info except AttributeError: # there is no .csm if --hc was given csm_info = self.datastore['csm_info'] samples_by_grp = csm_info.get_samples_by_grp() num_events = 0 num_ruptures = {} taskname = '%s#%d' % (event_based_risk.__name__, sm_id + 1) monitor = self.monitor(taskname) for grp_id in grp_ids: ruptures = self.ruptures_by_grp.get(grp_id, []) rlzs_by_gsim = rlzs_assoc.get_rlzs_by_gsim(grp_id) samples = samples_by_grp[grp_id] num_ruptures[grp_id] = len(ruptures) from_parent = hasattr(ruptures, 'split') if from_parent: # read the ruptures from the parent datastore logging.info('Reading ruptures group #%d', grp_id) with self.monitor('reading ruptures', measuremem=True): blocks = ruptures.split(ruptures_per_block) else: # the ruptures are already in memory blocks = block_splitter(ruptures, ruptures_per_block) for rupts in blocks: n_events = (rupts.n_events if from_parent else sum(ebr.multiplicity for ebr in rupts)) eps = self.get_eps(self.start, self.start + n_events) num_events += n_events self.start += n_events getter = getters.GmfGetter( rlzs_by_gsim, rupts, sitecol, imtls, min_iml, self.oqparam.maximum_distance, trunc_level, correl_model, self.oqparam.filter_distance, samples) ri = riskinput.RiskInput(getter, self.assets_by_site, eps) allargs.append((ri, riskmodel, assetcol, monitor)) if self.datastore.parent: # avoid hdf5 fork issues self.datastore.parent.close() ires = parallel.Starmap( event_based_risk, allargs, name=taskname).submit_all() ires.num_ruptures = num_ruptures ires.num_events = num_events ires.num_rlzs = len(rlzs_assoc.realizations) ires.sm_id = sm_id return ires
def eval_calc(self): """ Evaluate each calculators for different IMs """ # Define the GmfGetter #for args_tag in range(len(self.args)-1): # Looping over all source models (Note: the last attribute in self.args is a monitor - so skipping it) cur_getter = getters.GmfGetter( self.args[0][0], calc.filters.SourceFilter(self.dstore['sitecol'], self.dstore['oqparam'].maximum_distance), self.calculator.param['oqparam'], self.calculator.param['amplifier'], self.calculator.param['sec_perils']) print('eval_calc: cur_getter = ') print(cur_getter) # Evaluate each computer print('FetchOpenQuake: Evaluting ground motion models.') for computer in cur_getter.gen_computers(self.mon): # Looping over rupture(s) in the current realization sids = computer.sids print('eval_calc: site ID sids = ') print(sids) eids_by_rlz = computer.ebrupture.get_eids_by_rlz( cur_getter.rlzs_by_gsim) mag = computer.ebrupture.rupture.mag data = general.AccumDict(accum=[]) cur_T = self.event_info['IntensityMeasure'].get('Periods', None) for cur_gs, rlzs in cur_getter.rlzs_by_gsim.items(): # Looping over GMPE(s) print('eval_calc: cur_gs = ') print(cur_gs) num_events = sum(len(eids_by_rlz[rlz]) for rlz in rlzs) if num_events == 0: # it may happen continue # NB: the trick for performance is to keep the call to # .compute outside of the loop over the realizations; # it is better to have few calls producing big arrays tmpMean = [] tmpstdtot = [] tmpstdinter = [] tmpstdintra = [] for imti, imt in enumerate(computer.imts): # Looping over IM(s) #print('eval_calc: imt = ') #print(imt) if str(imt) in ['PGA', 'PGV', 'PGD']: cur_T = [0.0] imTag = 'ln' + str(imt) else: imTag = 'lnSA' if isinstance(cur_gs, gsim.multi.MultiGMPE): gs = cur_gs[str(imt)] # MultiGMPE else: gs = cur_gs # regular GMPE try: dctx = computer.dctx.roundup(cur_gs.minimum_distance) if computer.distribution is None: if computer.correlation_model: raise ValueError('truncation_level=0 requires ' 'no correlation model') mean, _stddevs = cur_gs.get_mean_and_stddevs( computer.sctx, computer.rctx, dctx, imt, stddev_types=[]) num_sids = len(computer.sids) if cur_gs.DEFINED_FOR_STANDARD_DEVIATION_TYPES == { const.StdDev.TOTAL }: # If the GSIM provides only total standard deviation, we need # to compute mean and total standard deviation at the sites # of interest. # In this case, we also assume no correlation model is used. if computer.correlation_model: raise CorrelationButNoInterIntraStdDevs( computer.correlation_model, cur_gs) mean, [stddev_total] = cur_gs.get_mean_and_stddevs( computer.sctx, computer.rctx, dctx, imt, [const.StdDev.TOTAL]) stddev_total = stddev_total.reshape( stddev_total.shape + (1, )) mean = mean.reshape(mean.shape + (1, )) if imti == 0: tmpMean = mean tmpstdtot = stddev_total else: tmpMean = np.concatenate((tmpMean, mean), axis=0) tmpstdtot = np.concatenate( (tmpstdtot, stddev_total), axis=0) else: mean, [stddev_inter, stddev_intra] = cur_gs.get_mean_and_stddevs( computer.sctx, computer.rctx, dctx, imt, [ const.StdDev.INTER_EVENT, const.StdDev.INTRA_EVENT ]) stddev_intra = stddev_intra.reshape( stddev_intra.shape + (1, )) stddev_inter = stddev_inter.reshape( stddev_inter.shape + (1, )) mean = mean.reshape(mean.shape + (1, )) if imti == 0: tmpMean = mean tmpstdinter = stddev_inter tmpstdintra = stddev_intra tmpstdtot = np.sqrt( stddev_inter * stddev_inter + stddev_intra * stddev_intra) else: tmpMean = np.concatenate((tmpMean, mean), axis=1) tmpstdinter = np.concatenate( (tmpstdinter, stddev_inter), axis=1) tmpstdintra = np.concatenate( (tmpstdintra, stddev_intra), axis=1) tmpstdtot = np.concatenate( (tmpstdtot, np.sqrt(stddev_inter * stddev_inter + stddev_intra * stddev_intra)), axis=1) except Exception as exc: raise RuntimeError( '(%s, %s, source_id=%r) %s: %s' % (gs, imt, computer.source_id.decode('utf8'), exc.__class__.__name__, exc)).with_traceback( exc.__traceback__) # initialize gm_collector = [] # transpose """ if len(tmpMean): tmpMean = tmpMean.transpose() if len(tmpstdinter): tmpstdinter = tmpstdinter.transpose() if len(tmpstdintra): tmpstdintra = tmpstdintra.transpose() if len(tmpstdtot): tmpstdtot = tmpstdtot.transpose() """ # collect data for k in range(tmpMean.shape[0]): imResult = {} if len(tmpMean): imResult.update( {'Mean': [float(x) for x in tmpMean[k].tolist()]}) if len(tmpstdtot): imResult.update({ 'TotalStdDev': [float(x) for x in tmpstdtot[k].tolist()] }) if len(tmpstdinter): imResult.update({ 'InterEvStdDev': [float(x) for x in tmpstdinter[k].tolist()] }) if len(tmpstdintra): imResult.update({ 'IntraEvStdDev': [float(x) for x in tmpstdintra[k].tolist()] }) gm_collector.append({imTag: imResult}) print(gm_collector) # close datastore instance self.calculator.datastore.close() # stop dbserver cdbs.main('stop') # Final results res = { 'Magnitude': mag, 'Periods': cur_T, 'GroundMotions': gm_collector } # return return res