def calculate_distances(src_files, site): """ Calculate Rrup, Rjb, Rx using multiple SRC files """ rrup = 10000000 rjb = 10000000 rx = 10000000 for src_file in src_files: src_keys = bband_utils.parse_src_file(src_file) 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) my_rjb, my_rrup, my_rx = putils.DistanceToSimpleFaultSurface( site_geom, fault_trace1, up_seis_depth, low_seis_depth, ave_dip) rjb = min(my_rjb, rjb) rrup = min(my_rrup, rrup) rx = min(my_rx, rx) return rrup, rjb, rx
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
a_rd50file2 = os.path.join(a_outdir2, "%d.%s.rd50" % (sim_id_2, stat)) if not os.path.exists(a_rd50file1) or not os.path.exists(a_rd50file2): # Just skip it print "Skipping station %s..." % (stat) continue # 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) bband_utils.check_path_lengths([a_rd50file1, a_rd50file2, resid_file], bband_utils.GP_MAX_FILENAME) cmd = ("%s/gen_resid_tbl_3comp bbp_format=1 " % (install.A_GP_BIN_DIR) + "datafile1=%s simfile1=%s " % (a_rd50file1, a_rd50file2) + "comp1=psa5n comp2=psa5e comp3=rotd50 " + "eqname=%s mag=%s stat=%s lon=%.4f lat=%.4f " % (event_label, src_keys['magnitude'], 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" % (print_header_rd50, resid_file, log_file))
def run(self): """ Runs the GMPEs for the six parameters in Rezaeian (2015) """ print("RZZ2015 GMPE".center(80, '-')) # Load configuration, set sim_id install = InstallCfg.getInstance() sim_id = self.sim_id # Build directory paths a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_logdir = os.path.join(install.A_OUT_LOG_DIR, str(sim_id)) a_validation_outdir = os.path.join(a_outdir, "validations", "rzz2015_gmpe") # Make sure the output and tmp directories exist bband_utils.mkdirs([a_tmpdir, a_indir, a_outdir, a_validation_outdir], print_cmd=False) # Source file, parse it! a_srcfile = os.path.join(a_indir, self.srcfile) self.src_keys = bband_utils.parse_src_file(a_srcfile) # Now the file paths self.log = os.path.join(a_logdir, "%d.rzz2015gmpe.log" % (sim_id)) sta_file = os.path.join(a_indir, self.stations) # Get station list slo = StationList(sta_file) site_list = slo.getStationList() # Initialize random seed np.random.seed(int(self.src_keys['seed'])) # Create output file, add header out_file = open( os.path.join(a_validation_outdir, '%d.rzz2015gmpe.txt' % (self.sim_id)), 'w') out_file.write("#station, r_rup, vs_30," " ai_mean, d595_mean, tmid_mean," " wmid_mean, wslp_mean, zeta_mean," " ai_stddev, d595_stddev, tmid_stddev," " wmid_stddev, wslp_stddev, zeta_stddev\n") # Go through each station for site in site_list: stat = site.scode print("==> Processing station: %s" % (stat)) # Calculate Rrup origin = (self.src_keys['lon_top_center'], self.src_keys['lat_top_center']) dims = (self.src_keys['fault_length'], self.src_keys['dlen'], self.src_keys['fault_width'], self.src_keys['dwid'], self.src_keys['depth_to_top']) mech = (self.src_keys['strike'], self.src_keys['dip'], self.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) vs30 = site.vs30 mag = self.src_keys['magnitude'] # Fault type is 1 (Reverse) unless condition below is met # Then it is 0 (Strike-pp) fault_type = 1 rake = self.src_keys['rake'] if ((rake >= -180 and rake < -150) or (rake >= -30 and rake <= 30) or (rake > 150 and rake <= 180)): fault_type = 0 #rrup = 13.94 #fault_type = 1 #vs30 = 659.6 #mag = 7.35 [ai_mean, d595_mean, tmid_mean, wmid_mean, wslp_mean, zeta_mean] = self.calculate_mean_values(rrup, vs30, mag, fault_type) # Randomize parameters using standard deviations and correlations sta_ai = [] sta_d595 = [] sta_tmid = [] sta_wmid = [] sta_wslp = [] sta_zeta = [] # Simulate number_of_samples realizations of the error # term for each parameter for _ in range(0, self.number_of_samples): # Simulate zero-mean normal correlated parameters with # stdv = sqrt(sigmai^2+taui^2) # totalerror = eps+etha=[eps1+etha1 eps2+etha2 eps3+etha3 eps4+etha4 # eps5+etha5 eps6+etha6] # mean error vector # m_totalerror = [0, 0, 0, 0, 0, 0] # Covariance matrix std1 = np.sqrt(self.sigma1**2 + self.tau1**2) std2 = np.sqrt(self.sigma2**2 + self.tau2**2) std3 = np.sqrt(self.sigma3**2 + self.tau3**2) std4 = np.sqrt(self.sigma4**2 + self.tau4**2) std5 = np.sqrt(self.sigma5**2 + self.tau5**2) std6 = np.sqrt(self.sigma6**2 + self.tau6**2) s_total_error = [ [ std1**2, std1 * std2 * self.rho_totalerror[0][1], std1 * std3 * self.rho_totalerror[0][2], std1 * std4 * self.rho_totalerror[0][3], std1 * std5 * self.rho_totalerror[0][4], std1 * std6 * self.rho_totalerror[0][5] ], [ std2 * std1 * self.rho_totalerror[1][0], std2**2, std2 * std3 * self.rho_totalerror[1][2], std2 * std4 * self.rho_totalerror[1][3], std2 * std5 * self.rho_totalerror[1][4], std2 * std6 * self.rho_totalerror[1][5] ], [ std3 * std1 * self.rho_totalerror[2][0], std3 * std2 * self.rho_totalerror[2][1], std3**2, std3 * std4 * self.rho_totalerror[2][3], std3 * std5 * self.rho_totalerror[2][4], std3 * std6 * self.rho_totalerror[2][5] ], [ std4 * std1 * self.rho_totalerror[3][0], std4 * std2 * self.rho_totalerror[3][1], std4 * std3 * self.rho_totalerror[3][2], std4**2, std4 * std5 * self.rho_totalerror[3][4], std4 * std6 * self.rho_totalerror[3][5] ], [ std5 * std1 * self.rho_totalerror[4][0], std5 * std2 * self.rho_totalerror[4][1], std5 * std3 * self.rho_totalerror[4][2], std5 * std4 * self.rho_totalerror[4][3], std5**2, std5 * std6 * self.rho_totalerror[4][5] ], [ std6 * std1 * self.rho_totalerror[5][0], std6 * std2 * self.rho_totalerror[5][1], std6 * std3 * self.rho_totalerror[5][2], std6 * std4 * self.rho_totalerror[5][3], std6 * std5 * self.rho_totalerror[5][4], std6**2 ] ] # Matlab returns upper-triangular while Python returns # lower-triangular by default -- no need to transpose later! r_total_error = np.linalg.cholesky(s_total_error) y_total_error = np.random.normal(0, 1, 6) total_error = np.dot(r_total_error, y_total_error) # Generate randomize parameters in the standardnormal space: ui u1 = (self.beta1[0] + self.beta1[1] * (mag / 7.0) + self.beta1[2] * fault_type + self.beta1[3] * math.log(rrup / 25.0) + self.beta1[4] * math.log(vs30 / 750.0)) + total_error[0] u2 = (self.beta2[0] + self.beta2[1] * mag + self.beta2[2] * fault_type + self.beta2[3] * rrup + self.beta2[4] * vs30) + total_error[1] u3 = (self.beta3[0] + self.beta3[1] * mag + self.beta3[2] * fault_type + self.beta3[3] * rrup + self.beta3[4] * vs30) + total_error[2] u4 = (self.beta4[0] + self.beta4[1] * mag + self.beta4[2] * fault_type + self.beta4[3] * rrup + self.beta4[4] * vs30) + total_error[3] u5 = (self.beta5[0] + self.beta5[1] * mag + self.beta5[2] * fault_type + self.beta5[3] * rrup + self.beta5[4] * vs30) + total_error[4] u6 = (self.beta6[0] + self.beta6[1] * mag + self.beta6[2] * fault_type + self.beta6[3] * rrup + self.beta6[4] * vs30) + total_error[5] # Transform parameters ui from standardnormal to the physical space: # thetai (constraint: tmid < d_5_95, removed) theta1 = norm.ppf(norm.cdf(u1), -4.8255, 1.4318) theta2 = 5.0 + (45 - 5) * beta.ppf(norm.cdf(u2), 1.1314, 2.4474) theta3 = 0.5 + (40 - 0.5) * beta.ppf(norm.cdf(u3), 1.5792, 3.6405) theta4 = gamma.ppf(norm.cdf(u4), 4.0982, scale=1.4330) theta5 = self.slpinv(norm.cdf(u5), 17.095, 6.7729, 4.8512, -2, 0.5) theta6 = 0.02 + (1 - 0.02) * beta.ppf(norm.cdf(u6), 1.4250, 5.7208) sta_ai.append(math.exp(theta1)) sta_d595.append(theta2) sta_tmid.append(theta3) sta_wmid.append(theta4) sta_wslp.append(theta5) sta_zeta.append(theta6) # Write output to gmpe file out_file.write( "%s, %7.4f, %7.2f, " % (stat, rrup, vs30) + "%7.4f, %7.4f, %7.4f, %7.4f, %7.4f, %7.4f, " % (ai_mean, d595_mean, tmid_mean, wmid_mean, wslp_mean, zeta_mean) + "%7.4f, %7.4f, %7.4f, %7.4f, %7.4f, %7.4f\n" % (np.std(sta_ai), np.std(sta_d595), np.std(sta_tmid), np.std(sta_wmid), np.std(sta_wslp), np.std(sta_zeta))) ## Write output to file #sta_out_file = open(os.path.join(a_validation_outdir, # '%d.rzz2015gmpe.%s.txt' % # (self.sim_id, stat)), 'w') #sta_out_file.write("#ai(s.g^2), d595(s), tmid(s), " # "wmid(Hz), wslp(Hz/sec), zeta(ratio)\n") #for ai, d595, tmid, wmid, wslp, zeta in zip(sta_ai, sta_d595, # sta_tmid, sta_wmid, # sta_wslp, sta_zeta): # sta_out_file.write("%7.4f, %7.4f, %7.4f, %7.4f, %7.4f, %7.4f\n" % # (ai, d595, tmid, wmid, wslp, zeta)) #sta_out_file.close() # Generate Plots self.plot(stat, a_validation_outdir, rrup, fault_type, vs30, mag, sta_ai, sta_d595, sta_tmid, sta_wmid, sta_wslp, sta_zeta, ai_mean, d595_mean, tmid_mean, wmid_mean, wslp_mean, zeta_mean) # Close output file out_file.close() print("RZZ2015 GMPE Completed".center(80, '-'))
def run(self): """ This function in the main entry point for this module. It runs the gp_gof component. """ print("GP GoF".center(80, '-')) # Initialize basic variables self.install = InstallCfg.getInstance() self.config = GPGofCfg() install = self.install config = self.config sim_id = self.sim_id sta_base = os.path.basename(os.path.splitext(self.r_stations)[0]) self.log = os.path.join(install.A_OUT_LOG_DIR, str(sim_id), "%d.gp_gof.log" % (sim_id)) # Input, tmp, and output directories a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_outdir_seis = os.path.join(install.A_OUT_DATA_DIR, str(sim_id), "obs_seis_%s" % (sta_base)) a_outdir_gmpe = os.path.join(install.A_OUT_DATA_DIR, str(sim_id), "gmpe_data_%s" % (sta_base)) # Source file, parse it! a_srcfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_srcfile) self.src_keys = bband_utils.parse_src_file(a_srcfile) # Station file a_statfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_stations) # List of observed seismogram files filelist = os.listdir(a_outdir_seis) slo = StationList(a_statfile) site_list = slo.getStationList() # check cutoff value if self.max_cutoff is None: self.max_cutoff = config.MAX_CDST print_header_rd50 = 1 # Remove rd50 resid file rd50_resid_output = os.path.join(a_outdir, "%s-%d.rd50-resid.txt" % (self.comp_label, sim_id)) if os.path.exists(rd50_resid_output): os.remove(rd50_resid_output) for site in site_list: slon = float(site.lon) slat = float(site.lat) stat = site.scode # Now process rd50 files expected_rd50_file = os.path.join(a_outdir, "%d.%s.rd50" % (sim_id, stat)) if not os.path.exists(expected_rd50_file): # just skip it print("Skipping rotd50/psa5 for station %s..." % (stat)) continue # See if the rd50 file exist for comparison. If it doesn't # exist, skip this station rd50_file = None if ("%s.rd50" % (stat)) in filelist: rd50_file = "%s.rd50" % (stat) else: # Skip this station continue # Calculate Rrup origin = (self.src_keys['lon_top_center'], self.src_keys['lat_top_center']) dims = (self.src_keys['fault_length'], self.src_keys['dlen'], self.src_keys['fault_width'], self.src_keys['dwid'], self.src_keys['depth_to_top']) mech = (self.src_keys['strike'], self.src_keys['dip'], self.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) # Create path names and check if their sizes are within bounds datafile1 = os.path.join(a_outdir_seis, rd50_file) simfile1 = os.path.join(a_outdir, "%d.%s.rd50" % (sim_id, stat)) outfile = os.path.join(a_outdir, "%s-%d.rd50-resid.txt" % (self.comp_label, self.sim_id)) bband_utils.check_path_lengths([datafile1, simfile1, outfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/gen_resid_tbl_3comp bbp_format=1 " % (install.A_GP_BIN_DIR) + "datafile1=%s simfile1=%s " % (datafile1, simfile1) + "comp1=psa5n comp2=psa5e comp3=rotd50 " + "eqname=%s mag=%s stat=%s lon=%.4f lat=%.4f " % (self.comp_label, self.mag, 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" % (print_header_rd50, outfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Only need to print header the first time if print_header_rd50 == 1: print_header_rd50 = 0 # Finished per station processing, now summarize and plot the data if os.path.exists(rd50_resid_output): self.summarize_rotd50(site_list, a_outdir, a_outdir_gmpe) print("GP GoF Completed".center(80, '-'))
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 calculate_residuals(self, station, gmpe_model, gmpe_data, obs_periods, obs_data, resid_file, print_headers): """ This function calculates the residuals for the gmpe data versus the obs_data, and outputs the results to the resid_file """ # Get gmpe periods gmpe_periods = [points[0] for points in gmpe_data] # Find common set period_set = sorted(list(set(gmpe_periods).intersection(obs_periods))) # Create new index arrays for observations and gmpes gmpe_items = [] obs_items = [] for period in period_set: gmpe_items.append(gmpe_periods.index(period)) obs_items.append(obs_periods.index(period)) # Get gmpe data array gmpe_group = gmpe_config.GMPES[self.gmpe_group_name] index = gmpe_group["models"].index(gmpe_model) res1 = [points[1][index] for points in gmpe_data] # Update gmpe_data, and obs_data arrays gmpe_points = [] obs_points = [] for item1, item2 in zip(gmpe_items, obs_items): gmpe_points.append(res1[item1]) obs_points.append(obs_data[item2]) # Calculate residuals for idx in range(0, len(obs_points)): if gmpe_points[idx] != 0.0: gmpe_points[idx] = math.log(obs_points[idx] / gmpe_points[idx]) else: gmpe_points[idx] = -99 # Now, output to file if print_headers: outf = open(resid_file, 'w') outf.write( "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s" % ("EQ", "Mag", "stat", "lon", "lat", "stat_seq_no", "Vs30", "close_dist", "Xcos", "Ycos", "T_min", "T_max", "comp")) for period in period_set: outf.write("\t%.5e" % (period)) outf.write("\n") else: outf = open(resid_file, 'a') # Calculate Rrup origin = (self.src_keys['lon_top_center'], self.src_keys['lat_top_center']) dims = (self.src_keys['fault_length'], self.src_keys['dlen'], self.src_keys['fault_width'], self.src_keys['dwid'], self.src_keys['depth_to_top']) mech = (self.src_keys['strike'], self.src_keys['dip'], self.src_keys['rake']) site_geom = [float(station.lon), float(station.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) outf.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s" % (self.comp_label, str( self.src_keys['magnitude']), station.scode, station.lon, station.lat, "-999", station.vs30, rrup, "-999", "-999")) if station.high_freq_corner > 0: outf.write("\t%.3f" % (1.0 / station.high_freq_corner)) else: outf.write("\t-99999.999") if station.low_freq_corner > 0: outf.write("\t%.3f" % (1.0 / station.low_freq_corner)) else: outf.write("\t-99999.999") outf.write("\t%s" % (gmpe_model.lower())) for value in gmpe_points: outf.write("\t%.5e" % (value)) outf.write("\n") outf.close() return period_set
def run(self): """ This function generates velocity and/or acceleration seismogram plots, as requested by the user """ print("Plot Seismograms".center(80, '-')) if not self.plot_vel and not self.plot_acc: # Nothing needs to be plotted return install = InstallCfg.getInstance() sim_id = self.sim_id a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_statlist = os.path.join(a_indir, self.r_stations) slo = StationList(a_statlist) site_list = slo.getStationList() # Get fault information, if available if self.src_keys is not None: origin = (self.src_keys['lon_top_center'], self.src_keys['lat_top_center']) dims = (self.src_keys['fault_length'], self.src_keys['dlen'], self.src_keys['fault_width'], self.src_keys['dwid'], self.src_keys['depth_to_top']) mech = (self.src_keys['strike'], self.src_keys['dip'], self.src_keys['rake']) for site in site_list: print("==> Plotting station: %s" % (site.scode)) # Calculate Rrup rrup = None if self.src_keys is not None: 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) # Check if we need to plot velocity seismograms if self.plot_vel: print("===> Plotting velocity...") filename = os.path.join(a_outdir, "%d.%s.vel.bbp" % (sim_id, site.scode)) outfile = os.path.join( a_outdir, "%d.%s_velocity_seis.png" % (sim_id, site.scode)) plot_seismograms.plot_seis(site.scode, filename, sim_id, 'vel', outfile, rrup=rrup) # Check if we need to plot acceleration seismograms if self.plot_acc: print("===> Plotting acceleration...") filename = os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, site.scode)) outfile = os.path.join( a_outdir, "%d.%s_acceleration_seis.png" % (sim_id, site.scode)) plot_seismograms.plot_seis(site.scode, filename, sim_id, 'acc', outfile, rrup=rrup) print("Plot Seismograms Completed".center(80, '-'))
def run(self): """ Run the AS16 validation for all stations """ print("AS2016".center(80, '-')) # Load configuration, set sim_id install = InstallCfg.getInstance() sim_id = self.sim_id # Build directory paths a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_logdir = os.path.join(install.A_OUT_LOG_DIR, str(sim_id)) a_validation_outdir = os.path.join(a_outdir, "validations", "stewart_duration_gmpe") # Make sure the output and tmp directories exist bband_utils.mkdirs([a_tmpdir, a_indir, a_outdir, a_validation_outdir], print_cmd=False) # Now the file paths self.log = os.path.join(a_logdir, "%d.as16.log" % (sim_id)) sta_file = os.path.join(a_indir, self.stations) a_srcfile = os.path.join(a_indir, self.srcfile) # Read SRC file src_keys = bband_utils.parse_src_file(a_srcfile) # Load information from SRC file 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']) # Set region to be unknown -- this has no effect in the AS16 # method as z1 is not provided and that causes dz1 to be set # to zero and override the cj parameter cj = -999 # Figure out what mechanism to use # 0 = unknown # 1 = normal # 2 = reverse # 3 = strike-slip rake = src_keys['rake'] if abs(rake) <= 30 or abs(rake) >= 150: mechanism = 3 elif rake > 30 and rake < 150: mechanism = 2 elif rake < -30 and rake > -150: mechanism = 1 else: print("Warning: unknown mechanism for rake = %f" % (rake)) mechanism = 0 # Get station list slo = StationList(sta_file) site_list = slo.getStationList() # Create output file, add header out_file = open( os.path.join(a_validation_outdir, '%d.as16.%s.txt' % (self.sim_id, self.eventname)), 'w') out_file.write("#station, rrup, vs30, sd575, sd595, sd2080," " tau575, tau595, tau2080, phi575, phi595, phi2080\n") # Go through each station for site in site_list: stat = site.scode vs30 = float(site.vs30) # Calculate Rrup site_geom = [site.lon, 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) results = calculate_as16(src_keys['magnitude'], rrup, mechanism, vs30, -999.0, cj) out_file.write("%s, %3.2f, %3.2f" % (stat, rrup, vs30)) for piece in results: out_file.write(", %7.5f" % (piece)) out_file.write("\n") # All done, close output file out_file.close() # All done! print("AS2016 Completed".center(80, '-'))
def calculate_residuals(self, a_statfile, a_dstdir): """ This function calculates the residuals comparing observations and calculated data. """ install = install_cfg.InstallCfg.getInstance() sim_id = self.sim_id slo = StationList(a_statfile) site_list = slo.getStationList() print_header = 1 rd100_resid_output = os.path.join( a_dstdir, "%s-%d-resid-rd100.txt" % (self.comp_label, sim_id)) # If output file exists, delete it if os.path.exists(rd100_resid_output): os.remove(rd100_resid_output) # Filenames for tmp files, check if filename size within bounds obsfile = os.path.join(a_dstdir, "rd100_obs.txt") simfile = os.path.join(a_dstdir, "rd100_sim.txt") bband_utils.check_path_lengths([obsfile, simfile, rd100_resid_output], bband_utils.GP_MAX_FILENAME) # Loop through all stations for site in site_list: slon = float(site.lon) slat = float(site.lat) stat = site.scode # Trim files self.trim_rd100_file( os.path.join(a_dstdir, "%d.%s.rd100" % (sim_id, stat)), simfile) self.trim_rd100_file(os.path.join(a_dstdir, "%s.rd100" % (stat)), obsfile) # Calculate Rrup origin = (self.src_keys['lon_top_center'], self.src_keys['lat_top_center']) dims = (self.src_keys['fault_length'], self.src_keys['dlen'], self.src_keys['fault_width'], self.src_keys['dwid'], self.src_keys['depth_to_top']) mech = (self.src_keys['strike'], self.src_keys['dip'], self.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) cmd = ( "%s bbp_format=1 " % (os.path.join(install.A_GP_BIN_DIR, "gen_resid_tbl_3comp")) + "datafile1=%s simfile1=%s " % (obsfile, simfile) + "comp1=rotd50 comp2=rotd100 comp3=ratio " + "eqname=%s mag=%s stat=%s lon=%.4f lat=%.4f " % (self.comp_label, self.src_keys['magnitude'], 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" % (print_header, rd100_resid_output, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Only need to print header the first time if print_header == 1: print_header = 0 # Remove temp files try: os.remove(obsfile) os.remove(simfile) except: pass
def calculate_gmpe(self, station, output_file): """ This function calculates the gmpe for a station and writes the output in the output_file """ gmpe_group = gmpe_config.GMPES[self.gmpe_group_name] src_keys = self.src_keys 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']) # Station location site_geom = [float(station.lon), float(station.lat), 0.0] (fault_trace1, upper_seis_depth, lower_seis_depth, ave_dip, dummy1, dummy2) = putils.FaultTraceGen(origin, dims, mech) rjb, rrup, rx = putils.DistanceToSimpleFaultSurface( site_geom, fault_trace1, upper_seis_depth, lower_seis_depth, ave_dip) # If using corrected ground observation data, calcualte GMPEs # with a Vs30 of 863 m/s if self.data_corrected: vs30 = 863 else: vs30 = station.vs30 z10 = None # Let PyNGA calculate it z25 = None # Let PyNGA calculate it # Compute PSA for this station station_median = [] for period in gmpe_group["periods"]: period_medians = [] for nga_model in gmpe_group["models"]: median = gmpe_config.calculate_gmpe( self.gmpe_group_name, nga_model, src_keys['magnitude'], rjb, vs30, period, rake=src_keys['rake'], dip=src_keys['dip'], W=src_keys['fault_width'], Ztor=src_keys['depth_to_top'], Rrup=rrup, Rx=rx, Z10=z10, Z25=z25) period_medians.append(median) station_median.append((period, period_medians)) # Create label file_label = "" for nga_model in gmpe_group["models"]: file_label = "%s %s" % (file_label, nga_model) # Output data to file outfile = open(output_file, 'w') outfile.write("#station: %s\n" % (station.scode)) outfile.write("#period%s\n" % (file_label)) for item in station_median: period = item[0] vals = item[1] out_str = "%.4f" % (period) for method in vals: out_str = out_str + "\t%.6f" % (method) outfile.write("%s\n" % (out_str)) outfile.close() # Return list return station_median
def calculate_gmpe(src_keys, station, output_file, rrups, gmpe_group_name): """ Calculate the GMPE results for a given station. """ gmpe_group = gmpe_config.GMPES[gmpe_group_name] 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']) # Station location site_geom = [float(station.lon), float(station.lat), 0.0] (fault_trace1, upper_seis_depth, lower_seis_depth, ave_dip, dummy1, dummy2) = putils.FaultTraceGen(origin, dims, mech) rjb, rrup, rx = putils.DistanceToSimpleFaultSurface(site_geom, fault_trace1, upper_seis_depth, lower_seis_depth, ave_dip) print "station: %s, Rrup: %f" % (station.scode, rrup) rrups.append(rrup) vs30 = 1000 z10 = None # Let PyNGA calculate it z25 = None # Let PyNGA calculate it # Compute PSA for this stations station_median = [] for period in gmpe_group["periods"]: period_medians = [] for nga_model in gmpe_group["models"]: median = gmpe_config.calculate_gmpe(gmpe_group_name, nga_model, src_keys['magnitude'], rjb, vs30, period, rake=src_keys['rake'], dip=src_keys['dip'], W=src_keys['fault_width'], Ztor=src_keys['depth_to_top'], Rrup=rrup, Rx=rx, Z10=z10, Z25=z25) period_medians.append(median) station_median.append((period, period_medians)) # Create label file_label = "" for nga_model in gmpe_group["models"]: file_label = "%s %s" % (file_label, nga_model) # Output data to file outfile = open(output_file, 'w') outfile.write("#station: %s\n" % (station.scode)) outfile.write("#period%s\n" % (file_label)) for item in station_median: period = item[0] vals = item[1] out_str = "%.4f" % (period) for method in vals: out_str = out_str + "\t%.6f" % (method) outfile.write("%s\n" % (out_str)) outfile.close() # Return list return station_median