def _collect_bins_data(trt_num, sources, site, curves, src_group_id,
rlzs_assoc, gsims, imtls, poes, truncation_level,
n_epsilons, iml_disagg, mon):
# returns a BinData instance
sitecol = SiteCollection([site])
mags = []
dists = []
lons = []
lats = []
trts = []
pnes = collections.defaultdict(list)
sitemesh = sitecol.mesh
make_ctxt = mon('making contexts', measuremem=False)
disagg_poe = mon('disaggregate_poe', measuremem=False)
cmaker = ContextMaker(gsims)
for source in sources:
try:
tect_reg = trt_num[source.tectonic_region_type]
for rupture in source.iter_ruptures():
with make_ctxt:
try:
sctx, rctx, dctx = cmaker.make_contexts(
sitecol, rupture)
except filters.FarAwayRupture:
continue
# extract rupture parameters of interest
mags.append(rupture.mag)
dists.append(dctx.rjb[0]) # single site => single distance
[closest_point] = rupture.surface.get_closest_points(sitemesh)
lons.append(closest_point.longitude)
lats.append(closest_point.latitude)
trts.append(tect_reg)
# a dictionary rlz.id, poe, imt_str -> (iml, prob_no_exceed)
for gsim in gsims:
gs = str(gsim)
for imt_str, imls in imtls.items():
imt = from_string(imt_str)
imls = numpy.array(imls[::-1])
for rlz in rlzs_assoc[src_group_id, gs]:
rlzi = rlz.ordinal
iml = iml_disagg.get(imt_str)
curve_poes = curves[rlzi, imt_str][::-1]
for k, v in _disagg(
iml, poes, curve_poes, imls, gsim, rupture,
rlzi, imt, imt_str, sctx, rctx, dctx,
truncation_level, n_epsilons, disagg_poe):
pnes[k].append(v)
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, err)
raise_(etype, msg, tb)
return BinData(numpy.array(mags, float),
numpy.array(dists, float),
numpy.array(lons, float),
numpy.array(lats, float),
numpy.array(trts, int),
pnes)
def _collect_bins_data(trt_num, sources, site, curves, src_group_id,
rlzs_assoc, gsims, imtls, poes, truncation_level,
n_epsilons, iml_disagg, mon):
# returns a BinData instance
sitecol = SiteCollection([site])
mags = []
dists = []
lons = []
lats = []
trts = []
pnes = collections.defaultdict(list)
sitemesh = sitecol.mesh
make_ctxt = mon('making contexts', measuremem=False)
disagg_poe = mon('disaggregate_poe', measuremem=False)
cmaker = ContextMaker(gsims)
for source in sources:
try:
tect_reg = trt_num[source.tectonic_region_type]
for rupture in source.iter_ruptures():
with make_ctxt:
try:
sctx, rctx, dctx = cmaker.make_contexts(
sitecol, rupture)
except FarAwayRupture:
continue
# extract rupture parameters of interest
mags.append(rupture.mag)
dists.append(dctx.rjb[0]) # single site => single distance
[closest_point] = rupture.surface.get_closest_points(sitemesh)
lons.append(closest_point.longitude)
lats.append(closest_point.latitude)
trts.append(tect_reg)
# a dictionary rlz.id, poe, imt_str -> (iml, prob_no_exceed)
for gsim in gsims:
gs = str(gsim)
for imt_str, imls in imtls.items():
imt = from_string(imt_str)
imls = numpy.array(imls[::-1])
for rlz in rlzs_assoc[src_group_id, gs]:
rlzi = rlz.ordinal
iml = iml_disagg.get(imt_str)
curve_poes = curves[rlzi, imt_str][::-1]
for k, v in _disagg(iml, poes, curve_poes, imls,
gsim, rupture, rlzi, imt,
imt_str, sctx, rctx, dctx,
truncation_level, n_epsilons,
disagg_poe):
pnes[k].append(v)
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, err)
raise_(etype, msg, tb)
return BinData(numpy.array(mags, float), numpy.array(dists, float),
numpy.array(lons, float), numpy.array(lats, float),
numpy.array(trts, int), pnes)
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 = []
serial = 1
sampl_mon = monitor('sampling ruptures', measuremem=True)
filt_mon = monitor('filtering ruptures', measuremem=False)
res.trt = DEFAULT_TRT
ebruptures = []
background_sids = src.get_background_sids(src_filter)
sitecol = src_filter.sitecol
cmaker = ContextMaker(gsims, src_filter.integration_distance)
for sample in range(param['samples']):
for ses_idx, ses_seed in param['ses_seeds']:
seed = sample * 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.serial = serial
rup.seed = seed
try:
rup.ctx = cmaker.make_contexts(sitecol, rup)
indices = rup.ctx[0].sids
except FarAwayRupture:
continue
events = []
for _ in range(n_occ):
events.append((0, src.src_group_id, ses_idx, sample))
if events:
evs = numpy.array(events, stochastic.event_dt)
ebruptures.append(EBRupture(rup, indices, evs))
serial += 1
res.num_events = len(stochastic.set_eids(ebruptures))
res[src.src_group_id] = ebruptures
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 get_hazard_curve_source(input_set):
"""
From a dictionary input set returns hazard curves
"""
try:
cmaker = ContextMaker(
[input_set["gsims"][key] for key in input_set["gsims"]],
None)
for rupture, r_sites in input_set["ruptures_sites"]:
gsim = input_set["gsims"][rupture.tectonic_region_type]
sctx, rctx, dctx = cmaker.make_contexts(r_sites, rupture)
for iimt in input_set["imts"]:
poes = gsim.get_poes(sctx, rctx, dctx, imt.from_string(iimt),
input_set["imts"][iimt],
input_set["truncation_level"])
pno = rupture.get_probability_no_exceedance(poes)
input_set["curves"][iimt] *= r_sites.expand(pno, placeholder=1)
except Exception, err:
pass
def get_conditional_gmfs(database, rupture, sites, gsims, imts,
number_simulations, truncation_level,
correlation_model=DEFAULT_CORRELATION):
"""
Get a set of random fields conditioned on a set of observations
:param database:
Ground motion records for the event as instance of :class:
smtk.sm_database.GroundMotionDatabase
:param rupture:
Event rupture as instance of :class:
openquake.hazardlib.source.rupture.Rupture
:param sites:
Target sites as instance of :class:
openquake.hazardlib.site.SiteCollection
:param list gsims:
List of GMPEs required
:param list imts:
List of intensity measures required
:param int number_simulations:
Number of simulated fields required
:param float truncation_level:
Ground motion truncation level
"""
# Get known sites mesh
known_sites = database.get_site_collection()
# Get Observed Residuals
residuals = Residuals(gsims, imts)
residuals.get_residuals(database)
imt_dict = OrderedDict([
(imtx, np.zeros([len(sites.lons), number_simulations]))
for imtx in imts])
gmfs = OrderedDict([(gmpe, imt_dict) for gmpe in gsims])
gmpe_list = [GSIM_LIST[gmpe]() for gmpe in gsims]
cmaker = ContextMaker(gmpe_list)
sctx, rctx, dctx = cmaker.make_contexts(sites, rupture)
for gsim in gmpe_list:
gmpe = gsim.__class__.__name__
#gsim = GSIM_LIST[gmpe]()
#sctx, rctx, dctx = gsim.make_contexts(sites, rupture)
for imtx in imts:
if truncation_level == 0:
gmfs[gmpe][imtx], _ = gsim.get_mean_and_stddevs(sctx, rctx,
dctx, from_string(imtx), stddev_types=[])
continue
if "Intra event" in gsim.DEFINED_FOR_STANDARD_DEVIATION_TYPES:
epsilon = conditional_simulation(
known_sites,
residuals.residuals[gmpe][imtx]["Intra event"],
sites,
imtx,
number_simulations,
correlation_model)
tau = np.unique(residuals.residuals[gmpe][imtx]["Inter event"])
mean, [stddev_inter, stddev_intra] = gsim.get_mean_and_stddevs(
sctx,
rctx,
dctx,
from_string(imtx),
["Inter event", "Intra event"])
for iloc in range(0, number_simulations):
gmfs[gmpe][imtx][:, iloc] = np.exp(
mean +
(tau * stddev_inter) +
(epsilon[:, iloc].A1 * stddev_intra))
else:
epsilon = conditional_simulation(
known_sites,
residuals.residuals[gmpe][imtx]["Total"],
sites,
imtx,
number_simulations,
correlation_model)
tau = None
mean, [stddev_total] = gsim.get_mean_and_stddevs(
sctx,
rctx,
dctx,
from_string(imtx),
["Total"])
for iloc in range(0, number_simulations):
gmfs[gmpe][imtx][:, iloc] = np.exp(
mean +
(epsilon[:, iloc].A1 * stddev_total.flatten()))
return gmfs
def _collect_bins_data(sources, site, imt, iml, gsims,
truncation_level, n_epsilons,
source_site_filter, rupture_site_filter):
"""
Extract values of magnitude, distance, closest point, tectonic region
types and PoE distribution.
This method processes the source model (generates ruptures) and collects
all needed parameters to arrays. It also defines tectonic region type
bins sequence.
"""
mags = []
dists = []
lons = []
lats = []
tect_reg_types = []
probs_no_exceed = []
sitecol = SiteCollection([site])
sitemesh = sitecol.mesh
_next_trt_num = 0
trt_nums = {}
# here we ignore filtered site collection because either it is the same
# as the original one (with one site), or the source/rupture is filtered
# out and doesn't show up in the filter's output
for src_idx, (source, s_sites) in \
enumerate(source_site_filter(sources, sitecol)):
try:
tect_reg = source.tectonic_region_type
gsim = gsims[tect_reg]
cmaker = ContextMaker([gsim])
if tect_reg not in trt_nums:
trt_nums[tect_reg] = _next_trt_num
_next_trt_num += 1
tect_reg = trt_nums[tect_reg]
for rupture, r_sites in rupture_site_filter(
source.iter_ruptures(), s_sites):
# extract rupture parameters of interest
mags.append(rupture.mag)
[jb_dist] = rupture.surface.get_joyner_boore_distance(sitemesh)
dists.append(jb_dist)
[closest_point] = rupture.surface.get_closest_points(sitemesh)
lons.append(closest_point.longitude)
lats.append(closest_point.latitude)
tect_reg_types.append(tect_reg)
# compute conditional probability of exceeding iml given
# the current rupture, and different epsilon level, that is
# ``P(IMT >= iml | rup, epsilon_bin)`` for each of epsilon bins
sctx, rctx, dctx = cmaker.make_contexts(sitecol, rupture)
[poes_given_rup_eps] = gsim.disaggregate_poe(
sctx, rctx, dctx, imt, iml, truncation_level, n_epsilons
)
# collect probability of a rupture causing no exceedances
probs_no_exceed.append(
rupture.get_probability_no_exceedance(poes_given_rup_eps)
)
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, str(err))
raise_(etype, msg, tb)
mags = numpy.array(mags, float)
dists = numpy.array(dists, float)
lons = numpy.array(lons, float)
lats = numpy.array(lats, float)
tect_reg_types = numpy.array(tect_reg_types, int)
probs_no_exceed = numpy.array(probs_no_exceed, float)
trt_bins = [
trt for (num, trt) in sorted((num, trt)
for (trt, num) in trt_nums.items())
]
return (mags, dists, lons, lats, tect_reg_types, trt_bins, probs_no_exceed)
def _collect_bins_data(sources, site, imt, iml, gsims, truncation_level,
n_epsilons, source_site_filter, rupture_site_filter):
"""
Extract values of magnitude, distance, closest point, tectonic region
types and PoE distribution.
This method processes the source model (generates ruptures) and collects
all needed parameters to arrays. It also defines tectonic region type
bins sequence.
"""
mags = []
dists = []
lons = []
lats = []
tect_reg_types = []
probs_no_exceed = []
sitecol = SiteCollection([site])
sitemesh = sitecol.mesh
_next_trt_num = 0
trt_nums = {}
# here we ignore filtered site collection because either it is the same
# as the original one (with one site), or the source/rupture is filtered
# out and doesn't show up in the filter's output
for src_idx, (source, s_sites) in \
enumerate(source_site_filter(sources, sitecol)):
try:
tect_reg = source.tectonic_region_type
gsim = gsims[tect_reg]
cmaker = ContextMaker([gsim])
if tect_reg not in trt_nums:
trt_nums[tect_reg] = _next_trt_num
_next_trt_num += 1
tect_reg = trt_nums[tect_reg]
for rupture, r_sites in rupture_site_filter(
source.iter_ruptures(), s_sites):
# extract rupture parameters of interest
mags.append(rupture.mag)
[jb_dist] = rupture.surface.get_joyner_boore_distance(sitemesh)
dists.append(jb_dist)
[closest_point] = rupture.surface.get_closest_points(sitemesh)
lons.append(closest_point.longitude)
lats.append(closest_point.latitude)
tect_reg_types.append(tect_reg)
# compute conditional probability of exceeding iml given
# the current rupture, and different epsilon level, that is
# ``P(IMT >= iml | rup, epsilon_bin)`` for each of epsilon bins
sctx, rctx, dctx = cmaker.make_contexts(sitecol, rupture)
[poes_given_rup_eps
] = gsim.disaggregate_poe(sctx, rctx, dctx, imt, iml,
truncation_level, n_epsilons)
# collect probability of a rupture causing no exceedances
probs_no_exceed.append(
rupture.get_probability_no_exceedance(poes_given_rup_eps))
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, str(err))
raise_(etype, msg, tb)
mags = numpy.array(mags, float)
dists = numpy.array(dists, float)
lons = numpy.array(lons, float)
lats = numpy.array(lats, float)
tect_reg_types = numpy.array(tect_reg_types, int)
probs_no_exceed = numpy.array(probs_no_exceed, float)
trt_bins = [
trt
for (num, trt) in sorted((num, trt) for (trt, num) in trt_nums.items())
]
return (mags, dists, lons, lats, tect_reg_types, trt_bins, probs_no_exceed)
def hazard_curves_per_trt(
sources, sites, imtls, gsims, truncation_level=None,
source_site_filter=filters.source_site_noop_filter,
rupture_site_filter=filters.rupture_site_noop_filter,
maximum_distance=None, bbs=(), monitor=Monitor()):
"""
Compute the hazard curves for a set of sources belonging to the same
tectonic region type for all the GSIMs associated to that TRT.
The arguments are the same as in :func:`calc_hazard_curves`, except
for ``gsims``, which is a list of GSIM instances.
:returns:
A list of G arrays of size N, where N is the number of sites and
G the number of gsims. Each array contains records with fields given
by the intensity measure types; the size of each field is given by the
number of levels in ``imtls``.
"""
cmaker = ContextMaker(gsims, maximum_distance)
gnames = list(map(str, gsims))
imt_dt = numpy.dtype([(imt, float, len(imtls[imt]))
for imt in sorted(imtls)])
imts = {from_string(imt): imls for imt, imls in imtls.items()}
curves = [numpy.ones(len(sites), imt_dt) for gname in gnames]
sources_sites = ((source, sites) for source in sources)
ctx_mon = monitor('making contexts', measuremem=False)
pne_mon = monitor('computing poes', measuremem=False)
monitor.calc_times = [] # pairs (src_id, delta_t)
monitor.eff_ruptures = 0 # effective number of contributing ruptures
for source, s_sites in source_site_filter(sources_sites):
t0 = time.time()
try:
rupture_sites = rupture_site_filter(
(rupture, s_sites) for rupture in source.iter_ruptures())
for rupture, r_sites in rupture_sites:
with ctx_mon:
try:
sctx, rctx, dctx = cmaker.make_contexts(
r_sites, rupture)
except FarAwayRupture:
continue
monitor.eff_ruptures += 1
# add optional disaggregation information (bounding boxes)
if bbs:
sids = set(sctx.sites.sids)
jb_dists = dctx.rjb
closest_points = rupture.surface.get_closest_points(
sctx.sites.mesh)
bs = [bb for bb in bbs if bb.site_id in sids]
# NB: the assert below is always true; we are
# protecting against possible refactoring errors
assert len(bs) == len(jb_dists) == len(closest_points)
for bb, dist, p in zip(bs, jb_dists, closest_points):
if dist < maximum_distance:
# ruptures too far away are ignored
bb.update([dist], [p.longitude], [p.latitude])
for i, gsim in enumerate(gsims):
with pne_mon:
for imt in imts:
poes = gsim.get_poes(
sctx, rctx, dctx, imt, imts[imt],
truncation_level)
pno = rupture.get_probability_no_exceedance(poes)
expanded_pno = sctx.sites.expand(pno, 1.0)
curves[i][str(imt)] *= expanded_pno
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, str(err))
raise_(etype, msg, tb)
# we are attaching the calculation times to the monitor
# so that oq-lite (and the engine) can store them
monitor.calc_times.append((source.id, time.time() - t0))
# NB: source.id is an integer; it should not be confused
# with source.source_id, which is a string
for i in range(len(gnames)):
for imt in imtls:
curves[i][imt] = 1. - curves[i][imt]
return curves
def hazard_curves_per_trt(
sources, sites, imtls, gsims, truncation_level=None,
source_site_filter=filters.source_site_noop_filter,
rupture_site_filter=filters.rupture_site_noop_filter,
maximum_distance=None, bbs=(), monitor=DummyMonitor()):
"""
Compute the hazard curves for a set of sources belonging to the same
tectonic region type for all the GSIMs associated to that TRT.
The arguments are the same as in :func:`calc_hazard_curves`, except
for ``gsims``, which is a list of GSIM instances.
:returns:
A list of G arrays of size N, where N is the number of sites and
G the number of gsims. Each array contains records with fields given
by the intensity measure types; the size of each field is given by the
number of levels in ``imtls``.
"""
cmaker = ContextMaker(gsims, maximum_distance)
gnames = list(map(str, gsims))
imt_dt = numpy.dtype([(imt, float, len(imtls[imt]))
for imt in sorted(imtls)])
imts = {from_string(imt): imls for imt, imls in imtls.items()}
curves = [numpy.ones(len(sites), imt_dt) for gname in gnames]
sources_sites = ((source, sites) for source in sources)
ctx_mon = monitor('making contexts', measuremem=False)
rup_mon = monitor('getting ruptures', measuremem=False)
pne_mon = monitor('computing poes', measuremem=False)
monitor.calc_times = [] # pairs (src_id, delta_t)
for source, s_sites in source_site_filter(sources_sites):
t0 = time.time()
try:
with rup_mon:
rupture_sites = list(rupture_site_filter(
(rupture, s_sites) for rupture in source.iter_ruptures()))
for rupture, r_sites in rupture_sites:
with ctx_mon:
try:
sctx, rctx, dctx = cmaker.make_contexts(
r_sites, rupture)
except FarAwayRupture:
continue
# add optional disaggregation information (bounding boxes)
if bbs:
sids = set(sctx.sites.sids)
jb_dists = dctx.rjb
closest_points = rupture.surface.get_closest_points(
sctx.sites.mesh)
bs = [bb for bb in bbs if bb.site_id in sids]
# NB: the assert below is always true; we are
# protecting against possible refactoring errors
assert len(bs) == len(jb_dists) == len(closest_points)
for bb, dist, p in zip(bs, jb_dists, closest_points):
if dist < maximum_distance:
# ruptures too far away are ignored
bb.update([dist], [p.longitude], [p.latitude])
for i, gsim in enumerate(gsims):
with pne_mon:
for imt in imts:
poes = gsim.get_poes(
sctx, rctx, dctx, imt, imts[imt],
truncation_level)
pno = rupture.get_probability_no_exceedance(poes)
expanded_pno = sctx.sites.expand(pno, 1.0)
curves[i][str(imt)] *= expanded_pno
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, str(err))
raise_(etype, msg, tb)
# we are attaching the calculation times to the monitor
# so that oq-lite (and the engine) can store them
monitor.calc_times.append((source.id, time.time() - t0))
# NB: source.id is an integer; it should not be confused
# with source.source_id, which is a string
for i in range(len(gnames)):
for imt in imtls:
curves[i][imt] = 1. - curves[i][imt]
return curves
def _collect_bins_data(trt_num, source_ruptures, site, curves, src_group_id,
rlzs_assoc, gsims, imtls, poes, truncation_level,
n_epsilons, mon):
# returns a BinData instance
sitecol = SiteCollection([site])
mags = []
dists = []
lons = []
lats = []
trts = []
pnes = []
sitemesh = sitecol.mesh
make_ctxt = mon('making contexts', measuremem=False)
disagg_poe = mon('disaggregate_poe', measuremem=False)
cmaker = ContextMaker(gsims)
for source, ruptures in source_ruptures:
try:
tect_reg = trt_num[source.tectonic_region_type]
for rupture in ruptures:
with make_ctxt:
sctx, rctx, dctx = cmaker.make_contexts(sitecol, rupture)
# extract rupture parameters of interest
mags.append(rupture.mag)
dists.append(dctx.rjb[0]) # single site => single distance
[closest_point] = rupture.surface.get_closest_points(sitemesh)
lons.append(closest_point.longitude)
lats.append(closest_point.latitude)
trts.append(tect_reg)
pne_dict = {}
# a dictionary rlz.id, poe, imt_str -> prob_no_exceed
for gsim in gsims:
gs = str(gsim)
for imt_str, imls in imtls.items():
imt = from_string(imt_str)
imls = numpy.array(imls[::-1])
for rlz in rlzs_assoc[src_group_id, gs]:
rlzi = rlz.ordinal
curve_poes = curves[rlzi, imt_str][::-1]
for poe in poes:
iml = numpy.interp(poe, curve_poes, imls)
# compute probability of exceeding iml given
# the current rupture and epsilon_bin, that is
# ``P(IMT >= iml | rup, epsilon_bin)``
# for each of the epsilon bins
with disagg_poe:
[poes_given_rup_eps] = \
gsim.disaggregate_poe(
sctx, rctx, dctx, imt, iml,
truncation_level, n_epsilons)
pne = rupture.get_probability_no_exceedance(
poes_given_rup_eps)
pne_dict[rlzi, poe, imt_str] = (iml, pne)
pnes.append(pne_dict)
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, err)
raise_(etype, msg, tb)
return BinData(numpy.array(mags, float),
numpy.array(dists, float),
numpy.array(lons, float),
numpy.array(lats, float),
numpy.array(trts, int),
pnes)
def _collect_bins_data(trt_num, source_ruptures, site, curves, trt_model_id,
rlzs_assoc, gsims, imtls, poes, truncation_level,
n_epsilons, mon):
# returns a BinData instance
sitecol = SiteCollection([site])
mags = []
dists = []
lons = []
lats = []
trts = []
pnes = []
sitemesh = sitecol.mesh
make_ctxt = mon('making contexts', measuremem=False)
disagg_poe = mon('disaggregate_poe', measuremem=False)
cmaker = ContextMaker(gsims)
for source, ruptures in source_ruptures:
try:
tect_reg = trt_num[source.tectonic_region_type]
for rupture in ruptures:
with make_ctxt:
sctx, rctx, dctx = cmaker.make_contexts(sitecol, rupture)
# extract rupture parameters of interest
mags.append(rupture.mag)
dists.append(dctx.rjb[0]) # single site => single distance
[closest_point] = rupture.surface.get_closest_points(sitemesh)
lons.append(closest_point.longitude)
lats.append(closest_point.latitude)
trts.append(tect_reg)
pne_dict = {}
# a dictionary rlz.id, poe, imt_str -> prob_no_exceed
for gsim in gsims:
for imt_str, imls in imtls.iteritems():
imt = from_string(imt_str)
imls = numpy.array(imls[::-1])
for rlz in rlzs_assoc[trt_model_id,
gsim.__class__.__name__]:
rlzi = rlz.ordinal
curve_poes = curves[rlzi, imt_str][::-1]
for poe in poes:
iml = numpy.interp(poe, curve_poes, imls)
# compute probability of exceeding iml given
# the current rupture and epsilon_bin, that is
# ``P(IMT >= iml | rup, epsilon_bin)``
# for each of the epsilon bins
with disagg_poe:
[poes_given_rup_eps] = \
gsim.disaggregate_poe(
sctx, rctx, dctx, imt, iml,
truncation_level, n_epsilons)
pne = rupture.get_probability_no_exceedance(
poes_given_rup_eps)
pne_dict[rlzi, poe, imt_str] = (iml, pne)
pnes.append(pne_dict)
except Exception as err:
etype, err, tb = sys.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (source.source_id, err)
raise etype, msg, tb
return BinData(numpy.array(mags, float), numpy.array(dists, float),
numpy.array(lons, float), numpy.array(lats, float),
numpy.array(trts, int), pnes)
