def medians(self, case): [gmfa] = self.execute(case.__file__, 'job.ini').values() median = {imt: [] for imt in self.calc.oqparam.imtls} for imti, imt in enumerate(self.calc.oqparam.imtls): gmfa_by_imt = get_array(gmfa, imti=imti) for sid in self.calc.sitecol.sids: gmvs = get_array(gmfa_by_imt, sid=sid)['gmv'] median[imt].append(numpy.median(gmvs)) return median
def frequencies(self, case, fst_value, snd_value): [gmfa] = self.execute(case.__file__, 'job.ini').values() [imt] = self.calc.oqparam.imtls gmvs0 = get_array(gmfa, sid=0, imti=0)['gmv'] gmvs1 = get_array(gmfa, sid=1, imti=0)['gmv'] realizations = float(self.calc.oqparam.number_of_ground_motion_fields) gmvs_within_range_fst = count_close(fst_value, gmvs0, gmvs1) gmvs_within_range_snd = count_close(snd_value, gmvs0, gmvs1) return (gmvs_within_range_fst / realizations, gmvs_within_range_snd / realizations)
def __call__(self, rlz): gsim = self.gsims[rlz.ordinal] gmfdict = collections.defaultdict(dict) for computer in self.computers: rup = computer.rupture if self.samples > 1: eids = get_array(rup.events, sample=rlz.sampleid)['eid'] else: eids = rup.events['eid'] array = computer.compute(gsim, len(eids)) # (i, n, e) for imti, imt in enumerate(self.imts): min_gmv = self.min_iml[imti] for eid, gmf in zip(eids, array[imti].T): for sid, gmv in zip(computer.sites.sids, gmf): if gmv > min_gmv: dic = gmfdict[sid] if imt in dic: dic[imt].append((gmv, eid)) else: dic[imt] = [(gmv, eid)] dicts = [] # a list of dictionaries imt -> array(gmv, eid) for sid in self.sids: dic = gmfdict[sid] for imt in dic: dic[imt] = arr = numpy.array(dic[imt], self.dt) self.gmfbytes += arr.nbytes dicts.append(dic) return dicts
def calcgmfs(self, seed, events, rlzs_by_gsim, min_iml=None): """ Yield the ground motion field for each seismic event. :param seed: seed for the numpy random number generator :param events: composite array of seismic events (eid, ses, occ, samples) :param rlzs_by_gsim: a dictionary {gsim instance: realizations} :yields: tuples (eid, imti, rlz, gmf_sids) """ sids = self.sites.sids imt_range = range(len(self.imts)) for i, gsim in enumerate(self.gsims): for j, rlz in enumerate(rlzs_by_gsim[gsim]): if self.samples > 1: eids = get_array(events, sample=rlz.sampleid)['eid'] else: eids = events['eid'] arr = self.compute(seed + j, gsim, len(eids)).transpose( 0, 2, 1) # array of shape (I, E, S) for imti in imt_range: for eid, gmf in zip(eids, arr[imti]): if min_iml is not None: # is an array ok = gmf >= min_iml[imti] gmf_sids = (gmf[ok], sids[ok]) else: gmf_sids = (gmf, sids) if len(gmf): yield eid, imti, rlz, gmf_sids
def export_all_loss_ratios(ekey, dstore): """ :param ekey: export key, i.e. a pair (datastore key, fmt) :param dstore: datastore object """ loss_types = dstore.get_attr('composite_risk_model', 'loss_types') name, ext = export.keyfunc(ekey) ass_losses = dstore[name] assetcol = dstore['assetcol'] oq = dstore['oqparam'] dtlist = [('event_tag', (numpy.string_, 100)), ('year', U32), ('aid', U32)] + oq.loss_dt_list() elt_dt = numpy.dtype(dtlist) rlzs_assoc = dstore['csm_info'].get_rlzs_assoc() sm_id, eid = get_sm_id_eid(ekey[0]) if sm_id is None: return [] sm_id, eid = int(sm_id), int(eid) sm_ids = [sm_id] zero = [0, 0] if oq.insured_losses else 0 writer = writers.CsvWriter(fmt=writers.FIVEDIGITS) for sm_id in sm_ids: rlzs = rlzs_assoc.rlzs_by_smodel[sm_id] try: event = dstore['events/sm-%04d' % sm_id][eid] except KeyError: continue [event_tag] = build_etags([event]) for rlz in rlzs: exportname = 'losses-sm=%04d-eid=%d' % (sm_id, eid) dest = dstore.build_fname(exportname, rlz, 'csv') losses_by_aid = AccumDict() rlzname = 'rlz-%03d' % rlz.ordinal for loss_type in ass_losses[rlzname]: data = get_array(ass_losses['%s/%s' % (rlzname, loss_type)], eid=eid) losses_by_aid += group_by_aid(data, loss_type) elt = numpy.zeros(len(losses_by_aid), elt_dt) elt['event_tag'] = event_tag elt['year'] = event['year'] elt['aid'] = sorted(losses_by_aid) for i, aid in numpy.ndenumerate(elt['aid']): for loss_type in loss_types: value = assetcol[int(aid)].value(loss_type, oq.time_event) loss = value * losses_by_aid[aid].get(loss_type, zero) if oq.insured_losses: elt[loss_type][i] = loss[0] elt[loss_type + '_ins'][i] = loss[1] else: elt[loss_type][i] = loss elt.sort(order='event_tag') writer.save(elt, dest) return writer.getsaved()
def get_gmfs(dstore, precalc=None): """ :param dstore: a datastore :param precalc: a scenario calculator with attribute .gmfa :returns: a dictionary grp_id, gsid -> gmfa """ oq = dstore['oqparam'] if 'gmfs' in oq.inputs: # from file logging.info('Reading gmfs from file') sitecol, etags, gmfs_by_imt = readinput.get_gmfs(oq) # reduce the gmfs matrices to the filtered sites for imt in oq.imtls: gmfs_by_imt[imt] = gmfs_by_imt[imt][sitecol.indices] logging.info('Preparing the risk input') return etags, [gmfs_by_imt] rlzs_assoc = dstore['csm_info'].get_rlzs_assoc() rlzs = rlzs_assoc.realizations sitecol = dstore['sitecol'] # NB: if the hazard site collection has N sites, the hazard # filtered site collection for the nonzero GMFs has N' <= N sites # whereas the risk site collection associated to the assets # has N'' <= N' sites if dstore.parent: haz_sitecol = dstore.parent['sitecol'] # N' values else: haz_sitecol = sitecol risk_indices = set(sitecol.indices) # N'' values N = len(haz_sitecol.complete) imt_dt = numpy.dtype([(str(imt), F32) for imt in oq.imtls]) E = oq.number_of_ground_motion_fields etags = numpy.array(sorted(b'scenario-%010d~ses=1' % i for i in range(E))) gmfs = numpy.zeros((len(rlzs_assoc), N, E), imt_dt) if precalc: for i, gsim in enumerate(precalc.gsims): for imti, imt in enumerate(oq.imtls): gmfs[imt][i, sitecol.sids] = precalc.gmfa[gsim][imti] return etags, gmfs # else read from the datastore for i, rlz in enumerate(rlzs): data = group_array(dstore['gmf_data/sm-0000/%04d' % i], 'sid') for sid, array in data.items(): if sid in risk_indices: for imti, imt in enumerate(oq.imtls): a = get_array(array, imti=imti) gmfs[imt][i, sid, a['eid']] = a['gmv'] return etags, gmfs
def gmvs_to_poe_map(gmvs_by_sid, imtls, invest_time, duration): """ Convert a dictionary sid -> gmva into a ProbabilityMap """ pmap = ProbabilityMap() for sid in gmvs_by_sid: data = [] for imti, imt in enumerate(imtls): gmvs = get_array(gmvs_by_sid[sid], imti=imti)['gmv'] data.append( _gmvs_to_haz_curve(gmvs, imtls[imt], invest_time, duration)) # the array underlying the ProbabilityCurve has size (num_levels, 1) array = numpy.concatenate(data).reshape(-1, 1) pmap[sid] = ProbabilityCurve(array) return pmap
def test_spatial_correlation(self): expected = {sc1: [0.99, 0.41], sc2: [0.99, 0.64], sc3: [0.99, 0.22]} for case in expected: self.run_calc(case.__file__, 'job.ini') oq = self.calc.oqparam self.assertEqual(list(oq.imtls), ['PGA']) dstore = read(self.calc.datastore.calc_id) gmvs = dstore['gmf_data/0000'].value dstore.close() gmvs_site_1 = get_array(gmvs, sid=0, imti=0)['gmv'] gmvs_site_2 = get_array(gmvs, sid=1, imti=0)['gmv'] joint_prob_0_5 = joint_prob_of_occurrence( gmvs_site_1, gmvs_site_2, 0.5, oq.investigation_time, oq.ses_per_logic_tree_path) joint_prob_1_0 = joint_prob_of_occurrence( gmvs_site_1, gmvs_site_2, 1.0, oq.investigation_time, oq.ses_per_logic_tree_path) p05, p10 = expected[case] numpy.testing.assert_almost_equal(joint_prob_0_5, p05, decimal=1) numpy.testing.assert_almost_equal(joint_prob_1_0, p10, decimal=1)
def get_gmfs(dstore): """ :param dstore: a datastore :returns: a dictionary grp_id, gsid -> gmfa """ oq = dstore['oqparam'] if 'gmfs' in oq.inputs: # from file logging.info('Reading gmfs from file') sitecol, etags, gmfs_by_imt = readinput.get_gmfs(oq) # reduce the gmfs matrices to the filtered sites for imt in oq.imtls: gmfs_by_imt[imt] = gmfs_by_imt[imt][sitecol.indices] logging.info('Preparing the risk input') return etags, {(0, 'FromFile'): gmfs_by_imt} # else from datastore rlzs_assoc = dstore['csm_info'].get_rlzs_assoc() rlzs = rlzs_assoc.realizations sitecol = dstore['sitecol'] # NB: if the hazard site collection has N sites, the hazard # filtered site collection for the nonzero GMFs has N' <= N sites # whereas the risk site collection associated to the assets # has N'' <= N' sites if dstore.parent: haz_sitecol = dstore.parent['sitecol'] # N' values else: haz_sitecol = sitecol risk_indices = set(sitecol.indices) # N'' values N = len(haz_sitecol.complete) imt_dt = dtype((imt, F32) for imt in oq.imtls) E = oq.number_of_ground_motion_fields # build a matrix N x E for each GSIM realization gmfs = {(grp_id, gsim): numpy.zeros((N, E), imt_dt) for grp_id, gsim in rlzs_assoc} for i, rlz in enumerate(rlzs): data = group_array(dstore['gmf_data/%04d' % i], 'sid') for sid, array in data.items(): if sid in risk_indices: for imti, imt in enumerate(oq.imtls): a = get_array(array, imti=imti) gs = str(rlz.gsim_rlz) gmfs[0, gs][imt][sid, a['eid']] = a['gmv'] etags = numpy.array( sorted([b'scenario-%010d~ses=1' % i for i in range(oq.number_of_ground_motion_fields)])) return etags, gmfs
def __iter__(self): completemesh = self.sitecol.complete.mesh gmfset = collections.defaultdict(list) for imti, imt_str in enumerate(self.imts): imt, sa_period, sa_damping = from_string(imt_str) for rupture in self.ruptures: mesh = completemesh[rupture.indices] gmf = get_array(rupture.gmfa, imti=imti)['gmv'] assert len(mesh) == len(gmf), (len(mesh), len(gmf)) nodes = (GroundMotionFieldNode(gmv, loc) for gmv, loc in zip(gmf, mesh)) gmfset[rupture.ses_idx].append( GroundMotionField( imt, sa_period, sa_damping, rupture.etag, nodes)) for ses_idx in sorted(gmfset): yield GmfSet(gmfset[ses_idx], self.investigation_time, ses_idx)
def get_gmfs(dstore): """ :param dstore: a datastore :returns: a dictionary trt_id, gsid -> gmfa """ oq = dstore["oqparam"] if "gmfs" in oq.inputs: # from file logging.info("Reading gmfs from file") sitecol, etags, gmfs_by_imt = readinput.get_gmfs(oq) # reduce the gmfs matrices to the filtered sites for imt in oq.imtls: gmfs_by_imt[imt] = gmfs_by_imt[imt][sitecol.indices] logging.info("Preparing the risk input") return etags, {(0, "FromFile"): gmfs_by_imt} # else from datastore rlzs_assoc = dstore["csm_info"].get_rlzs_assoc() rlzs = rlzs_assoc.realizations sitecol = dstore["sitecol"] # NB: if the hazard site collection has N sites, the hazard # filtered site collection for the nonzero GMFs has N' <= N sites # whereas the risk site collection associated to the assets # has N'' <= N' sites if dstore.parent: haz_sitecol = dstore.parent["sitecol"] # N' values else: haz_sitecol = sitecol risk_indices = set(sitecol.indices) # N'' values N = len(haz_sitecol.complete) imt_dt = numpy.dtype([(bytes(imt), F32) for imt in oq.imtls]) E = oq.number_of_ground_motion_fields # build a matrix N x E for each GSIM realization gmfs = {(trt_id, gsim): numpy.zeros((N, E), imt_dt) for trt_id, gsim in rlzs_assoc} for i, rlz in enumerate(rlzs): data = general.group_array(dstore["gmf_data/%04d" % i], "sid") for sid, array in data.items(): if sid in risk_indices: for imti, imt in enumerate(oq.imtls): a = general.get_array(array, imti=imti) gs = str(rlz.gsim_rlz) gmfs[0, gs][imt][sid, a["eid"]] = a["gmv"] return dstore["etags"].value, gmfs
def _get_gmfs(dstore, serial, eid): oq = dstore['oqparam'] min_iml = event_based.fix_minimum_intensity(oq.minimum_intensity, oq.imtls) rlzs_assoc = dstore['csm_info'].get_rlzs_assoc() sitecol = dstore['sitecol'].complete N = len(sitecol.complete) rup = dstore['sescollection/' + serial] correl_model = readinput.get_correl_model(oq) gsims = rlzs_assoc.gsims_by_trt_id[rup.trt_id] rlzs = [rlz for gsim in map(str, gsims) for rlz in rlzs_assoc[rup.trt_id, gsim]] gmf_dt = numpy.dtype([('%03d' % rlz.ordinal, F32) for rlz in rlzs]) gmfadict = create(event_based.GmfColl, [rup], sitecol, oq.imtls, rlzs_assoc, oq.truncation_level, correl_model, min_iml).by_rlzi() for imti, imt in enumerate(oq.imtls): gmfa = numpy.zeros(N, gmf_dt) for rlzname in gmf_dt.names: rlzi = int(rlzname) gmvs = get_array(gmfadict[rlzi], eid=eid, imti=imti)['gmv'] gmfa[rlzname][rup.indices] = gmvs yield gmfa, imt
def view_task_hazard(token, dstore): """ Display info about a given task. Here are a few examples of usage:: $ oq show task_hazard:0 # the fastest task $ oq show task_hazard:-1 # the slowest task """ tasks = set(dstore['task_info']) if 'source_data' not in dstore: return 'Missing source_data' if 'classical_split_filter' in tasks: data = dstore['task_info/classical_split_filter'][()] else: data = dstore['task_info/compute_gmfs'][()] data.sort(order='duration') rec = data[int(token.split(':')[1])] taskno = rec['taskno'] arr = get_array(dstore['source_data'][()], taskno=taskno) st = [stats('nsites', arr['nsites']), stats('weight', arr['weight'])] sources = dstore['task_sources'][taskno - 1].split() srcs = set(decode(s).split(':', 1)[0] for s in sources) res = 'taskno=%d, weight=%d, duration=%d s, sources="%s"\n\n' % ( taskno, rec['weight'], rec['duration'], ' '.join(sorted(srcs))) return res + rst_table(st, header='variable mean stddev min max n'.split())
def view_task_hazard(token, dstore): """ Display info about a given task. Here are a few examples of usage:: $ oq show task:classical:0 # the fastest task $ oq show task:classical:-1 # the slowest task """ _, name, index = token.split(':') if 'by_task' not in dstore: return 'Missing by_task' data = get_array(dstore['task_info'][()], taskname=encode(name)) if len(data) == 0: raise RuntimeError('No task_info for %s' % name) data.sort(order='duration') rec = data[int(index)] taskno = rec['task_no'] eff_ruptures = dstore['by_task/eff_ruptures'][taskno] eff_sites = dstore['by_task/eff_sites'][taskno] srcids = dstore['by_task/srcids'][taskno] srcs = dstore['source_info']['source_id'][srcids] res = ('taskno=%d, eff_ruptures=%d, eff_sites=%d, duration=%d s\n' 'sources="%s"' % (taskno, eff_ruptures, eff_sites, rec['duration'], ' '.join(srcs))) return res
def view_task_hazard(token, dstore): """ Display info about a given task. Here are a few examples of usage:: $ oq show task_hazard:0 # the fastest task $ oq show task_hazard:-1 # the slowest task """ tasks = set(dstore['task_info']) if 'source_data' not in dstore: return 'Missing source_data' if 'classical' in tasks: data = dstore['task_info/classical'].value else: data = dstore['task_info/compute_gmfs'].value data.sort(order='duration') rec = data[int(token.split(':')[1])] taskno = rec['taskno'] arr = get_array(dstore['source_data'].value, taskno=taskno) st = [stats('nsites', arr['nsites']), stats('weight', arr['weight'])] sources = dstore['task_sources'][taskno - 1].split() srcs = set(decode(s).split(':', 1)[0] for s in sources) res = 'taskno=%d, weight=%d, duration=%d s, sources="%s"\n\n' % ( taskno, rec['weight'], rec['duration'], ' '.join(sorted(srcs))) return res + rst_table(st, header='variable mean stddev min max n'.split())