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 gen_args(self, monitor):
"""
:yields: the arguments for compute_gmfs_and_curves
"""
oq = self.oqparam
param = dict(oqparam=oq,
min_iml=self.get_min_iml(oq),
truncation_level=oq.truncation_level,
imtls=oq.imtls,
filter_distance=oq.filter_distance,
ses_per_logic_tree_path=oq.ses_per_logic_tree_path)
concurrent_tasks = oq.concurrent_tasks
if oq.hazard_calculation_id:
U = len(self.datastore.parent['ruptures'])
logging.info('Found %d ruptures', U)
parent = self.can_read_parent() or self.datastore
samples_by_grp = self.csm_info.get_samples_by_grp()
for slc in split_in_slices(U, concurrent_tasks or 1):
for grp_id in self.rlzs_by_gsim_grp:
rlzs_by_gsim = self.rlzs_by_gsim_grp[grp_id]
ruptures = RuptureGetter(parent, slc, grp_id)
par = param.copy()
par['samples'] = samples_by_grp[grp_id]
yield ruptures, self.sitecol, rlzs_by_gsim, par, monitor
return
maxweight = self.csm.get_maxweight(weight, concurrent_tasks or 1)
logging.info('Using maxweight=%d', maxweight)
num_tasks = 0
num_sources = 0
for sm in self.csm.source_models:
par = param.copy()
par['samples'] = sm.samples
for sg in sm.src_groups:
# ignore the sources not producing ruptures
sg.sources = [src for src in sg.sources if src.eb_ruptures]
if not sg.sources:
continue
rlzs_by_gsim = self.rlzs_by_gsim_grp[sg.id]
if sg.src_interdep == 'mutex': # do not split
yield sg, self.src_filter, rlzs_by_gsim, par, monitor
num_tasks += 1
num_sources += len(sg.sources)
continue
for block in block_splitter(sg.sources, maxweight, weight):
yield block, self.src_filter, rlzs_by_gsim, par, monitor
num_tasks += 1
num_sources += len(block)
logging.info('Sent %d sources in %d tasks', num_sources, num_tasks)
def from_ruptures(self, param, monitor):
"""
:yields: the arguments for compute_gmfs_and_curves
"""
oq = self.oqparam
concurrent_tasks = oq.concurrent_tasks
U = len(self.datastore.parent['ruptures'])
logging.info('Found %d ruptures', U)
parent = self.can_read_parent() or self.datastore
for slc in split_in_slices(U, concurrent_tasks or 1):
for grp_id in self.rlzs_by_gsim_grp:
rlzs_by_gsim = self.rlzs_by_gsim_grp[grp_id]
ruptures = RuptureGetter(parent, slc, grp_id)
par = param.copy()
par['samples'] = self.samples_by_grp[grp_id]
yield ruptures, self.sitecol, rlzs_by_gsim, par, monitor