def compute_hazard(sources_or_ruptures, src_filter, rlzs_by_gsim, param,
monitor):
"""
Compute events, ruptures, gmfs and hazard curves
"""
res = AccumDict()
with monitor('building ruptures', measuremem=True):
if isinstance(sources_or_ruptures, RuptureGetter):
grp_id = sources_or_ruptures.grp_id
res['ruptures'] = {}
ruptures = list(sources_or_ruptures)
sitecol = src_filter
else:
grp_id = sources_or_ruptures[0].src_group_id
dic = sample_ruptures(sources_or_ruptures, src_filter,
rlzs_by_gsim, param, monitor)
ruptures = dic['eb_ruptures']
res.num_events = dic['num_events']
res.calc_times = dic['calc_times']
res.eff_ruptures = {grp_id: dic['num_ruptures']}
res['ruptures'] = {grp_id: ruptures}
res.num_ruptures = len(ruptures)
sitecol = src_filter.sitecol
res['num_ruptures'] = len(ruptures)
getter = GmfGetter(rlzs_by_gsim, ruptures, sitecol, param['oqparam'],
param['min_iml'], param['samples'])
res.update(getter.compute_gmfs_curves(monitor))
if param['oqparam'].save_ruptures is False:
res.events = get_events(ruptures)
res['ruptures'] = {}
return res
def compute_gmfs(sources_or_ruptures, src_filter, rlzs_by_gsim, param,
monitor):
"""
Compute GMFs and optionally hazard curves
"""
res = AccumDict(ruptures={})
ruptures = []
with monitor('building ruptures', measuremem=True):
if isinstance(sources_or_ruptures, RuptureGetter):
# the ruptures are read from the datastore
grp_id = sources_or_ruptures.grp_id
ruptures.extend(sources_or_ruptures)
sitecol = src_filter # this is actually a site collection
else:
# use the ruptures sampled in prefiltering
grp_id = sources_or_ruptures[0].src_group_id
for src in sources_or_ruptures:
ruptures.extend(src.eb_ruptures)
sitecol = src_filter.sitecol
if ruptures:
if not param['oqparam'].save_ruptures or isinstance(
sources_or_ruptures, RuptureGetter): # ruptures already saved
res.events = get_events(ruptures)
else:
res['ruptures'] = {grp_id: ruptures}
getter = GmfGetter(rlzs_by_gsim, ruptures, sitecol, param['oqparam'],
param['min_iml'], param['samples'])
res.update(getter.compute_gmfs_curves(monitor))
return res
def compute_gmfs(rupgetter, srcfilter, param, monitor):
"""
Compute GMFs and optionally hazard curves
"""
oq = param['oqparam']
getter = GmfGetter(rupgetter, srcfilter, oq, param['amplifier'])
return getter.compute_gmfs_curves(param.get('rlz_by_event'), monitor)
def compute_gmfs(rupgetter, srcfilter, param, monitor):
"""
Compute GMFs and optionally hazard curves
"""
getter = GmfGetter(rupgetter, srcfilter, param['oqparam'])
with monitor('getting ruptures'):
getter.init()
return getter.compute_gmfs_curves(monitor)
def compute_gmfs(rupgetter, srcfilter, param, monitor):
"""
Compute GMFs and optionally hazard curves
"""
getter = GmfGetter(rupgetter, srcfilter, param['oqparam'])
with monitor('getting ruptures'):
getter.init()
return getter.compute_gmfs_curves(monitor)
def compute_gmfs(rupgetter, param, monitor):
"""
Compute GMFs and optionally hazard curves
"""
oq = param['oqparam']
srcfilter = monitor.read('srcfilter')
getter = GmfGetter(rupgetter, srcfilter, oq, param['amplifier'],
param['sec_perils'])
return getter.compute_gmfs_curves(monitor)
def compute_gmfs(rupgetter, sitecol, param, monitor):
"""
Compute GMFs and optionally hazard curves
"""
with monitor('getting ruptures'):
ebruptures = list(rupgetter)
getter = GmfGetter(rupgetter.rlzs_by_gsim, ebruptures, sitecol,
param['oqparam'], param['min_iml'])
return getter.compute_gmfs_curves(monitor)
def gen_args(self):
"""
:yields: the arguments for compute_gmfs_and_curves
"""
oq = self.oqparam
sitecol = self.sitecol.complete
monitor = self.monitor(self.core_task.__name__)
imts = list(oq.imtls)
min_iml = self.get_min_iml(oq)
correl_model = oq.get_correl_model()
try:
csm_info = self.csm.info
except AttributeError: # no csm
csm_info = self.datastore['csm_info']
samples_by_grp = csm_info.get_samples_by_grp()
rlzs_by_gsim = {
grp_id: self.rlzs_assoc.get_rlzs_by_gsim(grp_id)
for grp_id in samples_by_grp
}
if self.precalc:
num_ruptures = sum(len(rs) for rs in self.precalc.result.values())
block_size = math.ceil(num_ruptures / (oq.concurrent_tasks or 1))
for grp_id, ruptures in self.precalc.result.items():
if not ruptures:
continue
for block in block_splitter(ruptures, block_size):
getter = GmfGetter(rlzs_by_gsim[grp_id], block, sitecol,
imts, min_iml, oq.maximum_distance,
oq.truncation_level, correl_model,
oq.filter_distance,
samples_by_grp[grp_id])
yield [getter], oq, monitor
return
U = len(self.datastore['ruptures'])
logging.info('Found %d ruptures', U)
parent = self.can_read_parent() or self.datastore
for slc in split_in_slices(U, oq.concurrent_tasks or 1):
getters = []
for grp_id in rlzs_by_gsim:
ruptures = RuptureGetter(parent, slc, grp_id)
if parent is self.datastore: # not accessible parent
ruptures = list(ruptures)
if not ruptures:
continue
getters.append(
GmfGetter(rlzs_by_gsim[grp_id], ruptures, sitecol, imts,
min_iml, oq.maximum_distance,
oq.truncation_level, correl_model,
oq.filter_distance, samples_by_grp[grp_id]))
yield getters, oq, monitor
def export_gmf_scenario_csv(ekey, dstore):
what = ekey[0].split('/')
if len(what) == 1:
raise ValueError('Missing "/rup-\d+"')
oq = dstore['oqparam']
csm_info = dstore['csm_info']
rlzs_assoc = csm_info.get_rlzs_assoc()
samples = csm_info.get_samples_by_grp()
num_ruptures = len(dstore['ruptures'])
imts = list(oq.imtls)
mo = re.match('rup-(\d+)$', what[1])
if mo is None:
raise ValueError("Invalid format: %r does not match 'rup-(\d+)$'" %
what[1])
ridx = int(mo.group(1))
assert 0 <= ridx < num_ruptures, ridx
ruptures = list(RuptureGetter(dstore, slice(ridx, ridx + 1)))
[ebr] = ruptures
rlzs_by_gsim = rlzs_assoc.get_rlzs_by_gsim(ebr.grp_id)
samples = samples[ebr.grp_id]
min_iml = calc.fix_minimum_intensity(oq.minimum_intensity, imts)
correl_model = oq.get_correl_model()
sitecol = dstore['sitecol'].complete
getter = GmfGetter(rlzs_by_gsim, ruptures, sitecol, imts, min_iml,
oq.maximum_distance, oq.truncation_level, correl_model,
oq.filter_distance, samples)
getter.init()
sids = getter.computers[0].sids
hazardr = getter.get_hazard()
rlzs = rlzs_assoc.realizations
fields = ['eid-%03d' % eid for eid in getter.eids]
dt = numpy.dtype([(f, F32) for f in fields])
mesh = numpy.zeros(len(sids), [('lon', F64), ('lat', F64)])
mesh['lon'] = sitecol.lons[sids]
mesh['lat'] = sitecol.lats[sids]
writer = writers.CsvWriter(fmt='%.5f')
for rlzi in range(len(rlzs)):
hazard = hazardr[rlzi]
for imti, imt in enumerate(imts):
gmfs = numpy.zeros(len(sids), dt)
for s, sid in enumerate(sids):
for rec in hazard[sid]:
event = 'eid-%03d' % rec['eid']
gmfs[s][event] = rec['gmv'][imti]
dest = dstore.build_fname(
'gmf', 'rup-%s-rlz-%s-%s' % (ebr.serial, rlzi, imt), 'csv')
data = util.compose_arrays(mesh, gmfs)
writer.save(data, dest)
return writer.getsaved()
def export_gmf_scenario_csv(ekey, dstore):
what = ekey[0].split('/')
if len(what) == 1:
raise ValueError(r'Missing "/rup-\d+"')
oq = dstore['oqparam']
csm_info = dstore['csm_info']
rlzs_assoc = csm_info.get_rlzs_assoc()
num_ruptures = len(dstore['ruptures'])
imts = list(oq.imtls)
mo = re.match(r'rup-(\d+)$', what[1])
if mo is None:
raise ValueError(r"Invalid format: %r does not match 'rup-(\d+)$'" %
what[1])
ridx = int(mo.group(1))
assert 0 <= ridx < num_ruptures, ridx
# for scenario there is an unique grp_id=0
[rgetter] = gen_rupture_getters(dstore, slice(ridx, ridx + 1))
[ebr] = rgetter.get_ruptures()
sitecol = dstore['sitecol'].complete
srcfilter = filters.SourceFilter(sitecol, oq.maximum_distance)
getter = GmfGetter(rgetter, srcfilter, oq)
getter.init()
eids = rgetter.get_eid_rlz()['eid']
sids = getter.computers[0].sids
rlzs = rlzs_assoc.realizations
hazardr = [collections.defaultdict(list) for rlz in rlzs]
for sid, haz in getter.get_hazard().items():
for rec in haz:
hazardr[rec['rlzi']][sid].append(rec)
fields = ['eid-%03d' % eid for eid in eids]
dt = numpy.dtype([(f, F32) for f in fields])
mesh = numpy.zeros(len(sids), [('lon', F64), ('lat', F64)])
mesh['lon'] = sitecol.lons[sids]
mesh['lat'] = sitecol.lats[sids]
writer = writers.CsvWriter(fmt='%.5f')
for rlzi in range(len(rlzs)):
hazard = hazardr[rlzi]
for imti, imt in enumerate(imts):
gmfs = numpy.zeros(len(sids), dt)
for s, sid in enumerate(sids):
for rec in hazard[sid]:
event = 'eid-%03d' % rec['eid']
gmfs[s][event] = rec['gmv'][imti]
dest = dstore.build_fname(
'gmf', 'rup-%s-rlz-%s-%s' % (ebr.serial, rlzi, imt), 'csv')
data = util.compose_arrays(mesh, gmfs)
writer.save(data, dest)
return writer.getsaved()
def export_gmf_scenario_csv(ekey, dstore):
what = ekey[0].split('/')
if len(what) == 1:
raise ValueError(r'Missing "/rup-\d+"')
oq = dstore['oqparam']
csm_info = dstore['csm_info']
rlzs_assoc = csm_info.get_rlzs_assoc()
num_ruptures = len(dstore['ruptures'])
imts = list(oq.imtls)
mo = re.match(r'rup-(\d+)$', what[1])
if mo is None:
raise ValueError(
r"Invalid format: %r does not match 'rup-(\d+)$'" % what[1])
ridx = int(mo.group(1))
assert 0 <= ridx < num_ruptures, ridx
# for scenario there is an unique grp_id=0
[rgetter] = gen_rupture_getters(dstore, slice(ridx, ridx + 1))
[ebr] = rgetter.get_ruptures()
sitecol = dstore['sitecol'].complete
srcfilter = filters.SourceFilter(sitecol, oq.maximum_distance)
getter = GmfGetter(rgetter, srcfilter, oq)
getter.init()
eids = rgetter.get_eid_rlz()['eid']
sids = getter.computers[0].sids
rlzs = rlzs_assoc.realizations
hazardr = [collections.defaultdict(list) for rlz in rlzs]
for sid, haz in getter.get_hazard().items():
for rec in haz:
hazardr[rec['rlzi']][sid].append(rec)
fields = ['eid-%03d' % eid for eid in eids]
dt = numpy.dtype([(f, F32) for f in fields])
mesh = numpy.zeros(len(sids), [('lon', F64), ('lat', F64)])
mesh['lon'] = sitecol.lons[sids]
mesh['lat'] = sitecol.lats[sids]
writer = writers.CsvWriter(fmt='%.5f')
for rlzi in range(len(rlzs)):
hazard = hazardr[rlzi]
for imti, imt in enumerate(imts):
gmfs = numpy.zeros(len(sids), dt)
for s, sid in enumerate(sids):
for rec in hazard[sid]:
event = 'eid-%03d' % rec['eid']
gmfs[s][event] = rec['gmv'][imti]
dest = dstore.build_fname(
'gmf', 'rup-%s-rlz-%s-%s' % (ebr.serial, rlzi, imt), 'csv')
data = util.compose_arrays(mesh, gmfs)
writer.save(data, dest)
return writer.getsaved()
def compute_gmfs(ruptures, src_filter, rlzs_by_gsim, param, monitor):
"""
Compute GMFs and optionally hazard curves
"""
res = AccumDict(ruptures={})
if isinstance(ruptures, RuptureGetter):
# the ruptures are read from the datastore
grp_id = ruptures.grp_id
sitecol = src_filter # this is actually a site collection
else:
# use the ruptures sampled in prefiltering
grp_id = ruptures[0].grp_id
sitecol = src_filter.sitecol
if not param['oqparam'].save_ruptures or isinstance(
ruptures, RuptureGetter): # ruptures already saved
res.events = get_events(ruptures)
else:
res['ruptures'] = {grp_id: ruptures}
getter = GmfGetter(rlzs_by_gsim, ruptures, sitecol, param['oqparam'],
param['min_iml'], param['samples'])
res.update(getter.compute_gmfs_curves(monitor))
return res
