def _build_eb_ruptures(src, num_occ_by_rup, idist, s_sites, random_seed,
rup_mon):
"""
Filter the ruptures stored in the dictionary num_occ_by_rup and
yield pairs (rupture, <list of associated EBRuptures>)
"""
for rup in sorted(num_occ_by_rup, key=operator.attrgetter('rup_no')):
with rup_mon:
try:
r_sites, dists = idist.get_closest(s_sites, rup)
except FarAwayRupture:
# ignore ruptures which are far away
del num_occ_by_rup[rup] # save memory
continue
# creating EBRuptures
serial = rup.seed - random_seed + 1
events = []
for (sampleid,
ses_idx), num_occ in sorted(num_occ_by_rup[rup].items()):
for _ in range(num_occ):
# NB: the 0 below is a placeholder; the right eid will be
# set a bit later, in set_eids
events.append((0, ses_idx, sampleid))
if events:
yield calc.EBRupture(rup, r_sites.indices,
numpy.array(events, calc.event_dt),
src.src_group_id, serial)
def compute_ruptures(sources, src_filter, gsims, param, monitor):
"""
:param sources: a list with a single UCERF source
:param src_filter: a SourceFilter instance
:param gsims: a list of GSIMs
:param param: extra parameters
:param monitor: a Monitor instance
:returns: an AccumDict grp_id -> EBRuptures
"""
[src] = sources
res = AccumDict()
res.calc_times = AccumDict()
serial = 1
sampl_mon = monitor('sampling ruptures', measuremem=True)
filt_mon = monitor('filtering ruptures', measuremem=False)
res.trt = DEFAULT_TRT
t0 = time.time()
ebruptures = []
background_sids = src.get_background_sids(src_filter)
sitecol = src_filter.sitecol
idist = src_filter.integration_distance
for sample in range(param['samples']):
for ses_idx, ses_seed in param['ses_seeds']:
seed = sample * event_based.TWO16 + ses_seed
with sampl_mon:
rups, n_occs = src.generate_event_set(background_sids,
src_filter, seed)
with filt_mon:
for rup, n_occ in zip(rups, n_occs):
rup.seed = seed
try:
r_sites, rrup = idist.get_closest(sitecol, rup)
except FarAwayRupture:
continue
indices = (numpy.arange(len(r_sites))
if r_sites.indices is None else r_sites.indices)
events = []
for _ in range(n_occ):
events.append((0, src.src_group_id, ses_idx, sample))
if events:
evs = numpy.array(events, calc.event_dt)
ebruptures.append(
calc.EBRupture(rup, indices, evs, serial))
serial += 1
res.num_events = event_based.set_eids(ebruptures)
res[src.src_group_id] = ebruptures
res.calc_times[src.src_group_id] = {
src.source_id:
numpy.array([src.weight, len(sitecol),
time.time() - t0, 1])
}
if not param['save_ruptures']:
res.events_by_grp = {
grp_id: event_based.get_events(res[grp_id])
for grp_id in res
}
res.eff_ruptures = {src.src_group_id: src.num_ruptures}
return res
def pre_execute(self):
"""
Read the site collection and initialize GmfComputer and seeds
"""
super(ScenarioCalculator, self).pre_execute()
oq = self.oqparam
trunc_level = oq.truncation_level
correl_model = oq.get_correl_model()
rup = readinput.get_rupture(oq)
rup.seed = self.oqparam.random_seed
self.gsims = readinput.get_gsims(oq)
maxdist = oq.maximum_distance['default']
with self.monitor('filtering sites', autoflush=True):
self.sitecol = filters.filter_sites_by_distance_to_rupture(
rup, maxdist, self.sitecol)
if self.sitecol is None:
raise RuntimeError(
'All sites were filtered out! maximum_distance=%s km' %
maxdist)
# eid, ses, occ, sample
events = numpy.zeros(oq.number_of_ground_motion_fields,
calc.stored_event_dt)
events['eid'] = numpy.arange(oq.number_of_ground_motion_fields)
rupture = calc.EBRupture(rup, self.sitecol.sids, events, 0, 0)
rupture.sidx = 0
rupture.eidx1 = 0
rupture.eidx2 = len(events)
self.datastore['sids'] = self.sitecol.sids
self.datastore['events/grp-00'] = events
array, nbytes = calc.RuptureSerializer.get_array_nbytes([rupture])
self.datastore.extend('ruptures/grp-00', array, nbytes=nbytes)
self.computer = GmfComputer(rupture, self.sitecol, oq.imtls,
self.gsims, trunc_level, correl_model)
gsim_lt = readinput.get_gsim_lt(oq)
cinfo = source.CompositionInfo.fake(gsim_lt)
self.datastore['csm_info'] = cinfo
self.rlzs_assoc = cinfo.get_rlzs_assoc()
