def classical(sources, sitecol, siteidx, rlzs_assoc, monitor):
"""
:param sources:
a non-empty sequence of sources of homogeneous tectonic region type
:param sitecol:
a SiteCollection instance
:param siteidx:
index of the first site (0 if there is a single tile)
:param rlzs_assoc:
a RlzsAssoc instance
:param monitor:
a monitor instance
:returns:
an AccumDict rlz -> curves
"""
truncation_level = monitor.oqparam.truncation_level
imtls = monitor.oqparam.imtls
trt_model_id = sources[0].trt_model_id
# sanity check: the trt_model must be the same for all sources
for src in sources[1:]:
assert src.trt_model_id == trt_model_id
gsims = rlzs_assoc.gsims_by_trt_id[trt_model_id]
trt = sources[0].tectonic_region_type
try:
max_dist = monitor.oqparam.maximum_distance[trt]
except KeyError:
max_dist = monitor.oqparam.maximum_distance['default']
dic = AccumDict()
dic.siteslice = slice(siteidx, siteidx + len(sitecol))
if monitor.oqparam.poes_disagg:
sm_id = rlzs_assoc.get_sm_id(trt_model_id)
dic.bbs = [BoundingBox(sm_id, sid) for sid in sitecol.sids]
else:
dic.bbs = []
# NB: the source_site_filter below is ESSENTIAL for performance inside
# hazard_curves_per_trt, since it reduces the full site collection
# to a filtered one *before* doing the rupture filtering
curves_by_gsim = hazard_curves_per_trt(
sources,
sitecol,
imtls,
gsims,
truncation_level,
source_site_filter=source_site_distance_filter(max_dist),
maximum_distance=max_dist,
bbs=dic.bbs,
monitor=monitor)
dic.calc_times = monitor.calc_times # added by hazard_curves_per_trt
dic.eff_ruptures = {trt_model_id: monitor.eff_ruptures} # idem
for gsim, curves in zip(gsims, curves_by_gsim):
dic[trt_model_id, str(gsim)] = curves
return dic
def classical(sources, sitecol, siteidx, rlzs_assoc, monitor):
"""
:param sources:
a non-empty sequence of sources of homogeneous tectonic region type
:param sitecol:
a SiteCollection instance
:param siteidx:
index of the first site (0 if there is a single tile)
:param rlzs_assoc:
a RlzsAssoc instance
:param monitor:
a monitor instance
:returns:
an AccumDict rlz -> curves
"""
truncation_level = monitor.oqparam.truncation_level
imtls = monitor.oqparam.imtls
trt_model_id = sources[0].trt_model_id
# sanity check: the trt_model must be the same for all sources
for src in sources[1:]:
assert src.trt_model_id == trt_model_id
gsims = rlzs_assoc.gsims_by_trt_id[trt_model_id]
trt = sources[0].tectonic_region_type
try:
max_dist = monitor.oqparam.maximum_distance[trt]
except KeyError:
max_dist = monitor.oqparam.maximum_distance['default']
dic = AccumDict()
dic.siteslice = slice(siteidx, siteidx + len(sitecol))
if monitor.oqparam.poes_disagg:
sm_id = rlzs_assoc.get_sm_id(trt_model_id)
dic.bbs = [BoundingBox(sm_id, sid) for sid in sitecol.sids]
else:
dic.bbs = []
# NB: the source_site_filter below is ESSENTIAL for performance inside
# hazard_curves_per_trt, since it reduces the full site collection
# to a filtered one *before* doing the rupture filtering
curves_by_gsim = hazard_curves_per_trt(
sources, sitecol, imtls, gsims, truncation_level,
source_site_filter=source_site_distance_filter(max_dist),
maximum_distance=max_dist, bbs=dic.bbs, monitor=monitor)
dic.calc_times = monitor.calc_times # added by hazard_curves_per_trt
dic.eff_ruptures = {trt_model_id: monitor.eff_ruptures} # idem
for gsim, curves in zip(gsims, curves_by_gsim):
dic[trt_model_id, str(gsim)] = curves
return dic
def ucerf_classical_hazard_by_branch(branchnames, ucerf_source, src_group_id,
src_filter, gsims, monitor):
"""
:param branchnames:
a list of branch names
:param ucerf_source:
a source-like object for the UCERF model
:param src_group_id:
an ordinal number for the source
:param source filter:
a filter returning the sites affected by the source
:param gsims:
a list of GSIMs
:param monitor:
a monitor instance
:returns:
an AccumDict rlz -> curves
"""
truncation_level = monitor.oqparam.truncation_level
imtls = monitor.oqparam.imtls
trt = ucerf_source.tectonic_region_type
max_dist = monitor.oqparam.maximum_distance[trt]
dic = AccumDict()
dic.bbs = []
dic.calc_times = []
for branchname in branchnames:
# Two step process here - the first generates the hazard curves from
# the rupture sets
monitor.eff_ruptures = 0
# Apply the initial rupture to site filtering
rupset_idx = ucerf_source.get_rupture_indices(branchname)
rupset_idx, s_sites = \
ucerf_source.filter_sites_by_distance_from_rupture_set(
rupset_idx, src_filter.sitecol, max_dist)
if len(s_sites):
dic[src_group_id] = hazard_curves_per_rupture_subset(
rupset_idx, ucerf_source, src_filter, imtls, gsims,
truncation_level, bbs=dic.bbs, monitor=monitor)
else:
dic[src_group_id] = ProbabilityMap(len(imtls.array), len(gsims))
dic.calc_times += monitor.calc_times # added by pmap_from_grp
dic.eff_ruptures = {src_group_id: monitor.eff_ruptures} # idem
logging.info('Branch %s', branchname)
# Get the background point sources
background_sids = ucerf_source.get_background_sids(
src_filter.sitecol, max_dist)
bckgnd_sources = ucerf_source.get_background_sources(background_sids)
if bckgnd_sources:
pmap = pmap_from_grp(
bckgnd_sources, src_filter, imtls, gsims, truncation_level,
bbs=dic.bbs, monitor=monitor)
dic[src_group_id] |= pmap
dic.eff_ruptures[src_group_id] += monitor.eff_ruptures
dic.calc_times += monitor.calc_times
return dic
def classical(sources, sitecol, gsims, monitor):
"""
:param sources:
a non-empty sequence of sources of homogeneous tectonic region type
:param sitecol:
a SiteCollection instance
:param gsims:
a list of GSIMs for the current tectonic region type
:param monitor:
a monitor instance
:returns:
an AccumDict rlz -> curves
"""
truncation_level = monitor.truncation_level
imtls = monitor.imtls
src_group_id = sources[0].src_group_id
# sanity check: the src_group must be the same for all sources
for src in sources[1:]:
assert src.src_group_id == src_group_id
trt = sources[0].tectonic_region_type
max_dist = monitor.maximum_distance[trt]
dic = AccumDict()
if monitor.poes_disagg:
sm_id = monitor.sm_id
dic.bbs = [BoundingBox(sm_id, sid) for sid in sitecol.sids]
else:
dic.bbs = []
# NB: the source_site_filter below is ESSENTIAL for performance inside
# pmap_from_grp, since it reduces the full site collection
# to a filtered one *before* doing the rupture filtering
dic[src_group_id] = pmap_from_grp(
sources, sitecol, imtls, gsims, truncation_level,
maximum_distance=max_dist, bbs=dic.bbs, monitor=monitor)
dic.calc_times = monitor.calc_times # added by pmap_from_grp
dic.eff_ruptures = {src_group_id: monitor.eff_ruptures} # idem
return dic
def ucerf_classical_hazard_by_rupture_set(
rupset_idx, branchname, ucerf_source, src_group_id, sitecol,
gsims, monitor):
"""
:param rupset_idx:
indices of the rupture sets
:param branchname:
name of the branch
:param ucerf_source:
an object taking the place of a source for UCERF
:param src_group_id:
source group index
:param sitecol:
a SiteCollection instance
:param gsims:
a list of GSIMs
:param monitor:
a monitor instance
:returns:
an AccumDict rlz -> curves
"""
truncation_level = monitor.oqparam.truncation_level
imtls = monitor.oqparam.imtls
max_dist = monitor.oqparam.maximum_distance[DEFAULT_TRT]
dic = AccumDict()
dic.bbs = []
dic.calc_times = []
monitor.eff_ruptures = 0
monitor.calc_times = []
# Apply the initial rupture to site filtering
rupset_idx, s_sites = \
ucerf_source.filter_sites_by_distance_from_rupture_set(
rupset_idx, sitecol,
monitor.oqparam.maximum_distance[DEFAULT_TRT])
if len(s_sites):
dic[src_group_id] = hazard_curves_per_rupture_subset(
rupset_idx, ucerf_source, s_sites, imtls, gsims,
truncation_level, maximum_distance=max_dist, bbs=dic.bbs,
monitor=monitor)
else:
dic[src_group_id] = ProbabilityMap(len(imtls.array), len(gsims))
dic.calc_times += monitor.calc_times # added by pmap_from_grp
dic.eff_ruptures = {src_group_id: monitor.eff_ruptures} # idem
return dic
def count_eff_ruptures(sources, srcfilter, gsims, param, monitor):
"""
Count the effective number of ruptures contained in the given sources
within the integration distance and return a dictionary src_group_id ->
num_ruptures. All sources must belong to the same tectonic region type.
"""
acc = AccumDict()
acc.grp_id = sources[0].src_group_id
acc.calc_times = []
count = 0
for src in sources:
t0 = time.time()
sites = srcfilter.get_close_sites(src)
if sites is not None:
count += src.num_ruptures
dt = time.time() - t0
acc.calc_times.append((src.source_id, len(sites), src.weight, dt))
acc.eff_ruptures = {acc.grp_id: count}
acc.bbs = []
return acc
