def main(mw, models, im_list, vs30, rrups, tect_type, output_dir):
site = classdef.Site()
site.vs30 = vs30
fault = classdef.Fault()
fault.Mw = mw
fault.tect_type = tect_type
# Default parameters
fault.rake = 180
fault.width = 0.1
fault.dip = 45
fault.ztor = 0
fault.hdepth = 0
median_im = np.zeros(len(rrups))
std_dev = np.zeros(len(rrups))
for im in im_list:
fig_im, ax_im = plt.subplots()
for model in models:
model = classdef.GMM[model]
for i, rrup in enumerate(rrups):
site.Rrup = rrup
site.Rjb = rrup
result = empirical_factory.compute_gmm(
fault, site, model, im.name, im.period
)
median_im[i] = result[0]
std_dev[i] = result[1][0]
# Individual Model Plot
fig, ax = plt.subplots()
ax.loglog(rrups, median_im, color="black", label=model.name)
ax.loglog(
rrups, median_im * np.exp(-std_dev), color="black", linestyle="dashed"
)
ax.loglog(
rrups, median_im * np.exp(std_dev), color="black", linestyle="dashed"
)
ax.set_xlabel("Rrup (km)")
ax.set_ylabel(im.pretty_im_name())
ax.set_title(
f"Mw: {mw} dip: {fault.dip} rake: {fault.rake} hdepth: {fault.hdepth} - {tect_type}"
)
ax.legend()
# Aggregated model plot for each IM
ax_im.loglog(rrups, median_im, label=model.name)
ax_im.set_title(
f"Mw: {mw} dip: {fault.dip} rake: {fault.rake} hdepth: {fault.hdepth} - {tect_type}"
)
fig.savefig(output_dir / f"{im.get_im_name()}_vs_rrup_{model}.png")
plt.close(fig)
ax_im.set_xlabel("Rrup (km)")
ax_im.set_ylabel(im.pretty_im_name())
ax_im.legend()
fig_im.savefig(output_dir / f"{im.get_im_name()}_vs_rrup.png")
plt.close(fig_im)
def test_zhao_2006(set_up):
set_up = Path(set_up)
expected_results = pd.read_csv(set_up / "output" / "zhao_output_21p8.csv")
all_results = {}
for i, (hdepth, tect_type, site_class, rrup, period) in enumerate(
itertools.product(hdepths, TECT_TYPES, SITE_CLASSES, rrups,
periods)):
FAULT.hdepth = hdepth
FAULT.tect_type = tect_type
SITE.Rrup = rrup
SITE.siteclass = site_class
mean, (std_total, std_inter,
std_intra) = compute_gmm(FAULT, SITE, GMM.ZA_06, IM, period)
all_results[i] = {
"period": period,
"rrup": rrup,
"siteclass": site_class,
"tect_type": tect_type,
"hdepth": hdepth,
"mean": mean,
"std_total": std_total,
"std_inter": std_inter,
"std_intra": std_intra,
}
results_df = pd.DataFrame.from_dict(all_results, orient="index")
assert np.all(np.isclose(expected_results["mean"], results_df["mean"]))
assert np.all(
np.isclose(expected_results["std_total"], results_df["std_total"]))
assert np.all(
np.isclose(expected_results["std_inter"], results_df["std_inter"]))
assert np.all(
np.isclose(expected_results["std_intra"], results_df["std_intra"]))
def test_Bradley_2013_Sa(set_up, test_rrup):
SITE.Rrup = test_rrup
test_results = empirical_factory.compute_gmm(FAULT, SITE, GMM.Br_10, IM,
PERIODS)
with open(
os.path.join(
set_up, "output",
"Bradley_2013_Sa_ret_val_rrup_{}.P".format(test_rrup)),
"rb",
) as f:
expected_results = pickle.load(f)
assert test_results == expected_results
def test_cb_2012(set_up, test_rrup, test_mag, test_im):
SITE.Rrup = test_rrup
FAULT.Mw = test_mag
test_results = compute_gmm(FAULT, SITE, GMM.CB_12, test_im)
with open(
os.path.join(
set_up,
"output",
"cb_2012_ret_val_rrup_{}_mag_{}_{}.P".format(test_rrup, test_mag, test_im),
),
"rb",
) as f:
expected_results = pickle.load(f)
assert test_results == expected_results
def test_as_2016(set_up, test_rrup, test_mag, test_im):
FAULT.Mw = test_mag
SITE.Rrup = test_rrup
test_results = compute_gmm(FAULT, SITE, GMM.AS_16, test_im)
with open(
os.path.join(
set_up,
"output",
"as_2016_ret_val_rrup_{}_mag_{}_{}.P".format(
test_rrup, test_mag, test_im),
),
"rb",
) as f:
expected_results = pickle.load(f)
assert test_results == expected_results
def get_empirical_values(fault, im, model_dict, r_rup_vals, period):
gmm = empirical_factory.determine_gmm(fault, im, model_dict)[0]
# https://github.com/ucgmsim/post-processing/blob/master/im_processing/computations/GMPE.py
# line 145
r_jbs_vals = np.sqrt(np.maximum(0, r_rup_vals**2 - fault.ztor**2))
e_medians = []
e_sigmas = []
for i in range(len(r_rup_vals)):
site = classdef.Site()
site.Rrup = r_rup_vals[i]
site.Rjb = r_jbs_vals[i]
value = empirical_factory.compute_gmm(fault, site, gmm, im, period)
if isinstance(value, tuple):
e_medians.append(value[0])
e_sigmas.append(value[1][0])
elif isinstance(value, list):
for v in value:
e_medians.append(v[0])
e_sigmas.append(v[1][0])
return np.array(e_medians), np.array(e_sigmas)
def meta_model(fault,
site,
im,
weights_path=None,
period=None,
config=None,
**kwargs):
"""
Computes the meta model gmm from a list of gmms and associated weights
:param fault: Fault object representing the fault the empirical is to be calculated for
:param site: Site object representing the location the empirical value is to be calculated for
:param weights_path: Path to the weights file
:param im: The intensity measure to be calculated
:param period: If the im takes a period, then this should be a list of periods to calculate the values for
:param config: A dictionary of any settings to be passed to subsequent gmpes
:param kwargs: Any additional settings to be passed to all gmpes
:return: a list of (median, (total sigma, intramodel sigma, intermodel sigma)) nested tuples.
Of length one or equal to the length of period
"""
# Local import to prevent cyclic dependencies
from empirical.util.classdef import GMM
from empirical.util.empirical_factory import compute_gmm
# Load the models and weights, then make sure they correspond
gmms = load_weights(weights_path, im, fault.tect_type)
models, weights = zip(*gmms.items())
assert np.isclose(np.sum(weights), 1, atol=0.01), (
f"Weights don't add to 1 ({np.sum(weights)} is more than 0.01 "
f"away from 1). Check your gmpe weights file. ")
medians = []
sigmas = []
for gmm in models:
if config is not None and gmm in config.keys():
tmp_params_dict = config[gmm]
else:
tmp_params_dict = {}
res = compute_gmm(fault, site, GMM[gmm], im, period, **tmp_params_dict,
**kwargs)
if isinstance(res, tuple):
median, (sigma, _, _) = res
median = median[0] if isinstance(median, Iterable) else median
else:
if len(res) == 1:
median, (sigma, _, _) = res[0]
else:
median, sigma_tuple = zip(*res)
sigma, __, __ = zip(*sigma_tuple)
medians.append(median)
sigmas.append(sigma)
# Get values as arrays in log space
logmedians = np.log(np.asarray(medians))
logsigmas = np.asarray(sigmas)
# Get weighted median
weighted_average_median = np.dot(weights, logmedians)
# Get weighted sigmas
sigma_average = np.dot(weights, logsigmas)
sigma_intermodel = np.sqrt(
np.square(logmedians - weighted_average_median).sum(axis=0) /
len(weights))
average_sigma_total = np.sqrt(
np.square(sigma_average) + np.square(sigma_intermodel))
# Get output matrices
e_medians = np.exp(weighted_average_median).squeeze()
e_sigmas = average_sigma_total.squeeze()
# Convert output into (median, (total sigma, intramodel sigma, intermodel sigma)) format
if isinstance(e_medians, np.ndarray):
sigmas = list(zip(e_sigmas, sigma_average, sigma_intermodel))
res = list(zip(e_medians, sigmas))
else:
res = [(e_medians, (e_sigmas, sigma_average, sigma_intermodel))]
return res
def calculate_empirical(
identifier,
srf_info,
output_dir,
config_file,
stations,
vs30_file,
vs30_default,
ims,
rupture_distance,
max_rupture_distance,
period,
extended_period,
components,
gmm_param_config=None,
):
"""Calculate empirical intensity measures"""
# Fault & Site parameters
fault = create_fault_parameters(srf_info)
sites = create_site_parameters(
rupture_distance,
vs30_file,
stations=stations,
vs30_default=vs30_default,
max_distance=max_rupture_distance,
)
if extended_period:
period = np.unique(np.append(period, constants.EXT_PERIOD))
tect_type_model_dict = empirical_factory.read_model_dict(config_file)
station_names = [site.name for site in sites] if stations is None else stations
for im in ims:
for cur_gmm, component in empirical_factory.determine_all_gmm(
fault, im, tect_type_model_dict, components
):
# File & column names
cur_filename = "{}_{}_{}.csv".format(identifier, cur_gmm.name, im)
cur_cols = []
if im in MULTI_VALUE_IMS:
if im == "IESDR":
for p in period:
for r in _STRENGTH_REDUCTION_FACTORS:
cur_cols.append("IESDR_{}_r_{}".format(p, r))
cur_cols.append("IESDR_{}_r_{}_sigma".format(p, r))
else:
for p in period:
cur_cols.append("{}_{}".format(im, p))
cur_cols.append("{}_{}_sigma".format(im, p))
else:
cur_cols.append(im)
cur_cols.append("{}_sigma".format(im))
# Get & save the data
cur_data = np.zeros((len(sites), len(cur_cols)), dtype=np.float)
for ix, site in enumerate(sites):
values = empirical_factory.compute_gmm(
fault,
site,
cur_gmm,
im,
period if im in MULTI_VALUE_IMS else None,
gmm_param_config,
)
if im in MULTI_VALUE_IMS:
cur_data[ix, :] = np.ravel(
[
[im_value, total_sigma]
for im_value, (total_sigma, *_) in values
]
)
else:
cur_data[ix, :] = [values[0], values[1][0]]
df = pd.DataFrame(columns=cur_cols, data=cur_data)
df[STATION_COL_NAME] = station_names
df[COMPONENT_COL_NAME] = component.str_value
# Correct column order
df = order_im_cols_df(df)
df.to_csv(os.path.join(output_dir, cur_filename), index=False)
continue
else:
if imt not in ["SA", "PGA"]:
# empirical engine ones don't have PGV etc...
# need to update as required
continue
fault.tect_type = gmms[g][1]
x = np.logspace(1, 3)
y = []
for rrup in x:
site.Rrup = rrup
site.Rjb = rrup * 0.9
period = None if imt != "SA" else im
# but zhao expects a list?
if g == GMM.ZA_06:
v = compute_gmm(fault, site, g, imt, period=[period])
if imt == "PGA":
# result
v, stdvs = v
else:
# list of result for each period
v, stdvs = v[0]
else:
v, stdvs = compute_gmm(fault,
site,
g,
imt,
period=period)
y.append(v[0] if hasattr(v, "__len__") else v)
y = np.array(y)
