def bbp2sdsu_statlist(working_dir, slo, sdsu_stalist,
srf_file, xyz_srf_file, extended_fault,
tmpfile="station.coords"):
"""
Takes BBP station list object and writes SDSU station list
"""
# Convert station coordinates to cartesian coordinates
a_srf_file = os.path.join(working_dir, srf_file)
a_xyz_srf_file = os.path.join(working_dir, xyz_srf_file)
out_coords = os.path.join(working_dir, tmpfile)
gbb = GeoBBSRF()
gbb.run(slo, out_coords, extended_fault, 'n',
a_srf_file, a_xyz_srf_file, 'y')
if not os.path.exists(out_coords):
raise bband_utils.ProcessingError("Error converting station coordinates"
" to SDSU format, exiting.")
coords_fp = open(out_coords, 'r')
coords_data = coords_fp.readlines()
coords_fp.close()
# Write station file
stat_list = slo.getStationList()
stalist_fp = open(sdsu_stalist, 'w')
for i in range(0, len(stat_list)):
pieces = coords_data[i].split()
stalist_fp.write("%f %f %s -1 -1 -1\n" % (float(pieces[0]),
float(pieces[1]),
stat_list[i].scode))
stalist_fp.flush()
stalist_fp.close()
# All done!
return "%s.param" % out_coords
def read_gmpe(self, input_file):
"""
Reads the GMPE input_file and returns the periods along with the data
"""
# Start empty
gmpe_data = []
gmpe_models = None
gmpefile = open(input_file, 'r')
for line in gmpefile:
line = line.strip()
if line.startswith('#period'):
# This line contains the models we want to use
gmpe_models = line.split(None, 1)[1]
gmpe_models = gmpe_models.split()
if line.startswith('#'):
# Skip other comments
continue
values = line.split()
values = [float(value) for value in values]
# Extract period and rotd50 value
period = values[0]
medians = values[1:]
gmpe_data.append((period, medians))
gmpefile.close()
# Make sure we parsed the line with the model names
if gmpe_models is None:
raise bband_utils.ProcessingError("Cannot find GMPE models in %s" %
(input_file))
# Return the station median data
return gmpe_data, gmpe_models
def combine_realizations_data(input_dir, temp_dir):
"""
This function creates a single file averaging the rd50 files for
each of the stations across all realizations
"""
# Get realizations
realizations = sorted(os.listdir(input_dir))
one_realization = realizations[0]
basedir = os.path.join(input_dir, one_realization)
# Figure out what our stations are
rd50_files = glob.glob("%s%s%s.*.rd50" %
(basedir, os.sep, one_realization))
rd50_files = [os.path.basename(each_file) for each_file in rd50_files]
stations = [station.split(".")[1] for station in rd50_files]
# Capture event_label
bias_file = glob.glob("%s%s*.bias" % (basedir, os.sep))
if len(bias_file) < 1:
raise bband_utils.ProcessingError("Cannot find event label!")
bias_file = bias_file[0]
# Let's capture the event label
event_label = os.path.basename(bias_file).split("-")[0]
# Now walk through all realizations and combine stations data
for station in stations:
print("working on station: %s" % (station))
combine_station_data(station, input_dir, temp_dir)
return event_label, len(realizations), len(stations)
def load_station_data(input_outdir, data, station):
"""
Load station data into the DATA dictionary
"""
# Get realizations
realizations = sorted(os.listdir(input_outdir))
for realization in realizations:
basedir = os.path.join(input_outdir, realization,
"validations", "anderson_gof")
data_file = glob.glob("%s%sgof-*-anderson-%s.txt" % (basedir,
os.sep,
station))
if len(data_file) != 1:
raise bband_utils.ProcessingError("Data for station %s " %
(station) +
"not found for "
"realization %s!" %
(realization))
data_file = data_file[0]
stat_data = readfmt(data_file)
# Add data to the data dict
for c_idx in range(10):
for b_idx in range(BMAX):
if station not in data[c_idx][b_idx]:
# Add 3rd level if it doesn't exist - stations
data[c_idx][b_idx][station] = []
data[c_idx][b_idx][station].append(stat_data[b_idx, c_idx])
def combine_realizations_data(input_dir, temp_dir):
"""
This function creates a single file averaging the rd100 files for
each of the stations across all realizations
"""
# Get realizations
realizations = sorted(os.listdir(input_dir))
one_realization = realizations[0]
basedir = os.path.join(input_dir, one_realization, "validations",
"rzz2015")
basedir_gmpe = os.path.join(input_dir, one_realization, "validations",
"rzz2015_gmpe")
# Figure out what our stations are
rzzgmpe_files = glob.glob("%s%s%s.rzz2015gmpe.*.png" %
(basedir_gmpe, os.sep, one_realization))
rzzgmpe_files = [
os.path.basename(each_file) for each_file in rzzgmpe_files
]
stations = [station.split(".")[2] for station in rzzgmpe_files]
# Capture event_label
rzz_file = glob.glob("%s%s%s.rzz2015.*.txt" %
(basedir, os.sep, one_realization))
if len(rzz_file) < 1:
raise bband_utils.ProcessingError("Cannot find event label!")
rzz_file = rzz_file[0]
# Let's capture the event label
event_label = os.path.basename(rzz_file).split(".")[2]
# Now walk through all realizations and combine stations data
for station in stations:
print "working on station: %s" % (station)
combine_station_data(station, input_dir, temp_dir)
return event_label, len(realizations), len(stations)
def combine_realization_data(tmpdir, period):
"""
This function reads the resid files from all realizations and
returns the combined data set
"""
data = {}
realizations = sorted(os.listdir(tmpdir))
for realization in realizations:
basedir = os.path.join(tmpdir, realization)
resid_file = glob.glob("%s%s*-resid-%.3f-rotd50.txt" %
(basedir, os.sep, period))
if len(resid_file) != 1:
raise bband_utils.ProcessingError("Residuals file not found for "
"realization %s!" % (realization))
resid_file = resid_file[0]
input_file = open(resid_file, 'r')
for line in input_file:
line = line.strip()
# Skip comments and empty lines
if line.startswith("#") or line.startswith("%") or not line:
continue
pieces = line.split()
# Make sure we have enough tokens
if len(pieces) != 2:
continue
# Convert to floats
pieces = [float(piece) for piece in pieces]
dist = pieces[0]
val = pieces[1]
if dist in data:
data[dist].append(val)
else:
data[dist] = [val]
input_file.close()
# Ok, processed all realizations, now combine the data
sta_dist_data = []
sta_min_data = []
sta_max_data = []
sta_resid_data = []
for item in data:
sta_dist_data.append(item)
sta_min_data.append(numpy.std(data[item]))
sta_max_data.append(numpy.std(data[item]))
sta_resid_data.append(numpy.mean(data[item]))
# Return the data we found
return sta_dist_data, sta_min_data, sta_max_data, sta_resid_data
def read_input_bias_data(input_dir):
"""
Read the bias data from all realizations
"""
periods = []
data = []
event_label = None
realizations = sorted(os.listdir(input_dir))
for realization in realizations:
basedir = os.path.join(input_dir, realization)
bias_file = glob.glob("%s%s*-rotd50.bias" % (basedir, os.sep))
if len(bias_file) != 1:
raise bband_utils.ProcessingError("Bias file not found for "
"realization %s!" %
(realization))
bias_file = bias_file[0]
# Let's capture the event label
if event_label is None:
event_label = os.path.basename(bias_file).split("-")[0]
input_file = open(bias_file, 'r')
cur_periods = []
cur_data = []
for line in input_file:
line = line.strip()
# Skip comments and empty lines
if line.startswith("#") or line.startswith("%") or not line:
continue
tokens = [float(token) for token in line.split()]
cur_periods.append(tokens[0])
cur_data.append(tokens[1])
# Close input_file
input_file.close()
# Keep list of periods if not already done
if not periods:
periods = cur_periods
# And keep data
data.append(cur_data)
bias_data = {}
bias_data["num_periods"] = len(periods)
bias_data["periods"] = periods
bias_data["num_realizations"] = len(realizations)
bias_data["data"] = data
bias_data["event_label"] = event_label
return bias_data
def create_resid_data_file(input_dir, combined_file):
"""
This function creates a file containing the combined residuals
from the simulation data from all realizations
"""
copy_header = True
event_label = None
num_stations = 0
# Open output file, write header
outfile = open(combined_file, 'w')
realizations = sorted(os.listdir(input_dir))
for realization in realizations:
basedir = os.path.join(input_dir, realization)
resid_file = glob.glob("%s%s*.rd50-resid.txt" % (basedir, os.sep))
if len(resid_file) != 1:
raise bband_utils.ProcessingError("Residuals file not found for "
"realization %s!" %
(realization))
resid_file = resid_file[0]
# Let's capture the event label
if event_label is None:
event_label = os.path.basename(resid_file).split("-")[0]
input_file = open(resid_file, 'r')
for line in input_file:
line = line.strip()
# Skip comments and empty lines
if line.startswith("#") or line.startswith("%") or not line:
continue
if line.startswith("EQ"):
# This is the header line, skip if already done
if not copy_header:
continue
# If not done, set flag
copy_header = False
if line.find("rotd50") > 0:
num_stations = num_stations + 1
outfile.write("%s\n" % (line))
input_file.close()
# All done!
outfile.close()
# Return event label
return event_label, len(realizations), num_stations
def combine_station_data(station, input_dir, temp_dir):
"""
This function combines data for a given station across multiple
realizations, writting a single output file in temp_dir
"""
data = {}
# Get realizations
realizations = sorted(os.listdir(input_dir))
for realization in realizations:
basedir = os.path.join(input_dir, realization)
data_file = glob.glob("%s%s%s.%s.rd50" % (basedir, os.sep,
realization,
station))
if len(data_file) != 1:
raise bband_utils.ProcessingError("Data for station %s " %
(station) +
"not found for "
"realization %s!" %
(realization))
data_file = data_file[0]
in_data = open(data_file, 'r')
for line in in_data:
line = line.strip()
# Skip comments
if line.startswith("#"):
continue
pieces = line.split()
pieces = [float(piece) for piece in pieces]
key = pieces[0]
pieces = pieces[1:]
if not key in data:
# Key is new to dictionary
empty_set = [[] for _ in pieces]
data[key] = empty_set
for idx, value in enumerate(pieces):
data[key][idx].append(value)
in_data.close()
# Now, write the output file
out_file = open((os.path.join(temp_dir, "%s.rd50" % (station))), 'w')
keys = sorted(data.keys())
for key in keys:
out_file.write("%10.4f" % (key))
for comp in data[key]:
out_file.write(" %10.5e" % (numpy.mean(comp)))
out_file.write("\n")
def summarize_rotd50(tmpdir, outdir, combined_resid_file, comp_label,
num_stations, num_realization, codebase):
"""
This function summarizes all rotd50 data and creates the combined
rotd50 GOF plot
"""
config = GPGofCfg()
# Figure out where out binaries are
if "BBP_DIR" in os.environ:
install_root = os.path.normpath(os.environ["BBP_DIR"])
else:
raise bband_utils.ProcessingError("BBP_DIR is not set!")
gp_bin_dir = os.path.join(install_root, "src", "gp", "bin")
logfile = os.path.join(tmpdir, "log.txt")
for comp in config.COMPS_PSA5:
# Build paths and check lengths
fileroot = os.path.join(
tmpdir, "%s-%s-combined-rd50-%s" % (codebase, comp_label, comp))
bband_utils.check_path_lengths([combined_resid_file, fileroot],
bband_utils.GP_MAX_FILENAME)
cmd = ("%s " % (os.path.join(gp_bin_dir, "resid2uncer_varN")) +
"residfile=%s fileroot=%s " % (combined_resid_file, fileroot) +
"comp=%s nstat=%d nper=63 " % (comp, num_stations) +
" >> %s 2>&1" % (logfile))
bband_utils.runprog(cmd, abort_on_error=True)
plottitle = ("Combined GOF Plot for %s\n%d Realizations - %s Method" %
(comp_label, num_realization, codebase.upper()))
fileroot = "%s-%s-combined-rd50" % (codebase, comp_label)
plotter = PlotGoF()
plotter.plot(plottitle,
fileroot,
tmpdir,
outdir,
cutoff=0,
mode="rd50-single",
colorset="combined")
print("Stations used: %s" % (num_stations))
def correct_station(self, station, extension):
"""
This function applies the user-provided correction factors to
the station's amplitudes, and outputs the corrected file
"""
if not station in self.factors:
raise bband_utils.ParameterError("Unknown station %s!" % (station))
orig_file = os.path.join(self.proc_dir,
"%s-orig.%s" % (station, extension))
corr_file = os.path.join(self.proc_dir, "%s.%s" % (station, extension))
# Make sure input files exist
if not os.path.exists(orig_file):
raise bband_utils.ProcessingError("File %s not found!" %
(orig_file))
# Pick set of correction factors
factors = self.factors[station]
# Correct rd50 file
self.correct_file(factors, orig_file, corr_file)
def combine_station_data(station, input_dir, temp_dir):
"""
This function combines data for a given station across multiple
realizations, writting a single output file in temp_dir
"""
data = []
# Get realizations
realizations = sorted(os.listdir(input_dir))
for realization in realizations:
basedir = os.path.join(input_dir, realization, "validations",
"rzz2015")
data_file = glob.glob("%s%s%s.rzz2015.*.txt" %
(basedir, os.sep, realization))
if len(data_file) != 1:
raise bband_utils.ProcessingError("Data for station %s " %
(station) + "not found for "
"realization %s!" %
(realization))
data_file = data_file[0]
in_data = open(data_file, 'r')
for line in in_data:
line = line.strip()
# Skip comments
if line.startswith("#"):
continue
pieces = line.split(",")
cur_station = pieces[0]
# Check if this is the station we want
if cur_station == station:
data.append(line)
in_data.close()
# Now, write the output file
out_file = open((os.path.join(temp_dir, "%s.rzz2015" % (station))), 'w')
for item in data:
out_file.write("%s\n" % (item))
out_file.close()
def load_all_data(input_indir, input_outdir):
"""
This function goes through all realizations and loads all data to
the DATA dictionary
"""
# First create data dictionary
data = {}
# First level is C1..CMAX
for i in range(10):
data[i] = {}
# Second level is B1..BMAX
for j in range(BMAX):
data[i][j] = {}
# Get realizations
realizations = sorted(os.listdir(input_indir))
one_realization = realizations[0]
basedir = os.path.join(input_indir, one_realization)
# Get the station list
a_statfile = glob.glob("%s%s*.stl" % (basedir, os.sep))
if len(a_statfile) != 1:
raise bband_utils.ProcessingError("Cannot get station list!")
a_statfile = a_statfile[0]
slo = StationList(a_statfile)
site_list = slo.getStationList()
# Go through all stations
for site in site_list:
station = site.scode
print "working on station: %s" % (station)
# Read data for this station
load_station_data(input_outdir, data, station)
# Return data dictionary
return data
def correct_file(self, factors, input_file, output_file):
"""
This function reads input_file and writes output_file after
applying the correction factors
"""
# Open files
ifile = open(input_file, 'r')
ofile = open(output_file, 'w')
for line in ifile:
if line.startswith("#"):
# Comment line, just write to output
ofile.write(line)
else:
# This line needs correction
pieces = line.split()
period = float(pieces[0])
pieces.pop(0)
values = [float(value) for value in pieces]
try:
index = self.periods.index(period)
except ValueError:
raise bband_utils.ProcessingError("Period %f not on the " %
(period) +
"correction list!")
# Apply correction value
values = [value * factors[index] for value in values]
ostr = " %10.5E" % (period)
for value in values:
ostr = "%s %10.5E" % (ostr, value)
# Write to output file
ofile.write("%s\n" % (ostr))
# All done!
ifile.close()
ofile.close()
def write_xyz_srf(self, srf_file, xyz_srf_file, T3M):
"""
Reads the SRF file and converts its lat/lon to XYZ format
using self.latmin and self.lonmin as reference points. The T3M
matrix is used to shift the coordinates to the new reference
point calculated in the run function.
"""
# Open files
infile = open(srf_file, 'r')
outfile = open(xyz_srf_file, 'w')
# Pick up version number from SRF file
version = float(infile.readline().strip().split()[0])
# Now go back to the start
infile.seek(0)
# Copy lines
while True:
line = infile.readline()
# Cannot mix for line in infile with readline...
if line is None:
break
outfile.write(line)
# Until we find the plane line
if line.find("PLANE") >= 0:
break
tokens = line.strip().split()
# Make sure we have a valid SRF file
if len(tokens) != 2:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srf_file))
planes = int(tokens[1])
# Make sure we have only 1 plane
if planes > 1:
raise bband_utils.ProcessingError("Only one plane is " +
"supported!" + " Found %d " %
(planes) + " in SRF file!")
line = infile.readline()
tokens = line.strip().split()
if len(tokens) != 6:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srf_file))
# Convert to XYZ
lon = float(tokens[0])
lat = float(tokens[1])
[x_cart, y_cart] = self.geo2cart(lon, lat, self.min_lon, self.min_lat)
tmp = T3M * np.mat([x_cart, y_cart, 0, 1]).transpose()
tokens[0] = str(float(tmp[0]))
tokens[1] = str(float(tmp[1]))
outfile.write(" %s\n" % " ".join(tokens))
# Continue copying
while True:
line = infile.readline()
# Cannot mix for line in infile with readline...
if line is None:
break
outfile.write(line)
if line.find("POINTS") >= 0:
break
# Figure out how many cells
tokens = line.strip().split()
if len(tokens) != 2:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srf_file))
n_cels = int(tokens[1])
# Go through each cell
for i in range(0, n_cels):
tokens = infile.readline().strip().split()
if version == 1.0 and len(tokens) != 8:
raise bband_utils.ProcessingError("Invalid SRF version 1 "
"file (%s)!" % (srffile))
if version == 2.0 and len(tokens) != 10:
raise bband_utils.ProcessingError("Invalid SRF version 2 "
"file (%s)!" % (srffile))
lon = float(tokens[0])
lat = float(tokens[1])
[x_cart, y_cart] = self.geo2cart(lon, lat, self.min_lon,
self.min_lat)
tmp = T3M * np.mat([x_cart, y_cart, 0, 1]).transpose()
tokens[0] = str(float(tmp[0]))
tokens[1] = str(float(tmp[1]))
outfile.write(" %s\n" % " ".join(tokens))
line = infile.readline()
tokens = line.strip().split()
if len(tokens) != 7:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srf_file))
nt1 = float(tokens[2])
nt2 = float(tokens[4])
nt3 = float(tokens[6])
# Write line
outfile.write(line)
if nt1 > 0:
for k in range(0, int(math.ceil(nt1 / 6.0))):
token = infile.readline()
if token == "":
raise bband_utils.ProcessingError("Invalid SRF "
"file (%s)!" %
(srf_file))
outfile.write(token)
if nt2 > 0:
for k in range(0, int(math.ceil(nt2 / 6.0))):
token = infile.readline()
if token == "":
raise bband_utils.ProcessingError("Invalid SRF "
"file (%s)!" %
(srf_file))
outfile.write(token)
if nt3 > 0:
for k in range(0, int(math.ceil(nt3 / 6.0))):
token = infile.readline()
if token == "":
raise bband_utils.ProcessingError("Invalid SRF "
"file (%s)!" %
(srf_file))
outfile.write(token)
# All done, close input and output files
infile.close()
outfile.close()
a_outdir1 = os.path.join(install.A_OUT_DATA_DIR, str(sim_id_1))
a_outdir2 = os.path.join(install.A_OUT_DATA_DIR, str(sim_id_2))
# Src file
a_srcfile = os.path.join(a_indir, src_file)
src_keys = bband_utils.parse_src_file(a_srcfile)
# Station file
a_statfile = os.path.join(a_indir, station_list)
slo = StationList(a_statfile)
site_list = slo.getStationList()
# Capture event_label
bias_file = glob.glob("%s%s*.bias" % (a_outdir1, os.sep))
if len(bias_file) < 1:
raise bband_utils.ProcessingError("Cannot find event label!")
bias_file = bias_file[0]
# Let's capture the event label
event_label = os.path.basename(bias_file).split("-")[0]
print_header_rd50 = 1
# Go through the stations
for site in site_list:
stat = site.scode
slon = float(site.lon)
slat = float(site.lat)
# Check files are there
a_rd50file1 = os.path.join(a_outdir1, "%d.%s.rd50" % (sim_id_1, stat))
a_rd50file2 = os.path.join(a_outdir2, "%d.%s.rd50" % (sim_id_2, stat))
def load_correction_factors(self):
"""
This function loads the correction factors from the corr_file
provided
"""
try:
cfile = open(self.corr_file, 'r')
except IOError:
raise bband_utils.ParameterError("Cannot read correction file %s" %
(self.corr_file))
# We are looking for the header first
headers = None
# Loop through the lines
for line in cfile:
if line.startswith("#StaName"):
headers = line.split()
break
# Make sure we got the header line
if headers is None:
cfile.close()
raise bband_utils.ProcessingError("Cannot find header line in "
"correction file %s" %
(self.corr_file))
skip_headers = 0
# Pick up the periods
while len(headers) > 0:
try:
tmp = float(headers[0])
except:
# Skip this one, and remove from list
skip_headers = skip_headers + 1
headers.pop(0)
else:
# Found first period, get out
break
# Make sure we have at least 1 period
if not headers:
cfile.close()
raise bband_utils.ProcessingError("Cannot find any periods in "
"correction file %s" %
(self.corr_file))
# Convert periods to floats
self.periods = [float(value) for value in headers]
# Now read the rest of the correction file
for line in cfile:
if line.startswith("#"):
continue
factors = line.split()
station = factors[0]
to_skip = skip_headers
# Remove everything other than the correction factors
while to_skip > 0:
factors.pop(0)
to_skip = to_skip - 1
factors = [float(value) for value in factors]
# Make sure we have the proper number of correction factors
if len(factors) != len(self.periods):
cfile.close()
raise bband_utils.ProcessingError("Station %s has %d periods" %
(station, len(factors)) +
", expecting %s periods" %
(len(self.periods)))
self.factors[station] = factors
# All done
cfile.close()
def convert_to_bbp(self, in_hor_file, in_ver_file, out_acc_file):
"""
This function converts the in_file Irikura seismogram to an
acceleration BBP file
"""
header_lines = 0
freq = None
fac1_hor = None
fac2_hor = None
fac1_ver = None
fac2_ver = None
# Read horizontal acc file
irikura_file = open(in_hor_file, 'r')
for line in irikura_file:
line = line.strip()
header_lines = header_lines + 1
if line.startswith("Sampling Freq"):
pieces = line.split()
token = pieces[2]
freq = float(token[0:token.find("Hz")])
continue
if line.startswith("Scale Factor"):
pieces = line.split()
token = pieces[2]
fac2_hor = float(token.split("/")[1])
fac1_hor = float(token.split("/")[0][0:token.find("(gal)")])
continue
if line.startswith("Memo"):
break
irikura_file.close()
# Read vertical acc file
irikura_file = open(in_ver_file, 'r')
for line in irikura_file:
line = line.strip()
if line.startswith("Scale Factor"):
pieces = line.split()
token = pieces[2]
fac2_ver = float(token.split("/")[1])
fac1_ver = float(token.split("/")[0][0:token.find("(gal)")])
continue
if line.startswith("Memo"):
break
irikura_file.close()
if (freq is None or fac1_hor is None or fac2_hor is None
or fac1_ver is None or fac2_ver is None):
# Not able to parse it properly, exit!
raise bband_utils.ProcessingError(
"Could not parse files %s and %s" % (in_hor_file, in_ver_file))
time_step = 1.0 / freq
time_curr = 0.0
skip_lines = 0
irikura_hor_file = open(in_hor_file, 'r')
irikura_ver_file = open(in_ver_file, 'r')
bbp_file = open(out_acc_file, 'w')
# Add header to BBP file
bbp_file.write("# time(sec) N-S(cm/s/s) "
"E-W(cm/s/s) U-D(cm/s/s)\n")
for line1, line2 in zip(irikura_hor_file, irikura_ver_file):
# Skip header lines
if skip_lines < header_lines:
skip_lines = skip_lines + 1
continue
line1 = line1.strip()
line2 = line2.strip()
pieces1 = line1.split()
pieces1 = [float(val) for val in pieces1]
pieces2 = line2.split()
pieces2 = [float(val) for val in pieces2]
# Convert each value to gal (cm/s/s)
pieces1 = [val * fac1_hor / fac2_hor for val in pieces1]
pieces2 = [val * fac1_ver / fac2_ver for val in pieces2]
# Write values to BBP file, repeating as needed for the
# 3-component file
for piece_h, piece_v in zip(pieces1, pieces2):
bbp_file.write("%15.6e%15.6e%15.6e%15.6e\n" %
(time_curr, piece_h, piece_h, piece_v))
# Don't forget to increment time
time_curr = time_curr + time_step
bbp_file.close()
irikura_hor_file.close()
irikura_ver_file.close()
def bbp2peer(in_bbp_file, out_peer_n_file, out_peer_e_file, out_peer_z_file):
"""
Convert bbp file into three peer files for use by RotD50 and
other programs that input PEER format seismograms
"""
num_header_lines = 0
bbp = open(in_bbp_file, "r")
lines = bbp.readlines()
bbp.close()
for line in lines:
elems = line.split()
if elems[0] == "#":
num_header_lines = num_header_lines + 1
else:
break
#print "Counted %d header lines" % (num_header_lines)
cur_line = 0
header_lines = []
dt_vals = []
n_vals = []
e_vals = []
z_vals = []
for line in lines:
if cur_line <= (num_header_lines - 2):
cur_line = cur_line + 1
header_lines.append(line)
elif cur_line == (num_header_lines - 1):
# Last line before start gives dt and npts
cur_line = cur_line + 1
# Print line
elems = line.split()
try:
npts = int(elems[1])
dt = float(elems[2])
except (IndexError, ValueError) as err:
# Ok, it doesn't seem we are re-converting to PEER
# format a previously PEER-BBP converted file
# Let's try to figure things out...
npts = len(lines) - num_header_lines
try:
time_1 = float(lines[num_header_lines].split()[0])
time_2 = float(lines[num_header_lines + 1].split()[0])
except ValueError:
print("Cannot figure out npts and dt from this bbp file!")
sys.exit(-1)
dt = time_2 - time_1
#print("Reformating BBP file with %d header lines." %
# (num_header_lines))
#print("Reformating BBP file with dt: %f " % (dt))
#print("Reformating BBP file with npts: %d" % (npts))
else:
elems = line.split()
if len(elems) != 4:
raise bband_utils.ProcessingError("Unexpected BBP time series "
"line format found."
"Error in conversion.")
else:
dt_vals.append(dt)
n_vals.append(float(elems[1]) / bband_utils.G2CMSS)
e_vals.append(float(elems[2]) / bband_utils.G2CMSS)
z_vals.append(float(elems[3]) / bband_utils.G2CMSS)
# Prepare to write 6 colume format
n_file = open(out_peer_n_file, "w")
e_file = open(out_peer_e_file, "w")
z_file = open(out_peer_z_file, "w")
#n_file.write("Created by: bbp2peer v12.8.0\n")
#e_file.write("Created by: bbp2peer v12.8.0\n")
#z_file.write("Created by: bbp2peer v12.8.0\n")
# Adjust header lines, so we always have enough
while len(header_lines) <= (PEER_HEADER_LINES - 2):
header_lines.append("\n")
for line in header_lines[0:(PEER_HEADER_LINES - 2)]:
n_file.write(line)
e_file.write(line)
z_file.write(line)
n_file.write("Acceleration in g\n")
n_file.write(" %d %1.6f NPTS, DT\n" % (npts, dt))
e_file.write("Acceleration in g\n")
e_file.write(" %d %1.6f NPTS, DT\n" % (npts, dt))
z_file.write("Acceleration in g\n")
z_file.write(" %d %1.6f NPTS, DT\n" % (npts, dt))
cur_line = 0
for index, elem in enumerate(dt_vals):
n_file.write("% 12.7E " % (n_vals[index]))
e_file.write("% 12.7E " % (e_vals[index]))
z_file.write("% 12.7E " % (z_vals[index]))
#print "%f"%(dt_vals[index])
#print "%e"%(n_vals[index])
#print "%e"%(e_vals[index])
#print "%e"%(z_vals[index])
if (index % 5) == 4:
n_file.write("\n")
e_file.write("\n")
z_file.write("\n")
#else:
# n_file.write("\t")
# e_file.write("\t")
# z_file.write("\t")
# Add newline at the end of last line to avoid issue when rotd50.f
# reads the file (only when compiled with gfortran 4.3.3 on HPCC)
n_file.write("\n")
e_file.write("\n")
z_file.write("\n")
# Close all files
n_file.close()
e_file.close()
z_file.close()
def create_resid_data_file(comp_label, input_indir, input_obsdir,
combined_file, temp_dir):
"""
This function creates a file containing the combined residuals
from the simulation data from all stations
"""
# Copy header for first file, set logfile
copy_header = 1
logfile = os.path.join(temp_dir, "log.txt")
# Figure out where out binaries are
if "BBP_DIR" in os.environ:
install_root = os.path.normpath(os.environ["BBP_DIR"])
else:
raise bband_utils.ProcessingError("BBP_DIR is not set!")
gp_bin_dir = os.path.join(install_root, "src", "gp", "bin")
# Get realizations
realizations = sorted(os.listdir(input_indir))
one_realization = realizations[0]
basedir = os.path.join(input_indir, one_realization)
# Get the station list
a_statfile = glob.glob("%s%s*.stl" % (basedir, os.sep))
if len(a_statfile) != 1:
raise bband_utils.ProcessingError("Cannot get station list!")
a_statfile = a_statfile[0]
slo = StationList(a_statfile)
site_list = slo.getStationList()
# Get source file
a_srcfile = glob.glob("%s%s*.src" % (basedir, os.sep))
if len(a_srcfile) == 0:
raise bband_utils.ProcessingError("Cannot get src file!")
a_srcfile = a_srcfile[0]
# Parse it!
src_keys = bband_utils.parse_src_file(a_srcfile)
# Get the obsdir
realizations = sorted(os.listdir(input_obsdir))
one_realization = realizations[0]
basedir = os.path.join(input_obsdir, one_realization)
obs_dir = glob.glob("%s%sobs_seis*" % (basedir, os.sep))
if len(obs_dir) != 1:
raise bband_utils.ProcessingError("Cannot get observation dir!")
obs_dir = obs_dir[0]
# Go through all stations
for site in site_list:
slon = float(site.lon)
slat = float(site.lat)
stat = site.scode
# Calculate Rrup
origin = (src_keys['lon_top_center'], src_keys['lat_top_center'])
dims = (src_keys['fault_length'], src_keys['dlen'],
src_keys['fault_width'], src_keys['dwid'],
src_keys['depth_to_top'])
mech = (src_keys['strike'], src_keys['dip'], src_keys['rake'])
site_geom = [float(site.lon), float(site.lat), 0.0]
(fault_trace1, up_seis_depth, low_seis_depth, ave_dip, dummy1,
dummy2) = putils.FaultTraceGen(origin, dims, mech)
_, rrup, _ = putils.DistanceToSimpleFaultSurface(
site_geom, fault_trace1, up_seis_depth, low_seis_depth, ave_dip)
simfile1 = os.path.join(temp_dir, "%s.rd50" % (stat))
datafile1 = os.path.join(obs_dir, "%s.rd50" % (stat))
cmd = ("%s bbp_format=1 " %
(os.path.join(gp_bin_dir, "gen_resid_tbl_3comp")) +
"datafile1=%s simfile1=%s " % (datafile1, simfile1) +
"comp1=psa5n comp2=psa5e comp3=rotd50 " +
"eqname=%s mag=0.0 stat=%s lon=%.4f lat=%.4f " %
(comp_label, stat, slon, slat) + "vs30=%d cd=%.2f " %
(site.vs30, rrup) + "flo=%f fhi=%f " %
(site.low_freq_corner, site.high_freq_corner) +
"print_header=%d >> %s 2>> %s" %
(copy_header, combined_file, logfile))
bband_utils.runprog(cmd, abort_on_error=True)
if copy_header == 1:
copy_header = 0
def exsim2bbp(in_exsim_n, in_exsim_e, in_exsim_z, out_bbp_file):
"""
Converts 3 exsim acc format files into 3 component bbp file.
Assumes all three files are for the same site.
"""
n_vals = []
e_vals = []
z_vals = []
header_lines = []
dt_vals = []
pfn = open(in_exsim_n, "r")
lines_n = pfn.readlines()
pfn.close()
pfe = open(in_exsim_e, "r")
lines_e = pfe.readlines()
pfe.close()
pfz = open(in_exsim_z, "r")
lines_z = pfz.readlines()
pfz.close()
#
# Test for empty input file and return error if found
if len(lines_n) < 1:
raise bband_utils.ProcessingError("Input file %s is empty!" %
(in_exsim_n))
elif len(lines_e) != len(lines_n):
raise bband_utils.ProcessingError("N and E peer files do not have "
"same number of lines!")
elif len(lines_z) != len(lines_n):
raise bband_utils.ProcessingError("N and Z peer files do not have "
"same number of lines!")
else:
print("Input EXSIM-format seismogram files with len: %d" %
(len(lines_n)))
pts = 0
dt = 0.0
start_line = 0
start_samples = False
while not start_samples:
for line in lines_n:
start_line = start_line + 1
elems = line.split()
if len(elems) == 2 and elems[1] == "samples":
pts = int(elems[0])
elif len(elems) >= 2 and elems[0] == "dt:":
dt = float(elems[1])
elif len(elems) >= 2 and elems[0] == "time(s)":
start_samples = True
break
else:
header_lines.append(line)
if not start_samples:
print("No samples found in peer file: " + in_exsim_n)
sys.exit(0)
else:
print("starting line: %d" % (start_line))
print("Reading Seismogram with NPTS: %d and DT: %f" % (pts, dt))
cur_line = 0
for line in lines_n:
cur_line = cur_line + 1
if cur_line > start_line:
vals = line.split()
n_vals.append(float(vals[1]))
cur_line = 0
for line in lines_e:
cur_line = cur_line + 1
if cur_line > start_line:
vals = line.split()
e_vals.append(float(vals[1]))
cur_line = 0
for line in lines_z:
cur_line = cur_line + 1
if cur_line > start_line:
vals = line.split()
z_vals.append(float(vals[1]))
#
# Populate the dt values for bbp format
# Use number of pts in time series as counter
#
dt_val = dt
pts_count = len(n_vals)
#
# Define the first sample at time dt
cur_dt = 0.0
for x in range(pts_count):
dt_vals.append(cur_dt)
cur_dt = cur_dt + dt_val
#
#
if len(dt_vals) == pts_count:
print("Read format consistent time series with %d samples." %
(len(dt_vals)))
else:
print("Inconsistent time series: %d %d" % (len(dt_vals), pts_count))
#
# Print bbp file
#
bbp_file = open(out_bbp_file, "w")
# Print header
bbp_file.write(
"# time(sec) N-S(cm/s/s) E-W(cm/s/s) U-D(cm/s/s)\n")
#for line in header_lines:
# bbp_file.write("# %s" % (line))
# bbp_file.write("# Column 1: Time (s)\n")
# bbp_file.write("# Column 2: North-south acceleration (cm/s/s) (+ is northward)\n")
# bbp_file.write("# Column 3: East-west acceleration (cm/s/s) (+ is eastward)\n")
# bbp_file.write("# Column 4: Up-down acceleration (cm/s/s) (+ is upward)\n#\n")
# bbp_file.write("# NPTS DT \n")
# bbp_file.write("# %d %s\n" % (pts_count, dt))
for x in range(pts_count):
bbp_file.write("%7e % 8e % 8e % 8e\n" %
(dt_vals[x], n_vals[x], e_vals[x], z_vals[x]))
bbp_file.close()
def peer2bbp(in_peer_n_file, in_peer_e_file, in_peer_z_file, out_bbp_file):
"""
This function converts the 3 input peer files (N/E/Z) to a
3-component bbp file
"""
n_vals = []
e_vals = []
z_vals = []
header_lines = []
dt_vals = []
start_line = 0
start_samples = False
# Read input files
pfn = open(in_peer_n_file, "r")
lines_n = pfn.readlines()
pfn.close()
pfe = open(in_peer_e_file, "r")
lines_e = pfe.readlines()
pfe.close()
pfz = open(in_peer_z_file, "r")
lines_z = pfz.readlines()
pfz.close()
#
# Test for empty input file and return error if found
if len(lines_n) < 1:
raise bband_utils.ProcessingError("Input file %s is empty!" %
(in_peer_n_file))
elif len(lines_e) != len(lines_n):
raise bband_utils.ProcessingError("N and E peer files do not have "
"same number of lines!")
elif len(lines_z) != len(lines_n):
raise bband_utils.ProcessingError("N and Z peer files do not have "
"same number of lines!")
else:
pass
#print("Input PEER-format seismogram files with len: %d" %
# (len(lines_n)))
while not start_samples:
for line in lines_n:
start_line = start_line + 1
elems = line.split()
if len(elems) > 0:
if elems[0] == "ACCELERATION" or elems[0] == 'Acceleration':
start_samples = True
break
header_lines.append(line)
if not start_samples:
raise bband_utils.ProcessingError("No samples found in peer file: %s" %
(in_peer_n_file))
else:
#print "starting line: %d"%(start_line)
cur_line = 0
pts = 0
dt = 0.0
for line in lines_n:
cur_line = cur_line + 1
if cur_line == start_line + 1:
pts_dt = line.split()
pts = float(pts_dt[0])
dt = float(pts_dt[1])
#print("Reading Seismogram with NPTS: %d and DT: %f" %
# (pts, dt))
elif cur_line > start_line + 1:
vals = line.split()
for x in vals:
n_vals.append(float(x) * bband_utils.G2CMSS)
else:
# This block will skip the header lines use
# ACCELERATION TAG as starting key
pass
cur_line = 0
for line in lines_e:
cur_line = cur_line + 1
if cur_line > start_line + 1:
vals = line.split()
for y in vals:
e_vals.append(float(y) * bband_utils.G2CMSS)
else:
# Skip header lines
pass
cur_line = 0
for line in lines_z:
cur_line = cur_line + 1
if cur_line > start_line + 1:
vals = line.split()
for z in vals:
z_vals.append(float(z) * bband_utils.G2CMSS)
else:
# Skip header lines
pass
#
# Populate the dt values for bbp format
# Use number of pts in time series as counter
#
dt_val = float(dt)
pts_count = len(n_vals)
#
# Define the first sample at time dt
cur_dt = 0.0
for x in range(pts_count):
dt_vals.append(cur_dt)
cur_dt = cur_dt + dt_val
#
#
if len(dt_vals) == pts_count:
pass
#print("Read format consistent time series with %d samples." %
# (len(dt_vals)))
else:
print("Inconsistent time series: %d %d" % (len(dt_vals), pts_count))
#
# Print files in bbp
#
# Open file
bbp_file = open(out_bbp_file, "w")
# Write header
bbp_file.write(
"# time(sec) N-S(cm/s/s) E-W(cm/s/s) U-D(cm/s/s)\n")
# for line in header_lines:
# bbp_file.write("# %s" % (line))
# bbp_file.write("# Column 1: Time (s)\n")
# bbp_file.write("# Column 2: North-south acceleration (cm/s/s) (+ is northward)\n")
# bbp_file.write("# Column 3: East-west acceleration (cm/s/s) (+ is eastward)\n")
# bbp_file.write("# Column 4: Up-down acceleration (cm/s/s) (+ is upward)\n#\n")
# bbp_file.write("# NPTS DT \n")
# bbp_file.write("# %d %s\n" % (pts_count, dt))
# Write the data
for x in range(pts_count):
bbp_file.write("%7e % 8e % 8e % 8e\n" %
(dt_vals[x], n_vals[x], e_vals[x], z_vals[x]))
# Lastly, close the file
bbp_file.close()
def plot_combined_map_gof(indir, tmpdir, outdir, codebase):
"""
This function reads data from the residuals files from multiple
realizations and plots a map gof plot with a number of periods.
"""
# Capture number of realizations and event label
num_realizations = len(os.listdir(tmpdir))
basedir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
resid_file = glob.glob("%s%s*-resid-map*rotd50.txt" % (basedir, os.sep))[0]
event_label = os.path.basename(resid_file).split("-")[0]
# Get one trace file
basedir = os.path.join(indir, os.listdir(indir)[0])
trace_file = glob.glob("%s%s*.trace" % (basedir, os.sep))[0]
# Now get the SRC (or SRF file) in order to get the hypocenter
# location. Note that this function will look for the hypocenter
# location from the first realization. If the simulation was
# created using randomized hypocenter locations, the plot will
# only display the location of the hypocenter from the first
# realization.
src_file = glob.glob("%s%s*.src" % (basedir, os.sep))
if not len(src_file):
srf_file = glob.glob("%s%s*.srf" % (basedir, os.sep))
if not len(srf_file):
raise bband_utils.ProcessingError("Cannot find SRC/SRF file!")
source_file = srf_file[0]
else:
source_file = src_file[0]
# Get hypo_lon, hypo_lat from src/srf file
hypo_lon, hypo_lat = fault_utils.calculate_epicenter(source_file)
# Collect all the data from the residuals file
all_sta_x_data = []
all_sta_y_data = []
all_sta_resid_data = []
for period in DIST_PERIODS:
(sta_x_data, sta_y_data,
sta_resid_data) = combine_realization_data(tmpdir, period)
all_sta_x_data.append(sta_x_data)
all_sta_y_data.append(sta_y_data)
all_sta_resid_data.append(sta_resid_data)
# Get plot boundaries
(north, south, east,
west) = set_boundaries_from_lon_lat(all_sta_x_data[0], all_sta_y_data[0])
# Get directory names
install = InstallCfg.getInstance()
# Prepare to plot map GOF
plotregion = [west, east, south, north]
topo = os.path.join(install.A_PLOT_DATA_DIR, 'calTopo18.bf')
coastal = os.path.join(install.A_PLOT_DATA_DIR, 'gshhs_h.txt')
border = os.path.join(install.A_PLOT_DATA_DIR, 'wdb_borders_h.txt')
# Now create the map GOF
outfile = os.path.join(
outdir, "gof-map-combined-%s-%s-rotd50.png" % (codebase, event_label))
create_combined_map_gof(all_sta_x_data,
all_sta_y_data,
all_sta_resid_data,
plotregion,
topo,
coastal,
border,
trace_file,
event_label,
num_realizations,
codebase,
outfile,
hypo_lat=hypo_lat,
hypo_lon=hypo_lon)
def load_all_data(comp_label, input_indir, input_obsdir, combined_file,
temp_dir, component):
"""
This function loads all data from each station file
and creates the structures needed for plotting.
"""
data = {}
# Get realizations
realizations = sorted(os.listdir(input_indir))
one_realization = realizations[0]
basedir = os.path.join(input_indir, one_realization)
# Get the GMPE data for the RZZ2015 metrics
base_outdir = os.path.join(input_obsdir, one_realization, "validations",
"rzz2015_gmpe")
a_rzz2015_gmpe = glob.glob("%s%s%s.rzz2015gmpe.txt" %
(base_outdir, os.sep, one_realization))
a_rzz2015_gmpe = a_rzz2015_gmpe[0]
# Get the station list
a_statfile = glob.glob("%s%s*.stl" % (basedir, os.sep))
if len(a_statfile) != 1:
raise bband_utils.ProcessingError("Cannot get station list!")
a_statfile = a_statfile[0]
slo = StationList(a_statfile)
site_list = slo.getStationList()
# Get source file
a_srcfile = glob.glob("%s%s*.src" % (basedir, os.sep))
if len(a_srcfile) != 1:
raise bband_utils.ProcessingError("Cannot get src file!")
a_srcfile = a_srcfile[0]
# Parse it!
src_keys = bband_utils.parse_src_file(a_srcfile)
# Go through all stations
for site in site_list:
slon = float(site.lon)
slat = float(site.lat)
stat = site.scode
# Calculate Rrup
origin = (src_keys['lon_top_center'], src_keys['lat_top_center'])
dims = (src_keys['fault_length'], src_keys['dlen'],
src_keys['fault_width'], src_keys['dwid'],
src_keys['depth_to_top'])
mech = (src_keys['strike'], src_keys['dip'], src_keys['rake'])
site_geom = [float(site.lon), float(site.lat), 0.0]
(fault_trace1, up_seis_depth, low_seis_depth, ave_dip, dummy1,
dummy2) = putils.FaultTraceGen(origin, dims, mech)
_, rrup, _ = putils.DistanceToSimpleFaultSurface(
site_geom, fault_trace1, up_seis_depth, low_seis_depth, ave_dip)
# Read data for this station
data_file = os.path.join(temp_dir, "%s.rzz2015" % (stat))
data[stat] = {}
data[stat]["dist"] = rrup
data[stat]["r1"] = []
data[stat]["r2"] = []
data[stat]["r3"] = []
data[stat]["r4"] = []
data[stat]["r5"] = []
data[stat]["r1_obs"] = None
data[stat]["r2_obs"] = None
data[stat]["r3_obs"] = None
data[stat]["r4_obs"] = None
data[stat]["r5_obs"] = None
data[stat]["r1_gmpe"] = None
data[stat]["r2_gmpe"] = None
data[stat]["r3_gmpe"] = None
data[stat]["r4_gmpe"] = None
data[stat]["r5_gmpe"] = None
in_file = open(data_file, 'r')
for line in in_file:
line = line.strip()
if line.startswith("#"):
# Skip comments
continue
pieces = line.split(",")
comp = pieces[1].strip()
# Check if we want this component
if component != "both":
if comp != component:
# Skip
continue
# We want this data point
pieces = pieces[2:]
pieces = [float(piece) for piece in pieces]
# Get observation values
if data[stat]["r1_obs"] is None:
data[stat]["r1_obs"] = pieces[6]
if data[stat]["r2_obs"] is None:
data[stat]["r2_obs"] = pieces[8]
if data[stat]["r3_obs"] is None:
data[stat]["r3_obs"] = pieces[10]
if data[stat]["r4_obs"] is None:
data[stat]["r4_obs"] = pieces[12]
if data[stat]["r5_obs"] is None:
data[stat]["r5_obs"] = pieces[14]
# Get simulated data values
data[stat]["r1"].append(pieces[7])
data[stat]["r2"].append(pieces[9])
data[stat]["r3"].append(pieces[11])
data[stat]["r4"].append(pieces[13])
data[stat]["r5"].append(pieces[15])
in_file.close()
gmpe_file = open(a_rzz2015_gmpe, 'r')
for line in gmpe_file:
line = line.strip()
# Skip comments
if line.startswith("#"):
continue
pieces = line.split(",")
stat = pieces[0].strip()
pieces = pieces[1:]
pieces = [float(piece.strip()) for piece in pieces]
data[stat]["r1_gmpe"] = pieces[2]
data[stat]["r2_gmpe"] = pieces[3]
data[stat]["r3_gmpe"] = pieces[2] / pieces[3]
data[stat]["r4_gmpe"] = pieces[5]
data[stat]["r5_gmpe"] = pieces[6]
gmpe_file.close()
# Return all data
return data
def read_srf(self, srffile):
if os.path.exists(srffile):
srff = open(srffile, 'r')
else:
raise bband_utils.ParameterError("Missing SRF file (%s)!" %
(srffile))
# Check number of planes
version = float(srff.readline().strip().split()[0])
tokens = srff.readline().strip().split()
# Make sure we have a valid SRF file
if len(tokens) != 2:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srffile))
planes = int(tokens[1])
# Make sure we have only 1 plane
if planes > 1:
raise bband_utils.ProcessingError("Only one plane is supported!" +
" Found %d planes in SRF file!" %
(planes))
# Read Fault Data
tokens = srff.readline().strip().split()
if len(tokens) != 6:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srffile))
self.f_len = float(tokens[4])
self.f_width = float(tokens[5])
tokens = srff.readline().strip().split()
if len(tokens) != 5:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srffile))
self.f_strike = float(tokens[0])
self.f_dip = float(tokens[1])
self.f_depth = float(tokens[2])
tokens = srff.readline().strip().split()
if len(tokens) != 2:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srffile))
n_cels = int(tokens[1])
# print ("F_len: %f, F_width: %f, F_Strike: %f" %
# (self.f_len, self.f_width, self.f_strike))
# print ("F_dip: %f, F_depth: %f, n_cells: %d" %
# (self.f_dip, self.f_depth, n_cels))
M0 = 0.0
lon = []
lat = []
dep = []
tinit = []
rake = []
for i in range(0, n_cels):
tokens = srff.readline().strip().split()
if version == 1.0 and len(tokens) != 8:
raise bband_utils.ProcessingError("Invalid SRF version 1 "
"file (%s)!" % (srffile))
if version == 2.0 and len(tokens) != 10:
raise bband_utils.ProcessingError("Invalid SRF version 2 "
"file (%s)!" % (srffile))
lon.append(float(tokens[0]))
lat.append(float(tokens[1]))
dep.append(float(tokens[2]))
area = float(tokens[5])
tinit.append(float(tokens[6]))
tokens = srff.readline().strip().split()
if len(tokens) != 7:
raise bband_utils.ProcessingError("Invalid SRF file (%s)!" %
(srffile))
rake.append(float(tokens[0]))
slip1 = float(tokens[1])
slip2 = float(tokens[3])
slip3 = float(tokens[5])
nt1 = float(tokens[2])
nt2 = float(tokens[4])
nt3 = float(tokens[6])
if nt1 > 0:
for k in range(0, int(math.ceil(nt1 / 6.0))):
token = srff.readline()
if token == "":
raise bband_utils.ProcessingError("Invalid SRF "
"file (%s)!" %
(srffile))
if nt2 > 0:
for k in range(0, int(math.ceil(nt2 / 6.0))):
token = srff.readline()
if token == "":
raise bband_utils.ProcessingError("Invalid SRF "
"file (%s)!" %
(srffile))
if nt3 > 0:
for k in range(0, int(math.ceil(nt3 / 6.0))):
token = srff.readline()
if token == "":
raise bband_utils.ProcessingError("Invalid SRF "
"file (%s)!" %
(srffile))
M0 = M0 + (area * (math.sqrt(slip1**2 + slip2**2 + slip3**2)) *
3) * (10**11)
srff.close()
np_tinit = np.array(tinit)
tinit_index = []
[tinit_index] = np.nonzero(np_tinit == np.min(np_tinit))
# Find hypocenter
hyp = []
hyp.append(lon[tinit_index[0]])
hyp.append(lat[tinit_index[0]])
hyp.append(dep[tinit_index[0]])
self.hyp = hyp
# Find mw
mw = (math.log10(M0)) / 1.5 - 10.73
self.mw = mw
# Find rake (i.e. mechanism)
rake_ave = np.mean(np.array(rake))
self.rake = rake_ave
if rake_ave > 45 and rake_ave < 135:
mecha = 'rs'
if rake_ave >= 135 and rake_ave < 225:
mecha = 'ss'
if rake_ave >= 225 and rake_ave < 315:
mecha = 'ns'
if rake_ave <= 45 or rake_ave >= 315:
mecha = 'ss'
self.mecha = mecha
# print "mw: %f, rake_ave: %f, mecha:%s"%(mw, rake_ave, mecha)
if self.extended == 'y':
# Find fault corners
i = []
j = []
k = []
np_dep = np.array(dep)
# print np.min(np_dep), len(np_dep)
[i] = np.nonzero(np_dep == min(dep))
if len(i) < 1:
raise bband_utils.ProcessingError("Invalid SRF file: %s\n" %
(srffile) +
"len(i)=%d Failed to " %
len(i) + "calculate " +
"extended fault data!")
np_lon = np.array(lon)
[j] = np.nonzero(np_lon[i] == np.min(np_lon[i]))
if len(j) < 1:
raise bband_utils.ProcessingError("Invalid SRF file: %s\n" %
(srffile) +
"len(j)=%d Failed to " %
len(j) + "calculate " +
"extended fault data!")
np_lat = np.array(lat)
[k] = np.nonzero(np_lat[j] == np.min(np_lat[j]))
if len(k) == 1:
lat_index = k[0]
self.corn = [lon[lat_index], lat[lat_index]]
# print "Corner:", self.corn
else:
raise bband_utils.ProcessingError("Invalid SRF file: %s\n" %
(srffile) +
"len(k)=%d Failed to " %
len(k) + "calculate " +
"extended fault data!")
self.fault_maxlon = np.max(np_lon)
self.fault_minlon = np.min(np_lon)
self.fault_maxlat = np.max(np_lat)
self.fault_minlat = np.min(np_lat)
#print ("fault_maxlon: %f, fault_minlon: %f, fault_maxlat: %f, " %
# (self.fault_maxlon,self.fault_minlon,self.fault_maxlat) +
# "fault_minlat: %f" % (self.fault_minlat))
# par.mw = mw; par.mecha = mecha;
return 0
