def evaluate_model(site_params, rup_params, df, npts, azimuth, moveout, mod,
imt):
sx = SitesContext()
rx = RuptureContext()
dx = DistancesContext()
# TODO: some site parameters can be pulled from the dataframe so we don't
# have to use the defaults (vs30, azimuth, etc.)
if not moveout:
npts = df.shape[0]
for param in site_params.keys():
setattr(sx, param, np.full(npts, site_params[param]))
rx.__dict__.update(rup_params)
rx.mag = df['EarthquakeMagnitude'].iloc[0]
rx.hypo_depth = df['EarthquakeDepth'].iloc[0]
if moveout:
dx.rjb = np.linspace(0, df['JoynerBooreDistance'].max(), npts)
dx.rrup = np.sqrt(dx.rjb**2 + df['EarthquakeDepth'].iloc[0]**2)
dx.rhypo = dx.rrup
dx.repi = dx.rjb
else:
dx.rjb = df['JoynerBooreDistance']
dx.rrup = df['RuptureDistance']
dx.rhypo = df['HypocentralDistance']
dx.repi = df['EpicentralDistance']
# TODO: some of these distances can be pulled from the dataframe
dx.ry0 = dx.rjb
dx.rx = np.full_like(dx.rjb, -1)
dx.azimuth = np.full_like(npts, azimuth)
dx.rcdpp = dx.rjb
dx.rvolc = dx.rjb
try:
mean, sd = MODELS_DICT[mod]().get_mean_and_stddevs(
sx, rx, dx,
manage_imts(imt)[0], [StdDev.TOTAL])
mean = convert_units(mean, imt)
if moveout:
return mean, dx
else:
return mean, sd[0]
except Exception:
return
def get_extent(rupture=None, config=None):
"""
Method to compute map extent from rupture. There are numerous methods for
getting the extent:
- It can be specified directly in the config file,
- it can be hard coded for specific magnitude ranges in the config
file, or
- it can be based on the MultiGMPE for the event.
All methods except for the first requires a rupture object.
If no config is provided then a rupture is required and the extent is based
on a generic set of active/stable.
Args:
rupture (Rupture): A ShakeMap Rupture instance.
config (ConfigObj): ShakeMap config object.
Returns:
tuple: lonmin, lonmax, latmin, latmax rounded to the nearest
arc-minute..
"""
# -------------------------------------------------------------------------
# Check to see what parameters are specified in the extent config
# -------------------------------------------------------------------------
spans = {}
bounds = []
if config is not None:
if 'extent' in config:
if 'magnitude_spans' in config['extent']:
if len(config['extent']['magnitude_spans']):
if isinstance(config['extent']['magnitude_spans'], dict):
spans = config['extent']['magnitude_spans']
if 'bounds' in config['extent']:
if 'extent' in config['extent']['bounds']:
if config['extent']['bounds']['extent'][0] != -999.0:
bounds = config['extent']['bounds']['extent']
# -------------------------------------------------------------------------
# Simplest option: extent was specified in the config, use that and exit.
# -------------------------------------------------------------------------
if len(bounds):
xmin, ymin, xmax, ymax = bounds
return (xmin, xmax, ymin, ymax)
if not rupture or not isinstance(rupture, Rupture):
raise TypeError('get_extent() requires a rupture object if the extent '
'is not specified in the config object.')
# Find the central point
origin = rupture.getOrigin()
if isinstance(rupture, (QuadRupture, EdgeRupture)):
# For an extended rupture, it is the midpoint between the extent of the
# verticies
lats = rupture.lats
lons = rupture.lons
# Remove nans
lons = lons[~np.isnan(lons)]
lats = lats[~np.isnan(lats)]
clat = 0.5 * (np.nanmax(lats) + np.nanmin(lats))
clon = 0.5 * (np.nanmax(lons) + np.nanmin(lons))
else:
# For a point source, it is just the epicenter
clat = origin.lat
clon = origin.lon
mag = origin.mag
# -------------------------------------------------------------------------
# Second simplest option: spans are hardcoded based on magnitude
# -------------------------------------------------------------------------
if len(spans):
xmin = None
xmax = None
ymin = None
ymax = None
for spankey, span in spans.items():
if mag > span[0] and mag <= span[1]:
ymin = clat - span[2] / 2
ymax = clat + span[2] / 2
xmin = clon - span[3] / 2
xmax = clon + span[3] / 2
break
if xmin is not None:
return (xmin, xmax, ymin, ymax)
# -------------------------------------------------------------------------
# Use MultiGMPE to get spans
# -------------------------------------------------------------------------
if config is not None:
gmpe = MultiGMPE.from_config(config)
gmice = get_object_from_config('gmice', 'modeling', config)
else:
# Put in some default values for conf
config = {
'extent': {
'mmi': {
'threshold': 4.5,
'mindist': 100,
'maxdist': 1000
}
}
}
# Generic GMPEs choices based only on active vs stable
# as defaults...
stable = is_stable(origin.lon, origin.lat)
if not stable:
ASK14 = AbrahamsonEtAl2014()
CB14 = CampbellBozorgnia2014()
CY14 = ChiouYoungs2014()
gmpes = [ASK14, CB14, CY14]
site_gmpes = None
weights = [1 / 3.0, 1 / 3.0, 1 / 3.0]
gmice = WGRW12()
else:
Fea96 = FrankelEtAl1996MwNSHMP2008()
Tea97 = ToroEtAl1997MwNSHMP2008()
Sea02 = SilvaEtAl2002MwNSHMP2008()
C03 = Campbell2003MwNSHMP2008()
TP05 = TavakoliPezeshk2005MwNSHMP2008()
AB06p = AtkinsonBoore2006Modified2011()
Pea11 = PezeshkEtAl2011()
Atk08p = Atkinson2008prime()
Sea01 = SomervilleEtAl2001NSHMP2008()
gmpes = [
Fea96, Tea97, Sea02, C03, TP05, AB06p, Pea11, Atk08p, Sea01
]
site_gmpes = [AB06p]
weights = [0.16, 0.0, 0.0, 0.17, 0.17, 0.3, 0.2, 0.0, 0.0]
gmice = AK07()
gmpe = MultiGMPE.from_list(gmpes,
weights,
default_gmpes_for_site=site_gmpes)
min_mmi = config['extent']['mmi']['threshold']
default_imt = imt.SA(1.0)
sd_types = [const.StdDev.TOTAL]
# Distance context
dx = DistancesContext()
# This imposes minimum/ maximum distances of:
# 80 and 800 km; could make this configurable
d_min = config['extent']['mmi']['mindist']
d_max = config['extent']['mmi']['maxdist']
dx.rjb = np.logspace(np.log10(d_min), np.log10(d_max), 2000)
# Details don't matter for this; assuming vertical surface rupturing fault
# with epicenter at the surface.
dx.rrup = dx.rjb
dx.rhypo = dx.rjb
dx.repi = dx.rjb
dx.rx = np.zeros_like(dx.rjb)
dx.ry0 = np.zeros_like(dx.rjb)
dx.rvolc = np.zeros_like(dx.rjb)
# Sites context
sx = SitesContext()
# Set to soft soil conditions
sx.vs30 = np.full_like(dx.rjb, 180)
sx = MultiGMPE.set_sites_depth_parameters(sx, gmpe)
sx.vs30measured = np.full_like(sx.vs30, False, dtype=bool)
sx = Sites._addDepthParameters(sx)
sx.backarc = np.full_like(sx.vs30, False, dtype=bool)
# Rupture context
rx = RuptureContext()
rx.mag = origin.mag
rx.rake = 0.0
# From WC94...
rx.width = 10**(-0.76 + 0.27 * rx.mag)
rx.dip = 90.0
rx.ztor = origin.depth
rx.hypo_depth = origin.depth
gmpe_imt_mean, _ = gmpe.get_mean_and_stddevs(sx, rx, dx, default_imt,
sd_types)
# Convert to MMI
gmpe_to_mmi, _ = gmice.getMIfromGM(gmpe_imt_mean, default_imt)
# Minimum distance that exceeds threshold MMI?
dists_exceed_mmi = dx.rjb[gmpe_to_mmi > min_mmi]
if len(dists_exceed_mmi):
mindist_km = np.max(dists_exceed_mmi)
else:
mindist_km = d_min
# Get a projection
proj = OrthographicProjection(clon - 4, clon + 4, clat + 4, clat - 4)
if isinstance(rupture, (QuadRupture, EdgeRupture)):
ruptx, rupty = proj(lons, lats)
else:
ruptx, rupty = proj(clon, clat)
xmin = np.nanmin(ruptx) - mindist_km
ymin = np.nanmin(rupty) - mindist_km
xmax = np.nanmax(ruptx) + mindist_km
ymax = np.nanmax(rupty) + mindist_km
# Put a limit on range of aspect ratio
dx = xmax - xmin
dy = ymax - ymin
ar = dy / dx
if ar > 1.2:
# Inflate x
dx_target = dy / 1.2
ddx = dx_target - dx
xmax = xmax + ddx / 2
xmin = xmin - ddx / 2
if ar < 0.83:
# Inflate y
dy_target = dx * 0.83
ddy = dy_target - dy
ymax = ymax + ddy / 2
ymin = ymin - ddy / 2
lonmin, latmin = proj(np.array([xmin]), np.array([ymin]), reverse=True)
lonmax, latmax = proj(np.array([xmax]), np.array([ymax]), reverse=True)
#
# Round coordinates to the nearest minute -- that should make the
# output grid register with common grid resolutions (60c, 30c,
# 15c, 7.5c)
#
logging.debug("Extent: %f, %f, %f, %f" % (lonmin, lonmax, latmin, latmax))
return _round_coord(lonmin[0]), _round_coord(lonmax[0]), \
_round_coord(latmin[0]), _round_coord(latmax[0])
def _get_extent_from_multigmpe(rupture, config=None):
"""
Use MultiGMPE to determine extent
"""
(clon, clat) = _rupture_center(rupture)
origin = rupture.getOrigin()
if config is not None:
gmpe = MultiGMPE.from_config(config)
gmice = get_object_from_config('gmice', 'modeling', config)
if imt.SA in gmice.DEFINED_FOR_INTENSITY_MEASURE_TYPES:
default_imt = imt.SA(1.0)
elif imt.PGV in gmice.DEFINED_FOR_INTENSITY_MEASURE_TYPES:
default_imt = imt.PGV()
else:
default_imt = imt.PGA()
else:
# Put in some default values for conf
config = {
'extent': {
'mmi': {
'threshold': 4.5,
'mindist': 100,
'maxdist': 1000
}
}
}
# Generic GMPEs choices based only on active vs stable
# as defaults...
stable = is_stable(origin.lon, origin.lat)
if not stable:
ASK14 = AbrahamsonEtAl2014()
CB14 = CampbellBozorgnia2014()
CY14 = ChiouYoungs2014()
gmpes = [ASK14, CB14, CY14]
site_gmpes = None
weights = [1/3.0, 1/3.0, 1/3.0]
gmice = WGRW12()
else:
Fea96 = FrankelEtAl1996MwNSHMP2008()
Tea97 = ToroEtAl1997MwNSHMP2008()
Sea02 = SilvaEtAl2002MwNSHMP2008()
C03 = Campbell2003MwNSHMP2008()
TP05 = TavakoliPezeshk2005MwNSHMP2008()
AB06p = AtkinsonBoore2006Modified2011()
Pea11 = PezeshkEtAl2011()
Atk08p = Atkinson2008prime()
Sea01 = SomervilleEtAl2001NSHMP2008()
gmpes = [Fea96, Tea97, Sea02, C03,
TP05, AB06p, Pea11, Atk08p, Sea01]
site_gmpes = [AB06p]
weights = [0.16, 0.0, 0.0, 0.17, 0.17, 0.3, 0.2, 0.0, 0.0]
gmice = AK07()
gmpe = MultiGMPE.from_list(
gmpes, weights, default_gmpes_for_site=site_gmpes)
default_imt = imt.SA(1.0)
min_mmi = config['extent']['mmi']['threshold']
sd_types = [const.StdDev.TOTAL]
# Distance context
dx = DistancesContext()
# This imposes minimum/ maximum distances of:
# 80 and 800 km; could make this configurable
d_min = config['extent']['mmi']['mindist']
d_max = config['extent']['mmi']['maxdist']
dx.rjb = np.logspace(np.log10(d_min), np.log10(d_max), 2000)
# Details don't matter for this; assuming vertical surface rupturing fault
# with epicenter at the surface.
dx.rrup = dx.rjb
dx.rhypo = dx.rjb
dx.repi = dx.rjb
dx.rx = np.zeros_like(dx.rjb)
dx.ry0 = np.zeros_like(dx.rjb)
dx.rvolc = np.zeros_like(dx.rjb)
# Sites context
sx = SitesContext()
# Set to soft soil conditions
sx.vs30 = np.full_like(dx.rjb, 180)
sx = MultiGMPE.set_sites_depth_parameters(sx, gmpe)
sx.vs30measured = np.full_like(sx.vs30, False, dtype=bool)
sx = Sites._addDepthParameters(sx)
sx.backarc = np.full_like(sx.vs30, False, dtype=bool)
# Rupture context
rx = RuptureContext()
rx.mag = origin.mag
rx.rake = 0.0
# From WC94...
rx.width = 10**(-0.76 + 0.27*rx.mag)
rx.dip = 90.0
rx.ztor = origin.depth
rx.hypo_depth = origin.depth
gmpe_imt_mean, _ = gmpe.get_mean_and_stddevs(
sx, rx, dx, default_imt, sd_types)
# Convert to MMI
gmpe_to_mmi, _ = gmice.getMIfromGM(gmpe_imt_mean, default_imt)
# Minimum distance that exceeds threshold MMI?
dists_exceed_mmi = dx.rjb[gmpe_to_mmi > min_mmi]
if len(dists_exceed_mmi):
mindist_km = np.max(dists_exceed_mmi)
else:
mindist_km = d_min
# Get a projection
proj = OrthographicProjection(clon - 4, clon + 4, clat + 4, clat - 4)
if isinstance(rupture, (QuadRupture, EdgeRupture)):
ruptx, rupty = proj(
rupture.lons[~np.isnan(rupture.lons)],
rupture.lats[~np.isnan(rupture.lats)]
)
else:
ruptx, rupty = proj(clon, clat)
xmin = np.nanmin(ruptx) - mindist_km
ymin = np.nanmin(rupty) - mindist_km
xmax = np.nanmax(ruptx) + mindist_km
ymax = np.nanmax(rupty) + mindist_km
# Put a limit on range of aspect ratio
dx = xmax - xmin
dy = ymax - ymin
ar = dy / dx
if ar > 1.2:
# Inflate x
dx_target = dy / 1.2
ddx = dx_target - dx
xmax = xmax + ddx / 2
xmin = xmin - ddx / 2
if ar < 0.83:
# Inflate y
dy_target = dx * 0.83
ddy = dy_target - dy
ymax = ymax + ddy / 2
ymin = ymin - ddy / 2
lonmin, latmin = proj(np.array([xmin]), np.array([ymin]), reverse=True)
lonmax, latmax = proj(np.array([xmax]), np.array([ymax]), reverse=True)
#
# Round coordinates to the nearest minute -- that should make the
# output grid register with common grid resolutions (60c, 30c,
# 15c, 7.5c)
#
logging.debug("Extent: %f, %f, %f, %f" %
(lonmin, lonmax, latmin, latmax))
return _round_coord(lonmin[0]), _round_coord(lonmax[0]), \
_round_coord(latmin[0]), _round_coord(latmax[0])
