def __init__(self, station_file, sim_id=0, hypo=None): self.station_file = station_file self.sim_id = sim_id self.install = InstallCfg.getInstance() self.coast_file = os.path.join(self.install.A_PLOT_DATA_DIR, "cali_coastline.mapgen") if not os.path.isfile(self.coast_file): self.coast_file = "" self.value = "GOF" self.stats = [] self.dx = 500.0 #100 mts grid resolution self.spacing = [self.dx, self.dx] self.hypo = hypo self.dim = [] self.rbounds = [] self.nw = [] self.sw = [] self.se = [] self.ne = [] self.PLOT_MAP_LOC = [0.10, 0.15, 0.8, 0.8] self.origin = [] self.offset = [] self.x_invert = False self.y_invert = False self.init_dims()
def run(self): """ Corrects the amplitudes from all stations found in the station list according to the correction coefficients provided by the user """ print("Correct PSA".center(80, '-')) # Initialize basic variables install = InstallCfg.getInstance() 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.obs_seis.log" % (sim_id)) # Input, tmp, and output directories a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) # Station file a_statfile = os.path.join(a_indir, self.r_stations) slo = StationList(a_statfile) site_list = slo.getStationList() # Go through each station # print "Working dir: %s" % (self.proc_dir) for site in site_list: stat = site.scode print("==> Correcting amplitudes for station: %s" % (stat)) self.correct_station(stat, self.extension) print("Correct PSA Completed".center(80, '-'))
def run(r_srffile, sim_id=0): """ Creates a SRF plot from an SRF file """ install = InstallCfg.getInstance() a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) # Save current directory old_cwd = os.getcwd() os.chdir(a_tmpdir) # Write slip file srfbase = r_srffile[0:r_srffile.find(".srf")] slipfile = "%s.slip" % (srfbase) cmd = ("%s/srf2xyz calc_xy=0 type=slip nseg=-1 < %s > %s" % (install.A_GP_BIN_DIR, r_srffile, slipfile)) bband_utils.runprog(cmd) # Write tinit file tinitfile = "%s.tinit" % (srfbase) cmd = ("%s/srf2xyz calc_xy=0 type=tinit nseg=-1 < %s > %s" % (install.A_GP_BIN_DIR, r_srffile, tinitfile)) bband_utils.runprog(cmd) plottitle = 'Rupture Model for %s' % (r_srffile) plot(plottitle, r_srffile, a_outdir) os.chdir(old_cwd)
def __init__(self, snum=None): if snum == None: self.sim_id = seqnum.get_seq_num() else: self.sim_id = int(snum) install = InstallCfg.getInstance() logdir = install.A_OUT_LOG_DIR self.outlogfile = logdir + "/%d/%d.txt" % (self.sim_id, self.sim_id)
def __init__(self, sim_id=0, options=None): """ Initialization for BBPStatus class """ self.sim_id = sim_id self.__options = options self.install = InstallCfg.getInstance() self.outdir = os.path.join(self.install.A_OUT_DATA_DIR, str(sim_id))
def run(self): """ Generates a map showing the fault with stations """ print("Plot MAP".center(80, '-')) if (self.input_file is None or self.input_file == "" or (not self.input_file.endswith(".srf") and not self.input_file.endswith(".src"))): # We need a SRC or SRF file to get the fault geometry return install = InstallCfg.getInstance() a_indir = os.path.join(install.A_IN_DATA_DIR, str(self.sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(self.sim_id)) a_input_file = os.path.join(a_indir, self.input_file) a_station_file = os.path.join(a_indir, self.station_file) # Define boundaries to plot using the stations in the station file (self.north, self.south, self.east, self.west) = set_boundaries_from_stations(a_station_file) self.log = os.path.join(install.A_OUT_LOG_DIR, str(self.sim_id), "%d.plot_map.log" % (self.sim_id)) trace_file = "%s.trace" % (a_input_file) simple_station_file = "%s.simple" % (a_station_file) if self.input_file.endswith(".srf"): self.trace = write_fault_trace(a_input_file, trace_file) else: self.trace = write_simple_trace(a_input_file, trace_file) write_simple_stations(a_station_file, simple_station_file) map_prefix = os.path.join(a_outdir, "station_map") kml_file = os.path.join(a_outdir, "station_map.kml") # Get hypo_lon, hypo_lat from src/srf file hypo_lon, hypo_lat = fault_utils.calculate_epicenter(a_input_file) # Write the kml file self.create_kml_output(a_station_file, kml_file, hypo_lat=hypo_lat, hypo_lon=hypo_lon) # Matplotlib plottitle = 'Fault Trace with Stations' plotregion = [self.west, self.east, self.south, self.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') plotter = PlotMap.PlotMap() plotter.plot(plottitle, plotregion, topo, coastal, border, trace_file, simple_station_file, map_prefix, hypo_lat=hypo_lat, hypo_lon=hypo_lon) print("Plot MAP Completed".center(80, '-'))
def __init__(self, vmodel_name, a_srcname=None): install = InstallCfg.getInstance() # # Name and Path to executable # self.R_UC_FFSP_EXE = "ffsp_v2" self.A_UC_FFSP_EXE = os.path.join(install.A_UCSB_BIN_DIR, self.R_UC_FFSP_EXE) self.FFSP_OUTPUT_PREFIX = "FFSP_OUTPUT" self.FMAX = 50.0 # Nyquist -- use 50 for 100Hz vmodel_obj = velocity_models.get_velocity_model_by_name(vmodel_name) if vmodel_obj is None: raise IndexError("Cannot find velocity model: %s" % (vmodel_name)) vmodel_params = vmodel_obj.get_codebase_params('ucsb') # Configure DT based on information from velocity model if 'GF_DT' in vmodel_params: self.DT = float(vmodel_params['GF_DT']) else: raise KeyError("%s parameter missing in velocity model %s" % ("GF_DT", vmodel_name)) # Other region-specific parameters if 'RV_AVG' in vmodel_params: self.RV_AVG = float(vmodel_params['RV_AVG']) else: self.RV_AVG = 2.5 if 'TP_TR' in vmodel_params: self.TP_TR = float(vmodel_params['TP_TR']) else: self.TP_TR = 0.1 if 'LF_VELMODEL' in vmodel_params: self.A_UC_LF_VELMODEL = os.path.join(vmodel_obj.base_dir, vmodel_params['LF_VELMODEL']) else: raise KeyError("%s parameter missing in velocity model %s" % ("LF_VELMODEL", vmodel_name)) if a_srcname: self.CFGDICT = bband_utils.parse_src_file(a_srcname) # RV_AVG is optional! # If SRC file has it, it overrides the region and the default values if "rv_avg" in self.CFGDICT: self.RV_AVG = self.CFGDICT["rv_avg"]
def run(self): """ Run the GP WccSiteamp 2014 module """ print("GP Site Response".center(80, '-')) self.install = InstallCfg.getInstance() install = self.install self.config = WccSiteampCfg() 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.wcc_siteamp_%s.log" % (sim_id, sta_base)) a_statfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_stations) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) 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)) progstring = "mkdir -p %s" % (a_tmpdir) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Read and parse the station list with this call # slo = StationList(a_statfile) site_list = slo.getStationList() for sites in site_list: site = sites.scode vs30 = sites.vs30 if vs30 > config.VREF_MAX: vs30 = config.VREF_MAX print("*** WccSiteamp Processing station %s..." % (site)) if self.method == "GP": self.process_separate_seismograms(site, sta_base, vs30, a_indir, a_tmpdir) elif self.method == "SDSU" or self.method == "EXSIM" or self.method == "UCSB": self.process_hybrid_seismogram(site, sta_base, vs30, a_tmpdir, a_outdir) print("GP Site Response Completed".center(80, '-'))
def run(self): """ Calculate GMPEs, create bias plot comparisons """ print("Calculate GMPE".center(80, '-')) # Initialize basic variables install = InstallCfg.getInstance() sim_id = self.sim_id sta_base = os.path.basename(os.path.splitext(self.r_stations)[0]) # Input, tmp, and output directories a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_outdir_gmpe = os.path.join(a_outdir, "gmpe_data_%s" % (sta_base)) a_logdir = os.path.join(install.A_OUT_LOG_DIR, str(sim_id)) self.log = os.path.join(a_logdir, "%d.gmpe_compare.log" % (sim_id)) # # Make sure the output and tmp directories exist # dirs = [a_outdir_gmpe, a_outdir, a_logdir] bband_utils.mkdirs(dirs, print_cmd=False) # Source file, parse it! a_srcfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_src_file) 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) slo = StationList(a_statfile) site_list = slo.getStationList() # Go through each station, and print comparison headers for # the first station we process for site in site_list: stat = site.scode print("==> Calculating GMPE for station: %s" % (stat)) output_file = os.path.join(a_outdir_gmpe, "%s-gmpe.ri50" % (stat)) self.calculate_gmpe(site, output_file) # All done print("Calculate GMPE Completed".center(80, '-'))
def plot_dist_gof(resid_file, comp_label, a_outdir_gmpe, sim_id): """ Reads data from resid_file and plots a gof distance plot all periods """ # Get directory names install = InstallCfg.getInstance() a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # Collect all the data all_data = [] all_distances = [] all_gmpe_data = [] all_gmpe_distances = [] # Read the residuals data for period in DIST_PERIODS: summary_output = os.path.join(a_outdir, "%s-%d-resid-%.3f-%s.txt" % (comp_label, sim_id, period, COMP_EXT_RD50)) data, distance = read_resid(resid_file, period, summary_output) all_data.append(data) all_distances.append(distance) # Now do the same for the GMPE data # for period in DIST_PERIODS: # if os.path.isdir(a_outdir_gmpe): # summary_output = os.path.join(a_outdir, # "%s-%d-resid-gmpe-%.3f-%s.txt" % # (comp_label, sim_id, # period, COMP_EXT_RD50)) # data, distance = read_gmpe_resid(a_outdir_gmpe, sim_id, # period, summary_output) # all_gmpe_data.append(data) # all_gmpe_distances.append(distance) # else: # all_gmpe_data.append([]) # all_gmpe_distances.append([]) # Now create the 2 plots, 1 linear and 1 log outfile = os.path.join(a_outdir, "gof-dist-linear-%s-%d-rotd50.png" % (comp_label, sim_id)) create_dist_gof(all_data, all_distances, all_gmpe_data, all_gmpe_distances, comp_label, sim_id, outfile) outfile = os.path.join(a_outdir, "gof-dist-log-%s-%d-rotd50.png" % (comp_label, sim_id)) create_dist_gof(all_data, all_distances, all_gmpe_data, all_gmpe_distances, comp_label, sim_id, outfile, log_scale=True)
def __init__(self): """ Initialize class structures """ self.install = InstallCfg.getInstance() self.output_sim_id = None self.a_indir = None self.a_outdir = None self.a_logdir = None self.a_tmpdir = None self.station_list = None self.input_sims = [] self.src_files = [] self.srf_files = [] self.val_event = None
def run(self): """ Goes through the station list and copy each low-frequency seismogram from the seis_dir to the simulation's tmpdir """ install = InstallCfg.getInstance() sim_id = self.sim_id 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_stations = os.path.join(a_indir, self.r_stations) print(self.seis_dir) slo = StationList(a_stations) stat_list = slo.getStationList() for stat in stat_list: # Look for bbp seismogram, copy in print("%s/%s-lf.bbp" % (self.seis_dir, stat.scode)) if os.path.exists("%s/%s-lf.bbp" % (self.seis_dir, stat.scode)): print("Copying for site %s" % (stat.scode)) # Need to eliminate negative times fp_in = open("%s/%s-lf.bbp" % (self.seis_dir, stat.scode), 'r') fp_out = open("%s/%d.%s-lf.bbp" % (a_tmpdir, sim_id, stat.scode), 'w') for line in fp_in: pieces = line.split() try: if pieces[0] == '#' or pieces[0] == '%': fp_out.write(line) elif float(pieces[0]) < -0.0001: continue elif float(pieces[0]) < 0.0001: fp_out.write("0.0\t%s\t%s\t%s\n" % (pieces[1], pieces[2], pieces[3])) else: fp_out.write(line) except ValueError: fp_out.write(line) fp_in.close() fp_out.flush() fp_out.close() else: print("Could not find LF seismogram for station %s!" % (stat.scode))
def __init__(self, i_r_stations, i_r_srcfile, plot_vel, plot_acc, sim_id=0): """ Initialize basic class parameters """ self.r_stations = i_r_stations self.plot_vel = plot_vel self.plot_acc = plot_acc self.sim_id = sim_id install = InstallCfg.getInstance() a_indir = os.path.join(install.A_IN_DATA_DIR, str(self.sim_id)) if i_r_srcfile is not None and i_r_srcfile != "": i_a_srcfile = os.path.join(a_indir, i_r_srcfile) self.src_keys = bband_utils.parse_src_file(i_a_srcfile) else: self.src_keys = None
def setUp(self): """ Configures the environment for the tests """ self.install = InstallCfg.getInstance() self.sim_id = int(seqnum.get_seq_num()) # Make sure all directories exist self.indir = os.path.join(self.install.A_IN_DATA_DIR, str(self.sim_id)) self.tmpdir = os.path.join(self.install.A_TMP_DATA_DIR, str(self.sim_id)) self.outdir = os.path.join(self.install.A_OUT_DATA_DIR, str(self.sim_id)) self.logdir = os.path.join(self.install.A_OUT_LOG_DIR, str(self.sim_id)) bband_utils.mkdirs([self.indir, self.tmpdir, self.outdir, self.logdir], print_cmd=False)
def generate_xml(self, optfiles): install = InstallCfg.getInstance() # Generate xml workflows tests = [] for key in optfiles.keys(): sim_id = int(seqnum.get_seq_num()) test = key.split('.')[0] xmlfile = os.path.join(self.input_dir, "%s.xml" % (test)) if os.path.basename(xmlfile) in self.resume_list: # Skip this test print("Skipping %s" % (key)) continue print("Generating %s" % (key)) optfile = os.path.join(self.input_dir, key) # Save the option file op = open(optfile, 'w') for line in optfiles[key]: op.write("%s\n" % (line)) op.close() # Generate xml print("Generating xml for %s" % (key)) print("\t %s" % (str(optfiles[key]))) cmd = ("%s/run_bbp.py --expert -s %d -g -o %s" % (install.A_COMP_DIR, sim_id, optfile)) print("Running: %s" % (cmd)) rc = bband_utils.runprog(cmd, False) if rc != 0: print("Failed to run bbp, aborting.") return [] oldxmlfile = os.path.join(install.A_XML_DIR, "%d.xml" % (sim_id)) shutil.copy2(oldxmlfile, xmlfile) if not os.path.exists(xmlfile): print("Workflow %s not found, aborting." % (xmlfile)) return [] tests.append([sim_id, xmlfile]) time.sleep(1) return tests
def run_tests(self, tests): install = InstallCfg.getInstance() # Run the tests and save results as reference data for test in tests: if os.path.basename(test[1]) in self.resume_list: # Skip this test print("Skipping %s" % (os.path.basename(test[1]))) continue # Execute each test cmd = ("%s/run_bbp.py -s %d -x %s" % (install.A_COMP_DIR, test[0], test[1])) rc = bband_utils.runprog(cmd, False) if rc != 0: print("Failed to run acceptance test %d-%s, aborting." % (test[0], test[1])) return 1 # Save the bbp and rsp files test_name = os.path.basename(test[1]).split('.')[0] cmd = "mkdir -p %s" % (os.path.join(self.ref_dir, test_name)) bband_utils.runprog(cmd) rd50files = glob.glob("%s/%d/%d.*.rd50" % (install.A_OUT_DATA_DIR, test[0], test[0])) if len(rd50files) < 1: print("Did not find expected RotD50 files") return 1 for rd50_file in rd50files: filecomps = os.path.basename(rd50_file).split('.') shutil.copy2(rd50_file, os.path.join(self.ref_dir, test_name, "%s.rd50" % (filecomps[1]))) # Write progress to checkpoint file resume_fp = open(os.path.join(install.A_OUT_LOG_DIR, "gen_resume.txt"), 'a') resume_fp.write("%s\n" % os.path.basename(test[1])) resume_fp.flush() resume_fp.close() return 0
def get_magnitude(velfile, srffile, suffix="tmp"): """ Scans the srffile and returns the magnitude of the event """ magfile = "srf2moment_%s.out" % (suffix) install = InstallCfg.getInstance() cmd = ("%s velfile=%s < %s 2> %s" % (os.path.join(install.A_GP_BIN_DIR, "srf2moment"), velfile, srffile, magfile)) bband_utils.runprog(cmd, False) srf2moment_fp = open(magfile, 'r') srf2moment_data = srf2moment_fp.readlines() srf2moment_fp.close() #magnitude on last line mag_line = srf2moment_data[len(srf2moment_data) - 4] pieces = mag_line.split() magnitude = float(pieces[5].split(")")[0]) cmd = "rm %s" % (magfile) bband_utils.runprog(cmd, False) return magnitude
def get_hypocenter(srffile, suffix="tmp"): """ Looks up the hypocenter of an event in a srffile """ hypfile = "srf_hypo_%s" % (suffix) install = InstallCfg.getInstance() cmd = ("%s < %s > %s" % (os.path.join(install.A_GP_BIN_DIR, "srf_gethypo"), srffile, hypfile)) bband_utils.runprog(cmd) srf_hypo_fp = open(hypfile, 'r') srf_hypo_data = srf_hypo_fp.readline() srf_hypo_fp.close() srf_hypo = srf_hypo_data.split() hypo = [] for i in range(0, 3): hypo.append(float(srf_hypo[i])) cmd = "rm %s" % (hypfile) bband_utils.runprog(cmd) return hypo
def __init__(self, resume=True): install = InstallCfg.getInstance() self.resume = resume self.resume_list = [] # Read checkpoint file if self.resume == True: resume_file = os.path.join(install.A_OUT_LOG_DIR, "gen_resume.txt") if os.path.exists(resume_file): resume_fp = open(resume_file, 'r') self.resume_list = resume_fp.read().splitlines() resume_fp.close() else: self.resume = False # Setup paths self.input_dir = os.path.join(install.A_TEST_REF_DIR, "accept_inputs") self.ref_dir = os.path.join(install.A_TEST_REF_DIR, "accept_refs")
def uc_create_fault_global(a_faultfile, sim_id, r_srcfile, i_vmodel_name, r_velmodel, r_srffile): """ This fuction creates the faultfile with the parameters specified in the src_file and velocity model """ install = InstallCfg.getInstance() a_srcfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), r_srcfile) # since KinModel appends .srf automatically, make sure it's not # already there if r_srffile.endswith(".srf"): r_srffile = r_srffile[0:len(r_srffile) - 4] # Read source file cfg = UCrmgCfg(i_vmodel_name, a_srcfile) # Write configuration file print("Creating %s" % (a_faultfile)) fault_file = open(a_faultfile, "w") fault_file.write("%.3f %.3f %.1f\n" % (cfg.CFGDICT["lon_top_center"], cfg.CFGDICT["lat_top_center"], cfg.CFGDICT["depth_to_top"])) fault_file.write("%.2f %.2f\n" % (cfg.CFGDICT["fault_length"], cfg.CFGDICT["fault_width"])) fault_file.write("%.f. %.f. %.f.\n" % (cfg.CFGDICT["strike"], cfg.CFGDICT["dip"], cfg.CFGDICT["rake"])) fault_file.write("%.1f %.1f\n" % (cfg.CFGDICT["hypo_along_stk"], cfg.CFGDICT["hypo_down_dip"])) fault_file.write("%4.2f\n" % (cfg.CFGDICT['magnitude'])) fault_file.write("%.3f %.3f\n" % (cfg.CFGDICT["dlen"], cfg.CFGDICT["dwid"])) fault_file.write("%d\n" % (cfg.CFGDICT['seed'])) fault_file.write("%.2f\n" % (cfg.DT)) fault_file.write("%.2f\n" % (cfg.CFGDICT['corner_freq'])) fault_file.write("%s\n" % (r_velmodel)) fault_file.write("%s\n" % (r_srffile)) fault_file.close()
def main(): """ Parse command line options and create the needed files/directories """ # Detect BBP installation bbp_install = InstallCfg.getInstance() prog_base = os.path.basename(sys.argv[0]) usage = "usage: %s [options]" % (prog_base) parser = optparse.OptionParser(usage) parser.add_option("-c", "--codebase", type="string", action="store", dest="codebase", help="Codebase for the simulation: %s" % (CODEBASES)) parser.add_option("-v", "--velocity-model", type="string", action="store", dest="vmodel", help="Velocity model (region) for this simulation") parser.add_option("--src", "--source", type="string", action="store", dest="source", help="Source description file for the simulation") parser.add_option("--stl", "--station-list", type="string", action="store", dest="station_list", help="Station list file for the simulation") parser.add_option("-d", "--dir", type="string", action="store", dest="simdir", help="Simulation directory") parser.add_option("-n", "--num-stations", type="int", action="store", dest="numsta", help="Number of stations per run") parser.add_option("--seed", type="int", action="store", dest="new_seed", help="Overrides seed in SRC file") parser.add_option("--email", type="string", action="store", dest="email", help="Email for job notifications") parser.add_option("--new-nodes", action="store_true", dest="newnodes", help="Schedule the job in the new HPCC nodes") parser.add_option("--no-site-response", action="store_true", dest="nosite", help="Disable the site response module for GP/SDSU/UCSB") (options, _) = parser.parse_args() # Check if using new HPCC nodes if options.newnodes: newnodes = True else: newnodes = False # Check if not using site response if options.nosite: nosite = True else: nosite = False # Validate codebase to use codebase = options.codebase if codebase is None: print "Please specify a codebase!" sys.exit(1) codebase = codebase.lower() if codebase not in CODEBASES: print "Codebase needs to be one of: %s" % (CODEBASES) # Check for velocity model vmodel_names = velocity_models.get_all_names() vmodel = options.vmodel if vmodel is None: print "Please provide a velocity model (region) for this simulation!" print "Available options are: %s" % (vmodel_names) sys.exit(1) vmodels = [v_model.lower() for v_model in vmodel_names] if vmodel.lower() not in vmodels: print ("Velocity model %s does not appear to be available on BBP" % (vmodel)) print ("Available options are: %s" % (vmodel_names)) print "Please provide another velocity model or check your BBP installation." sys.exit(1) # Now get the name with the correct case vmodel = vmodel_names[vmodels.index(vmodel.lower())] # Get the source file source_file = options.source if source_file is None: print "Please provide a source description (src file)!" sys.exit(1) # Make it a full path source_file = os.path.realpath(source_file) # Make sure source file is in the rcf-104 filesystem if not "rcf-104" in source_file: print "Source file should be in the rcf-104 filesystem!" sys.exit(1) # Make sure source file exists and is readable if not os.path.isfile(source_file) or not os.access(source_file, os.R_OK): print "Source file does not seem to be accessible!" sys.exit(1) # Get the station list station_list = options.station_list if station_list is None: print "Please provide a station list (stl file)!" sys.exit(1) # Make it a full path station_list = os.path.realpath(station_list) # Make sure station list is in the rcf-104 filesystem if not "rcf-104" in station_list: print "Station list should be in the rcf-104 filesystem!" sys.exit(1) # Make sure station list exists and is readable if not os.path.isfile(station_list) or not os.access(station_list, os.R_OK): print "Station list foes not seem to be accessible!" sys.exit(1) # Check for the simulation directory simdir = options.simdir if simdir is None: print "Please provide a simulation directory!" sys.exit(1) simdir = os.path.abspath(simdir) if os.path.exists(simdir): print "Simulation directory exists: %s" % (simdir) opt = raw_input("Do you want to delete its contents (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) opt = raw_input("ARE YOU SURE (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) # Delete existing directory (we already asked the user twice!!!) shutil.rmtree(simdir) # Pick up number of simulations to run numsta = options.numsta if numsta < 1: print ("Number of stations should be greater than 0") sys.exit(1) # Check for user-provided seed for this simulation new_seed = options.new_seed # Check for e-mail address email = options.email if email is None: print "Please provide an e-mail address for job notifications" sys.exit(1) # Make sure user has configured the setup_bbp_env.sh script setup_bbp_env = os.path.join(bbp_install.A_INSTALL_ROOT, "utils/batch/setup_bbp_env.sh") if not os.path.exists(setup_bbp_env): print ("Cannot find setup_bbp_env.sh script!") print ("Expected at: %s" % (setup_bbp_env)) sys.exit(1) # Create simulation directories prefix = "%s-%s" % (os.path.splitext(os.path.basename(source_file))[0], codebase.lower()) # Make sure we remove spaces from prefix prefix = prefix.replace(" ", '') os.makedirs(simdir) indir = os.path.join(simdir, "Sims", "indata") outdir = os.path.join(simdir, "Sims", "outdata") tmpdir = os.path.join(simdir, "Sims", "tmpdata") logsdir = os.path.join(simdir, "Sims", "logs") xmldir = os.path.join(simdir, "Xml") srcdir = os.path.join(simdir, "Src") stldir = os.path.join(simdir, "Stl") for mdir in [indir, outdir, tmpdir, logsdir, xmldir, srcdir, stldir]: os.makedirs(mdir) # Generate station lists numsim, stlbase = generate_stl_files(station_list, numsta, stldir) if numsim > MAX_SIMULATIONS: print "Too many simulations requested!" print "Maximum number allowed is %d!" % (MAX_SIMULATIONS) print "Try requesting more stations per simulation..." sys.exit(1) # Generate source files generate_src_files(numsim, source_file, srcdir, prefix, new_seed) # Generate xml files generate_xml(bbp_install, numsim, srcdir, xmldir, logsdir, vmodel, codebase, prefix, stlbase, nosite) # Write pbs file write_pbs(bbp_install, numsim, simdir, xmldir, email, prefix, newnodes)
def run(self): """ Runs Genslip """ print("GP Rupture Generator GenSlip".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)) # Make sure the output and tmp directories exist bband_utils.mkdirs([a_tmpdir, a_indir, a_outdir], print_cmd=False) # Now, file paths self.log = os.path.join(a_logdir, "%d.genslip.log" % (sim_id)) a_srcfile = os.path.join(a_indir, self.r_srcfile) a_velfile = os.path.join(a_indir, self.r_velmodel) # Read src file cfg = GenslipCfg(a_srcfile) # Define location of input velocity model file a_velmodel = os.path.join(a_tmpdir, self.r_velmodel) # Get pointer to the velocity model object vel_obj = velocity_models.get_velocity_model_by_name(self.vmodel_name) if vel_obj is None: raise bband_utils.ParameterError("Cannot find velocity model: %s" % (self.vmodel_name)) # Check for velocity model-specific parameters vmodel_params = vel_obj.get_codebase_params('gp') # Look for RISETIME_COEF if 'RISETIME_COEF' in vmodel_params: self.risetime_coef = float(vmodel_params['RISETIME_COEF']) else: self.risetime_coef = cfg.RISETIME_COEF # Look for SHAL_VRUP if 'SHAL_VRUP' in vmodel_params: self.shal_vrup = float(vmodel_params['SHAL_VRUP']) else: self.shal_vrup = cfg.SHAL_VRUP # Look for MEAN_RVFAC if 'MEAN_RVFAC' in vmodel_params: self.mean_rvfac = float(vmodel_params['MEAN_RVFAC']) else: self.mean_rvfac = cfg.MEAN_RVFAC # Look for RANGE_RVFAC if 'RANGE_RVFAC' in vmodel_params: self.range_rvfac = float(vmodel_params['RANGE_RVFAC']) else: self.range_rvfac = cfg.RANGE_RVFAC # Look for RISETIME_FAC if 'RISETIME_FAC' in vmodel_params: self.risetime_fac = float(vmodel_params['RISETIME_FAC']) else: self.risetime_fac = cfg.RISETIME_FAC # Look for DEEP_RISETIME_FAC if 'DEEP_RISETIME_FAC' in vmodel_params: self.deep_risetime_fac = float(vmodel_params['DEEP_RISETIME_FAC']) else: self.deep_risetime_fac = cfg.DEEP_RISETIME_FAC # Look for SLIP SIGMA if 'SLIP_SIGMA' in vmodel_params: self.slip_sigma = float(vmodel_params['SLIP_SIGMA']) else: self.slip_sigma = cfg.SLIP_SIGMA # Look for DT if 'GF_DT' in vmodel_params: gf_dt = float(vmodel_params['GF_DT']) else: raise bband_utils.ParameterError("Cannot find GF_DT parameter in" "velocity model %s!" % (self.vmodel_name)) # Calculate nstk,ndip nstk = round(cfg.CFGDICT["fault_length"] / cfg.CFGDICT["dlen"]) ndip = round(cfg.CFGDICT["fault_width"] / cfg.CFGDICT["dwid"]) # Calculate rvfac if "common_seed" in cfg.CFGDICT: rvfac = calculate_rvfac(self.mean_rvfac, self.range_rvfac, cfg.CFGDICT["common_seed"]) else: rvfac = calculate_rvfac(self.mean_rvfac, self.range_rvfac, cfg.CFGDICT["seed"]) # moment = math.pow(10, 1.5 * (cfg.MAG + 10.7)) # For multi-segment SRC files if "rupture_delay" in cfg.CFGDICT: rupture_delay = cfg.CFGDICT["rupture_delay"] else: rupture_delay = 0.0 if "moment_fraction" in cfg.CFGDICT: moment_fraction = cfg.CFGDICT["moment_fraction"] else: moment_fraction = -1.0 if "max_fault_length" in cfg.CFGDICT: flen_max = cfg.CFGDICT["max_fault_length"] else: flen_max = -1.0 r_gsftmp = "m%.2f-%.2fx%.2f.gsf" % (cfg.CFGDICT["magnitude"], cfg.CFGDICT["dlen"], cfg.CFGDICT["dwid"]) a_gsftmp = os.path.join(a_tmpdir, r_gsftmp) r_outroot = "m%.2f-%.2fx%.2f_s%d-v5.4.1" % (cfg.CFGDICT["magnitude"], cfg.CFGDICT["dlen"], cfg.CFGDICT["dwid"], cfg.CFGDICT["seed"]) a_srffile = os.path.join(a_indir, "%s.srf" % (r_outroot)) progstring = ("%s/fault_seg2gsf read_slip_vals=0 << EOF > %s 2>> %s\n" % (install.A_GP_BIN_DIR, a_gsftmp, self.log) + "1\n" + "%f %f %f %f %f %f %f %f %d %d\n" % (cfg.CFGDICT["lon_top_center"], cfg.CFGDICT["lat_top_center"], cfg.CFGDICT["depth_to_top"], cfg.CFGDICT["strike"], cfg.CFGDICT["dip"], cfg.CFGDICT["rake"], cfg.CFGDICT["fault_length"], cfg.CFGDICT["fault_width"], nstk, ndip) + "EOF") bband_utils.runprog(progstring) progstring = ("%s/genslip-v5.4.1 read_erf=0 write_srf=1 " % (install.A_GP_BIN_DIR) + "read_gsf=1 write_gsf=0 infile=%s " % (a_gsftmp) + "mag=%.2f nstk=%d ndip=%d " % (cfg.CFGDICT["magnitude"], nstk, ndip) + "ns=1 nh=1 " + "kmodel=2 seed=%d slip_sigma=%f " % (cfg.CFGDICT["seed"], self.slip_sigma) + "circular_average=0 modified_corners=0 " + "velfile=%s shypo=%f dhypo=%f rvfrac=%f " % (a_velfile, cfg.CFGDICT["hypo_along_stk"], cfg.CFGDICT["hypo_down_dip"], rvfac) + "shal_vrup_dep=%f shal_vrup_deprange=%f shal_vrup=%f " % (cfg.RTDEP, cfg.RTDEP_RANGE, self.shal_vrup) + "side_taper=0.02 bot_taper=0.0 top_taper=0.0 " + "dt=%f risetime_coef=%f plane_header=1 " % (gf_dt, self.risetime_coef) + "risetimefac=%f risetimedep=%f risetimedep_range=%f " % (self.risetime_fac, cfg.RTDEP, cfg.RTDEP_RANGE) + "rt_scalefac=%f slip_water_level=%f " % (cfg.RT_SCALEFAC, cfg.SLIP_WATER_LEVEL) + "deep_risetimedep=%f deep_risetimedep_range=%f " % (cfg.DEEP_RISETIMEDEP, cfg.DEEP_RISETIMEDEP_RANGE) + "deep_risetimefac=%f " % (self.deep_risetime_fac) + "flen_max=%f rupture_delay=%f moment_fraction=%f " % (flen_max, rupture_delay, moment_fraction) + "srf_version=2.0 rake_sigma=15.0 fdrup_time=1 " + "deep_vrup=0.6 use_gaus=1 alpha_rough=0.01 " + "lambda_min=0.08 tsfac_coef=1.1 tsfac1_sigma=1.0 " + "tsfac1_scor=0.8 rtime1_sigma=%f rtime1_scor=0.5 " % (self.slip_sigma) + "tsfac_bzero=-0.1 tsfac_slope=-0.5 " + "> %s 2>> %s" % (a_srffile, self.log)) bband_utils.runprog(progstring) # # mv result to outputfile # progstring = "cp %s %s" % (a_srffile, os.path.join(a_tmpdir, self.r_srffile)) bband_utils.runprog(progstring) progstring = "cp %s %s" % (a_srffile, os.path.join(a_indir, self.r_srffile)) bband_utils.runprog(progstring) progstring = "cp %s %s" % (a_srffile, os.path.join(a_outdir, self.r_srffile)) bband_utils.runprog(progstring) # Plot SRF plot_srf.run(self.r_srffile, sim_id=self.sim_id) print("GP GenSlip Completed".center(80, '-'))
'title="LP Sim NGAH, stat=%s" ' % site + 'nsfile=%s ewfile=%s udfile=%s > %s 2>> %s' % (nsfile, ewfile, udfile, bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) if self.r_srcfile == "": #calculate magnitude and write to file mag = fault_utils.get_magnitude(os.path.join(a_indir, self.r_velmodel), os.path.join(a_indir, self.r_srffile), sta_base) mag_file = open("%s" % os.path.join(a_indir, "magnitude_%s" % (sta_base)), 'w') mag_file.write("%.2f" % mag) mag_file.flush() mag_file.close() print("GP Jbsim Completed".center(80, '-')) if __name__ == "__main__": print("Testing Module: %s" % os.path.basename((sys.argv[0]))) INSTALL = InstallCfg() ME = Jbsim(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5], sim_id=int(sys.argv[6])) ME.run() sys.exit(0)
def run(self): """ Runs the GP low frequency component """ print("GP Jbsim".center(80, '-')) install = InstallCfg.getInstance() config = JbsimCfg(self.vmodel_name) 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.jbsim_%s.log" % (sim_id, sta_base)) a_statfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_stations) a_srffile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_srffile) # Set directories, and make sure they exist a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_veldir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) bband_utils.mkdirs([a_veldir, a_indir], print_cmd=False) # # Read and parse the station list with this call # slo = StationList(a_statfile) site_list = slo.getStationList() for sits in site_list: slon = float(sits.lon) slat = float(sits.lat) site = sits.scode print("==> Generating LF seismogram for station: %s" % (site)) # # We have a verbose of silent invocation. This is a very # verbose program so our default writes to dev/null # progstring = ("%s latloncoords=1 slon=%f slat=%f " % (os.path.join(install.A_GP_BIN_DIR, "jbsim"), slon, slat) + "rupmodtype=SRF rupmodfile=%s " % a_srffile + "moment=-1 outdir=%s stat=%s " % (a_veldir, site) + "min_taper_range=0.0 max_taper_range=0.0 " + "gftype=fk gflocs=%s gftimes=%s gf_swap_bytes=%d " % (config.GF_LOCS, config.GF_TIMES, config.GF_SWAP_BYTES) + "gfpath=%s gfname=%s maxnt=%d mindt=%f " % (config.A_GP_GF_DIR, config.GF_NAME, config.MAX_GFNT, config.MIN_GFDT) + "dtout=%f ntout=%d >> %s 2>&1" % (config.DTOUT, config.NTOUT, self.log)) bband_utils.runprog(progstring, print_cmd=False) #This would differentiate to accel, but we want velocity #for entries in config.COMPS: # compo = entries # progstring = ("%s/integ_diff diff=1 " % install.A_GP_BIN_DIR + \ # "filein=%s/%s.%s fileout=%s/%d.%s-lf.%s " % # (a_veldir, site, compo, a_veldir, sim_id, site, compo)) # bband_utils.runprog(progstring) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_veldir, "%s.000" % (site)) ewfile = os.path.join(a_veldir, "%s.090" % (site)) udfile = os.path.join(a_veldir, "%s.ver" % (site)) bbpfile = os.path.join(a_veldir, "%d.%s-lf.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) # Run wcc2bpp progstring = ("%s wcc2bbp=1 " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + 'title="LP Sim NGAH, stat=%s" ' % site + 'nsfile=%s ewfile=%s udfile=%s > %s 2>> %s' % (nsfile, ewfile, udfile, bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) if self.r_srcfile == "": #calculate magnitude and write to file mag = fault_utils.get_magnitude(os.path.join(a_indir, self.r_velmodel), os.path.join(a_indir, self.r_srffile), sta_base) mag_file = open("%s" % os.path.join(a_indir, "magnitude_%s" % (sta_base)), 'w') mag_file.write("%.2f" % mag) mag_file.flush() mag_file.close() print("GP Jbsim Completed".center(80, '-'))
def do_reset(): """ This function resets an user account by deleting all simulation data from previous runs. For each of outdata, tmpdata, indata, and logs, it confirms if the user wants to delete the data. """ install = InstallCfg() # Print warning message print "WARNING".center(80, '=') print (" You are about to permanently delete Broadband simulation data") print (" from all previous runs!") print (" Data in indata, outdata, tmpdata, xml, and logs directories ") print (" will be permanently deleted!") print '='*80 print print (" The BBP data directory is set to: %s" % (install.A_DATA_ROOT)) print while True: proceed = raw_input("Do you want to proceed? (yes/no) ") if str.lower(proceed) == "yes": print "Deleting simulation data directories..." break elif str.lower(proceed) == "no": sys.exit(0) #proceed = raw_input("Delete 'outdata'? (yes/no) ") if str.lower(proceed) == "yes": prog_string = "rm -r %s" % (install.A_OUT_DATA_DIR) bband_utils.runprog(prog_string) print "Deleted 'outdata'!" else: print "Skipped 'outdata'" #proceed = raw_input("Delete 'tmpdata'? (yes/no) ") if str.lower(proceed) == "yes": prog_string = "rm -r %s" % (install.A_TMP_DATA_DIR) bband_utils.runprog(prog_string) print "Deleted 'tmpdata'!" else: print "Skipped 'tmpdata'" #proceed = raw_input("Delete 'indata'? (yes/no) ") if str.lower(proceed) == "yes": prog_string = "rm -r %s" % (install.A_IN_DATA_DIR) bband_utils.runprog(prog_string) print "Deleted 'indata'!" else: print "Skipped 'indata'" #proceed = raw_input("Delete 'logs'? (yes/no) ") if str.lower(proceed) == "yes": prog_string = "rm -r %s" % (install.A_OUT_LOG_DIR) bband_utils.runprog(prog_string) print "Deleted 'logs'!" else: print "Skipped 'logs'" #proceed = raw_input("Delete 'xml'? (yes/no) ") if str.lower(proceed) == "yes": prog_string = "rm -r %s" % (install.A_XML_DIR) bband_utils.runprog(prog_string) print "Deleted 'xml'!" else: print "Skipped 'xml'" # # delete *.pyc files in comps and in test if str.lower(proceed) == "yes": prog_string = "rm %s/comps/*.pyc" % (install.A_INSTALL_ROOT) bband_utils.runprog(prog_string) print "Deleted *.pyc files in comps" prog_string = "rm %s/tests/*.pyc" % (install.A_INSTALL_ROOT) bband_utils.runprog(prog_string) print "Deleted *.pyc files in test" # # Make clean to remove executables # if str.lower(proceed) == "yes": prog_string = "cd %s/src;make clean" % (install.A_INSTALL_ROOT) bband_utils.runprog(prog_string) print "src/make clean removed executables in src directory"
if line.startswith("#") or line.startswith("%"): continue pieces = line.split() pieces = [float(piece) for piece in pieces] nsfile.write(" %1.9E\n" % (pieces[1])) ewfile.write(" %1.9E\n" % (pieces[2])) udfile.write(" %1.9E\n" % (pieces[3])) # All done, close everything nsfile.close() ewfile.close() udfile.close() ifile.close() # Get pointers install = InstallCfg.getInstance() # Now convert them into sac format for comp in ["000", "090", "ver"]: file_in = "%s.%s" % (base_file, comp) file_out = "%s.sac" % (file_in) cmd = "echo '%s' > tmp" % (file_in) bband_utils.runprog(cmd) cmd = ("%s < tmp >> /dev/null 2>&1" % (os.path.join(install.A_UCSB_BIN_DIR, "BBPtoSAC"))) bband_utils.runprog(cmd) os.rename("output.sac", file_out) os.unlink(file_in) # Remove tmp file os.unlink("tmp")
def run(self): """ Runs the Anderson GoF code """ print("Anderson GoF".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", "anderson_gof") # 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.anderson.log" % (sim_id)) sta_file = os.path.join(a_indir, self.stations) sta_base = os.path.basename(os.path.splitext(self.stations)[0]) sims_dir = a_outdir obs_dir = os.path.join(a_tmpdir, "obs_seis_%s" % (sta_base)) # Start with first record irec = 0 # Read station list slo = StationList(sta_file) site_list = slo.getStationList() # Figure out station names station_names = [] for station in site_list: station_names.append(station.scode) # Loop over stations for site in site_list: station = site.scode print("==> Processing station: %s" % (station)) file_sims_acc = os.path.join(sims_dir, "%d.%s.acc.bbp" % (sim_id, station)) file_sims_rd50 = os.path.join(sims_dir, "%d.%s.rd50" % (sim_id, station)) lowcut = site.low_freq_corner highcut = site.high_freq_corner #print(lowcut, highcut) (sims_acc_org_time, sims_acc_org_ns, sims_acc_org_ew, sims_acc_org_ver) = np.genfromtxt(file_sims_acc, skip_header=2, dtype='float64', unpack='TRUE') (sims_perd, sims_rd50_ns, sims_rd50_ew, sims_rd50_ver) = np.genfromtxt(file_sims_rd50, skip_header=2, dtype='float64', unpack='TRUE') file_obs_acc = os.path.join(obs_dir, "%s.bbp" % (station)) file_obs_rd50 = os.path.join(obs_dir, "%s.rd50" % (station)) (obs_acc_org_time, obs_acc_org_ns, obs_acc_org_ew, obs_acc_org_ver) = np.genfromtxt(file_obs_acc, skip_header=2, dtype='float64', unpack='TRUE') (obs_perd, obs_rd50_ns, obs_rd50_ew, obs_rd50_ver) = np.genfromtxt(file_obs_rd50, skip_header=2, dtype='float64', unpack='TRUE') # Intitialize the rd50 arrays RD50PER = len(obs_perd) rd1 = np.zeros(RD50PER) rd2 = np.zeros(RD50PER) rd3 = np.zeros(RD50PER) rd4 = np.zeros(RD50PER) # Resample and align the time series (obs_acc_time, obs_acc_ew, sims_acc_time, sims_acc_ew) = self.align_seismograms(obs_acc_org_time, obs_acc_org_ew, sims_acc_org_time, sims_acc_org_ew) (obs_acc_time, obs_acc_ns, sims_acc_time, sims_acc_ns) = self.align_seismograms(obs_acc_org_time, obs_acc_org_ns, sims_acc_org_time, sims_acc_org_ns) obs_org_dt = obs_acc_org_time[1] - obs_acc_org_time[0] sims_org_dt = sims_acc_org_time[1] - sims_acc_org_time[0] obs_dt = obs_acc_time[1] - obs_acc_time[0] sims_dt = sims_acc_time[1] - sims_acc_time[0] if obs_dt == sims_dt: self.dt = obs_dt fs = 1. / self.dt fnyq = 0.5 * fs # Compute the number of pads for the time series # to have equal number of points for the fft # and for criteria 1 and 2. (sims_acc_ns, sims_acc_ew, obs_acc_ns, obs_acc_ew, ndata) = self.smcpadf(sims_acc_ns, sims_acc_ew, obs_acc_ns, obs_acc_ew, self.dt, lowcut, 8, highcut, 8, 'FALSE') # Start the loop for the different frequency bands for iband in range(len(self.B)): f1 = self.B[iband][0] f2 = self.B[iband][1] # Do the job only if the frequency band is within # the filtered band and if fnyq is higher than f1 if f1 >= lowcut and f2 <= highcut and fnyq >= f2: #print("Working on Period Band :", iband + 1, # "[", 1. / f2, 1. / f1, "]") T1 = 1. / f1 T2 = 1. / f2 t_tmp = sims_perd[(sims_perd <= T1) & (T2 <= sims_perd)] acc_1_flt = self.butter_bandpass(f1, f2, fnyq, sims_acc_ns, 2) acc_2_flt = self.butter_bandpass(f1, f2, fnyq, sims_acc_ew, 2) acc_3_flt = self.butter_bandpass(f1, f2, fnyq, obs_acc_ns, 2) acc_4_flt = self.butter_bandpass(f1, f2, fnyq, obs_acc_ew, 2) # Work on the frequency domain # Do the response spectra # Save the rsp for the specific frequency band rd1 = sims_rd50_ns[(sims_perd <= T1) & (T2 <= sims_perd)] rd2 = sims_rd50_ew[(sims_perd <= T1) & (T2 <= sims_perd)] rd3 = obs_rd50_ns[(obs_perd <= T1) & (T2 <= obs_perd)] rd4 = obs_rd50_ew[(obs_perd <= T1) & (T2 <= obs_perd)] self.C8[irec, iband] = np.nanmean([ self.c8_eval(rd1, rd3, t_tmp), self.c8_eval(rd2, rd4, t_tmp) ]) # Now the FFT # Compute the FFT frequencies F = np.fft.fftfreq(ndata, self.dt) # Compute the fft and the amplitudes fft_1 = np.fft.fft(sims_acc_ns) fft_1 = fft_1[(0. <= F) & (f1 <= F) & (F <= f2)] fft_2 = np.fft.fft(sims_acc_ew) fft_2 = fft_2[(0. <= F) & (f1 <= F) & (F <= f2)] fft_3 = np.fft.fft(obs_acc_ns) fft_3 = fft_3[(0. <= F) & (f1 <= F) & (F <= f2)] fft_4 = np.fft.fft(obs_acc_ew) fft_4 = fft_4[(0. <= F) & (f1 <= F) & (F <= f2)] # Slice the FFT frequencies for the working frequency band F = F[(f1 <= F) & (F <= f2)] fs1 = abs(fft_1) / len(fft_1) fs2 = abs(fft_2) / len(fft_2) fs3 = abs(fft_3) / len(fft_3) fs4 = abs(fft_4) / len(fft_4) self.C9[irec, iband] = np.nanmean( [self.c9_eval(fs1, fs3, F), self.c9_eval(fs2, fs4, F)]) # Work on the time domain """ # Compute the site corrected accelerograms acc_3_scor = np.fft.ifft(fft_3) acc_4_scor = np.fft.ifft(fft_4) # These do not need filtering because I'm working # in the sliced frequency domain acc_3_flt = abs(acc_3_scor) acc_4_flt = abs(acc_4_scor) """ vel_1 = self.integ(acc_1_flt, self.dt) vel_2 = self.integ(acc_2_flt, self.dt) vel_3 = self.integ(acc_3_flt, self.dt) vel_4 = self.integ(acc_4_flt, self.dt) dis_1 = self.integ(vel_1, self.dt) dis_2 = self.integ(vel_2, self.dt) dis_3 = self.integ(vel_3, self.dt) dis_4 = self.integ(vel_4, self.dt) c11, c31 = self.c13_eval(acc_1_flt, acc_3_flt) c12, c32 = self.c13_eval(acc_2_flt, acc_4_flt) c21, c41 = self.c24_eval(vel_1, vel_3) c22, c42 = self.c24_eval(vel_2, vel_4) self.C1[irec, iband] = np.nanmean(np.array(c11, c12)) self.C2[irec, iband] = np.nanmean(np.array(c21, c22)) self.C3[irec, iband] = np.nanmean(np.array(c31, c32)) self.C4[irec, iband] = np.nanmean(np.array(c41, c42)) self.C5[irec, iband] = np.nanmean([ self.c5_eval(acc_1_flt, acc_3_flt), self.c5_eval(acc_2_flt, acc_4_flt) ]) self.C6[irec, iband] = np.nanmean([ self.c6_eval(vel_1, vel_3), self.c6_eval(vel_2, vel_4) ]) self.C7[irec, iband] = np.nanmean([ self.c7_eval(dis_1, dis_3), self.c7_eval(dis_2, dis_4) ]) self.C10[irec, iband] = np.nanmean([ self.c10_eval(acc_1_flt, acc_3_flt), self.c10_eval(acc_2_flt, acc_4_flt) ]) #print(self.C1[irec, iband], # self.C2[irec, iband], # self.C3[irec, iband], # self.C4[irec, iband], # self.C5[irec, iband], # self.C6[irec, iband], # self.C7[irec, iband], # self.C8[irec, iband], # self.C9[irec, iband], # self.C10[irec, iband]) self.S1[irec] = np.nanmean( np.array([ np.nanmean(self.C1[irec, :]), np.nanmean(self.C2[irec, :]), np.nanmean(self.C3[irec, :]), np.nanmean(self.C4[irec, :]), np.nanmean(self.C5[irec, :]), np.nanmean(self.C6[irec, :]), np.nanmean(self.C7[irec, :]), np.nanmean(self.C8[irec, :]), np.nanmean(self.C9[irec, :]), np.nanmean(self.C10[irec, :]) ])) output_file = os.path.join( a_validation_outdir, "gof-%s-%d-anderson-%s.txt" % (self.eventname, self.sim_id, station)) out_file = open(output_file, 'w') line = ('#%s%5s%4s%4s%4s%4s%4s%4s%4s%4s%4s\n' % ('band', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10')) out_file.write(line) for i in range(self.BMAX): line = ( '%s %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f\n' % (self.BNAMES[i], self.C1[irec, i], self.C2[irec, i], self.C3[irec, i], self.C4[irec, i], self.C5[irec, i], self.C6[irec, i], self.C7[irec, i], self.C8[irec, i], self.C9[irec, i], self.C10[irec, i])) out_file.write(line) out_file.close() output_file = os.path.join( a_validation_outdir, "gof-%s-%d-anderson-%s.png" % (self.eventname, self.sim_id, station)) self.cplots(irec, station, output_file) print('===> Station score :', "{:3.1f}".format(self.S1[irec])) irec = irec + 1 print('==> Total number of stations processed: %d' % (irec)) self.C1 = self.C1[0:irec, :] self.C2 = self.C2[0:irec, :] self.C3 = self.C3[0:irec, :] self.C4 = self.C4[0:irec, :] self.C5 = self.C5[0:irec, :] self.C6 = self.C6[0:irec, :] self.C7 = self.C7[0:irec, :] self.C8 = self.C8[0:irec, :] self.C9 = self.C9[0:irec, :] self.C10 = self.C10[0:irec, :] self.S1 = self.S1[0:irec] c1conf = [self.statts(self.C1[:, i]) for i in range(self.BMAX)] c2conf = [self.statts(self.C2[:, i]) for i in range(self.BMAX)] c3conf = [self.statts(self.C3[:, i]) for i in range(self.BMAX)] c4conf = [self.statts(self.C4[:, i]) for i in range(self.BMAX)] c5conf = [self.statts(self.C5[:, i]) for i in range(self.BMAX)] c6conf = [self.statts(self.C6[:, i]) for i in range(self.BMAX)] c7conf = [self.statts(self.C7[:, i]) for i in range(self.BMAX)] c8conf = [self.statts(self.C8[:, i]) for i in range(self.BMAX)] c9conf = [self.statts(self.C9[:, i]) for i in range(self.BMAX)] c10conf = [self.statts(self.C10[:, i]) for i in range(self.BMAX)] s1_event = np.nanmean(self.S1) print('==> Overall event score:', "{:3.1f}".format(s1_event)) output_file = os.path.join( a_validation_outdir, '%d.gof_anderson.%s.txt' % (self.sim_id, self.eventname)) out_file = open(output_file, 'w') line = ('#%s%5s%4s%4s%4s%4s%4s%4s%4s%4s%4s\n' % ('band', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10')) out_file.write(line) for i in range(self.BMAX): line = ( '%s %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f\n' % (self.BNAMES[i], c1conf[i][0], c2conf[i][0], c3conf[i][0], c4conf[i][0], c5conf[i][0], c6conf[i][0], c7conf[i][0], c8conf[i][0], c9conf[i][0], c10conf[i][0])) out_file.write(line) out_file.close() output_file = os.path.join( a_validation_outdir, "gof-%s-%d-anderson-summary.png" % (self.eventname, self.sim_id)) self.fplots(s1_event, np.asarray(c1conf), np.asarray(c2conf), np.asarray(c3conf), np.asarray(c4conf), np.asarray(c5conf), np.asarray(c6conf), np.asarray(c7conf), np.asarray(c8conf), np.asarray(c9conf), np.asarray(c10conf), output_file) print("Anderson GoF Completed".center(80, '-'))
def run(self): """ This function prepares the parameters for HFSim and then calls it """ print("GP HfSims".center(80, '-')) install = InstallCfg.getInstance() sim_id = self.sim_id # Find validation object if this is a validation run if self.val_name is not None: self.val_obj = validation_cfg.VE_EVENTS.get_event_by_name(self.val_name) 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.hfsims_%s.log" % (sim_id, sta_base)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_srffile = os.path.join(a_indir, self.r_srffile) # Make sure we work when starting from an SRF file if self.r_srcfile: a_srcfile = os.path.join(a_indir, self.r_srcfile) else: a_srcfile = "" # Set up basic parameters, read SRC file if provided config = HfsimsCfg(a_srcfile=a_srcfile) # Get pointer to the velocity model object vel_obj = velocity_models.get_velocity_model_by_name(self.vmodel_name) if vel_obj is None: raise bband_utils.ParameterError("Cannot find velocity model: %s" % (self.vmodel_name)) # Check for velocity model-specific parameters vmodel_params = vel_obj.get_codebase_params('gp') # Look for KAPPA if 'KAPPA' in vmodel_params: self.kappa = float(vmodel_params['KAPPA']) else: self.kappa = config.KAPPA # Look for QFEXP if 'QFEXP' in vmodel_params: self.qfexp = float(vmodel_params['QFEXP']) else: self.qfexp = config.DEFAULT_QFEXP # Look for SDROP if 'SDROP' in vmodel_params: self.sdrop = int(vmodel_params['SDROP']) else: self.sdrop = config.DEFAULT_SDROP # Look for C0 and C1 if 'C0' in vmodel_params: self.c0 = int(vmodel_params['C0']) else: self.c0 = config.DEFAULT_C0 if 'C1' in vmodel_params: self.c1 = int(vmodel_params['C1']) else: self.c1 = config.DEFAULT_C1 # Look for DEFAULT_FCFAC if 'DEFAULT_FCFAC' in vmodel_params: self.default_fcfac = float(vmodel_params['DEFAULT_FCFAC']) else: self.default_fcfac = config.DEFAULT_FCFAC # Look for rayset if 'RAYSET' in vmodel_params: self.rayset = ast.literal_eval(vmodel_params['RAYSET']) else: self.rayset = config.RAYSET # Look for a high frequency DT if 'HF_DT' in vmodel_params: self.dt = float(vmodel_params['HF_DT']) else: self.dt = config.DT # Look for MEAN_RVFAC if 'MEAN_RVFAC' in vmodel_params: self.mean_rvfac = float(vmodel_params['MEAN_RVFAC']) else: self.mean_rvfac = config.MEAN_RVFAC # Look for RANGE_RVFAC if 'RANGE_RVFAC' in vmodel_params: self.range_rvfac = float(vmodel_params['RANGE_RVFAC']) else: self.range_rvfac = config.RANGE_RVFAC # Look for SHAL_RVFAC if 'SHAL_RVFAC' in vmodel_params: self.shal_rvfac = float(vmodel_params['SHAL_RVFAC']) else: self.shal_rvfac = config.SHAL_RVFAC # Look for VSMOHO if 'VSMOHO' in vmodel_params: self.vsmoho = float(vmodel_params['VSMOHO']) else: self.vsmoho = config.DEFAULT_VSMOHO # Look for DEEP_RVFAC if 'DEEP_RVFAC' in vmodel_params: self.deep_rvfac = float(vmodel_params['DEEP_RVFAC']) else: self.deep_rvfac = config.DEEP_RVFAC # Look for PATH_DUR_MODEL if 'PATH_DUR_MODEL' in vmodel_params: self.path_dur_model = int(vmodel_params['PATH_DUR_MODEL']) else: self.path_dur_model = config.PATH_DUR_MODEL # Look for RVSIG if 'RVSIG' in vmodel_params: self.rvsig = float(vmodel_params['RVSIG']) else: self.rvsig = config.RVSIG # Look for DX if 'DEFAULT_DX' in vmodel_params: self.default_dx = float(vmodel_params['DEFAULT_DX']) else: self.default_dx = config.DEFAULT_DX # Look for DY if 'DEFAULT_DY' in vmodel_params: self.default_dy = float(vmodel_params['DEFAULT_DY']) else: self.default_dy = config.DEFAULT_DY # Calculate rvfac if "common_seed" in config.CFGDICT: rvfac = calculate_rvfac(self.mean_rvfac, self.range_rvfac, config.CFGDICT["common_seed"]) else: rvfac = calculate_rvfac(self.mean_rvfac, self.range_rvfac, config.CFGDICT["seed"]) # Look for tlen if "TLEN" in vmodel_params: self.tlen = float(vmodel_params['TLEN']) else: self.tlen = config.TLEN # Start with some default values moment = -1 extra_fcfac = config.DEFAULT_EXTRA_FCFAC if self.val_obj is not None: extra_fcfac = float(self.val_obj.get_input("GP", "EXTRA_FCFAC")) try: tlen = float(self.val_obj.get_input("GP", "TLEN")) self.tlen = tlen except (ValueError, KeyError, TypeError): # No problem, just use the default TLEN for this simulation pass fcfac = round((1 + self.default_fcfac) * (1 + extra_fcfac) - 1, 4) a_slipfile = os.path.join(a_tmpdir, "%s.%s.%fx%f" % (self.r_srffile, sta_base, self.default_dx, self.default_dy)) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "srf2stoch")) + "infile=%s outfile=%s " % (a_srffile, a_slipfile) + "target_dx=%f target_dy=%f " % (self.default_dx, self.default_dy) + ">> %s 2>&1" % (self.log)) bband_utils.runprog(progstring) a_outp = os.path.join(a_tmpdir, "tmp_hfsim_out") a_velmod = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_velmodel) a_statfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_stations) # Create local velocity model vel_in_fp = open(a_velmod, 'r') a_velmod = "%s_%s.local" % (a_velmod, sta_base) vel_out_fp = open(a_velmod, 'w') vel_in_data = vel_in_fp.readlines() vel_in_fp.close() i = 0 for line in vel_in_data: i += 1 if line.startswith('#') or line.startswith('%'): continue pieces = line.split() if len(pieces) >= 4: th = float(pieces[0]) vp = float(pieces[1]) vs = float(pieces[2]) dn = float(pieces[3]) qs = self.c0 + self.c1 * vs if i == len(vel_in_data): th = 0.0 vel_out_fp.write("%8.4f %8.4f %8.4f %8.4f %8.2f %8.2f\n" % (th, vp, vs, dn, qs, qs)) else: vel_out_fp.write(line) vel_out_fp.flush() vel_out_fp.close() # # Scan the station list with this object construction # This scanner removes all the comment lines and the # list that is returned has one station per line in it. # slo = StationList(a_statfile) site_list = slo.getStationList() nstat = len(site_list) # Create rayset param list rayset_param = "" for item in self.rayset: rayset_param = rayset_param + "%d " % (item) rayset_param = rayset_param.strip() # # Run initial hfsim conf # progstring = ("%s >> %s 2>&1 << END\n" % (os.path.join(install.A_GP_BIN_DIR, config.HFSIM), self.log) + "%d\n" % self.sdrop + "%s\n" % a_statfile + "%s\n" % a_outp + "%s\n" % rayset_param + "%d\n" % config.SITEAMP + "4 0 0.02 19.9\n" + "%d\n" % config.CFGDICT["seed"] + "%d\n" % nstat + "%f %f %f %f %f\n" % (self.tlen, self.dt, config.FMAX, self.kappa, self.qfexp) + "%f %f %f %f %f\n" % (rvfac, self.shal_rvfac, self.deep_rvfac, fcfac, config.C_ALPHA) + "%s %f\n" % (moment, config.RUPV) + "%s\n" % a_slipfile + "%s\n" % a_velmod + "%f\n" % self.vsmoho + "-99 0.0 0.0 0.0 0.0 1\n" + "-1\n" + "%f 0.0 %f\n" % (config.FA_SIG1, self.rvsig) + "%d\n" % (self.path_dur_model) + "END") bband_utils.runprog(progstring) # # Start the per station processing # for site in site_list: # Need to integrate each component, since hfsims outputs cm/s/s for comp in ['000', '090', 'ver']: cmd = ("%s integ=1 " % (os.path.join(install.A_GP_BIN_DIR, "integ_diff")) + "filein=%s_%s.%s fileout=%s/%d.%s-hf.%s >> %s 2>&1" % (a_outp, site.scode, comp, a_tmpdir, sim_id, site.scode, comp, self.log)) bband_utils.runprog(cmd, print_cmd=False) progstring1 = ("%s wcc2bbp=1 " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + 'title="HF Sim NGAH, stat=%s" ' % (site.scode) + "nsfile=%s/%d.%s-hf.000 " % (a_tmpdir, sim_id, site.scode) + "ewfile=%s/%d.%s-hf.090 " % (a_tmpdir, sim_id, site.scode) + "udfile=%s/%d.%s-hf.ver " % (a_tmpdir, sim_id, site.scode) + 'units="%s" > %s/%d.%s-hf.bbp 2>> %s\n' % (str(config.UNITS), a_tmpdir, sim_id, site.scode, self.log)) bband_utils.runprog(progstring1, print_cmd=False) progstring1 = ("%s wcc2bbp=1 " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + 'title="HF Sim NGAH, stat=%s" ' % site.scode + "nsfile=%s_%s.000 " % (a_outp, site.scode) + "ewfile=%s_%s.090 " % (a_outp, site.scode) + "udfile=%s_%s.ver " % (a_outp, site.scode) + '> %s_%s.bbp 2>> %s\n' % (a_outp, site.scode, self.log)) bband_utils.runprog(progstring1, print_cmd=False) print("GP HfSims Completed".center(80, '-'))
def main(): """ Parse command line options and create the needed files/directories """ prog_base = os.path.basename(sys.argv[0]) usage = "usage: %s [options]" % (prog_base) parser = argparse.ArgumentParser(description="Merges a number of " "validation segments into a single " "multi-segment simulation") parser.add_argument("-d", "--dir", dest="merged_simdir", help="Merged simulation directory") parser.add_argument("-e", "--event", dest="event", help="validation event") parser.add_argument('input_segments', nargs='*', help="top-level directories for all segments") args = parser.parse_args() # Input segments if len(args.input_segments) < 2: print("Please provide at least two simulations to merge!") sys.exit(-1) input_segments = args.input_segments # Event name if args.event is None: print("[ERROR]: Please provide an event name!") sys.exit(-1) event = args.event # Check for the simulation directory merged_simdir = args.merged_simdir if merged_simdir is None: print("Please provide a merged simulation directory!") sys.exit(1) merged_simdir = os.path.abspath(merged_simdir) if os.path.exists(merged_simdir): print("Merged simulation directory exists: %s" % (merged_simdir)) opt = raw_input("Do you want to delete its contents (y/n)? ") if opt.lower() != "y": print("Please provide another simulation directory!") sys.exit(1) opt = raw_input("ARE YOU SURE (y/n)? ") if opt.lower() != "y": print("Please provide another simulation directory!") sys.exit(1) # Delete existing directory (we already asked the user twice!!!) shutil.rmtree(merged_simdir) # Create merged simulation directories os.makedirs(merged_simdir) merged_indir = os.path.join(merged_simdir, "Sims", "indata") merged_outdir = os.path.join(merged_simdir, "Sims", "outdata") merged_tmpdir = os.path.join(merged_simdir, "Sims", "tmpdata") merged_logdir = os.path.join(merged_simdir, "Sims", "logs") xmldir = os.path.join(merged_simdir, "Xml") srcdir = os.path.join(merged_simdir, "Src") for mdir in [merged_indir, merged_outdir, merged_tmpdir, merged_logdir, xmldir, srcdir]: os.makedirs(mdir) # Setup BBP installation os.environ["BBP_DATA_DIR"] = os.path.join(merged_simdir, "Sims") bbp_install = InstallCfg.getInstance() # Make sure event exists event_names = validation_cfg.VE_EVENTS.get_all_names() event_names_lc = [e.lower() for e in event_names] if not event.lower() in event_names_lc: print("[ERROR]: Unknown event: %s" % (event)) print("[ERROR]: Available events: ", event_names) shutil.rmtree(merged_simdir) sys.exit(1) val_event = event val_obj = validation_cfg.VE_EVENTS.get_event_by_print_name(event) # Make sure directories exist input_sims = [] for simdir in input_segments: simdir = os.path.abspath(simdir) if not os.path.exists(simdir): print("Simulation directory %s does not exist!" % (simdir)) sys.exit(1) input_sims.append(simdir) # Figure out the realizations input_sim = os.path.join(input_sims[0], "Sims", "outdata") realizations = glob.glob("%s%s*" % (input_sim, os.path.sep)) num_realizations = len(realizations) realizations = [os.path.basename(item) for item in realizations] # Merge each realization print(" BBP Multi-segment merging tool ".center(80, "-")) print("=> Merging %d realizations..." % (num_realizations)) for realization in realizations: print("==> Realization %s" % (realization)) # Create directories merged_realization_indir = os.path.join(merged_indir, realization) merged_realization_tmpdir = os.path.join(merged_tmpdir, realization) merged_realization_outdir = os.path.join(merged_outdir, realization) merged_realization_logdir = os.path.join(merged_logdir, realization) for mdir in [merged_realization_indir, merged_realization_outdir, merged_realization_tmpdir, merged_realization_logdir]: os.makedirs(mdir) # Copy indata files (src_files, srf_files, station_list) = copy_indata_files(input_sims, merged_realization_indir, merged_realization_tmpdir, realization) # Merge seismograms merge_seismograms(input_sims, station_list, merged_realization_outdir, realization) # Plot combined SRF plot plot_srf_file(merged_realization_indir, merged_realization_tmpdir, merged_realization_outdir, bbp_install, srf_files, val_event) # Post-processing steps post_process(station_list, src_files, merged_realization_outdir, realization, val_obj) print("==> Realization %s Completed" % (realization)) print("%s" % ("*" * 80))
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 run(self): """ Runs the UCSB site response program """ print("UCSB Site".center(80, '-')) # # Global installation parameters # install = InstallCfg.getInstance() # # Required Inputs are sim_id, SRC file, and station list # 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.uc_site_%s.log" % (sim_id, sta_base)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_mod = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "uc_site_%s" % (sta_base)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_velocity = os.path.join(a_indir, self.r_velocity) # # Make sure the output and tmp directories exist # bband_utils.mkdirs([a_tmpdir, a_tmpdir_mod, a_outdir], print_cmd=False) # Parse SRC file if self.r_srcfile is None or self.r_srcfile == "": raise bband_utils.ParameterError("SRC file not defined!") a_srcfile = os.path.join(a_indir, self.r_srcfile) self.cfg = UCSiteCfg(a_srcfile) cfg = self.cfg # Store cwd and change over to tmpdir so the executable can # find the files old_cwd = os.getcwd() os.chdir(a_tmpdir_mod) # Copy velocity file to tmpdir_mod shutil.copy2(a_velocity, os.path.join(a_tmpdir_mod, self.r_velocity)) # Read station list a_stations = os.path.join(a_indir, self.r_stations) print(a_stations) slo = StationList(a_stations) site_list = slo.getStationList() # This is not a UCSB format station list, convert station # list to UCSB format, generating the station file and the # vs30 file a_uc_stations = os.path.join(a_tmpdir_mod, cfg.R_UC_STATION_FILE) a_uc_vs30 = os.path.join(a_tmpdir_mod, cfg.R_UC_VS30_FILE) stas2files.gp2uc_stalist(slo, a_uc_stations, a_uc_vs30) # # The UCSB codes require fixed input names. So here, we copy # the UCSB file over to the expected name "stations.ll" # cmd = ("cp %s %s" % (a_uc_stations, os.path.join(a_tmpdir_mod, "stations.ll"))) bband_utils.runprog(cmd) # Copy .bbp files over to .3comp # If we have anything but just a hybrid file, combine them first # Use site 0 as the dummy for site in site_list: if os.path.exists("%s/%d.%s.bbp" % (a_tmpdir, sim_id, site.scode)): shutil.copy2("%s/%d.%s.bbp" % (a_tmpdir, sim_id, site.scode), "%s/%s.3comp" % (a_tmpdir_mod, site.scode)) elif os.path.exists("%s/%s.3comp" % (a_tmpdir, site.scode)): shutil.copy2("%s/%s.3comp" % (a_tmpdir, site.scode), "%s/%s.3comp" % (a_tmpdir_mod, site.scode)) # determine dt for input seismogram bbp_fp = open("%s/%s.3comp" % (a_tmpdir_mod, site.scode), 'r') bbp_data = bbp_fp.readlines() bbp_fp.close() i = 0 while bbp_data[i][0] == '%' or bbp_data[i][0] == '#': i += 1 t0 = float(bbp_data[i].split()[0]) t1 = float(bbp_data[i + 1].split()[0]) input_dt = t1 - t0 print("input_dt: %f\n" % (input_dt)) # # Create deconvBBP.inp, stitchBBP.inp, VMname.list # dBBP_in = open("deconvBBP.inp", "w") dBBP_in.write("%s\n" % self.r_velocity) dBBP_in.write("0.29\n") dBBP_in.write("1\n") dBBP_in.write("%d\n" % len(site_list)) for site in site_list: dBBP_in.write("%s\n" % site.scode) dBBP_in.flush() dBBP_in.close() sBBP_in = open("stitchBBP.inp", "w") sBBP_in.write("stations.xy\n") sBBP_in.write("VMname.list\n") sBBP_in.write("./\n") sBBP_in.write("./\n") sBBP_in.write("1.0, 15.0\n") # depth of hypocenter hypo_dep = fault_utils.calculate_hypo_depth(a_srcfile) sBBP_in.write("%s\n" % hypo_dep) sBBP_in.write("1\n") sBBP_in.write("2\n") sBBP_in.flush() sBBP_in.close() vMname_in = open("VMname.list", "w") for site in site_list: vMname_in.write("%s\n" % self.r_velocity) vMname_in.flush() vMname_in.close() # # Create stations.xy if it doesn't exist yet # if not os.path.exists("stations.xy"): # # Create faultGlobal.in # r_faultfile = "faultGlobal.in" a_faultfile = os.path.join(a_tmpdir_mod, r_faultfile) self.create_fault_global_in(a_faultfile) # # Convert stations to xy # cmd = "%s >> %s 2>&1" % (self.cfg.A_SLL2XY, self.log) bband_utils.runprog(cmd) # # Deconvolve # cmd = "%s >> %s 2>&1" % (self.cfg.A_UC_DECON_EXE, self.log) bband_utils.runprog(cmd) # # Logic of separateStats.csh pulled out into function # stations_to_stitch = self.separate_stats(install, a_uc_vs30, input_dt) # # Stitch # # Update station files to only stitch non class A stations # (Class A stations don't have a non-linear component) # Must use 'stations.xy' because it's in stitchBBP.inp # shutil.copy2("stations.xy", "stations.xy.orig") shutil.copy2("stations.ll", "stations.ll.orig") station_in = open("stations.xy.orig", 'r') station_ll_in = open("stations.ll.orig", "r") station_ll_data = station_ll_in.readlines() station_data = station_in.readlines() station_in.close() station_ll_in.close() station_out = open("stations.xy", "w") station_ll_out = open("stations.ll", "w") pieces = station_data[0].split() station_out.write("%d %f %f %f\n" % (len(stations_to_stitch), float( pieces[1]), float(pieces[2]), float(pieces[3]))) station_ll_out.write("%d\n" % len(stations_to_stitch)) i = 1 while i < len(station_data): inList = False stat_data_name = station_data[i].strip() for site in stations_to_stitch: if stat_data_name == site: inList = True break if inList: station_out.write("%s\n" % stat_data_name) station_out.write("%s" % station_data[i + 1]) station_ll_out.write("%s" % station_ll_data[(i + 1) // 2]) i += 2 station_out.flush() station_ll_out.flush() station_out.close() station_ll_out.close() cmd = "%s >> %s 2>&1" % (self.cfg.A_STITCH, self.log) bband_utils.runprog(cmd) # # Copy original stations file back in # shutil.copy2("stations.xy", "stations.xy.stitch") shutil.copy2("stations.xy.orig", "stations.xy") # Convert to 3-component seismograms # cmd = "%s/conv3CompBB >> %s 2>&1" % (install.A_UCSB_BIN_DIR, self.log) bband_utils.runprog(cmd) shutil.copy2("stations.ll", "stations.ll.stitch") shutil.copy2("stations.ll.orig", "station.ll") # Move the results to the output directory, as bbp format for result_file in os.listdir(a_tmpdir_mod): dot_index = result_file.rfind('.3comp') if dot_index > -1: basename = result_file[0:dot_index] shutil.copy2(result_file, "%s/%d.%s.vel.bbp" % (a_outdir, sim_id, basename)) shutil.copy2(result_file, "%s/%d.%s.vel.bbp" % (a_tmpdir, sim_id, basename)) shutil.copy2(result_file, "%s/%s.3comp" % (a_tmpdir, basename)) # Create acceleration seismogram # Create path names and check if their sizes are # within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.000" % (sim_id, basename)) ewfile = os.path.join(a_tmpdir, "%d.%s.090" % (sim_id, basename)) udfile = os.path.join(a_tmpdir, "%d.%s.ver" % (sim_id, basename)) bbpfile = os.path.join(a_tmpdir, "%d.%s.vel.bbp" % (sim_id, basename)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/wcc2bbp " % (install.A_GP_BIN_DIR) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True) for comp in cfg.COMPS: # Differentiate each component filein = os.path.join( a_tmpdir, "%d.%s.%s" % (sim_id, basename, comp)) fileout = os.path.join( a_tmpdir, "%d.%s.acc.%s" % (sim_id, basename, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s/integ_diff diff=1 filein=%s fileout=%s" % (install.A_GP_BIN_DIR, filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True) # Create path names and check if their sizes are # within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.acc.000" % (sim_id, basename)) ewfile = os.path.join(a_tmpdir, "%d.%s.acc.090" % (sim_id, basename)) udfile = os.path.join(a_tmpdir, "%d.%s.acc.ver" % (sim_id, basename)) bbpfile = os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, basename)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/wcc2bbp " % (install.A_GP_BIN_DIR) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True) # Copy acceleration bbp file to outdir shutil.copy2( os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, basename)), os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, basename))) os.chdir(old_cwd) print("UCSB Site Completed".center(80, '-'))
def main(): """ Parse command line options and create the needed files/directories """ # Detect BBP installation bbp_install = InstallCfg.getInstance() prog_base = os.path.basename(sys.argv[0]) usage = "usage: %s [options]" % (prog_base) parser = optparse.OptionParser(usage) parser.add_option("-c", "--codebase", type="string", action="store", dest="codebase", help="Codebase for the simulation: %s" % (CODEBASES)) parser.add_option("-e", "--event", type="string", action="store", dest="event", help="Validation event (should be configured in BBP)") parser.add_option("-d", "--dir", type="string", action="store", dest="simdir", help="Simulation directory") parser.add_option("--skip-rupgen", action="store_true", dest="skiprupgen", help="Skip the rupture generator, run only 1 simulation") parser.add_option("--hypo-rand", action="store_true", dest="hyporand", help="Enables hypocenter randomization") parser.add_option("--no-hypo-rand", action="store_false", dest="hyporand", help="Disables hypocenter randomization") parser.add_option("-n", "--num-simulations", type="int", action="store", dest="numsim", help="Number of simulations to run") parser.add_option("--email", type="string", action="store", dest="email", help="Email for job notifications") (options, args) = parser.parse_args() # Validate codebase to use codebase = options.codebase if codebase is None: print "Please specify a codebase!" sys.exit(1) codebase = codebase.lower() if codebase not in CODEBASES: print "Codebase needs to be one of: %s" % (CODEBASES) # Check for event event = options.event if event is None: print "Please provide a validation event!" sys.exit(1) event_names = validation_cfg.VE_EVENTS.get_all_names() events = [v_event.lower() for v_event in event_names] if event.lower() not in events: print ("Event %s does not appear to be properly configured on BBP" % (event)) print ("Available options are: %s" % (event_names)) print "Please provide another event or check your BBP installation." sys.exit(1) val_obj = validation_cfg.VE_EVENTS.get_event_by_print_name(event) # Check if we want to run the rupture generator skip_rupgen = options.skiprupgen # Check for hypocenter randomization if options.hyporand is None: print "Please specify --hypo-rand or --no-hypo-rand!" sys.exit(1) if options.hyporand: hypo_rand = True else: hypo_rand = False if not skip_rupgen: # Get source file try: source_file = val_obj.get_input(codebase, "source").strip() except KeyError: print ("Unable to get source file for event %s, codebase %s!" % (event, codebase)) sys.exit(1) if not source_file: print ("Source file for event %s, codebase %s not specified!" % (event, codebase)) sys.exit(1) else: # No need to get the source file, we start from the srf source_file = None try: srf_file = val_obj.get_input(codebase, "srf").strip() except KeyError: print ("Event %s does not have a srf file for codebase %s!" % (event, codebase)) sys.exit(1) if not srf_file: print ("Event %s does not have a srf file for codebase %s!" % (event, codebase)) sys.exit(1) # Force number of simulations to 1 options.numsim = 1 # Check for the simulation directory simdir = options.simdir if simdir is None: print "Please provide a simulation directory!" sys.exit(1) simdir = os.path.abspath(simdir) if os.path.exists(simdir): print "Simulation directory exists: %s" % (simdir) opt = raw_input("Do you want to delete its contents (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) opt = raw_input("ARE YOU SURE (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) # Delete existing directory (we already asked the user twice!!!) shutil.rmtree(simdir) # Pick up number of simulations to run numsim = options.numsim if numsim < 1 or numsim > MAX_SIMULATIONS: print ("Number of simulations should be between 1 and %d" % (MAX_SIMULATIONS)) sys.exit(1) # Check for e-mail address email = options.email if email is None: print "Please provide an e-mail address for job notifications" sys.exit(1) # Make sure user has configured the setup_bbp_epicenter_env.sh script setup_bbp_env = os.path.join(bbp_install.A_INSTALL_ROOT, "utils/batch/setup_bbp_epicenter_env.sh") if not os.path.exists(setup_bbp_env): print ("Cannot find setup_bbp_epicenter_env.sh script!") print ("Expected at: %s" % (setup_bbp_env)) sys.exit(1) # Create simulation directories prefix = "%s-%s" % (event.lower(), codebase.lower()) # Make sure we remove spaces from prefix (e.g. for the "Loma Prieta" event) prefix = prefix.replace(" ", '') os.makedirs(simdir) indir = os.path.join(simdir, "Sims", "indata") outdir = os.path.join(simdir, "Sims", "outdata") tmpdir = os.path.join(simdir, "Sims", "tmpdata") logsdir = os.path.join(simdir, "Sims", "logs") xmldir = os.path.join(simdir, "Xml") srcdir = os.path.join(simdir, "Src") for mdir in [indir, outdir, tmpdir, logsdir, xmldir, srcdir]: os.makedirs(mdir) # Generate source files if needed if source_file is not None: generate_src_files(numsim, source_file, srcdir, prefix, hypo_rand) # Generate xml files generate_xml(bbp_install, numsim, srcdir, xmldir, logsdir, event, codebase, prefix, skip_rupgen) # Write pbs file write_pbs(bbp_install, numsim, simdir, xmldir, email, prefix)
def run(self): """ This function prepares the parameters for Irikura's gen_srf then calls it """ # 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)) # Make sure the output and tmp directories exist bband_utils.mkdirs([a_tmpdir, a_indir, a_outdir]) # Now, file paths self.log = os.path.join(a_logdir, "%d.gen_srf.log" % (sim_id)) a_srcfile = os.path.join(a_indir, self.r_srcfile) # Read src file cfg = IrikuraCfg(a_srcfile) # Define location of input velocity model and output srf file a_srffile = os.path.join(a_indir, self.r_srffile) a_velmod = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_velmodel) # Run in tmpdir subdir to isolate temp fortran files # Save cwd, change back to it at the end old_cwd = os.getcwd() os.chdir(a_tmpdir) # # Run gen_srf code # progstring = ("%s >> %s 2>&1 << END\n" % (os.path.join(install.A_IRIKURA_BIN_DIR, cfg.GENSRF), self.log) + "%s\n" % a_srffile + "%f %f %f %f %f\n" % (cfg.CFGDICT["fault_length"], cfg.CFGDICT["fault_width"], cfg.CFGDICT['strike'], cfg.CFGDICT['dip'], cfg.CFGDICT['rake']) + "%f %f %f\n" % (cfg.CFGDICT["lon_top_center"], cfg.CFGDICT["lat_top_center"], cfg.CFGDICT["depth_to_top"]) + "%f %f\n" % (cfg.CFGDICT["dlen"], cfg.CFGDICT["dwid"]) + "%f %f %f %f\n" % (cfg.CFGDICT["hypo_along_stk"], cfg.CFGDICT["hypo_down_dip"], cfg.DENS, cfg.VS) + "%f\n" % (cfg.DT) + "%d\n" % (int(cfg.CFGDICT['seed'])) + "%s\n" % a_velmod + "END") bband_utils.runprog(progstring) # Restore working directory os.chdir(old_cwd) # # mv result to outputfile # progstring = "cp %s %s" % (a_srffile, os.path.join(a_tmpdir, self.r_srffile)) bband_utils.runprog(progstring) progstring = "cp %s %s" % (a_srffile, os.path.join(a_outdir, self.r_srffile)) bband_utils.runprog(progstring) # Plot SRF plot_srf.run(self.r_srffile, sim_id=self.sim_id) print("Completed Irikura gen_srf .....")
def run(self): """ Runs the Anderson GoF code """ print("Anderson GoF".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", "anderson_gof") # 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.anderson.log" % (sim_id)) sta_file = os.path.join(a_indir, self.stations) sta_base = os.path.basename(os.path.splitext(self.stations)[0]) sims_dir = a_outdir obs_dir = os.path.join(a_tmpdir, "obs_seis_%s" % (sta_base)) # Start with first record irec = 0 # Read station list slo = StationList(sta_file) site_list = slo.getStationList() # Figure out station names station_names = [] for station in site_list: station_names.append(station.scode) # Loop over stations for site in site_list: station = site.scode print("==> Processing station: %s" % (station)) file_sims_acc = os.path.join(sims_dir, "%d.%s.acc.bbp" % (sim_id, station)) file_sims_rd50 = os.path.join(sims_dir, "%d.%s.rd50" % (sim_id, station)) lowcut = site.low_freq_corner highcut = site.high_freq_corner #print(lowcut, highcut) (sims_acc_org_time, sims_acc_org_ns, sims_acc_org_ew, sims_acc_org_ver) = np.genfromtxt(file_sims_acc, skip_header=2, dtype='float64', unpack='TRUE') (sims_perd, sims_rd50_ns, sims_rd50_ew, sims_rd50_ver) = np.genfromtxt(file_sims_rd50, skip_header=2, dtype='float64', unpack='TRUE') file_obs_acc = os.path.join(obs_dir, "%s.bbp" % (station)) file_obs_rd50 = os.path.join(obs_dir, "%s.rd50" % (station)) (obs_acc_org_time, obs_acc_org_ns, obs_acc_org_ew, obs_acc_org_ver) = np.genfromtxt(file_obs_acc, skip_header=2, dtype='float64', unpack='TRUE') (obs_perd, obs_rd50_ns, obs_rd50_ew, obs_rd50_ver) = np.genfromtxt(file_obs_rd50, skip_header=2, dtype='float64', unpack='TRUE') # Intitialize the rd50 arrays RD50PER = len(obs_perd) rd1 = np.zeros(RD50PER) rd2 = np.zeros(RD50PER) rd3 = np.zeros(RD50PER) rd4 = np.zeros(RD50PER) # Resample and align the time series (obs_acc_time, obs_acc_ew, sims_acc_time, sims_acc_ew) = self.align_seismograms(obs_acc_org_time, obs_acc_org_ew, sims_acc_org_time, sims_acc_org_ew) (obs_acc_time, obs_acc_ns, sims_acc_time, sims_acc_ns) = self.align_seismograms(obs_acc_org_time, obs_acc_org_ns, sims_acc_org_time, sims_acc_org_ns) obs_org_dt = obs_acc_org_time[1] - obs_acc_org_time[0] sims_org_dt = sims_acc_org_time[1] - sims_acc_org_time[0] obs_dt = obs_acc_time[1] - obs_acc_time[0] sims_dt = sims_acc_time[1] - sims_acc_time[0] if obs_dt == sims_dt: self.dt = obs_dt fs = 1. / self.dt fnyq = 0.5 * fs # Compute the number of pads for the time series # to have equal number of points for the fft # and for criteria 1 and 2. (sims_acc_ns, sims_acc_ew, obs_acc_ns, obs_acc_ew, ndata) = self.smcpadf(sims_acc_ns, sims_acc_ew, obs_acc_ns, obs_acc_ew, self.dt, lowcut, 8, highcut, 8, 'FALSE') # Start the loop for the different frequency bands for iband in range(len(self.B)): f1 = self.B[iband][0] f2 = self.B[iband][1] # Do the job only if the frequency band is within # the filtered band and if fnyq is higher than f1 if f1 >= lowcut and f2 <= highcut and fnyq >= f2: #print("Working on Period Band :", iband + 1, # "[", 1. / f2, 1. / f1, "]") T1 = 1. / f1 T2 = 1. / f2 t_tmp = sims_perd[(sims_perd <= T1) & (T2 <= sims_perd)] acc_1_flt = self.butter_bandpass(f1, f2, fnyq, sims_acc_ns, 2) acc_2_flt = self.butter_bandpass(f1, f2, fnyq, sims_acc_ew, 2) acc_3_flt = self.butter_bandpass(f1, f2, fnyq, obs_acc_ns, 2) acc_4_flt = self.butter_bandpass(f1, f2, fnyq, obs_acc_ew, 2) # Work on the frequency domain # Do the response spectra # Save the rsp for the specific frequency band rd1 = sims_rd50_ns[(sims_perd <= T1) & (T2 <= sims_perd)] rd2 = sims_rd50_ew[(sims_perd <= T1) & (T2 <= sims_perd)] rd3 = obs_rd50_ns[(obs_perd <= T1) & (T2 <= obs_perd)] rd4 = obs_rd50_ew[(obs_perd <= T1) & (T2 <= obs_perd)] self.C8[irec, iband] = np.nanmean( [self.c8_eval(rd1, rd3, t_tmp), self.c8_eval(rd2, rd4, t_tmp)]) # Now the FFT # Compute the FFT frequencies F = np.fft.fftfreq(ndata, self.dt) # Compute the fft and the amplitudes fft_1 = np.fft.fft(sims_acc_ns) fft_1 = fft_1[(0. <= F) & (f1 <= F) & (F <= f2)] fft_2 = np.fft.fft(sims_acc_ew) fft_2 = fft_2[(0. <= F) & (f1 <= F) & (F <= f2)] fft_3 = np.fft.fft(obs_acc_ns) fft_3 = fft_3[(0. <= F) & (f1 <= F) & (F <= f2)] fft_4 = np.fft.fft(obs_acc_ew) fft_4 = fft_4[(0. <= F) & (f1 <= F) & (F <= f2)] # Slice the FFT frequencies for the working frequency band F = F[(f1 <= F) & (F <= f2)] fs1 = abs(fft_1) / len(fft_1) fs2 = abs(fft_2) / len(fft_2) fs3 = abs(fft_3) / len(fft_3) fs4 = abs(fft_4) / len(fft_4) self.C9[irec, iband] = np.nanmean( [self.c9_eval(fs1, fs3, F), self.c9_eval(fs2, fs4, F)]) # Work on the time domain """ # Compute the site corrected accelerograms acc_3_scor = np.fft.ifft(fft_3) acc_4_scor = np.fft.ifft(fft_4) # These do not need filtering because I'm working # in the sliced frequency domain acc_3_flt = abs(acc_3_scor) acc_4_flt = abs(acc_4_scor) """ vel_1 = self.integ(acc_1_flt, self.dt) vel_2 = self.integ(acc_2_flt, self.dt) vel_3 = self.integ(acc_3_flt, self.dt) vel_4 = self.integ(acc_4_flt, self.dt) dis_1 = self.integ(vel_1, self.dt) dis_2 = self.integ(vel_2, self.dt) dis_3 = self.integ(vel_3, self.dt) dis_4 = self.integ(vel_4, self.dt) c11, c31 = self.c13_eval(acc_1_flt, acc_3_flt) c12, c32 = self.c13_eval(acc_2_flt, acc_4_flt) c21, c41 = self.c24_eval(vel_1, vel_3) c22, c42 = self.c24_eval(vel_2, vel_4) self.C1[irec, iband] = np.nanmean( np.array(c11, c12)) self.C2[irec, iband] = np.nanmean( np.array(c21, c22)) self.C3[irec, iband] = np.nanmean( np.array(c31, c32)) self.C4[irec, iband] = np.nanmean( np.array(c41, c42)) self.C5[irec, iband] = np.nanmean( [self.c5_eval(acc_1_flt, acc_3_flt), self.c5_eval(acc_2_flt, acc_4_flt)]) self.C6[irec, iband] = np.nanmean( [self.c6_eval(vel_1, vel_3), self.c6_eval(vel_2, vel_4)]) self.C7[irec, iband] = np.nanmean( [self.c7_eval(dis_1, dis_3), self.c7_eval(dis_2, dis_4)]) self.C10[irec, iband] = np.nanmean( [self.c10_eval(acc_1_flt, acc_3_flt), self.c10_eval(acc_2_flt, acc_4_flt)]) #print(self.C1[irec, iband], # self.C2[irec, iband], # self.C3[irec, iband], # self.C4[irec, iband], # self.C5[irec, iband], # self.C6[irec, iband], # self.C7[irec, iband], # self.C8[irec, iband], # self.C9[irec, iband], # self.C10[irec, iband]) self.S1[irec] = np.nanmean( np.array([np.nanmean(self.C1[irec, :]), np.nanmean(self.C2[irec, :]), np.nanmean(self.C3[irec, :]), np.nanmean(self.C4[irec, :]), np.nanmean(self.C5[irec, :]), np.nanmean(self.C6[irec, :]), np.nanmean(self.C7[irec, :]), np.nanmean(self.C8[irec, :]), np.nanmean(self.C9[irec, :]), np.nanmean(self.C10[irec, :])])) output_file = os.path.join(a_validation_outdir, "gof-%s-%d-anderson-%s.txt" % (self.eventname, self.sim_id, station)) out_file = open(output_file, 'w') line = ('#%s%5s%4s%4s%4s%4s%4s%4s%4s%4s%4s\n' % ('band', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10')) out_file.write(line) for i in range(self.BMAX): line = ('%s %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f\n' % (self.BNAMES[i], self.C1[irec, i], self.C2[irec, i], self.C3[irec, i], self.C4[irec, i], self.C5[irec, i], self.C6[irec, i], self.C7[irec, i], self.C8[irec, i], self.C9[irec, i], self.C10[irec, i])) out_file.write(line) out_file.close() output_file = os.path.join(a_validation_outdir, "gof-%s-%d-anderson-%s.png" % (self.eventname, self.sim_id, station)) self.cplots(irec, station, output_file) print('===> Station score :', "{:3.1f}".format(self.S1[irec])) irec = irec + 1 print('==> Total number of stations processed: %d' % (irec)) self.C1 = self.C1[0:irec, :] self.C2 = self.C2[0:irec, :] self.C3 = self.C3[0:irec, :] self.C4 = self.C4[0:irec, :] self.C5 = self.C5[0:irec, :] self.C6 = self.C6[0:irec, :] self.C7 = self.C7[0:irec, :] self.C8 = self.C8[0:irec, :] self.C9 = self.C9[0:irec, :] self.C10 = self.C10[0:irec, :] self.S1 = self.S1[0:irec] c1conf = [self.statts(self.C1[:, i]) for i in range(self.BMAX)] c2conf = [self.statts(self.C2[:, i]) for i in range(self.BMAX)] c3conf = [self.statts(self.C3[:, i]) for i in range(self.BMAX)] c4conf = [self.statts(self.C4[:, i]) for i in range(self.BMAX)] c5conf = [self.statts(self.C5[:, i]) for i in range(self.BMAX)] c6conf = [self.statts(self.C6[:, i]) for i in range(self.BMAX)] c7conf = [self.statts(self.C7[:, i]) for i in range(self.BMAX)] c8conf = [self.statts(self.C8[:, i]) for i in range(self.BMAX)] c9conf = [self.statts(self.C9[:, i]) for i in range(self.BMAX)] c10conf = [self.statts(self.C10[:, i]) for i in range(self.BMAX)] s1_event = np.nanmean(self.S1) print('==> Overall event score:', "{:3.1f}".format(s1_event)) output_file = os.path.join(a_validation_outdir, '%d.gof_anderson.%s.txt' % (self.sim_id, self.eventname)) out_file = open(output_file, 'w') line = ('#%s%5s%4s%4s%4s%4s%4s%4s%4s%4s%4s\n' % ('band', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10')) out_file.write(line) for i in range(self.BMAX): line = ('%s %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f\n' % (self.BNAMES[i], c1conf[i][0], c2conf[i][0], c3conf[i][0], c4conf[i][0], c5conf[i][0], c6conf[i][0], c7conf[i][0], c8conf[i][0], c9conf[i][0], c10conf[i][0])) out_file.write(line) out_file.close() output_file = os.path.join(a_validation_outdir, "gof-%s-%d-anderson-summary.png" % (self.eventname, self.sim_id)) self.fplots(s1_event, np.asarray(c1conf), np.asarray(c2conf), np.asarray(c3conf), np.asarray(c4conf), np.asarray(c5conf), np.asarray(c6conf), np.asarray(c7conf), np.asarray(c8conf), np.asarray(c9conf), np.asarray(c10conf), output_file) print("Anderson GoF Completed".center(80, '-'))
# This is a Mac OS X computer md5sum = subprocess.Popen(["md5", a_entry], stdout=subprocess.PIPE) computed_sum = md5sum.communicate()[0].split()[3] else: print "Unknow platform %s!" % (sys.platform) sys.exit(1) # Now, write md5sum to file md5_out = open(md5_filename, 'w') md5_out.write("%s %s\n" % (computed_sum, filename)) md5_out.close() #------------------------------------------------------------------------------- # Main program starts here #------------------------------------------------------------------------------- CFG = InstallCfg() if len(sys.argv) == 2: if sys.argv[1] == '-g': # Generate md5sums instead for CHECK_DIR in [CFG.A_GF_DIR, CFG.A_VAL_DIR]: SUB_DIRS = bband_utils.list_subdirs(CHECK_DIR) for DIRECTORY in SUB_DIRS: BASE_DIR = os.path.join(CHECK_DIR, DIRECTORY) MD5_DIR = os.path.join(CHECK_DIR, DIRECTORY, "checksums") # First, remove checksums directory if it already exists if os.path.exists(MD5_DIR): os.system("rm -rf %s" % (MD5_DIR)) generate_md5s(BASE_DIR, MD5_DIR, True) # All done! sys.exit(0)
def main(): """ Parse command line options and create the needed files/directories """ # Detect BBP installation bbp_install = InstallCfg.getInstance() prog_base = os.path.basename(sys.argv[0]) usage = "usage: %s [options]" % (prog_base) parser = optparse.OptionParser(usage) parser.add_option("-c", "--codebase", type="string", action="store", dest="codebase", help="Codebase for the simulation: %s" % (CODEBASES)) parser.add_option("-v", "--velocity-model", type="string", action="store", dest="vmodel", help="Velocity model (region) for this simulation") parser.add_option("--src", "--source", type="string", action="store", dest="source", help="Source description file for the simulation") parser.add_option("--stl", "--station-list", type="string", action="store", dest="station_list", help="Station list file for the simulation") parser.add_option("--srf", "--srf-prefix", type="string", action="store", dest="srf_prefix", help="Prefix of SRF files to use, " "only for GP, SDSU and UCSB methods. " "Simulations begin after the rupture generator.") parser.add_option("-d", "--dir", type="string", action="store", dest="simdir", help="Simulation directory") parser.add_option("--hypo-rand", action="store_true", dest="hyporand", help="Enables hypocenter randomization") parser.add_option("--no-hypo-rand", action="store_false", dest="hyporand", help="Disables hypocenter randomization") parser.add_option("-n", "--num-simulations", type="int", action="store", dest="numsim", help="Number of simulations to run") parser.add_option("--email", type="string", action="store", dest="email", help="Email for job notifications") parser.add_option("-w", "--walltime", type="int", action="store", dest="walltime", help="Number of hours for walltime") parser.add_option("--new-nodes", action="store_true", dest="newnodes", help="Schedule the job in the new HPCC nodes") parser.add_option("--save-tmpdata", action="store_true", dest="savetemp", help="Save the contents of the tmpdata directory") parser.add_option("--hdd-min", type="float", action="store", dest="hdd_min", help="Min value for hypo down dip in randomization") parser.add_option("--hdd-max", type="float", action="store", dest="hdd_max", help="Max value for hypo down dip in randomization") parser.add_option("--has-min", type="float", action="store", dest="has_min", help="Min value for hypo along strike in randomization") parser.add_option("--has-max", type="float", action="store", dest="has_max", help="Max value for hypo along strike in randomization") parser.add_option("--only-rup", action="store_true", dest="only_rup", help="Only runs the rupture generator") parser.add_option("--var", "--variation", type="int", action="store", dest="variation", help="seed variation (default 1)") parser.add_option("--multiseg", action="store_true", dest="multiseg", help="Indicates simulation part of multiseg run") parser.add_option("--first-seg-dir", type="string", action="store", dest="first_seg_dir", help="required for multi-segment segments 2..n") parser.add_option("-s", "--site", action="store_true", dest="site_response", help="Use site response module") (options, _) = parser.parse_args() # Check if using new HPCC nodes if options.newnodes: newnodes = True else: newnodes = False # Check if multi-segment simulation if options.multiseg: multiseg = True else: multiseg = False # Check for first segment directory if options.first_seg_dir is not None: first_seg_dir = os.path.abspath(options.first_seg_dir) if not os.path.exists(first_seg_dir): print("First segment directory for exists: %s" % (first_seg_dir)) sys.exit(1) else: first_seg_dir = None # Check if user specified custom walltime if options.walltime: if options.walltime < 1: print("Walltime must be at least 1 hour!") sys.exit(1) walltime = options.walltime else: if newnodes: walltime = 24 else: walltime = 300 # Check for variation sequence if options.variation: variation = options.variation else: variation = 1 # Check if user wants to save the contents of tmpdata if options.savetemp: savetemp = True else: savetemp = False # Check if user wants to only run the rupture generator if options.only_rup: only_rup = True else: only_rup = False # Validate codebase to use codebase = options.codebase if codebase is None: print "Please specify a codebase!" sys.exit(1) codebase = codebase.lower() if codebase not in CODEBASES: print "Codebase needs to be one of: %s" % (CODEBASES) # Check for velocity model vmodel_names = velocity_models.get_all_names() vmodel = options.vmodel if vmodel is None: print "Please provide a velocity model (region) for this simulation!" print "Available options are: %s" % (vmodel_names) sys.exit(1) vmodels = [v_model.lower() for v_model in vmodel_names] if vmodel.lower() not in vmodels: print("Velocity model %s does not appear to be available on BBP" % (vmodel)) print("Available options are: %s" % (vmodel_names)) print "Please provide another velocity model or check your BBP installation." sys.exit(1) # Now get the name with the correct case vmodel = vmodel_names[vmodels.index(vmodel.lower())] # Check if users wants to run site response module if options.site_response: site_response = True if codebase not in CODEBASES_SITE: print "Cannot use site response with method: %s" % (codebase) sys.exit(1) else: site_response = False # Check for hypocenter randomization if options.hyporand is None: print "Please specify --hypo-rand or --no-hypo-rand!" sys.exit(1) if options.hyporand: hypo_rand = True else: hypo_rand = False # Define area where hypocenter will be randomized hypo_area = {} hypo_area["hdd_min"] = options.hdd_min hypo_area["hdd_max"] = options.hdd_max hypo_area["has_min"] = options.has_min hypo_area["has_max"] = options.has_max # Get the source file (SRC or SRFs) source_file = options.source srf_prefix = options.srf_prefix if source_file is None and srf_prefix is None: print( "Please provide either source description (src file) " "or a srf prefix!") sys.exit(1) # If user specified both a source file and a srf prefix, we abort! if source_file is not None and srf_prefix is not None: print "Cannot specify both srf_prefic and source_file!" sys.exit(1) # If user specified a source file if source_file is not None: # Make it a full path source_file = os.path.realpath(source_file) # Make sure source file is in the rcf-104 / scec-00 filesystem if not "rcf-104" in source_file and not "scec-00" in source_file: print "Source file should be in the rcf-104 / scec-00 filesystems!" sys.exit(1) # Make sure source file exists and is readable if (not os.path.isfile(source_file) or not os.access(source_file, os.R_OK)): print "Source file does not seem to be accessible!" sys.exit(1) # Create a prefix prefix = ("%s-%s" % (os.path.splitext( os.path.basename(source_file))[0], codebase.lower())) # If user specified a SRF prefix if srf_prefix is not None: # Make it a full path srf_prefix = os.path.realpath(srf_prefix) # Make sure source file is in the rcf-104 or scec-00 filesystems if not "rcf-104" in srf_prefix and not "scec-00" in srf_prefix: print "SRF files should be in the rcf-104 / scec-00 filesystems!" sys.exit(1) # Create a prefix prefix = os.path.splitext(os.path.basename(srf_prefix))[0] #prefix = prefix.rsplit("-", 1)[0] # Make sure we remove spaces from prefix prefix = prefix.replace(" ", '') # Get the station list station_list = options.station_list if station_list is None: print "Please provide a station list (stl file)!" sys.exit(1) # Make it a full path station_list = os.path.realpath(station_list) # Make sure station list is in the rcf-104 or scec-00 filesystems if not "rcf-104" in station_list and not "scec-00" in station_list: print "Station list should be in the rcf-104 / scec-00 filesystems!" sys.exit(1) # Make sure station list exists and is readable if (not os.path.isfile(station_list) or not os.access(station_list, os.R_OK)): print "Station list foes not seem to be accessible!" sys.exit(1) # Check for the simulation directory simdir = options.simdir if simdir is None: print "Please provide a simulation directory!" sys.exit(1) simdir = os.path.abspath(simdir) if os.path.exists(simdir): print "Simulation directory exists: %s" % (simdir) opt = raw_input("Do you want to delete its contents (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) opt = raw_input("ARE YOU SURE (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) # Delete existing directory (we already asked the user twice!!!) shutil.rmtree(simdir) # Pick up number of simulations to run numsim = options.numsim if numsim < 1 or numsim > MAX_SIMULATIONS: print("Number of simulations should be between 1 and %d" % (MAX_SIMULATIONS)) sys.exit(1) # Check for e-mail address email = options.email if email is None: print "Please provide an e-mail address for job notifications" sys.exit(1) # Make sure user has configured the setup_bbp_env.sh script setup_bbp_env = os.path.join(bbp_install.A_INSTALL_ROOT, "utils/batch/setup_bbp_env.sh") if not os.path.exists(setup_bbp_env): print("Cannot find setup_bbp_env.sh script!") print("Expected at: %s" % (setup_bbp_env)) sys.exit(1) # Create simulation directories os.makedirs(simdir) indir = os.path.join(simdir, "Sims", "indata") outdir = os.path.join(simdir, "Sims", "outdata") tmpdir = os.path.join(simdir, "Sims", "tmpdata") logsdir = os.path.join(simdir, "Sims", "logs") xmldir = os.path.join(simdir, "Xml") srcdir = os.path.join(simdir, "Src") for mdir in [indir, outdir, tmpdir, logsdir, xmldir, srcdir]: os.makedirs(mdir) if srf_prefix is None: # Generate source files generate_src_files(numsim, source_file, srcdir, prefix, hypo_rand, hypo_area, variation, multiseg, first_seg_dir) # Generate xml files generate_xml(bbp_install, numsim, srcdir, xmldir, logsdir, vmodel, codebase, prefix, station_list, only_rup, srf_prefix, site_response) # Write pbs file write_pbs(bbp_install, numsim, simdir, xmldir, email, prefix, newnodes, walltime, savetemp) # Write .info file info_file = open(os.path.join(simdir, "%s.info" % (prefix)), 'w') info_file.write("# %s\n" % (" ".join(sys.argv))) info_file.close()
def run(self): """ This function prepares the parameter file for ExSim, invokes it, and formats its output to be compatible with the Broadband Platform """ print("ExSIM".center(80, '-')) self.install = InstallCfg.getInstance() self.config = ExSimCfg( os.path.join(self.install.A_IN_DATA_DIR, str(self.sim_id), self.r_srcfile)) install = self.install config = self.config sim_id = self.sim_id self.kappa = config.KAPPA self.stress = config.STRESS 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.exsim_%s.log" % (sim_id, sta_base)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_mod = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "exsim_%s" % (sta_base)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_param_outdir = os.path.join(a_outdir, "param_files") # # Make sure the output and two tmp directories exist # bband_utils.mkdirs([a_tmpdir, a_tmpdir_mod, a_outdir, a_param_outdir], print_cmd=False) a_stations = os.path.join(a_indir, self.r_stations) self.stat_list = StationList(a_stations) self.num_stations = len(self.stat_list.site_list) # Need to create ExSim's parameter file self.create_exsim_param_file() # Keep a copy of ExSim's parameter file in outdata a_param_file = os.path.join(a_tmpdir_mod, self.config.PARAM_FILE) shutil.copy2(a_param_file, os.path.join(a_param_outdir, self.config.PARAM_FILE)) # Run in tmpdir subdir to isolate temp fortran files # Save cwd, change back to it at the end old_cwd = os.getcwd() os.chdir(a_tmpdir_mod) exsim_bin = os.path.join(install.A_UWO_BIN_DIR, "exsim14") cmd = ("%s >> %s 2>&1 << END\n" % (exsim_bin, self.log) + "%s\n" % (self.config.PARAM_FILE) + "END") print("==> Running ExSIM...") bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Restore working directory os.chdir(old_cwd) # Need to copy and re-format output files output_stem = "exsim-output-%s" % (sta_base) site_list = self.stat_list.getStationList() for site, idx in zip(site_list, range(1, self.num_stations + 1)): stat = site.scode #out_rotd50_base = "%d.%s.rd50" % (sim_id, stat) #out_rotd50 = os.path.join(a_outdir, out_rotd50_base) #in_exsim_base = "%s_psa_fs_s%03d.out" % (output_stem, idx) #in_exsim_file = os.path.join(a_tmpdir_mod, "PSA", in_exsim_base) #print("==> Writing RotD50 file for station: %s" % (stat)) #self.convert_exsim_to_rd50(in_exsim_file, out_rotd50) in_exsim_acc_base = "%sS%03diter001.acc" % (output_stem, idx) in_exsim_acc_file = os.path.join(a_tmpdir_mod, "ACC", in_exsim_acc_base) print("==> Writing BBP file for station: %s" % (stat)) self.convert_exsim_to_bbp(in_exsim_acc_file, stat, a_tmpdir, a_outdir) print("ExSIM Completed".center(80, '-'))
def find_tests(test, rerun): """ # This function searches for .xml files in the accept_inputs directory """ install = InstallCfg() resume = True accept_test_inputs = "accept_inputs" accept_test_refs = "accept_refs" input_dir = os.path.join(install.A_TEST_REF_DIR, accept_test_inputs) if not os.path.exists(input_dir): # These are expected to be in the dist print("Acceptance test inputs dir %s does not exist, aborting" % (input_dir)) sys.exit() # Create list of test XML files files = os.listdir(input_dir) wfext = ".xml" # First we find all the tests test_files = [] for testfile in files: if testfile.endswith(wfext): # Don't add SDSU tests on Mac OS X if sys.platform == 'darwin' and testfile.find("SDSU") >= 0: if test is None or (test is not None and testfile.find(test) >= 0): print("*** Mac OS X detected: skipping test %s." % (testfile)) continue if test is None: test_files.append(testfile) else: if testfile.find(test) >= 0: test_files.append(testfile) resume_file = os.path.join(install.A_OUT_LOG_DIR, "resume.txt") resume_list = "" if rerun: os.remove(resume_file) # Check for already completed tests if not rerunning if resume == True and rerun == False: if os.path.exists(resume_file): resume_fp = open(resume_file, 'r') resume_list = resume_fp.read().splitlines() completed_test_count = len(resume_list) print("==> Completed Tests : %d" % (completed_test_count)) resume_fp.close() if ((test is None) and (completed_test_count >= len(test_files))): print("All the acceptance tests have passed previously!") proceed = raw_input("Would you like to re-run " "all the acceptance tests? (y/n)") if str.lower(proceed) == 'y': os.remove(resume_file) resume_list = "" else: sys.exit(0) # Create unittest test case for each file for xml_file in test_files: # Skip test if we ran it already if xml_file in resume_list: print("==> Skipping %s" % (xml_file)) continue file_base = xml_file[0:xml_file.find(wfext)] # pieces = file_base.split('-') # Adjust tolerance depending on test mode tolerance = 0.03 #This defines a method that we're going to add to the #BBPAcceptanceTests class. The keyword binding has to #be done b/c Python is storing pointers to 'file' and 'file_base' #so w/o the keywords, 'file' and 'file_base' in the function will #point to the final values def permutation_test(self, file_base=file_base, xml_file=xml_file): input_dir = os.path.join(self.install.A_TEST_REF_DIR, accept_test_inputs) log_dir = os.path.join(self.install.A_OUT_LOG_DIR, "acceptance_test_logs") sim_id = int(seqnum.get_seq_num()) self.file_base = file_base self.log_file = os.path.join(log_dir, "%s.log" % (self.file_base)) self.input_file = os.path.join(input_dir, xml_file) cmd = ("%s/run_bbp.py -x %s -s %d -l %s" % (self.install.A_COMP_DIR, self.input_file, sim_id, self.log_file)) rc = bband_utils.runprog(cmd, False) self.failIf(rc != 0, "Acceptance test failed to execute") ref_file_dir = os.path.join(self.install.A_TEST_REF_DIR, accept_test_refs, self.file_base) agree = True for ref_file in os.listdir(ref_file_dir): if os.path.isfile(os.path.join(ref_file_dir, ref_file)): test_file = os.path.join(self.install.A_OUT_DATA_DIR, str(sim_id), ("%d.%s" % (sim_id, ref_file))) a_ref_file = os.path.join(ref_file_dir, ref_file) compare_result = cmp_bbp.cmp_bbp(a_ref_file, test_file, tolerance=tolerance) errmsg = ("Output file " "%s does not match reference file: %s" % (test_file, a_ref_file)) self.failIf(compare_result != 0, errmsg) if compare_result != 0: agree = False if agree == True: # Write success to the resume file resume_fp = open(os.path.join(install.A_OUT_LOG_DIR, "resume.txt"), 'a') resume_fp.write("%s\n" % xml_file) resume_fp.flush() resume_fp.close() sys.stdout.flush() sys.stderr.flush() # We create a method object which is an instance method for # BBPAcceptanceTests which executes the code in # testPermutation method = new.instancemethod(permutation_test, None, BBPAcceptanceTests) # We give the method a new name in BBPAcceptanceTests # which contains the xml file being run setattr(BBPAcceptanceTests, "test_%s" % file_base, method)
def validation_test(self, event, code_base, test_name, run_rupture_gen): """ This function runs the full validation test for the event and code_base specified. It creates a Broadband option file with the required answers in the input directory and then invokes the platform. After execution finishes, it checks if the .bbp files were correctly generated, and looks for the gof output file. """ # event - Northridge = 1, Loma Prieta = 2, Landers = 3, LOMAP = 4 # NR = 5, Whittier = 6, Saguenay = 7 # code_base GP = 1, UCSB = 2, SDSU = 3 events = [ "Northridge", "Loma Prieta", "Landers", "LOMAP", "NR", "Whittier", "Saguenay" ] num_stations = 0 bbp_files_found = 0 gof_png_file_found = False gof_png_file_valid = False a_station_list_filename = None install = InstallCfg() if SIM_ID is None: self.sim_id = int(seqnum.get_seq_num()) else: self.sim_id = SIM_ID #print #print "Using sim_ID: %d..." % self.sim_id # Create input and log directories cmd = "mkdir -p %s" % os.path.join(install.A_IN_DATA_DIR, str(self.sim_id)) self.failIf( bband_utils.runprog(cmd, False) != 0, "Error creating input directory") cmd = "mkdir -p %s" % os.path.join(install.A_OUT_LOG_DIR, str(self.sim_id)) self.failIf( bband_utils.runprog(cmd, False) != 0, "Error creating log directory") # Create path for option file a_opt_filename = os.path.join(install.A_IN_DATA_DIR, str(self.sim_id), "%d.optfile" % (self.sim_id)) try: opt_file = open(a_opt_filename, 'w') # Select validation run opt_file.write("y\n") # Select event opt_file.write("%s\n" % (events[event - 1])) # Select the rupture generator if run_rupture_gen: # Yes to rupture generator opt_file.write("y\n") if code_base == 2: # Run UCSB rupture generator opt_file.write("2\n") else: # Otherwise run GP rupture generator opt_file.write("1\n") # No need to provide custom src file, use existing opt_file.write("n\n") else: # Not using the rupture generator opt_file.write("n\n") # Validate all stations opt_file.write("1\n") # Select codebase if code_base == 1: # GP across the board opt_file.write("1\n1\n4\n") elif code_base == 2: # UCSB low-frequency requires UCSB across the board opt_file.write("3\n2\n4\n") elif code_base == 3: # SDSU doesn't have a low-frequency component opt_file.write("1\n3\n4\n") else: self.failIf(True, "Code base not supported!") # We don't want velocity seismograms opt_file.write("y\n") # But we want acceleration seismograms opt_file.write("y\n") # Select GOF module, for validation we want to use GP opt_file.write("1\n") opt_file.close() except IOError: self.failIf(True, "Cannot create option file!") # Log output to a_log_filename a_log_filename = os.path.join( install.A_OUT_LOG_DIR, str(self.sim_id), "%s.%s.log" % (str(self.sim_id), test_name)) # Run BBP command cmd = "%s/run_bbp.py -s %d -o %s >> %s" % ( install.A_COMP_DIR, self.sim_id, a_opt_filename, a_log_filename) # print cmd # Run the validation scenario self.failIf( bband_utils.runprog(cmd, False) != 0, "Fatal error while running the Broadband Platform") # First look for the station list try: files = os.listdir( os.path.join(install.A_IN_DATA_DIR, str(self.sim_id))) except OSError: self.failIf(True, "Cannot access input directory!") for my_file in files: if my_file.endswith(".stl"): a_station_list_filename = os.path.join(install.A_IN_DATA_DIR, str(self.sim_id), my_file) break # Fail if we don't have a station list self.failIf(a_station_list_filename is None, "Cannot find file with station list!") # Now, figure out how many stations we have try: stl_file = open(a_station_list_filename, 'r') for _ in stl_file: num_stations = num_stations + 1 except IOError: self.failIf(True, "Cannot read station list file!") # Now look for the output files try: files = os.listdir( os.path.join(install.A_OUT_DATA_DIR, str(self.sim_id))) except OSError: self.failIf(True, "Cannot access output directory!") for my_file in files: if my_file.endswith(".acc.bbp"): a_bbp_file_path = os.path.join(install.A_OUT_DATA_DIR, str(self.sim_id), my_file) try: my_size = os.stat(a_bbp_file_path).st_size except OSError: self.failIf(True, "Cannot stat file %s!" % a_bbp_file_path) # Ok, let's count this file if my_size > 0: bbp_files_found = bbp_files_found + 1 if my_file.startswith("gof-") and my_file.endswith(".png"): # Found the gof.png file gof_png_file_found = True a_gofpng_file_path = os.path.join(install.A_OUT_DATA_DIR, str(self.sim_id), my_file) try: my_size = os.stat(a_gofpng_file_path).st_size except OSError: self.failIf(True, "Cannot stat file %s!" % a_gofpng_file_path) # Check if size > 0 if my_size > 0: gof_png_file_valid = True # Now check if we got the right results self.failIf(not gof_png_file_found, "GOF file not found!") self.failIf(not gof_png_file_valid, "GOF file size is 0!") self.failIf( bbp_files_found != num_stations, "Found %d valid BBP files, expecting %d!" % (bbp_files_found, num_stations))
def run(self): """ Generate an index file in the outdata directory """ print("GenHTML".center(80, '-')) install = InstallCfg.getInstance() sim_id = self.sim_id a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) self.log = os.path.join(install.A_OUT_LOG_DIR, str(sim_id), "%d.genhtml.log" % (sim_id)) a_statfile = os.path.join(a_indir, self.r_stations) a_param_outdir = os.path.join(a_outdir, "param_files") a_param_statfile = os.path.join(a_param_outdir, self.r_stations) if self.r_src_file is not None and self.r_src_file != "": a_src_file = os.path.join(a_indir, self.r_src_file) a_param_srcfile = os.path.join(a_param_outdir, self.r_src_file) src_props = bband_utils.parse_properties(a_src_file) if "seed" in src_props: seed = src_props["seed"] else: seed = "not available" else: a_src_file = None a_param_srcfile = None # Make sure tmpdir, outdir exist dirs = [a_tmpdir, a_outdir, a_param_outdir] bband_utils.mkdirs(dirs, print_cmd=False) # Copy station list, srf_file to outdir's param_files directory shutil.copy2(a_statfile, a_param_statfile) if a_param_srcfile is not None: shutil.copy2(a_src_file, a_param_srcfile) # Get pointer to the velocity model object vel_obj = velocity_models.get_velocity_model_by_name(self.vmodel_name) if vel_obj is None: raise bband_utils.ParameterError("Cannot find velocity model: %s" % (self.vmodel_name)) vel_version = ("%s - %s" % (vel_obj.get_name(), vel_obj.get_version())) # Get pointer to validation object, if any val_version = None if self.val_name: val_obj = validation_cfg.VE_EVENTS.get_event_by_name(self.val_name) if val_obj is not None: val_version = ("%s - %s" % (val_obj.get_print_name(), val_obj.get_version())) # # Read and parse the station list with this call # slo = StationList(a_statfile) site_list = slo.getStationList() index_file = os.path.join(a_outdir, "index-%d.html" % (sim_id)) idxout = open(index_file, 'w') idxout.write("<html>\n") idxout.write("<title>Results for simulation %d</title>\n" % (sim_id)) idxout.write("<body>\n") idxout.write("<h2>Simulation Results</h2>\n") idxout.write("<table>\n") idxout.write("<tr>\n") idxout.write("<td>Broadband Version</td>\n") idxout.write("<td>%s</td>\n" % (install.VERSION)) idxout.write("</tr>\n") idxout.write("<tr>\n") idxout.write("<td>Velocity model version</td>\n") idxout.write("<td>%s</td>\n" % (vel_version)) idxout.write("</tr>\n") if val_version: idxout.write("<tr>\n") idxout.write("<td>Validation package version</td>\n") idxout.write("<td>%s</td>\n" % (val_version)) idxout.write("</tr>\n") if install.start_time is not None: idxout.write("<tr>\n") idxout.write("<td>Simulation Start Time</td>\n") idxout.write("<td>%s</td>\n" % (time.strftime("%a %d %b %Y %X %Z", install.start_time))) idxout.write("</tr>\n") idxout.write("<tr>\n") idxout.write("<td>Simulation End Time</td>\n") idxout.write("<td>%s</td>\n" % (time.strftime("%a %d %b %Y %X %Z", time.localtime()))) idxout.write("</tr>\n") idxout.write("<tr>\n") idxout.write("<td>Simulation ID</td>\n") idxout.write("<td>%d</td>\n" % (sim_id)) idxout.write("</tr>\n") idxout.write("<tr>\n") idxout.write("<td>Simulation Method</td>\n") idxout.write("<td>%s</td>\n" % (self.method)) idxout.write("</tr>\n") # Add xml file if os.path.exists(os.path.join(a_outdir, "%d.xml" % (sim_id))): idxout.write("<tr>\n") idxout.write("<td>Sim Spec</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%d.xml" % (sim_id)), "%d.xml" % (sim_id))) idxout.write("</tr>\n") # Add station list and src_file if os.path.exists(os.path.join(a_param_outdir, self.r_stations)): idxout.write("<tr>\n") idxout.write("<td>Station List</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "param_files", self.r_stations), self.r_stations)) idxout.write("</tr>\n") if a_param_srcfile is not None: if os.path.exists(os.path.join(a_param_outdir, self.r_src_file)): idxout.write("<tr>\n") idxout.write("<td>Source Description</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "param_files", self.r_src_file), self.r_src_file)) idxout.write("</tr>\n") idxout.write("<tr>\n") idxout.write("<td>Random Seed</td>\n") idxout.write('<td>%s</td>\n' % (seed)) idxout.write("</tr>\n") # Get bias plots dist_lin_plot = glob.glob(os.path.join(a_outdir, "gof-dist-lin*.png")) dist_log_plot = glob.glob(os.path.join(a_outdir, "gof-dist-log*.png")) plots = glob.glob(os.path.join(a_outdir, "gof*.png")) rd50plot = glob.glob(os.path.join(a_outdir, "gof*-rd50.png")) gmpegofplot = glob.glob(os.path.join(a_outdir, "gof*-GMPE-*.png")) mapgofplot = glob.glob(os.path.join(a_outdir, "gof-map-*.png")) if len(gmpegofplot) == 1: gmpegofplot = gmpegofplot[0] else: gmpegofplot = "" if len(mapgofplot) == 1: mapgofplot = mapgofplot[0] else: mapgofplot = "" if len(dist_lin_plot) == 1: dist_lin_plot = dist_lin_plot[0] else: dist_lin_plot = "" if len(dist_log_plot) == 1: dist_log_plot = dist_log_plot[0] else: dist_log_plot = "" if len(rd50plot) == 1: rd50plot = rd50plot[0] else: if gmpegofplot: rd50plot = [plot for plot in rd50plot if plot != gmpegofplot] if mapgofplot: rd50plot = [plot for plot in rd50plot if plot != mapgofplot] if dist_lin_plot: rd50plot = [plot for plot in rd50plot if plot != dist_lin_plot] if dist_log_plot: rd50plot = [plot for plot in rd50plot if plot != dist_log_plot] if len(rd50plot) == 1: rd50plot = rd50plot[0] else: rd50plot = "" if len(plots) > 1: rspplot = [plot for plot in plots if (plot != rd50plot and plot != gmpegofplot and plot != mapgofplot and plot != dist_lin_plot and plot != dist_log_plot)] if len(rspplot) == 1: rspplot = rspplot[0] else: rspplot = "" else: rspplot = "" gmpegofplot = os.path.basename(gmpegofplot) mapgofplot = os.path.basename(mapgofplot) rd50plot = os.path.basename(rd50plot) rspplot = os.path.basename(rspplot) dist_lin_plot = os.path.basename(dist_lin_plot) dist_log_plot = os.path.basename(dist_log_plot) # Add RotD50 bias plot if rd50plot: idxout.write("<tr>\n") idxout.write("<td>RotD50 Bias Plot</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%s" % (rd50plot)), "PNG")) idxout.write("</tr>\n") if mapgofplot: idxout.write("<tr>\n") idxout.write("<td>RotD50 Map GOF Plot</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%s" % (mapgofplot)), "PNG")) idxout.write("</tr>\n") # Add RSP bias plot if rspplot: idxout.write("<tr>\n") idxout.write("<td>Respect Bias Plot</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%s" % (rspplot)), "PNG")) idxout.write("</tr>\n") # Add the GMPE bias plot if gmpegofplot: idxout.write("<tr>\n") idxout.write("<td>GMPE Comparison Bias Plot</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%s" % (gmpegofplot)), "PNG")) idxout.write("</tr>\n") # Add distance plots if dist_lin_plot: idxout.write("<tr>\n") idxout.write("<td>RotD50 Dist Bias Linear</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%s" % (dist_lin_plot)), "PNG")) idxout.write("</tr>\n") if dist_log_plot: idxout.write("<tr>\n") idxout.write("<td>RotD50 Dist Bias Log</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "%s" % (dist_log_plot)), "PNG")) idxout.write("</tr>\n") # Add station map and kml file if os.path.exists(os.path.join(a_outdir, "station_map.png")): idxout.write("<tr>\n") idxout.write("<td>Station Map</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "station_map.png"), "PNG")) if os.path.exists(os.path.join(a_outdir, "station_map.kml")): idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", "station_map.kml"), "KML")) idxout.write("</tr>\n") # Now get SRF file and plot srfs = glob.glob(os.path.join(a_outdir, "*.srf")) if len(srfs) == 1: srffile = os.path.basename(srfs[0]) srfplot = ("%s.png" % (os.path.basename(os.path.splitext(srffile)[0]))) if not os.path.exists(os.path.join(a_outdir, srfplot)): srfplot = "" else: srffile = "" srfplot = "" if srffile: idxout.write("<tr>\n") idxout.write("<td>Rupture file</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", srffile), "data")) if srfplot: idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", srfplot), "PNG")) idxout.write("</tr>\n") idxout.write("</table>\n") idxout.write("<p><p>\n") for sits in site_list: site = sits.scode idxout.write("<p>\n") idxout.write("<h2>%s</h2>\n" % (site)) idxout.write("<table>\n") # Find all files velfile = "%d.%s.vel.bbp" % (sim_id, site) velplot = "%d.%s_velocity_seis.png" % (sim_id, site) accfile = "%d.%s.acc.bbp" % (sim_id, site) accplot = "%d.%s_acceleration_seis.png" % (sim_id, site) rd50file = "%d.%s.rd50" % (sim_id, site) rspfile = "%d.%s.rsp" % (sim_id, site) rd50plot = glob.glob(os.path.join(a_outdir, "*_%d_%s_rotd50.png" % (sim_id, site))) if len(rd50plot) == 1: rd50plot = os.path.basename(rd50plot[0]) else: rd50plot = "" rspplot = glob.glob(os.path.join(a_outdir, "*_%d_%s_rsp.png" % (sim_id, site))) if len(rspplot) == 1: rspplot = os.path.basename(rspplot[0]) else: rspplot = "" overlayfile = glob.glob(os.path.join(a_outdir, "*_%d_%s_overlay.png" % (sim_id, site))) if len(overlayfile) == 1: overlayfile = os.path.basename(overlayfile[0]) else: overlayfile = "" gmpeplot = glob.glob(os.path.join(a_outdir, "*_%d_%s_gmpe.png" % (sim_id, site))) if len(gmpeplot) == 1: gmpeplot = os.path.basename(gmpeplot[0]) else: gmpeplot = "" if os.path.exists(os.path.join(a_outdir, velfile)): idxout.write("<tr>\n") idxout.write("<td>Velocity</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", velfile), "BBP")) if os.path.exists(os.path.join(a_outdir, velplot)): idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", velplot), "PNG")) idxout.write("</tr>\n") if os.path.exists(os.path.join(a_outdir, accfile)): idxout.write("<tr>\n") idxout.write("<td>Acceleration</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", accfile), "BBP")) if os.path.exists(os.path.join(a_outdir, accplot)): idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", accplot), "PNG")) idxout.write("</tr>\n") if os.path.exists(os.path.join(a_outdir, rd50file)): idxout.write("<tr>\n") idxout.write("<td>RotD50</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", rd50file), "data")) if rd50plot: idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", rd50plot), "PNG")) idxout.write("</tr>\n") if os.path.exists(os.path.join(a_outdir, rspfile)): idxout.write("<tr>\n") idxout.write("<td>Respect</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", rspfile), "data")) if rspplot: idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", rspplot), "PNG")) idxout.write("</tr>\n") if overlayfile: idxout.write("<tr>\n") idxout.write("<td>Overlay</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", overlayfile), "PNG")) idxout.write("</tr>\n") if gmpeplot: idxout.write("<tr>\n") idxout.write("<td>GMPE Plot</td>\n") idxout.write('<td><a href="%s">%s</a></td>\n' % (os.path.join(".", gmpeplot), "PNG")) idxout.write("</tr>\n") idxout.write("</table>\n") idxout.write("</body>\n") idxout.write("</html>\n") idxout.close() print("==> Wrote file: %s" % (index_file)) print("GenHTML Completed".center(80, '-'))
def run(self): """ Runs the UCSB Syn1D simulator """ print("UCSB Syn1D".center(80, '-')) # # Global installation parameters # install = InstallCfg.getInstance() # # Required inputs are sim_id, the src file, the FFSP output # and station list # 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.syn1d_%s.log" % (sim_id, sta_base)) self.a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) self.a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_lf = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "syn1D_lf_%s" % (sta_base)) a_tmpdir_hf = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "syn1D_hf_%s" % (sta_base)) a_tmpdir_stitch = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "stitch_%s" % (sta_base)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # # Make sure the output and tmp directories exist # bband_utils.mkdirs([self.a_tmpdir, a_tmpdir_lf, a_tmpdir_hf, a_tmpdir_stitch, a_outdir], print_cmd=False) # Parse SRC file a_srcfile = os.path.join(self.a_indir, self.r_srcfile) self.cfg = Syn1DCfg(self.vmodel_name, a_srcfile) # Read station list a_stations = os.path.join(self.a_indir, self.r_stations) print(a_stations) self.slo = StationList(a_stations) site_list = self.slo.getStationList() # Make sure syn1D can handle our station list if len(site_list) > self.cfg.MAX_STATIONS: raise bband_utils.ParameterError("Too many stations in " "the station list: %d. " % (len(site_list)) + "Maximum limit is %d." % (self.cfg.MAX_STATIONS)) # Run Syn1D for LF print("Running Syn1D for LF...") self.run_syn1d(a_tmpdir_lf, self.cfg.A_UC_LF_VELMODEL, self.cfg.A_UC_GREENBANK, self.cfg.A_UC_GREEN_SOIL, self.cfg.A_UC_SYN1D_INP_FILE) # Run Syn1D for HF print("Running Syn1D for HF...") self.run_syn1d(a_tmpdir_hf, self.cfg.A_UC_HF_VELMODEL, self.cfg.A_UC_HF_GREENBANK, self.cfg.A_UC_HF_GREEN_SOIL, self.cfg.A_UC_SYN1D_INP_FILE) # Run Stitch to combine LF and HF print("Running Stitch...") self.run_stitch(a_tmpdir_stitch, a_tmpdir_lf, a_tmpdir_hf, self.cfg.A_UC_LF_VELMODEL) # # Convert the outputs to BB format # # Copy station list ll to the stitch directory r_station_file = "stations.ll" shutil.copy2(os.path.join(a_tmpdir_lf, r_station_file), os.path.join(a_tmpdir_stitch, r_station_file)) # Save old directory old_cwd = os.getcwd() os.chdir(a_tmpdir_stitch) cmd = "%s >> %s 2>&1" % (self.cfg.A_CONV, self.log) bband_utils.runprog(cmd) # Restore old directory os.chdir(old_cwd) # # Move the results to the tmpdir directory. Use the stations # list to determine the names of the output file the system # should have produced. Define an output name for each # station BB file. Read each line in the file as a station. # for stat in site_list: a_tmpfile = os.path.join(a_tmpdir_stitch, "%s.3comp" % (stat.scode)) expected_file = os.path.join(self.a_tmpdir, "%d.%s.bbp" % (sim_id, stat.scode)) shutil.copy2(a_tmpfile, expected_file) if self.r_srcfile == "": # calculate magnitude and write to file mag = fault_utils.get_magnitude(os.path.join(self.a_indir, self.r_velmodel), os.path.join(self.a_indir, self.r_srffile), sta_base) mag_file = open(os.path.join(self.a_indir, "magnitude_%s" % (sta_base)), 'w') mag_file.write("%.2f" % mag) mag_file.flush() mag_file.close() print("UCSB Syn1D Completed".center(80, '-'))
def run(self): print("Generating Plots".center(80, '-')) # Initialize basic variables install = InstallCfg.getInstance() 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, "%d/%d.gen_plots.log" % (sim_id, sim_id)) # Input, tmp, and output directories a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # if self.a_datadir is None: # # When datadir is None, we look for the observation data in # # the tmpdir where the ObsSeismograms module generates them a_tmpdir_seis = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "obs_seis_%s" % (sta_base)) # 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_tmpdir_seis) slo = StationList(a_statfile) site_list = slo.getStationList() for site in site_list: stat = site.scode # Since we're using the GP station list, make sure the # .bbp for the station exists. It might not if we ran the # validation with a different station list (like UCSB for # Landers) bbpfile = os.path.join(a_tmpdir_seis, "%s.bbp" % stat) expected_file = os.path.join(a_outdir, "%d.%s.vel.bbp" % (sim_id, stat)) if (not os.path.exists(expected_file) or not os.path.exists(bbpfile)): # just skip this station continue print("==> Plotting seismogram comparison for station: %s" % (stat)) if self.format == 'vel': # We have velocity, nothing we need to do filename1 = bbpfile elif self.format == 'acc': # We have acceleration, must integrate first # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "temp.acc.000") ewfile = os.path.join(a_tmpdir, "temp.acc.090") udfile = os.path.join(a_tmpdir, "temp.acc.ver") bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/wcc2bbp " % (install.A_GP_BIN_DIR) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in ['000', '090', 'ver']: # Create path names and check if their sizes are # within bounds filein = os.path.join(a_tmpdir, "temp.acc.%s" % (comp)) fileout = os.path.join(a_tmpdir, "temp.vel.%s" % (comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s/integ_diff integ=1 " % (install.A_GP_BIN_DIR) + "filein=%s fileout=%s >> %s 2>&1" % (filein, fileout, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "temp.vel.000") ewfile = os.path.join(a_tmpdir, "temp.vel.090") udfile = os.path.join(a_tmpdir, "temp.vel.ver") vel_bbp_file = os.path.join(a_tmpdir, "temp.%s.vel" % stat) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/wcc2bbp wcc2bbp=1 " % install.A_GP_BIN_DIR + "nsfile=%s ewfile=%s udfile=%s > %s 2>> %s" % (nsfile, ewfile, udfile, vel_bbp_file, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) filename1 = vel_bbp_file # Generate arias duration files for calculated data calc_acc = os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, stat)) calc_peer_n = os.path.join(a_tmpdir, "%d.%s_N.acc" % (sim_id, stat)) calc_peer_e = os.path.join(a_tmpdir, "%d.%s_E.acc" % (sim_id, stat)) calc_peer_z = os.path.join(a_tmpdir, "%d.%s_Z.acc" % (sim_id, stat)) # Convert calculated acc seismogram into peer format bbp_formatter.bbp2peer(calc_acc, calc_peer_n, calc_peer_e, calc_peer_z) # Now calculate arias duration for each component for comp in ["N", "E", "Z"]: file_in = os.path.join(a_tmpdir, "%d.%s_%s.acc" % (sim_id, stat, comp)) file_out = os.path.join( a_tmpdir, "%d.%s_%s.arias" % (sim_id, stat, comp)) arias_duration.ad_from_acc(file_in, file_out) # Generate arias duration files for observed data obs_acc = os.path.join(a_tmpdir_seis, "%s.bbp" % stat) obs_peer_n = os.path.join(a_tmpdir, "obs.%s_N.acc" % (stat)) obs_peer_e = os.path.join(a_tmpdir, "obs.%s_E.acc" % (stat)) obs_peer_z = os.path.join(a_tmpdir, "obs.%s_Z.acc" % (stat)) # Convert observed acc seismogram into peer format bbp_formatter.bbp2peer(obs_acc, obs_peer_n, obs_peer_e, obs_peer_z) # Now calculate arias duration for each component for comp in ["N", "E", "Z"]: file_in = os.path.join(a_tmpdir, "obs.%s_%s.acc" % (stat, comp)) file_out = os.path.join(a_tmpdir, "obs.%s_%s.arias" % (stat, comp)) arias_duration.ad_from_acc(file_in, file_out) # Plot seismograms with arias duration filename2 = os.path.join(a_outdir, "%d.%s.vel.bbp" % (sim_id, stat)) outfile = os.path.join( a_outdir, "%s_%d_%s_overlay.png" % (self.comp_label, sim_id, stat)) obs_arias_n = os.path.join(a_tmpdir, "obs.%s_N.arias" % (stat)) obs_arias_e = os.path.join(a_tmpdir, "obs.%s_E.arias" % (stat)) obs_arias_z = os.path.join(a_tmpdir, "obs.%s_Z.arias" % (stat)) calc_arias_n = os.path.join(a_tmpdir, "%d.%s_N.arias" % (sim_id, stat)) calc_arias_e = os.path.join(a_tmpdir, "%d.%s_E.arias" % (sim_id, stat)) calc_arias_z = os.path.join(a_tmpdir, "%d.%s_Z.arias" % (sim_id, stat)) plot_seismograms.plot_overlay_with_arias( stat, filename1, filename2, obs_arias_n, obs_arias_e, obs_arias_z, calc_arias_n, calc_arias_e, calc_arias_z, self.comp_label, "run %d" % sim_id, outfile) # Now create rd50 comparison plots for site in site_list: stat = site.scode print("==> Plotting RotD50 comparison for station: %s" % (stat)) # 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 .rd50 file exists for comparison. If it don't # exist, skip it rd50_file = None if ("%s.rd50" % (stat)) in filelist: rd50_file = "%s.rd50" % (stat) else: # Skip this station continue # Plot rotd50 results rd50_filename1 = os.path.join(a_tmpdir_seis, rd50_file) rd50_filename2 = os.path.join(a_outdir, "%d.%s.rd50" % (sim_id, stat)) outfile = os.path.join( a_outdir, "%s_%d_%s_rotd50.png" % (self.comp_label, sim_id, stat)) plot_rotd50.plot_rd50(stat, rd50_filename1, rd50_filename2, self.comp_label, sim_id, outfile, site.low_freq_corner, site.high_freq_corner, quiet=True) print("Generating Plots Completed".center(80, '-'))
def __init__(self): install = InstallCfg.getInstance() # Name and Path to executable self.COMPS = ["000", "090", "ver"] self.INPUT_FORMAT_GOF = "GOF" # Path to GOF binaries self.GOF_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_MO") self.GOF_SpFit_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_SpFit") self.GOF_PGX_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_PGX") self.GOF_CCFit_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_CCFit") self.GOF_DCumEn_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_DCumEn") self.GOF_FSComp_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_FSComp") self.GOF_InElFit_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_InElFit") self.GOF_SAFit16_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_SAFit16") self.GOF_SpecDurFit_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_SpecDurFit") self.GOF_NGA_BIN = os.path.join(install.A_SDSU_BIN_DIR, "GOF_MO_NGA") # Working file names self.PARAM_DAT_FILE = "PARAM.dat" self.INPUT_SEISMO_1 = "CONCAT_1" self.INPUT_SEISMO_2 = "CONCAT_2" # Summary file self.SUMMARY_FILE = "gof_summary.txt" self.cfggof = {} self.cfggof["input_format"] = "GOF" self.cfggof["input_set_1"] = "./sample1_1.input" self.cfggof["input_set_2"] = "./sample1_2.input" self.cfggof["output_dir"] = "./output" self.cfggof["work_dir"] = "./work" self.cfggof["use_nga"] = False self.cfggof["num_headers"] = 0 #number of headers preceeding each seismogram self.cfggof["num_station"] = 1 #number of stations self.cfggof["timesteps_set_1"] = 0 #nt number of timesteps in set 1 self.cfggof["timesteps_set_2"] = 0 #nt number of timesteps in set 2 self.cfggof["input_param"] = "A" #Input format(A,V,D), (meter, sec) self.cfggof["seismo_length"] = 0 #length of seismograms (seconds) self.cfggof["low_cut"] = 0.1 #Low cut (period) self.cfggof["high_cut"] = 10.0 #High cut (period) self.cfggof["weights"] = dict() self.cfggof["weights"]["pga"] = 1.0 # Weighting on PGA self.cfggof["weights"]["pgv"] = 1.0 # Weighting on PGV self.cfggof["weights"]["pgd"] = 1.0 # Weighting on PGD self.cfggof["weights"]["psa"] = 1.0 # Weighting on PSA self.cfggof["weights"]["spectral_Fit"] = 1.0 # Weighting on Spectral Fit self.cfggof["weights"]["cumulative_energy_fit"] = 1.0 # Weighting on Cumulative Energy Fit self.cfggof["weights"]["inelastic_elastic_fit"] = 1.0 # Weighting on Inelastic/Elastic Fit (16) self.cfggof["weights"]["sepctral_acc"] = 1.0 # Weighting on Spec Acc (16) self.cfggof["weights"]["spec_duration"] = 1.0 # Weighting on Spec Dur (16) self.cfggof["weights"]["data_energy_release_duration"] = 1.0 # Weighting on Data Energy Release Duration (5%-75%) self.cfggof["weights"]["cross_correlation"] = 1.0 # Weighting on Cross-Correlation self.cfggof["weights"]["fourier_spectrum"] = 1.0 # Weighting on Fourier Spectrum self.cfggof["file"] = dict() self.cfggof["file"]["pga"] = "GOF_PGA.list" self.cfggof["file"]["pgv"] = "GOF_PGV.list" self.cfggof["file"]["pgd"] = "GOF_PGD.list" self.cfggof["file"]["psa"] = "GOF_PSA.list" self.cfggof["file"]["spectral_Fit"] = "GOF_SPECFIT.list" self.cfggof["file"]["cumulative_energy_fit"] = "GOF_ENERGYFIT.list" self.cfggof["file"]["inelastic_elastic_fit"] = "GOF_InElEl.list" self.cfggof["file"]["sepctral_acc"] = "GOF_SAFIT.list" self.cfggof["file"]["spec_duration"] = "GOF_SPECDUR.list" self.cfggof["file"]["data_energy_release_duration"] = "GOF_DUR.list" self.cfggof["file"]["cross_correlation"] = "GOF_CROSSCOR.list" self.cfggof["file"]["fourier_spectrum"] = "GOF_FS.list" self.cfgnga = {} self.cfgnga["source_mag"] = 0.0 self.cfgnga["dip"] = 0.0 self.cfgnga["rake"] = 0.0 self.cfgnga["depth_coseismic"] = 0.0 self.cfgnga["site_file"] = ""
def calculate_epicenter(input_file): """ This function returns the epicenter of an event using either a SRC file or a SRF file to look for the hypocenter location. It uses Rob Graves' xy2ll utility to convert the coordinates to lat/lon. """ # If we have a SRF file, we already have a function that does this if input_file.endswith(".srf"): # Get information from srf file hypo_lon, hypo_lat, _ = get_hypocenter(input_file) return hypo_lon, hypo_lat # If we don't have a SRC file, we should print an error here if not input_file.endswith(".src"): bband_utils.ParameterError("input file should be a SRC or SRF file!") # Ok, we have a SRC file # Get information from SRC file cfgdict = bband_utils.parse_properties(input_file) try: strike = cfgdict["strike"] except KeyError: bband_utils.ParameterError("SRC file missing STRIKE parameter!") strike = float(strike) try: dip = cfgdict["dip"] except KeyError: bband_utils.ParameterError("SRC file missing DIP parameter!") dip = float(dip) try: hypo_down_dip = cfgdict["hypo_down_dip"] except KeyError: bband_utils.ParameterError("SRC file missing " "HYPO_DOWN_DIP parameter!") hypo_down_dip = float(hypo_down_dip) try: hypo_along_strike = cfgdict["hypo_along_stk"] except KeyError: bband_utils.ParameterError("SRC file missing " "HYPO_ALONG_STK parameter!") hypo_along_strike = float(hypo_along_strike) try: lat_top_center = cfgdict["lat_top_center"] except KeyError: bband_utils.ParameterError("SRC file missing " "LAT_TOP_CENTER parameter!") lat_top_center = float(lat_top_center) try: lon_top_center = cfgdict["lon_top_center"] except KeyError: bband_utils.ParameterError("SRC file missing " "LON_TOP_CENTER parameter!") lon_top_center = float(lon_top_center) # Ok, we have all the parameters that we need! hypo_perpendicular_strike = hypo_down_dip * math.cos(math.radians(dip)) # Now call xy2ll program to convert it to lat/long # Create temp directory to avoid any race conditions tmpdir = tempfile.mkdtemp(prefix="bbp-") hypfile = os.path.join(tmpdir, "src_hypo.tmp") install = InstallCfg.getInstance() cmd = ('echo "%f %f" | %s mlat=%f mlon=%f xazim=%f > %s' % (hypo_along_strike, hypo_perpendicular_strike, os.path.join(install.A_GP_BIN_DIR, "xy2ll"), lat_top_center, lon_top_center, strike, hypfile)) bband_utils.runprog(cmd, print_cmd=False) src_hypo_fp = open(hypfile, 'r') src_hypo_data = src_hypo_fp.readline() src_hypo_fp.close() src_hypo = [float(val) for val in src_hypo_data.split()] # Delete temp directory shutil.rmtree(tmpdir) # Return calculated lon/lat return src_hypo[0], src_hypo[1]
def findXML(): parser = optparse.OptionParser() parser.add_option("-i", "--in-dir", dest="inDir", help="Input folder with XML files", metavar="IN_DIR") parser.add_option("-r", "--resume", action="store_true", dest="resume", help="Resume batch processing of XML files", metavar="RESUME") parser.add_option( "-o", "--out-dir", dest="outDir", help= "Output folder for simulation data (indata, outdata, log, tmpdata) with simID", metavar="OUT_DIR") parser.add_option( "-f", "--force", action="store_true", dest="force", help= "Force overwrite of BBP folders (indata, outdata, log, tmpdata) with same simID", metavar="FORCE") (options, args) = parser.parse_args() if not options.inDir: parser.error("Folder with XML files is required!") if os.path.exists(options.inDir): files = os.listdir(options.inDir) else: print "Invalid input dir: %s" % options.inDir sys.exit(1) if not files: print "No XML files were found in input dir: %s" % options.inDir sys.exit(1) if options.outDir: if not os.path.exists(options.outDir): try: os.mkdir(options.outDir) except: print("Failed to create output dir: %s! Aborting..." % (options.outDir)) sys.exit(1) if not os.path.exists("%s/indata" % options.outDir): try: os.mkdir("%s/indata" % options.outDir) except: print("Failed to create dir: %s/indata! Aborting..." % (options.outDir)) sys.exit(1) if not os.path.exists("%s/outdata" % options.outDir): try: os.mkdir("%s/outdata" % options.outDir) except: print("Failed to create dir: %s/outdata! Aborting..." % (options.outDir)) sys.exit(1) if not os.path.exists("%s/tmpdata" % options.outDir): try: os.mkdir("%s/tmpdata" % options.outDir) except: print("Failed to create dir: %s/tmpdata! Aborting..." % (options.outDir)) sys.exit(1) if not os.path.exists("%s/logs" % options.outDir): try: os.mkdir("%s/logs" % options.outDir) except: print("Failed to create dir: %s/logs! Aborting..." % (options.outDir)) sys.exit(1) if options.force: print "WARNING: Force overwrite is ON!" print "Some existing BBP data folders will be overwritten!" install = InstallCfg() num_sims = 0 total_sims = 0 if options.inDir[-1:] == os.path.sep: options.inDir = options.inDir[0:-1] files = sorted([ f for f in os.listdir(options.inDir) if os.path.isfile(options.inDir + os.path.sep + f) ]) resume_list = "" if options.resume == True: if os.path.exists("%s/batch_resume.txt" % install.A_OUT_LOG_DIR): resume_fp = open("%s/batch_resume.txt" % install.A_OUT_LOG_DIR, 'r') resume_list = resume_fp.readlines() resume_fp.close() else: if os.path.exists("%s/batch_resume.txt" % install.A_OUT_LOG_DIR): os.remove("%s/batch_resume.txt" % install.A_OUT_LOG_DIR) run_list = [] for file in files: if file.endswith(".xml"): total_sims += 1 if options.resume == True: match = False for i in resume_list: if file == i.strip(): match = True print "Skipping %s" % file break if match == True: continue run_list.append(os.path.abspath(os.path.join(options.inDir, file))) num_sims += 1 if not num_sims == total_sims: sims = "%d/%d" % (num_sims, total_sims) else: sims = str(num_sims) # Setup the simlist and movelist for logging simlist = [] mvlist = [] print "Preparing to run %s simulations from %s" % (sims, options.inDir) run_count = 1 for file in run_list: filename = os.path.basename(file) file_base = filename[0:filename.find(".xml")] pieces = file_base.split("_") simID = -1 if len(pieces) > 1: try: simID = int(pieces[0]) except ValueError: print "Failed to fetch simID from XML file name: %s" % file if simID == -1: simID = int(seqnum.getSeqNum()) print "Running with generated simID: %d" % simID t0 = time.time() start_time = time.strftime("%Y/%m/%d-%H:%M:%S", time.localtime()) indatadir = "%s/%d" % (install.A_IN_DATA_DIR, simID) outdatadir = "%s/%d" % (install.A_OUT_DATA_DIR, simID) tmpdatadir = "%s/%d" % (install.A_TMP_DATA_DIR, simID) logdir = "%s/%d" % (install.A_OUT_LOG_DIR, simID) logfiledir = "%s/logs/%d" % (options.outDir, simID) log_file = "%s/%s.log" % (logfiledir, file_base) # Make sure we have an absolute path for log_file log_file = os.path.abspath(log_file) if not os.path.exists(logfiledir): try: os.mkdir(logfiledir) except: print("Failed to create dir: %s! Aborting..." % (logfiledir)) sys.exit(1) dir_exists = False if os.path.exists(indatadir): if options.force: shutil.rmtree(indatadir) else: dir_exists = True if os.path.exists(tmpdatadir): if options.force: shutil.rmtree(tmpdatadir) else: dir_exists = True if os.path.exists(outdatadir): if options.force: shutil.rmtree(outdatadir) else: dir_exists = True if os.path.exists(logdir): if options.force: shutil.rmtree(logdir) else: dir_exists = True if dir_exists: print "BBP folders with simID %d exists!" print "Force overwrite is OFF, skipping %s" % (simID, file) continue print "Processing file (%d/%d): %s" % (run_count, num_sims, file) cmd = "%s/run_bbp.py -x %s -s %d -l %s" % (install.A_COMP_DIR, file, simID, log_file) if (LOG_ONLY == True): simlist.append("%s\n" % (cmd)) if options.outDir: # Notes: # 1) force option not currently supported while # logging sims # 2) assumption is that dir outdir/simid # does not already exist od_indatadir = "%s/indata" % (options.outDir) od_outdatadir = "%s/outdata" % (options.outDir) od_tmpdatadir = "%s/tmpdata" % (options.outDir) od_logdir = "%s/logs" % (options.outDir) mvlist.append("mv %s %s\n" % (indatadir, od_indatadir)) mvlist.append("mv %s %s\n" % (tmpdatadir, od_tmpdatadir)) mvlist.append("mv %s %s\n" % (outdatadir, od_outdatadir)) mvlist.append("mv %s %s\n" % (logdir, od_logdir)) run_count += 1 continue bband_utils.runprog(cmd, False) if options.outDir: od_indatadir = "%s/indata/%d" % (options.outDir, simID) od_outdatadir = "%s/outdata/%d" % (options.outDir, simID) od_tmpdatadir = "%s/tmpdata/%d" % (options.outDir, simID) od_logdir = "%s/logs/%d" % (options.outDir, simID) od_dir_exists = False if os.path.exists(od_indatadir): if options.force: shutil.rmtree(od_indatadir) else: od_dir_exists = True if os.path.exists(od_tmpdatadir): if options.force: shutil.rmtree(od_tmpdatadir) else: od_dir_exists = True if os.path.exists(od_outdatadir): if options.force: shutil.rmtree(od_outdatadir) else: od_dir_exists = True if os.path.exists(od_logdir): if options.force: shutil.rmtree(od_logdir) else: od_dir_exists = True if dir_exists: print "Warning: Folder(s) with simID %d exists in output folder %s! Force overwrite is OFF, output will be left in BBP folders!" % ( simID, options.outDir) else: if os.path.exists(indatadir): shutil.move(indatadir, od_indatadir) if os.path.exists(tmpdatadir): shutil.move(tmpdatadir, od_tmpdatadir) if os.path.exists(outdatadir): shutil.move(outdatadir, od_outdatadir) if os.path.exists(logdir): shutil.move(logdir, od_logdir) run_time = time.time() - t0 run_time_str = str(datetime.timedelta(seconds=run_time)) end_time = time.strftime("%Y/%m/%d-%H:%M:%S", time.localtime()) if options.outDir: if not od_dir_exists: out_data_dir = od_outdatadir else: out_data_dir = "%s/%d" % (install.A_OUT_DATA_DIR, simID) files = os.listdir(out_data_dir) if files: try: run_log_fp = open("%s/batch_run.log" % options.inDir, 'a') except IOError: run_log_fp = open("%s/batch_run.log" % install.A_OUT_LOG_DIR, 'a') run_log_fp.write( "%d\t%s\t%s\t%s\t%s\t%s\n" % (simID, os.path.abspath(file), os.path.abspath(out_data_dir), start_time, end_time, run_time_str)) run_log_fp.flush() run_log_fp.close() resume_fp = open("%s/batch_resume.txt" % install.A_OUT_LOG_DIR, 'a') resume_fp.write("%s\n" % filename) resume_fp.flush() resume_fp.close() run_count += 1 # Write the sims to the execlog print "Opening %s/batch_run_bbp_sims.log" % (options.inDir) execlog = open("%s/batch_run_bbp_sims.log" % (options.inDir), 'w') for sim in simlist: execlog.write(sim) execlog.close() # Write the moves to the execlog print "Opening %s/batch_run_bbp_moves.log" % (options.inDir) execlog = open("%s/batch_run_bbp_moves.log" % (options.inDir), 'w') for mv in mvlist: execlog.write(mv) execlog.close()
def run(self): """ Run the UCSB Stitch code """ print("UCSB Stitch".center(80, '-')) install = InstallCfg.getInstance() 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.uc_stitch_%s.log" % (sim_id, sta_base)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_mod = os.path.join(install.A_TMP_DATA_DIR, str(self.sim_id), "uc_stitch_%s" % (sta_base)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # # Make sure the outpute and tmp directories exist # bband_utils.mkdirs([a_tmpdir, a_tmpdir_mod, a_outdir], print_cmd=False) a_velocity = os.path.join(a_indir, self.r_velocity) print("UC_stich - SRF File: %s" % (self.r_srffile)) if not os.path.isfile(self.r_srffile): a_srffile = os.path.join(a_indir, self.r_srffile) if not os.path.isfile(a_srffile): print("Error (uc_stich): Unable to locate SRF file:", a_srffile, "\nExiting Broadband...") sys.exit(1) else: a_srffile = self.r_srffile # Copy srf and velocity files to tmpdir shutil.copy2(a_srffile, os.path.join(a_tmpdir_mod, self.r_srffile)) shutil.copy2(a_velocity, os.path.join(a_tmpdir_mod, self.r_velocity)) # Store cwd and change over to tmpdir so the executable can # find the files old_cwd = os.getcwd() os.chdir(a_tmpdir_mod) a_stations = os.path.join(a_indir, self.r_stations) print(a_stations) slo = StationList(a_stations) site_list = slo.getStationList() # Need stations in UCSB LL format a_uc_stations = os.path.join(a_tmpdir_mod, "stations.ll") a_uc_vs30 = os.path.join(a_tmpdir_mod, "stations.vs30") stas2files.gp2uc_stalist(slo, a_uc_stations, a_uc_vs30) # Convert stations to UCSB XY format, if it doesn't exist if not os.path.exists("stations.xy"): r_faultfile = "faultGlobal.in" a_faultfile = os.path.join(a_tmpdir_mod, r_faultfile) if not os.path.isfile(a_faultfile): if os.path.isfile(os.path.join(a_indir, r_faultfile)): shutil.copy2(os.path.join(a_indir, r_faultfile), a_faultfile) else: print("Extracting faultGlobal.in from " "SRF and velocity model.") fp = open("faultGlobalTmp", 'w') fp.write("%s\n" % self.r_velocity) fp.write("%s\n" % self.r_srffile) fp.close() cmd = ("%s/getfaultGlobal < faultGlobalTmp >> %s 2>&1" % (install.A_UCSB_BIN_DIR, self.log)) bband_utils.runprog(cmd) cmd = "%s/statLL2XY >> %s 2>&1 " % (install.A_UCSB_BIN_DIR, self.log) bband_utils.runprog(cmd) #write stitch BBP sBBP_in = open("stitchBBP.inp", "w") #stations list sBBP_in.write("stations.xy\n") #velocity file list sBBP_in.write("VMname.list\n") #dir with 1D synthetics (<stat>.3comp) sBBP_in.write("%s/\n" % a_tmpdir) #dir with non-linear 3D synthetics (<stat>.<comp>.nl1D.001) sBBP_in.write("%s/\n" % a_tmpdir) #joint frequency, fmax sBBP_in.write("1.0, 15.0\n") # depth of hypocenter if self.r_srcfile is not None and self.r_srcfile != "": a_srcfile = os.path.join(a_indir, self.r_srcfile) hypo_dep = fault_utils.calculate_hypo_depth(a_srcfile) elif self.r_srffile is not None and self.r_srffile != "": hypo_dep = fault_utils.get_hypocenter(a_srffile, sta_base)[2] else: # No way to determine hypocenter depth, existing print("No way to determine hypocenter depth, exiting!") sys.exit(1) sBBP_in.write("%s\n" % hypo_dep) #source model sBBP_in.write("1\n") #output format 2=velocity sBBP_in.write("2\n") sBBP_in.flush() sBBP_in.close() vMname_in = open("%s/VMname.list" % a_tmpdir_mod, "w") for stat in site_list: vMname_in.write("%s\n" % self.r_velocity) vMname_in.flush() vMname_in.close() #stitch expects <stat>.3comp for LF and <stat>.<comp>.nl1D.001 for HF for stat in site_list: if self.acc: if os.path.exists("%s/%d.%s-lf.acc.bbp" % (a_tmpdir, sim_id, stat.scode)): #integrate to velocity cmd = "%s/wcc2bbp nsfile=%s/%d.%s-lf.acc.000 ewfile=%s/%d.%s-lf.acc.090 udfile=%s/%d.%s-lf.acc.ver wcc2bbp=0 < %s/%d.%s-lf.acc.bbp >> %s 2>&1" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, self.log) bband_utils.runprog(cmd) for comp in ['000', '090', 'ver']: cmd = "%s/integ_diff integ=1 filein=%s/%d.%s-lf.acc.%s fileout=%s/%d.%s-lf.vel.%s" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, comp, a_tmpdir, sim_id, stat.scode, comp) bband_utils.runprog(cmd) cmd = "%s/wcc2bbp nsfile=%s/%d.%s-lf.vel.000 ewfile=%s/%d.%s-lf.vel.090 udfile=%s/%d.%s-lf.vel.ver units=cm/s wcc2bbp=1 > %s/%d.%s-lf.bbp" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode) bband_utils.runprog(cmd) else: print("Can't find LF acceleration file for " "site %s, aborting." % (stat.scode)) sys.exit(2) if os.path.exists("%s/%d.%s.acc.bbp" % (a_tmpdir, sim_id, stat.scode)): #split into components and rename #nl1D requires 1 line with nt dt #followed by 5 entries per line #Assumes UCSB HF, or why would we be running this? cmd = "%s/wcc2bbp nsfile=%s/%d.%s.acc.000 ewfile=%s/%d.%s.acc.090 udfile=%s/%d.%s.acc.ver wcc2bbp=0 < %s/%d.%s.acc.bbp >> %s 2>&1" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, self.log) bband_utils.runprog(cmd) for comp in ['000', '090', 'ver']: cmd = "%s/integ_diff integ=1 filein=%s/%d.%s.acc.%s fileout=%s/%d.%s.vel.%s" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, comp, a_tmpdir, sim_id, stat.scode, comp) bband_utils.runprog(cmd) cmd = "%s/wcc2bbp nsfile=%s/%d.%s.vel.000 ewfile=%s/%d.%s.vel.090 udfile=%s/%d.%s.vel.ver units=cm/s wcc2bbp=1 > %s/%d.%s.bbp" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode) bband_utils.runprog(cmd) elif os.path.exists("%s/%d.%s-hf.acc.bbp" % (a_tmpdir, sim_id, stat.scode)): print("Using HF only.") cmd = "%s/wcc2bbp nsfile=%s/%d.%s-hf.acc.000 ewfile=%s/%d.%s-hf.acc.090 udfile=%s/%d.%s-hf.acc.ver wcc2bbp=0 < %s/%d.%s-hf.acc.bbp >> %s 2>&1" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, self.log) bband_utils.runprog(cmd) for comp in ['000', '090', 'ver']: cmd = "%s/integ_diff integ=1 filein=%s/%d.%s-hf.acc.%s fileout=%s/%d.%s-hf.vel.%s" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, comp, a_tmpdir, sim_id, stat.scode, comp) bband_utils.runprog(cmd) cmd = "%s/wcc2bbp nsfile=%s/%d.%s-hf.vel.000 ewfile=%s/%d.%s-hf.vel.090 udfile=%s/%d.%s-hf.vel.ver units=cm/s wcc2bbp=1 > %s/%d.%s-hf.bbp" % ( install.A_GP_BIN_DIR, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode, a_tmpdir, sim_id, stat.scode) bband_utils.runprog(cmd) else: print("Can't find HF acceleration file for " "site %s, aborting." % (stat.scode)) if os.path.exists("%s/%d.%s-lf.bbp" % (a_tmpdir, sim_id, stat.scode)): shutil.copy2( "%s/%d.%s-lf.bbp" % (a_tmpdir, sim_id, stat.scode), "%s/%d.%s-lf.prestitch.bbp" % (a_tmpdir, sim_id, stat.scode)) shutil.copy2( "%s/%d.%s-lf.bbp" % (a_tmpdir, sim_id, stat.scode), "%s/%s.3comp" % (a_tmpdir, stat.scode)) else: print("Can't find LF velocity file for site %s, aborting." % (stat.scode)) sys.exit(2) if os.path.exists("%s/%d.%s.bbp" % (a_tmpdir, sim_id, stat.scode)): #split into components and rename #nl1D requires 1 line with nt dt #followed by 5 entries per line #Assumes UCSB HF, or why would we be running this? shutil.copy2( "%s/%d.%s.bbp" % (a_tmpdir, sim_id, stat.scode), "%s/%d.%s.prestitch.bbp" % (a_tmpdir, sim_id, stat.scode)) self.split_bbp(a_tmpdir, stat.scode, "%s/%d.%s.bbp" % (a_tmpdir, sim_id, stat.scode)) elif os.path.exists("%s/%d.%s-hf.bbp" % (a_tmpdir, sim_id, stat.scode)): shutil.copy2( "%s/%d.%s-hf.bbp" % (a_tmpdir, sim_id, stat.scode), "%s/%d.%s-hf.prestitch.bbp" % (a_tmpdir, sim_id, stat.scode)) self.split_bbp( a_tmpdir, stat.scode, "%s/%d.%s-hf.bbp" % (a_tmpdir, sim_id, stat.scode)) else: print("Can't find HF velocity file for site %s, aborting." % (stat.scode)) cmd = "%s/stitchBBP >> %s 2>&1" % (install.A_UCSB_BIN_DIR, self.log) bband_utils.runprog(cmd) #reconstitute BBP file for stat in site_list: print("%s/%s.000.gmBB.001" % (a_tmpdir, stat.scode)) if os.path.exists("%s/%s.000.gmBB.001" % (a_tmpdir_mod, stat.scode)): self.make_bbp(a_tmpdir_mod, stat.scode) shutil.copy2( "%s/%d.%s-stitch.bbp" % (a_tmpdir_mod, sim_id, stat.scode), "%s/%d.%s.vel.bbp" % (a_tmpdir, sim_id, stat.scode)) shutil.copy2( "%s/%d.%s-stitch.bbp" % (a_tmpdir_mod, sim_id, stat.scode), "%s/%d.%s.vel.bbp" % (a_outdir, sim_id, stat.scode)) # Create acceleration seismogram # Create path names and check if their sizes are # within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.000" % (sim_id, stat.scode)) ewfile = os.path.join(a_tmpdir, "%d.%s.090" % (sim_id, stat.scode)) udfile = os.path.join(a_tmpdir, "%d.%s.ver" % (sim_id, stat.scode)) bbpfile = os.path.join(a_tmpdir, "%d.%s.vel.bbp" % (sim_id, stat.scode)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/wcc2bbp " % (install.A_GP_BIN_DIR) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True) for comp in ['000', '090', 'ver']: # Differentiate each component filein = os.path.join(a_tmpdir, "%d.%s.%s" % (sim_id, stat.scode, comp)) fileout = os.path.join( a_tmpdir, "%d.%s.acc.%s" % (sim_id, stat.scode, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s/integ_diff diff=1 filein=%s fileout=%s" % (install.A_GP_BIN_DIR, filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True) # Create path names and check if their sizes are # within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.acc.000" % (sim_id, stat.scode)) ewfile = os.path.join(a_tmpdir, "%d.%s.acc.090" % (sim_id, stat.scode)) udfile = os.path.join(a_tmpdir, "%d.%s.acc.ver" % (sim_id, stat.scode)) bbpfile = os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, stat.scode)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s/wcc2bbp " % (install.A_GP_BIN_DIR) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True) # Copy acceleration bbp file to outdir shutil.copy2( os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, stat.scode)), os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, stat.scode))) os.chdir(old_cwd) print("UCSB Stitch Completed".center(80, '-'))
""" print("Usage: %s <command> <options>" % os.path.basename(sys.argv[0])) print() print("Available commands:") print(" plot <bbp_in> <png_out> - plots bbp_in, generating png_out") print(" comp <bbp1> <bbp2> <png_out> - plots bbp1 and bbp2 into png_out") print(" integrate <acc_bbp> <vel_bbp> - acc_bbp -> integration -> vel_bbp") print(" diff <vel_bbp> <acc_bbp> - vel_bbp -> diff -> acc_bbp") print() sys.exit(0) # ------------------------------------------------------------------------------ # Main # ------------------------------------------------------------------------------ INSTALL = InstallCfg.getInstance() # Check if at least 1 parameter if len(sys.argv) < 2: usage() # Get command CMD = sys.argv[1].lower() if CMD == "plot": if len(sys.argv) < 4: usage() plot(sys.argv[2], sys.argv[3]) elif CMD == "comp": if len(sys.argv) < 5: usage() comp(sys.argv[2], sys.argv[3], sys.argv[4]) elif CMD == "integrate" or CMD == "int":
def main(): """ Parse command line options and create the needed files/directories """ # Detect BBP installation bbp_install = InstallCfg.getInstance() prog_base = os.path.basename(sys.argv[0]) usage = "usage: %s [options]" % (prog_base) parser = optparse.OptionParser(usage) parser.add_option("-c", "--codebase", type="string", action="store", dest="codebase", help="Codebase for the simulation: %s" % (CODEBASES)) parser.add_option("-v", "--velocity-model", type="string", action="store", dest="vmodel", help="Velocity model (region) for this simulation") parser.add_option("--src", "--source", type="string", action="store", dest="source", help="Source description file for the simulation") parser.add_option("--stl", "--station-list", type="string", action="store", dest="station_list", help="Station list file for the simulation") parser.add_option("-d", "--dir", type="string", action="store", dest="simdir", help="Simulation directory") parser.add_option("--hypo-rand", action="store_true", dest="hyporand", help="Enables hypocenter randomization") parser.add_option("--no-hypo-rand", action="store_false", dest="hyporand", help="Disables hypocenter randomization") parser.add_option("-n", "--num-simulations", type="int", action="store", dest="numsim", help="Number of simulations to run") parser.add_option("--email", type="string", action="store", dest="email", help="Email for job notifications") (options, _) = parser.parse_args() # Validate codebase to use codebase = options.codebase if codebase is None: print "Please specify a codebase!" sys.exit(1) codebase = codebase.lower() if codebase not in CODEBASES: print "Codebase needs to be one of: %s" % (CODEBASES) # Check for velocity model vmodel_names = velocity_models.get_all_names() vmodel = options.vmodel if vmodel is None: print "Please provide a velocity model (region) for this simulation!" print "Available options are: %s" % (vmodel_names) sys.exit(1) vmodels = [v_model.lower() for v_model in vmodel_names] if vmodel.lower() not in vmodels: print("Velocity model %s does not appear to be available on BBP" % (vmodel)) print("Available options are: %s" % (vmodel_names)) print "Please provide another velocity model or check your BBP installation." sys.exit(1) # Now get the name with the correct case vmodel = vmodel_names[vmodels.index(vmodel.lower())] # Check for hypocenter randomization if options.hyporand is None: print "Please specify --hypo-rand or --no-hypo-rand!" sys.exit(1) if options.hyporand: hypo_rand = True else: hypo_rand = False # Get the source file source_file = options.source if source_file is None: print "Please provide a source description (src file)!" sys.exit(1) # Make it a full path source_file = os.path.realpath(source_file) # Make sure source file exists and is readable if not os.path.isfile(source_file) or not os.access(source_file, os.R_OK): print "Source file does not seem to be accessible!" sys.exit(1) # Get the station list station_list = options.station_list if station_list is None: print "Please provide a station list (stl file)!" sys.exit(1) # Make it a full path station_list = os.path.realpath(station_list) # Make sure station list exists and is readable if not os.path.isfile(station_list) or not os.access( station_list, os.R_OK): print "Station list foes not seem to be accessible!" sys.exit(1) # Check for the simulation directory simdir = options.simdir if simdir is None: print "Please provide a simulation directory!" sys.exit(1) simdir = os.path.abspath(simdir) if os.path.exists(simdir): print "Simulation directory exists: %s" % (simdir) opt = raw_input("Do you want to delete its contents (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) opt = raw_input("ARE YOU SURE (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) # Delete existing directory (we already asked the user twice!!!) shutil.rmtree(simdir) # Pick up number of simulations to run numsim = options.numsim if numsim < 1 or numsim > MAX_SIMULATIONS: print("Number of simulations should be between 1 and %d" % (MAX_SIMULATIONS)) sys.exit(1) # Check for e-mail address email = options.email if email is None: print "Please provide an e-mail address for job notifications" sys.exit(1) # Make sure user has configured the setup_bbp_epicenter_env.sh script setup_bbp_env = os.path.join(bbp_install.A_INSTALL_ROOT, "utils/batch/setup_bbp_epicenter_env.sh") if not os.path.exists(setup_bbp_env): print("Cannot find setup_bbp_epicenter_env.sh script!") print("Expected at: %s" % (setup_bbp_env)) sys.exit(1) # Create simulation directories prefix = "%s-%s" % (os.path.splitext( os.path.basename(source_file))[0], codebase.lower()) # Make sure we remove spaces from prefix prefix = prefix.replace(" ", '') os.makedirs(simdir) indir = os.path.join(simdir, "Sims", "indata") outdir = os.path.join(simdir, "Sims", "outdata") tmpdir = os.path.join(simdir, "Sims", "tmpdata") logsdir = os.path.join(simdir, "Sims", "logs") xmldir = os.path.join(simdir, "Xml") srcdir = os.path.join(simdir, "Src") for mdir in [indir, outdir, tmpdir, logsdir, xmldir, srcdir]: os.makedirs(mdir) # Generate source files generate_src_files(numsim, source_file, srcdir, prefix, hypo_rand) # Generate xml files generate_xml(bbp_install, numsim, srcdir, xmldir, logsdir, vmodel, codebase, prefix, station_list) # Write pbs file write_pbs(bbp_install, numsim, simdir, xmldir, email, prefix)
def plot_map_gof(r_srcfile, r_stations, resid_file, comp_label, sim_id): """ Reads data from resid_file and plots a map gof plot with a number of periods """ # Make sure we have a src or srf file if (r_srcfile is None or r_srcfile == "" or (not r_srcfile.endswith(".srf") and not r_srcfile.endswith(".src"))): # We need a SRC or SRF file to get the fault geometry return # Get directory names install = InstallCfg.getInstance() 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_input_file = os.path.join(a_indir, r_srcfile) a_station_file = os.path.join(a_indir, r_stations) # Define boundaries to plot using the stations in the station file (north, south, east, west) = plot_map.set_boundaries_from_stations(a_station_file) trace_file = "%s.trace" % (a_input_file) simple_station_file = "%s.simple" % (a_station_file) if r_srcfile.endswith(".srf"): plot_map.write_fault_trace(a_input_file, trace_file) else: plot_map.write_simple_trace(a_input_file, trace_file) plot_map.write_simple_stations(a_station_file, simple_station_file) # Get hypo_lon, hypo_lat from src/srf file hypo_lon, hypo_lat = fault_utils.calculate_epicenter(a_input_file) 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') # 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: summary_output = os.path.join( a_outdir, "%s-%d-resid-map-%.3f-%s.txt" % (comp_label, sim_id, period, COMP_EXT_RD50)) sta_x_data, sta_y_data, sta_resid_data = read_resid( resid_file, period, summary_output) all_sta_x_data.append(sta_x_data) all_sta_y_data.append(sta_y_data) all_sta_resid_data.append(sta_resid_data) # Now create the map GOF outfile = os.path.join(a_outdir, "gof-map-%s-%d-rotd50.png" % (comp_label, sim_id)) create_map_gof(all_sta_x_data, all_sta_y_data, all_sta_resid_data, plotregion, topo, coastal, border, trace_file, comp_label, sim_id, outfile, hypo_lat=hypo_lat, hypo_lon=hypo_lon)
def run(self): """ This function prepares the parameter file for BBToolbox, and then invokes it """ print("SDSU BBToolBox".center(80, '-')) self.install = InstallCfg.getInstance() install = self.install sim_id = self.sim_id # Build path names 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.bbtoolbox_%s.log" % (sim_id, sta_base)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_mod = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "bbtoolbox_%s" % (sta_base)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) a_param_outdir = os.path.join(a_outdir, "param_files") # # Make sure the output and two tmp directories exist # bband_utils.mkdirs([a_tmpdir, a_tmpdir_mod, a_outdir, a_param_outdir], print_cmd=False) # Make sure BBToolbox works when starting from a srf file if self.r_srcfile: a_srcfile = os.path.join(a_indir, self.r_srcfile) else: a_srcfile = "" self.config = BBToolboxCfg(a_srcfile=a_srcfile) # Set default parameters config = self.config # Initialize random number with seed and calculate new iseed random.seed(config.SEED) self.iseed = int(random.random() * 10000) self.fmax = config.FMAX self.kappa = config.KAPPA self.q_coda = config.Q_CODA self.fdec = config.FDEC self.source_func = config.SOURCE_FUNC self.gs_flag = config.GS_FLAG self.ngaw_flag = config.NGAW_FLAG self.tr_sca = config.TR_SCA self.afac = config.AFAC self.bfac = config.BFAC self.str_fac = config.STR_FAC # Write valid par file, which includes correct references to # output dir, velocity model, stations list, fault # description, and scattering a_stations = os.path.join(a_indir, self.r_stations) # Need to create SDSU's BBToolbox files first self.create_bbtoolbox_files(a_stations) a_stations = os.path.join(a_indir, "bbtstations_%s.dat" % (sta_base)) parfilename = os.path.join(a_tmpdir_mod, "parfilename_%s" % (sta_base)) filename_fp = open(parfilename, "w") filename_fp.write('"%s"\n' % (os.path.join(a_indir, self.r_bbparfile))) filename_fp.flush() filename_fp.close() # Get list of stations stat_file_fp = open(a_stations, "r") data = stat_file_fp.readlines() stat_file_fp.close() for i in range(0, len(data)): pieces = data[i].split() if len(pieces) > 1: if pieces[1] == "X": break stat_names = [] for j in range(i + 1, len(data)): pieces = data[j].split() stat_names.append(pieces[2]) # Check if we have stations in our list if len(stat_names) == 0: # No stations! We should output an error raise ValueError("No stations in the station list!") # Stagein seismograms to working dir for i in range(0, len(stat_names)): glob_list = glob.glob("%s/%d.%s*" % (a_tmpdir, sim_id, stat_names[i])) for seismogram_file in glob_list: basename = os.path.basename(seismogram_file) shutil.copy2(seismogram_file, os.path.join(a_tmpdir_mod, basename)) # Run in tmpdir subdir to isolate temp fortran files os.chdir(a_tmpdir_mod) cmd = "%s/BBtoolbox.exe < %s >> %s 2>&1" % (install.A_SDSU_BIN_DIR, parfilename, self.log) bband_utils.runprog(cmd, abort_on_error=True) for i in range(0, len(stat_names)): shutil.copy2("%s/BB.%s.hyb" % (a_tmpdir_mod, stat_names[i]), "%s/%d.%s.bbp" % (a_tmpdir, sim_id, stat_names[i])) # Change to tmpdir so run.log file is put in tmpdir os.chdir(a_tmpdir) print("SDSU BBToolBox 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, '-'))
print("Usage: %s <command> <options>" % os.path.basename(sys.argv[0])) print() print("Available commands:") print(" plot <bbp_in> <png_out> - plots bbp_in, generating png_out") print(" comp <bbp1> <bbp2> <png_out> - plots bbp1 and bbp2 into png_out") print(" integrate <acc_bbp> <vel_bbp> - acc_bbp -> integration -> vel_bbp") print(" diff <vel_bbp> <acc_bbp> - vel_bbp -> diff -> acc_bbp") print() sys.exit(0) # ------------------------------------------------------------------------------ # Main # ------------------------------------------------------------------------------ INSTALL = InstallCfg.getInstance() # Check if at least 1 parameter if len(sys.argv) < 2: usage() # Get command CMD = sys.argv[1].lower() if CMD == "plot": if len(sys.argv) < 4: usage() plot(sys.argv[2], sys.argv[3]) elif CMD == "comp": if len(sys.argv) < 5: usage() comp(sys.argv[2], sys.argv[3], sys.argv[4]) elif CMD == "integrate" or CMD == "int":
sys.exit(1) # Create temp dir TMPDIR = tempfile.mkdtemp(prefix="bbp-") resid_file = os.path.join(TMPDIR, "bbp-rd50-resid.txt") log_file = os.path.join(TMPDIR, "bbp-rd50-resid.log") # Get input parameters station_list = sys.argv[1] src_file = sys.argv[2] sim_id_1 = int(sys.argv[3]) sim_id_2 = int(sys.argv[4]) output_dir = sys.argv[5] # Create directory paths install = InstallCfg.getInstance() config = GPGofCfg() a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id_1)) 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
def run(self): """ Runs the UCSB rupture generator """ print("UCSB Rupture Generator".center(80, '-')) # # installation directories # install = InstallCfg.getInstance() sim_id = self.sim_id 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_param_outdir = os.path.join(a_outdir, "param_files") logfile = os.path.join(install.A_OUT_LOG_DIR, str(sim_id), "%d.ucrmg.log" % (sim_id)) # # Update the Configuration File # a_srcfile = os.path.join(a_indir, self.r_srcfile) cfg = UCrmgCfg(self.vmodel_name, a_srcfile) # Make sure the tmp and output directories exist bband_utils.mkdirs([a_tmpdir, a_outdir, a_param_outdir], print_cmd=False) # Save cwd; change back to it at the end old_cwd = os.getcwd() os.chdir(a_tmpdir) # define location of input velocity model file # a_velmodel = os.path.join(a_indir, self.r_velmodel) # Create ffsp.inp r_ffsp_inp = "ffsp.inp" a_ffsp_inp = os.path.join(a_tmpdir, r_ffsp_inp) uc_fault_utils.uc_create_ffsp_inp(a_ffsp_inp, a_srcfile, self.vmodel_name) # Copy velocity model to work directory shutil.copy2( cfg.A_UC_LF_VELMODEL, os.path.join(a_tmpdir, os.path.basename(cfg.A_UC_LF_VELMODEL))) # Save a copy of the ffsp.inp file shutil.copy2(a_ffsp_inp, os.path.join(a_param_outdir, r_ffsp_inp)) # Now, run the UCSB rupture generator cmd = ("%s >> %s 2>&1" % (cfg.A_UC_FFSP_EXE, logfile)) bband_utils.runprog(cmd) # Copy output to indata and outdata directories ffsp_output_file = "%s.001" % (cfg.FFSP_OUTPUT_PREFIX) shutil.copy2(ffsp_output_file, os.path.join(a_indir, ffsp_output_file)) shutil.copy2(ffsp_output_file, os.path.join(a_outdir, ffsp_output_file)) os.chdir(old_cwd) print("UCSB Rupture Generator Completed".center(80, '-'))
def run(self): """ Runs the match module to merge low and high frequency seismograms """ print("Match".center(80, '-')) install = InstallCfg.getInstance() config = MatchCfg() 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.match_%s.log" % (sim_id, sta_base)) a_statfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_stations) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # Make sure tmpdir exists dirs = [a_tmpdir] bband_utils.mkdirs(dirs, print_cmd=False) pow2_param = 0 if self.pow2: pow2_param = 1 # Start with defaults self.phase = config.PHASE self.hf_fhi = config.HF_FHI self.lf_flo = config.LF_FLO # Set match method if config.MATCH_METHOD == 1: self.phase = 1 elif config.MATCH_METHOD == 2: val = 1.0 / (2.0 * config.HF_ORD) self.hf_fhi = (self.hf_fhi * math.exp(val * math.log(math.sqrt(2.0) - 1.0))) val = -1.0 / (2.0 * config.LF_ORD) self.lf_flo = (self.lf_flo * math.exp(val * math.log(math.sqrt(2.0) - 1.0))) # # Read and parse the station list with this call # slo = StationList(a_statfile) site_list = slo.getStationList() # Get pointer to the velocity model object vel_obj = velocity_models.get_velocity_model_by_name(self.vmodel_name) if vel_obj is None: raise bband_utils.ParameterError("Cannot find velocity model: %s" % (self.vmodel_name)) # Check for velocity model-specific parameters vmodel_params = vel_obj.get_codebase_params('gp') # Figure out what DT we should use when resampling # Figure out the LF DT value if self.acc: seis_ext = '.acc.bbp' else: seis_ext = '.bbp' lf_seis = None # Find one LF seismogram for sites in site_list: site = sites.scode if os.path.exists(os.path.join(a_tmpdir, "%d.%s-lf%s" % (sim_id, site, seis_ext))): lf_seis = os.path.join(a_tmpdir, "%d.%s-lf%s" % (sim_id, site, seis_ext)) break # Need one file if lf_seis is None: raise bband_utils.ParameterError("Cannot find a LF seismogram") # Pick DT from this file lf_dt = None lf_file = open(lf_seis) for line in lf_file: line = line.strip() if line.startswith("#") or line.startswith("%"): continue # Got to first timestamp. Now, pick two consecutive # timestamps values lf_t1 = float(line.strip().split()[0]) lf_t2 = float(lf_file.next().strip().split()[0]) # Subtract the two times lf_dt = lf_t2 - lf_t1 # All done! break lf_file.close() if lf_dt is None: raise bband_utils.ParameterError("Cannot find LF_DT!") # lf_dt *should* match the gf_dt used by jbsim #if not 'GF_DT' in vmodel_params: # raise bband_utils.ParameterError("Cannot find GF_DT parameter in " # "velocity model: %s" % # (self.vmodel_name)) # In the GP method, we can potentially have two independent DT # values, one used by the rupture generator and the # low-frequency jbsim seismogram simulator, and another value # used by the high-frequency hfsims program. We have to use # the smaller of these two values in order to properly combine # the low-, and high-frequency seismograms. #gf_dt = float(vmodel_params['GF_DT']) if 'HF_DT' in vmodel_params: hf_dt = float(vmodel_params['HF_DT']) else: hf_dt = config.NEW_HFDT new_dt = min(lf_dt, hf_dt) # Go through the stations for sites in site_list: # Pick station name site = sites.scode # # We have a verbose of silent invocation. This is a very # verbose program so our default writes to dev/null # # # There are multiple possibilities; either we have # separate HF and LF files, we have HF and .bbp, LF and # .bbp, or just .bbp. In all cases, we need to separate # them to get components. # hf_exists = False lf_exists = False if not self.acc: print("==> Processing velocity seismograms for station: %s" % (site)) # Need to convert to acc first if os.path.exists(os.path.join(a_tmpdir, "%d.%s-hf.bbp" % (sim_id, site))): hf_exists = True if os.path.exists(os.path.join(a_tmpdir, "%d.%s-lf.bbp" % (sim_id, site))): lf_exists = True # If no files exist for this station, make a note and continue if not hf_exists and not lf_exists: print("===> No velocity seismograms found!") print("===> Skipping station...") continue # First process HF files to convert velocity to acceleration # Create path names and check if their sizes are # within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-hf.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-hf.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-hf.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-hf.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) # Run wcc2bbp cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in config.COMPS: # Create path names and check if their sizes # are within bounds filein = os.path.join(a_tmpdir, "%d.%s-hf.%s" % (sim_id, site, comp)) fileout = os.path.join(a_tmpdir, "%d.%s-hf.acc.%s" % (sim_id, site, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s diff=1 " % (os.path.join(install.A_GP_BIN_DIR, "integ_diff")) + "filein=%s fileout=%s" % (filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Then process LF files to convert velocity to acceleration # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-lf.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-lf.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-lf.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-lf.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in config.COMPS: # Create path names and check if their sizes # are within bounds filein = os.path.join(a_tmpdir, "%d.%s-lf.%s" % (sim_id, site, comp)) fileout = os.path.join(a_tmpdir, "%d.%s-lf.acc.%s" % (sim_id, site, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "integ_diff")) + "diff=1 filein=%s fileout=%s" % (filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # We should have acceleration files at this point hf_exists = False lf_exists = False if os.path.exists(os.path.join(a_tmpdir, "%d.%s-hf.acc.bbp" % (sim_id, site))): hf_exists = True if os.path.exists(os.path.join(a_tmpdir, "%d.%s-lf.acc.bbp" % (sim_id, site))): lf_exists = True print("==> Processing acceleration seismograms for station: %s" % (site)) # If no files exist for this station, make a note and continue if not hf_exists and not lf_exists: print("===> No acceleration seismograms found!") print("===> Skipping station...") continue # # Convert HF file to wcc components # # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Convert LF file to wcc components # # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Process each component # for entries in config.COMPS: compo = entries # # HF First # listfile = os.path.join(a_tmpdir, "%s.%s.hf.%s" % (config.FILTLIST, sta_base, compo)) bband_utils.check_path_lengths([listfile], bband_utils.GP_MAX_FILENAME) # Create wcc_tfilter input file out = open(listfile, 'w') # Contains HF input file infile = os.path.join(a_tmpdir, "%d.%s-hf.acc.%s" % (sim_id, site, compo)) out.write("%s\n" % infile) out.flush() out.close() # Also check infile bband_utils.check_path_lengths([infile], bband_utils.GP_MAX_FILENAME) # # Pre-filter and resample HF file # shutil.copy2(infile, "%s.prefilter" % infile) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_tfilter")) + "filelist=%s order=%d fhi=%f flo=%s " % (listfile, config.HF_ORD, self.hf_fhi, config.HF_FLO) + "inbin=0 outbin=0 phase=%d " % (self.phase) + "outpath=%s >> %s 2>&1" % (a_tmpdir, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) outfile = os.path.join(a_tmpdir, "%d.%s-hf-resamp.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([outfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s newdt=%f " % (os.path.join(install.A_GP_BIN_DIR, "wcc_resamp_arbdt"), new_dt) + "pow2=%d infile=%s outfile=%s >> %s 2>&1" % (pow2_param, infile, outfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # LF Next # listfile = os.path.join(a_tmpdir, "%s.%s.lf.%s" % (config.FILTLIST, sta_base, compo)) bband_utils.check_path_lengths([listfile], bband_utils.GP_MAX_FILENAME) # Create wcc_tfilter input file out = open(listfile, 'w') # Contains LF input file infile = os.path.join(a_tmpdir, "%d.%s-lf.acc.%s" % (sim_id, site, compo)) out.write("%s\n" % infile) out.flush() out.close() # Also check infile bband_utils.check_path_lengths([infile], bband_utils.GP_MAX_FILENAME) # # Pre-filter and resample LF file # shutil.copy2(infile, "%s.prefilter" % infile) if not self.using_3d: progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_tfilter")) + "filelist=%s order=%d fhi=%f flo=%s " % (listfile, config.LF_ORD, config.LF_FHI, self.lf_flo) + "inbin=0 outbin=0 phase=%d " % (self.phase) + "outpath=%s >> %s 2>&1 " % (a_tmpdir, self.log)) bband_utils.runprog(progstring, print_cmd=False) outfile = os.path.join(a_tmpdir, "%d.%s-lf-resamp.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([outfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_resamp_arbdt")) + "newdt=%f pow2=%d " % (new_dt, pow2_param) + "infile=%s outfile=%s >> %s 2>&1" % (infile, outfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Add LF and HF resampled acc seismograms # # Check all path lengths infile1 = os.path.join(a_tmpdir, "%d.%s-lf-resamp.%s" % (sim_id, site, compo)) infile2 = os.path.join(a_tmpdir, "%d.%s-hf-resamp.%s" % (sim_id, site, compo)) outfile = os.path.join(a_tmpdir, "%d.%s.acc.add.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([infile1, infile2, outfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_add")) + "f1=1.00 t1=%f inbin1=0 infile1=%s " % (config.LF_TSTART, infile1) + "f2=1.00 t2=%f inbin2=0 infile2=%s " % (config.HF_TSTART, infile2) + "outbin=0 outfile=%s >> %s 2>&1" % (outfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Create combined velocity files # # Check path lengths filein = os.path.join(a_tmpdir, "%d.%s.acc.add.%s" % (sim_id, site, compo)) fileout = os.path.join(a_tmpdir, "%d.%s.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s integ=1 filein=%s fileout=%s" % (os.path.join(install.A_GP_BIN_DIR, "integ_diff"), filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # We have all the component files, create velocity seismogram # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s wcc2bbp=1 " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + 'title="Sim NGAH, stat=%s" ' % site + 'nsfile=%s ewfile=%s udfile=%s > %s 2>> %s' % (nsfile, ewfile, udfile, bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # Copy velocity bbp file to outdir shutil.copy2(os.path.join(a_tmpdir, "%d.%s.bbp" % (sim_id, site)), os.path.join(a_outdir, "%d.%s.vel.bbp" % (sim_id, site))) # Also create acceleration bbp file in outdir # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in config.COMPS: # Create path names and check if their sizes are within bounds filein = os.path.join(a_tmpdir, "%d.%s.%s" % (sim_id, site, comp)) fileout = os.path.join(a_tmpdir, "%d.%s.acc.%s" % (sim_id, site, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s diff=1 filein=%s fileout=%s" % (os.path.join(install.A_GP_BIN_DIR, "integ_diff"), filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Copy acceleration bbp file to outdir shutil.copy2(os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, site)), os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, site))) print("Match Completed".center(80, '-'))
def run(self): """ This function prepares the parameter file for the Irikura Recipe, invokes it, and formats its output to be compatible with the Broadband Platform """ print("IrikuraHF".center(80, '-')) self.install = InstallCfg.getInstance() install = self.install 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.irikura_hf_%s.log" % (sim_id, sta_base)) a_indir = os.path.join(install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) irikura_dir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "irikura_hf_%s" % (sta_base)) irikura_hor_dir = os.path.join(irikura_dir, "HOR") irikura_ver_dir = os.path.join(irikura_dir, "VER") a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # # Make sure the output and two tmp directories exist # bband_utils.mkdirs([ a_tmpdir, irikura_dir, a_outdir, irikura_hor_dir, irikura_ver_dir ]) a_velmodel = os.path.join(a_indir, self.r_velmodel) a_stations = os.path.join(a_indir, self.r_stations) a_srffile = os.path.join(a_indir, self.r_srffile) self.stat_list = StationList(a_stations) # Read input files, calculate CSM parameters self.config = IrikuraHFCfg( os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_srcfile), a_velmodel) # Initilize random number generator with seed from src file random.seed(self.config.SEED) # Create filenames for all intermediate files vel_file = os.path.join(irikura_dir, "%d_soil.dat" % (sim_id)) vel_file_p = os.path.join(irikura_dir, "%d_soil_p.dat" % (sim_id)) station_file = os.path.join(irikura_dir, "%d_station.dat" % (sim_id)) fault_param_dat_file = os.path.join(irikura_dir, "%d_fault_param.dat" % (sim_id)) elem_param_dat_file = os.path.join(irikura_dir, "%s_elem_param.dat" % (sim_id)) srf2grns_input_file = os.path.join(irikura_dir, "input.txt") phase_file = os.path.join(irikura_dir, "phase.dat") phase2_file = os.path.join(irikura_dir, "phase2.dat") # Create Irikura velocity model file self.create_velocity_file(vel_file, vel_file_p) # Create Irikura station list self.create_station_list(station_file) # Create other input files self.create_irikura_files(fault_param_dat_file) # Create phase files self.create_phase_files(phase_file, phase2_file) # Copy velocity model and srf file to Irikura dir shutil.copy2(a_velmodel, os.path.join(irikura_dir, self.r_velmodel)) shutil.copy2(a_srffile, os.path.join(irikura_dir, self.r_srffile)) # Irikura binaries srf2grns_bin = os.path.join(install.A_IRIKURA_BIN_DIR, "srf2grns") statgreen_bin = os.path.join(install.A_IRIKURA_BIN_DIR, "statgreen") statgreen2_bin = os.path.join(install.A_IRIKURA_BIN_DIR, "statgreen2") greenscale_bin = os.path.join(install.A_IRIKURA_BIN_DIR, "greenscale") # Run in tmpdir subdir to isolate files # Save cwd, change back to it at the end old_cwd = os.getcwd() os.chdir(irikura_dir) # Run the srf2grns code config_file = open(srf2grns_input_file, 'w') config_file.write("%s\n" % (self.r_srffile)) config_file.write("%s\n" % (os.path.basename(elem_param_dat_file))) config_file.close() cmd = ("%s < %s >> %s 2>&1" % (srf2grns_bin, os.path.basename(srf2grns_input_file), self.log)) bband_utils.runprog(cmd, abort_on_error=True) # Run the statgreen program os.chdir(irikura_hor_dir) cmd = ("%s %s %s %s ../phase.dat >> %s 2>&1" % (statgreen_bin, station_file, fault_param_dat_file, vel_file, self.log)) bband_utils.runprog(cmd, abort_on_error=True) # Create directories for the AS and SAS files, and move data bband_utils.mkdirs([ os.path.join(irikura_hor_dir, "AS"), os.path.join(irikura_hor_dir, "SAS") ]) for fname in glob.iglob(os.path.join(irikura_hor_dir, "AS*.dat")): shutil.move(fname, os.path.join(irikura_hor_dir, "AS")) for fname in glob.iglob(os.path.join(irikura_hor_dir, "SAS*.dat")): shutil.move(fname, os.path.join(irikura_hor_dir, "SAS")) # Run statgreen2 (for vertical component) os.chdir(irikura_ver_dir) cmd = ("%s %s %s %s ../phase2.dat >> %s 2>&1" % (statgreen2_bin, station_file, fault_param_dat_file, vel_file_p, self.log)) bband_utils.runprog(cmd, abort_on_error=True) # Create directories for the AS and SAS files, and move data bband_utils.mkdirs([ os.path.join(irikura_ver_dir, "AS"), os.path.join(irikura_ver_dir, "SAS") ]) for fname in glob.iglob(os.path.join(irikura_ver_dir, "AS*.dat")): shutil.move(fname, os.path.join(irikura_ver_dir, "AS")) for fname in glob.iglob(os.path.join(irikura_ver_dir, "SAS*.dat")): shutil.move(fname, os.path.join(irikura_ver_dir, "SAS")) # Now, run the greenscale code for the # horizontal and vertical components for working_dir in [irikura_hor_dir, irikura_ver_dir]: os.chdir(working_dir) cmd = ("%s SAS %s %s %s LogGS.dat HP 1.0 0 >> %s 2>&1" % (greenscale_bin, station_file, elem_param_dat_file, fault_param_dat_file, self.log)) bband_utils.runprog(cmd, abort_on_error=True) # Create directories for the output files, move data bband_utils.mkdirs([ os.path.join(working_dir, "acc"), os.path.join(working_dir, "vel"), os.path.join(working_dir, "velf") ]) for fname in glob.iglob(os.path.join(working_dir, "ac0*.dat")): shutil.move(fname, os.path.join(working_dir, "acc")) for fname in glob.iglob(os.path.join(working_dir, "ve0*HP*.dat")): shutil.move(fname, os.path.join(working_dir, "velf")) for fname in glob.iglob(os.path.join(working_dir, "ve0*.dat")): shutil.move(fname, os.path.join(working_dir, "vel")) # Restore working directory os.chdir(old_cwd) # Need to copy and re-format output seismograms self.process_seismograms(irikura_dir) print("IrikuraHF Completed".center(80, '-'))
def main(): """ Parse command line options and create the needed files/directories """ # Detect BBP installation bbp_install = InstallCfg.getInstance() prog_base = os.path.basename(sys.argv[0]) usage = "usage: %s [options]" % (prog_base) parser = optparse.OptionParser(usage) parser.add_option("-c", "--codebase", type="string", action="store", dest="codebase", help="Codebase for the simulation: %s" % (CODEBASES)) parser.add_option("-v", "--velocity-model", type="string", action="store", dest="vmodel", help="Velocity model (region) for this simulation") parser.add_option("--src", "--source", type="string", action="store", dest="source", help="Source description file for the simulation") parser.add_option("--stl", "--station-list", type="string", action="store", dest="station_list", help="Station list file for the simulation") parser.add_option("--srf", "--srf-prefix", type="string", action="store", dest="srf_prefix", help="Prefix of SRF files to use, " "only for GP, SDSU and UCSB methods. " "Simulations begin after the rupture generator.") parser.add_option("-d", "--dir", type="string", action="store", dest="simdir", help="Simulation directory") parser.add_option("--hypo-rand", action="store_true", dest="hyporand", help="Enables hypocenter randomization") parser.add_option("--no-hypo-rand", action="store_false", dest="hyporand", help="Disables hypocenter randomization") parser.add_option("-n", "--num-simulations", type="int", action="store", dest="numsim", help="Number of simulations to run") parser.add_option("--email", type="string", action="store", dest="email", help="Email for job notifications") parser.add_option("-w", "--walltime", type="int", action="store", dest="walltime", help="Number of hours for walltime") parser.add_option("--new-nodes", action="store_true", dest="newnodes", help="Schedule the job in the new HPCC nodes") parser.add_option("--save-tmpdata", action="store_true", dest="savetemp", help="Save the contents of the tmpdata directory") parser.add_option("--hdd-min", type="float", action="store", dest="hdd_min", help="Min value for hypo down dip in randomization") parser.add_option("--hdd-max", type="float", action="store", dest="hdd_max", help="Max value for hypo down dip in randomization") parser.add_option("--has-min", type="float", action="store", dest="has_min", help="Min value for hypo along strike in randomization") parser.add_option("--has-max", type="float", action="store", dest="has_max", help="Max value for hypo along strike in randomization") parser.add_option("--only-rup", action="store_true", dest="only_rup", help="Only runs the rupture generator") parser.add_option("--var", "--variation", type="int", action="store", dest="variation", help="seed variation (default 1)") parser.add_option("--multiseg", action="store_true", dest="multiseg", help="Indicates simulation part of multiseg run") parser.add_option("--first-seg-dir", type="string", action="store", dest="first_seg_dir", help="required for multi-segment segments 2..n") parser.add_option("-s", "--site", action="store_true", dest="site_response", help="Use site response module") (options, _) = parser.parse_args() # Check if using new HPCC nodes if options.newnodes: newnodes = True else: newnodes = False # Check if multi-segment simulation if options.multiseg: multiseg = True else: multiseg = False # Check for first segment directory if options.first_seg_dir is not None: first_seg_dir = os.path.abspath(options.first_seg_dir) if not os.path.exists(first_seg_dir): print("First segment directory for exists: %s" % (first_seg_dir)) sys.exit(1) else: first_seg_dir = None # Check if user specified custom walltime if options.walltime: if options.walltime < 1: print("Walltime must be at least 1 hour!") sys.exit(1) walltime = options.walltime else: if newnodes: walltime = 24 else: walltime = 300 # Check for variation sequence if options.variation: variation = options.variation else: variation = 1 # Check if user wants to save the contents of tmpdata if options.savetemp: savetemp = True else: savetemp = False # Check if user wants to only run the rupture generator if options.only_rup: only_rup = True else: only_rup = False # Validate codebase to use codebase = options.codebase if codebase is None: print "Please specify a codebase!" sys.exit(1) codebase = codebase.lower() if codebase not in CODEBASES: print "Codebase needs to be one of: %s" % (CODEBASES) # Check for velocity model vmodel_names = velocity_models.get_all_names() vmodel = options.vmodel if vmodel is None: print "Please provide a velocity model (region) for this simulation!" print "Available options are: %s" % (vmodel_names) sys.exit(1) vmodels = [v_model.lower() for v_model in vmodel_names] if vmodel.lower() not in vmodels: print ("Velocity model %s does not appear to be available on BBP" % (vmodel)) print ("Available options are: %s" % (vmodel_names)) print "Please provide another velocity model or check your BBP installation." sys.exit(1) # Now get the name with the correct case vmodel = vmodel_names[vmodels.index(vmodel.lower())] # Check if users wants to run site response module if options.site_response: site_response = True if codebase not in CODEBASES_SITE: print "Cannot use site response with method: %s" % (codebase) sys.exit(1) else: site_response = False # Check for hypocenter randomization if options.hyporand is None: print "Please specify --hypo-rand or --no-hypo-rand!" sys.exit(1) if options.hyporand: hypo_rand = True else: hypo_rand = False # Define area where hypocenter will be randomized hypo_area = {} hypo_area["hdd_min"] = options.hdd_min hypo_area["hdd_max"] = options.hdd_max hypo_area["has_min"] = options.has_min hypo_area["has_max"] = options.has_max # Get the source file (SRC or SRFs) source_file = options.source srf_prefix = options.srf_prefix if source_file is None and srf_prefix is None: print ("Please provide either source description (src file) " "or a srf prefix!") sys.exit(1) # If user specified both a source file and a srf prefix, we abort! if source_file is not None and srf_prefix is not None: print "Cannot specify both srf_prefic and source_file!" sys.exit(1) # If user specified a source file if source_file is not None: # Make it a full path source_file = os.path.realpath(source_file) # Make sure source file is in the rcf-104 / scec-00 filesystem if not "rcf-104" in source_file and not "scec-00" in source_file: print "Source file should be in the rcf-104 / scec-00 filesystems!" sys.exit(1) # Make sure source file exists and is readable if (not os.path.isfile(source_file) or not os.access(source_file, os.R_OK)): print "Source file does not seem to be accessible!" sys.exit(1) # Create a prefix prefix = ("%s-%s" % (os.path.splitext(os.path.basename(source_file))[0], codebase.lower())) # If user specified a SRF prefix if srf_prefix is not None: # Make it a full path srf_prefix = os.path.realpath(srf_prefix) # Make sure source file is in the rcf-104 or scec-00 filesystems if not "rcf-104" in srf_prefix and not "scec-00" in srf_prefix: print "SRF files should be in the rcf-104 / scec-00 filesystems!" sys.exit(1) # Create a prefix prefix = os.path.splitext(os.path.basename(srf_prefix))[0] #prefix = prefix.rsplit("-", 1)[0] # Make sure we remove spaces from prefix prefix = prefix.replace(" ", '') # Get the station list station_list = options.station_list if station_list is None: print "Please provide a station list (stl file)!" sys.exit(1) # Make it a full path station_list = os.path.realpath(station_list) # Make sure station list is in the rcf-104 or scec-00 filesystems if not "rcf-104" in station_list and not "scec-00" in station_list: print "Station list should be in the rcf-104 / scec-00 filesystems!" sys.exit(1) # Make sure station list exists and is readable if (not os.path.isfile(station_list) or not os.access(station_list, os.R_OK)): print "Station list foes not seem to be accessible!" sys.exit(1) # Check for the simulation directory simdir = options.simdir if simdir is None: print "Please provide a simulation directory!" sys.exit(1) simdir = os.path.abspath(simdir) if os.path.exists(simdir): print "Simulation directory exists: %s" % (simdir) opt = raw_input("Do you want to delete its contents (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) opt = raw_input("ARE YOU SURE (y/n)? ") if opt.lower() != "y": print "Please provide another simulation directory!" sys.exit(1) # Delete existing directory (we already asked the user twice!!!) shutil.rmtree(simdir) # Pick up number of simulations to run numsim = options.numsim if numsim < 1 or numsim > MAX_SIMULATIONS: print ("Number of simulations should be between 1 and %d" % (MAX_SIMULATIONS)) sys.exit(1) # Check for e-mail address email = options.email if email is None: print "Please provide an e-mail address for job notifications" sys.exit(1) # Make sure user has configured the setup_bbp_env.sh script setup_bbp_env = os.path.join(bbp_install.A_INSTALL_ROOT, "utils/batch/setup_bbp_env.sh") if not os.path.exists(setup_bbp_env): print ("Cannot find setup_bbp_env.sh script!") print ("Expected at: %s" % (setup_bbp_env)) sys.exit(1) # Create simulation directories os.makedirs(simdir) indir = os.path.join(simdir, "Sims", "indata") outdir = os.path.join(simdir, "Sims", "outdata") tmpdir = os.path.join(simdir, "Sims", "tmpdata") logsdir = os.path.join(simdir, "Sims", "logs") xmldir = os.path.join(simdir, "Xml") srcdir = os.path.join(simdir, "Src") for mdir in [indir, outdir, tmpdir, logsdir, xmldir, srcdir]: os.makedirs(mdir) if srf_prefix is None: # Generate source files generate_src_files(numsim, source_file, srcdir, prefix, hypo_rand, hypo_area, variation, multiseg, first_seg_dir) # Generate xml files generate_xml(bbp_install, numsim, srcdir, xmldir, logsdir, vmodel, codebase, prefix, station_list, only_rup, srf_prefix, site_response) # Write pbs file write_pbs(bbp_install, numsim, simdir, xmldir, email, prefix, newnodes, walltime, savetemp) # Write .info file info_file = open(os.path.join(simdir, "%s.info" % (prefix)), 'w') info_file.write("# %s\n" % (" ".join(sys.argv))) info_file.close()
def run(self): """ Runs the match module to merge low and high frequency seismograms """ print("Match".center(80, '-')) install = InstallCfg.getInstance() config = MatchCfg() 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.match_%s.log" % (sim_id, sta_base)) a_statfile = os.path.join(install.A_IN_DATA_DIR, str(sim_id), self.r_stations) a_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_outdir = os.path.join(install.A_OUT_DATA_DIR, str(sim_id)) # Make sure tmpdir exists dirs = [a_tmpdir] bband_utils.mkdirs(dirs, print_cmd=False) pow2_param = 0 if self.pow2: pow2_param = 1 # Start with defaults self.phase = config.PHASE self.hf_fhi = config.HF_FHI self.lf_flo = config.LF_FLO # Set match method if config.MATCH_METHOD == 1: self.phase = 1 elif config.MATCH_METHOD == 2: val = 1.0 / (2.0 * config.HF_ORD) self.hf_fhi = (self.hf_fhi * math.exp(val * math.log(math.sqrt(2.0) - 1.0))) val = -1.0 / (2.0 * config.LF_ORD) self.lf_flo = (self.lf_flo * math.exp(val * math.log(math.sqrt(2.0) - 1.0))) # # Read and parse the station list with this call # slo = StationList(a_statfile) site_list = slo.getStationList() # Get pointer to the velocity model object vel_obj = velocity_models.get_velocity_model_by_name(self.vmodel_name) if vel_obj is None: raise bband_utils.ParameterError("Cannot find velocity model: %s" % (self.vmodel_name)) # Check for velocity model-specific parameters vmodel_params = vel_obj.get_codebase_params('gp') # Figure out what DT we should use when resampling # Figure out the LF DT value if self.acc: seis_ext = '.acc.bbp' else: seis_ext = '.bbp' lf_seis = None hf_seis = None # Find one LF seismogram and one HF seismogram for sites in site_list: site = sites.scode if os.path.exists( os.path.join(a_tmpdir, "%d.%s-lf%s" % (sim_id, site, seis_ext))): lf_seis = os.path.join(a_tmpdir, "%d.%s-lf%s" % (sim_id, site, seis_ext)) if os.path.exists( os.path.join(a_tmpdir, "%d.%s-hf%s" % (sim_id, site, seis_ext))): hf_seis = os.path.join( a_tmpdir, "%d.%s-hf%s" % (sim_id, site, seis_ext)) break # Need one of each if lf_seis is None: raise bband_utils.ParameterError("Cannot find a LF seismogram") if hf_seis is None: raise bband_utils.ParameterError("Cannot find a HF seismogram") # Pick DT from these files lf_dt = None lf_file = open(lf_seis) for line in lf_file: line = line.strip() if line.startswith("#") or line.startswith("%"): continue # Got to first timestamp. Now, pick two consecutive # timestamps values lf_t1 = float(line.strip().split()[0]) lf_t2 = float(lf_file.next().strip().split()[0]) # Subtract the two times lf_dt = lf_t2 - lf_t1 # All done! break lf_file.close() if lf_dt is None: raise bband_utils.ParameterError("Cannot find LF_DT!") hf_dt = None hf_file = open(hf_seis) for line in hf_file: line = line.strip() if line.startswith("#") or line.startswith("%"): continue # Got to first timestamp. Now, pick two consecutive # timestamps values hf_t1 = float(line.strip().split()[0]) hf_t2 = float(hf_file.next().strip().split()[0]) # Subtract the two times hf_dt = hf_t2 - hf_t1 # All done! break hf_file.close() if hf_dt is None: raise bband_utils.ParameterError("Cannot find HF_DT!") # In the GP method, we can potentially have two independent DT # values, one used by the rupture generator and the # low-frequency jbsim seismogram simulator, and another value # used by the high-frequency hfsims program. We have to use # the smaller of these two values in order to properly combine # the low-, and high-frequency seismograms. new_dt = min(lf_dt, hf_dt) # Go through the stations for sites in site_list: # Pick station name site = sites.scode # # We have a verbose of silent invocation. This is a very # verbose program so our default writes to dev/null # # # There are multiple possibilities; either we have # separate HF and LF files, we have HF and .bbp, LF and # .bbp, or just .bbp. In all cases, we need to separate # them to get components. # hf_exists = False lf_exists = False if not self.acc: print("==> Processing velocity seismograms for station: %s" % (site)) # Need to convert to acc first if os.path.exists( os.path.join(a_tmpdir, "%d.%s-hf.bbp" % (sim_id, site))): hf_exists = True if os.path.exists( os.path.join(a_tmpdir, "%d.%s-lf.bbp" % (sim_id, site))): lf_exists = True # If no files exist for this station, make a note and continue if not hf_exists and not lf_exists: print("===> No velocity seismograms found!") print("===> Skipping station...") continue # First process HF files to convert velocity to acceleration # Create path names and check if their sizes are # within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-hf.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-hf.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-hf.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-hf.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) # Run wcc2bbp cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in config.COMPS: # Create path names and check if their sizes # are within bounds filein = os.path.join(a_tmpdir, "%d.%s-hf.%s" % (sim_id, site, comp)) fileout = os.path.join( a_tmpdir, "%d.%s-hf.acc.%s" % (sim_id, site, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s diff=1 " % (os.path.join(install.A_GP_BIN_DIR, "integ_diff")) + "filein=%s fileout=%s" % (filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Then process LF files to convert velocity to acceleration # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-lf.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-lf.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-lf.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-lf.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in config.COMPS: # Create path names and check if their sizes # are within bounds filein = os.path.join(a_tmpdir, "%d.%s-lf.%s" % (sim_id, site, comp)) fileout = os.path.join( a_tmpdir, "%d.%s-lf.acc.%s" % (sim_id, site, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "integ_diff")) + "diff=1 filein=%s fileout=%s" % (filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # We should have acceleration files at this point hf_exists = False lf_exists = False if os.path.exists( os.path.join(a_tmpdir, "%d.%s-hf.acc.bbp" % (sim_id, site))): hf_exists = True if os.path.exists( os.path.join(a_tmpdir, "%d.%s-lf.acc.bbp" % (sim_id, site))): lf_exists = True print("==> Processing acceleration seismograms for station: %s" % (site)) # If no files exist for this station, make a note and continue if not hf_exists and not lf_exists: print("===> No acceleration seismograms found!") print("===> Skipping station...") continue # # Convert HF file to wcc components # # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-hf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Convert LF file to wcc components # # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s-lf.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Process each component # for entries in config.COMPS: compo = entries # # HF First # listfile = os.path.join( a_tmpdir, "%s.%s.hf.%s" % (config.FILTLIST, sta_base, compo)) bband_utils.check_path_lengths([listfile], bband_utils.GP_MAX_FILENAME) # Create wcc_tfilter input file out = open(listfile, 'w') # Contains HF input file infile = os.path.join( a_tmpdir, "%d.%s-hf.acc.%s" % (sim_id, site, compo)) out.write("%s\n" % infile) out.flush() out.close() # Also check infile bband_utils.check_path_lengths([infile], bband_utils.GP_MAX_FILENAME) # # Pre-filter and resample HF file # shutil.copy2(infile, "%s.prefilter" % infile) progstring = ( "%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_tfilter")) + "filelist=%s order=%d fhi=%f flo=%s " % (listfile, config.HF_ORD, self.hf_fhi, config.HF_FLO) + "inbin=0 outbin=0 phase=%d " % (self.phase) + "outpath=%s >> %s 2>&1" % (a_tmpdir, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) outfile = os.path.join( a_tmpdir, "%d.%s-hf-resamp.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([outfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s newdt=%f " % (os.path.join( install.A_GP_BIN_DIR, "wcc_resamp_arbdt"), new_dt) + "pow2=%d infile=%s outfile=%s >> %s 2>&1" % (pow2_param, infile, outfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # LF Next # listfile = os.path.join( a_tmpdir, "%s.%s.lf.%s" % (config.FILTLIST, sta_base, compo)) bband_utils.check_path_lengths([listfile], bband_utils.GP_MAX_FILENAME) # Create wcc_tfilter input file out = open(listfile, 'w') # Contains LF input file infile = os.path.join( a_tmpdir, "%d.%s-lf.acc.%s" % (sim_id, site, compo)) out.write("%s\n" % infile) out.flush() out.close() # Also check infile bband_utils.check_path_lengths([infile], bband_utils.GP_MAX_FILENAME) # # Pre-filter and resample LF file # shutil.copy2(infile, "%s.prefilter" % infile) progstring = ( "%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_tfilter")) + "filelist=%s order=%d fhi=%f flo=%s " % (listfile, config.LF_ORD, config.LF_FHI, self.lf_flo) + "inbin=0 outbin=0 phase=%d " % (self.phase) + "outpath=%s >> %s 2>&1 " % (a_tmpdir, self.log)) bband_utils.runprog(progstring, print_cmd=False) outfile = os.path.join( a_tmpdir, "%d.%s-lf-resamp.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([outfile], bband_utils.GP_MAX_FILENAME) progstring = ( "%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_resamp_arbdt")) + "newdt=%f pow2=%d " % (new_dt, pow2_param) + "infile=%s outfile=%s >> %s 2>&1" % (infile, outfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Add LF and HF resampled acc seismograms # # Check all path lengths infile1 = os.path.join( a_tmpdir, "%d.%s-lf-resamp.%s" % (sim_id, site, compo)) infile2 = os.path.join( a_tmpdir, "%d.%s-hf-resamp.%s" % (sim_id, site, compo)) outfile = os.path.join( a_tmpdir, "%d.%s.acc.add.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([infile1, infile2, outfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc_add")) + "f1=1.00 t1=%f inbin1=0 infile1=%s " % (config.LF_TSTART, infile1) + "f2=1.00 t2=%f inbin2=0 infile2=%s " % (config.HF_TSTART, infile2) + "outbin=0 outfile=%s >> %s 2>&1" % (outfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # # Create combined velocity files # # Check path lengths filein = os.path.join( a_tmpdir, "%d.%s.acc.add.%s" % (sim_id, site, compo)) fileout = os.path.join(a_tmpdir, "%d.%s.%s" % (sim_id, site, compo)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s integ=1 filein=%s fileout=%s" % (os.path.join( install.A_GP_BIN_DIR, "integ_diff"), filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # We have all the component files, create velocity seismogram # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) progstring = ("%s wcc2bbp=1 " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + 'title="Sim NGAH, stat=%s" ' % site + 'nsfile=%s ewfile=%s udfile=%s > %s 2>> %s' % (nsfile, ewfile, udfile, bbpfile, self.log)) bband_utils.runprog(progstring, abort_on_error=True, print_cmd=False) # Copy velocity bbp file to outdir shutil.copy2( os.path.join(a_tmpdir, "%d.%s.bbp" % (sim_id, site)), os.path.join(a_outdir, "%d.%s.vel.bbp" % (sim_id, site))) # Also create acceleration bbp file in outdir # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "wcc2bbp=0 < %s >> %s 2>&1" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) for comp in config.COMPS: # Create path names and check if their sizes are within bounds filein = os.path.join(a_tmpdir, "%d.%s.%s" % (sim_id, site, comp)) fileout = os.path.join(a_tmpdir, "%d.%s.acc.%s" % (sim_id, site, comp)) bband_utils.check_path_lengths([filein, fileout], bband_utils.GP_MAX_FILENAME) cmd = ("%s diff=1 filein=%s fileout=%s" % (os.path.join( install.A_GP_BIN_DIR, "integ_diff"), filein, fileout)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Create path names and check if their sizes are within bounds nsfile = os.path.join(a_tmpdir, "%d.%s.acc.000" % (sim_id, site)) ewfile = os.path.join(a_tmpdir, "%d.%s.acc.090" % (sim_id, site)) udfile = os.path.join(a_tmpdir, "%d.%s.acc.ver" % (sim_id, site)) bbpfile = os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, site)) bband_utils.check_path_lengths([nsfile, ewfile, udfile], bband_utils.GP_MAX_FILENAME) cmd = ("%s " % (os.path.join(install.A_GP_BIN_DIR, "wcc2bbp")) + "nsfile=%s ewfile=%s udfile=%s " % (nsfile, ewfile, udfile) + "units=cm/s/s wcc2bbp=1 > %s 2>> %s" % (bbpfile, self.log)) bband_utils.runprog(cmd, abort_on_error=True, print_cmd=False) # Copy acceleration bbp file to outdir shutil.copy2( os.path.join(a_tmpdir, "%d.%s.acc.bbp" % (sim_id, site)), os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, site))) print("Match Completed".center(80, '-'))
def run(self): """ Extracts needed seismograms from the bin file """ print("SDSU Seismograms".center(80, '-')) install = InstallCfg.getInstance() sim_id = self.sim_id sta_base = os.path.basename(os.path.splitext(self.r_stations)[0]) 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_tmpdir = os.path.join(install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_mod = os.path.join(install.A_TMP_DATA_DIR, str(sim_id), "sdsu_seismograms_%s" % (sta_base)) binfile = os.path.join(a_indir, self.r_binfile) # # Make sure the output and tmp directories exist # bband_utils.mkdirs([a_tmpdir, a_tmpdir_mod, a_outdir], print_cmd=False) a_full_stations = os.path.join(a_indir, self.r_full_stations) a_stations = os.path.join(a_indir, self.r_stations) # Copy station files to the tmpdir_mod directory cmd = "cp %s %s" % (a_full_stations, os.path.join(a_tmpdir_mod, self.r_full_stations)) bband_utils.runprog(cmd) cmd = "cp %s %s" % (a_stations, os.path.join(a_tmpdir_mod, self.r_stations)) bband_utils.runprog(cmd) # # Make sure path names are within the limits accepted by the # Fortran code # if len(binfile) >= bband_utils.SDSU_MAX_FILENAME: raise ValueError("binfile is %d characters long, maximum is %d" % (len(binfile), bband_utils.SDSU_MAX_FILENAME)) old_cwd = os.getcwd() os.chdir(a_tmpdir_mod) # Get number of stations in seismogram file, this is a # variation of the code in station_list.py stat_names = {} num_stations = 0 stat_fp = open(a_full_stations, 'r') for line in stat_fp: if line.startswith('#'): continue sta = line.split() if len(sta) >= 3: scode = sta[2] num_stations = num_stations + 1 stat_names[scode] = num_stations stat_fp.close() # Create list of stations to save slo = StationList(a_stations) site_list = slo.getStationList() save_stat_names = [] for stat in site_list: save_stat_names.append(stat.scode) # Convert to bbp format cmd = "%s/bin2bbp %s %d" % (install.A_SDSU_BIN_DIR, binfile, len(stat_names)) bband_utils.runprog(cmd) # Copy over the names for stat in save_stat_names: if not stat in stat_names: continue sta_id = stat_names[stat] shutil.copy2("%s/%d.bbp" % (a_tmpdir_mod, sta_id), "%s/%d.%s-lf.bbp" % (a_tmpdir, sim_id, stat)) del stat_names[stat] # Delete the ones you don't need for stat in stat_names.keys(): os.remove("%s/%d.bbp" % (a_tmpdir_mod, stat_names[stat])) os.chdir(old_cwd) print("SDSU Seismograms Completed".center(80, '-'))
def setUp(self): self.install = InstallCfg() self.stations = "nr_v13_3_1.stl" self.eventname = "NR" self.sim_id = int(seqnum.get_seq_num()) sta_base = os.path.basename(os.path.splitext(self.stations)[0]) sim_id = self.sim_id # Set up paths a_indir = os.path.join(self.install.A_IN_DATA_DIR, str(sim_id)) a_tmpdir = os.path.join(self.install.A_TMP_DATA_DIR, str(sim_id)) a_tmpdir_seis = os.path.join(self.install.A_TMP_DATA_DIR, str(sim_id), "obs_seis_%s" % (sta_base)) a_outdir = os.path.join(self.install.A_OUT_DATA_DIR, str(sim_id)) a_logdir = os.path.join(self.install.A_OUT_LOG_DIR, str(sim_id)) a_validation_outdir = os.path.join(a_outdir, "validations", "anderson_gof") # Create directories bband_utils.mkdirs([ a_indir, a_tmpdir, a_tmpdir_seis, a_outdir, a_logdir, a_validation_outdir ], print_cmd=False) # Copy station and correction files cmd = "cp %s %s" % (os.path.join(self.install.A_TEST_REF_DIR, "anderson_gof", self.stations), a_indir) bband_utils.runprog(cmd, print_cmd=False) # Read station list slo = StationList(os.path.join(a_indir, self.stations)) site_list = slo.getStationList() # Loop over stations for site in site_list: station = site.scode src_sims_acc = os.path.join(self.install.A_TEST_REF_DIR, "anderson_gof", "syn_seis", "%s.acc.bbp" % (station)) src_sims_rd50 = os.path.join(self.install.A_TEST_REF_DIR, "anderson_gof", "syn_seis", "%s.rd50" % (station)) dst_sims_acc = os.path.join(a_outdir, "%d.%s.acc.bbp" % (sim_id, station)) dst_sims_rd50 = os.path.join(a_outdir, "%d.%s.rd50" % (sim_id, station)) src_obs_acc = os.path.join(self.install.A_TEST_REF_DIR, "anderson_gof", "obs_seis", "%s.bbp" % (station)) src_obs_rd50 = os.path.join(self.install.A_TEST_REF_DIR, "anderson_gof", "obs_seis", "%s.rd50" % (station)) dst_obs_acc = os.path.join(a_tmpdir_seis, "%s.bbp" % (station)) dst_obs_rd50 = os.path.join(a_tmpdir_seis, "%s.rd50" % (station)) cmd = "cp %s %s" % (src_sims_acc, dst_sims_acc) bband_utils.runprog(cmd, print_cmd=False) cmd = "cp %s %s" % (src_sims_rd50, dst_sims_rd50) bband_utils.runprog(cmd, print_cmd=False) cmd = "cp %s %s" % (src_obs_acc, dst_obs_acc) bband_utils.runprog(cmd, print_cmd=False) cmd = "cp %s %s" % (src_obs_rd50, dst_obs_rd50) bband_utils.runprog(cmd, print_cmd=False)