def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") # Load Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) specfemspecs = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) # Database Setup. DB = DataBaseSkeleton(basedir=DB_params["databasedir"], cmt_fn=cmt_filename, specfem_dir=specfemspecs["SPECFEM_DIR"], verbose=DB_params['verbose'], overwrite=DB_params['overwrite']) # Database Create entry DB.create_all() # Return new earthquake location. cmt_in_database = os.path.join(DB.eq_dirs[0], "eq_" + DB.eq_ids[0]) return cmt_in_database
def create_entry(cmt_filename, param_path): # Define parameter directory databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") stations_path = os.path.join(param_path, "RequestParams/STATIONS") # Load Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) specfemspecs = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) # Check whether stationsfile in Parampath if os.path.exists(stations_path): stations_file = stations_path else: # if no stations file in the parameter directory, # the standard stations file is going to be used stations_file = None # Database Setup. DB = DataBaseSkeleton(basedir=DB_params["databasedir"], cmt_fn=cmt_filename, specfem_dir=specfemspecs["SPECFEM_DIR"], stations_file=stations_file, overwrite=DB_params['overwrite']) # Database Create entry DB.create_all() # Return new earthquake location. cmt_in_database = os.path.join(DB.Cdirs[0], "C" + DB.Cids[0]) return cmt_in_database
def Create_Entry(cmt_filename): """ This function creates a database entry for the inversion. :param cmt_filename: path to cmt file that an Entry is supposed to be created for :return: no returns since it is simply a copy and create dirs function """ # Define parameter directory param_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath( __file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") # Load Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) specfemspecs = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) # Database Setup. DB = DataBaseSkeleton(basedir=DB_params["databasedir"], cmt_fn=cmt_filename, specfem_dir=specfemspecs["SPECFEM_DIR"], verbose=DB_params['verbose'], overwrite=DB_params['overwrite']) # Database Create entry DB.create_all() # Return new earthquake location. cmt_in_database = os.path.join(DB.Cdirs[0], "C" + DB.Cids[0]) return cmt_in_database
def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") comp_and_modules_path = os.path.join( param_path, "SpecfemParams/CompilersAndModules.yml") # Load Parameters specfemspecs = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) cm_dict = smart_read_yaml(comp_and_modules_path, mpi_mode=is_mpi_env()) cmt_dir = os.path.dirname(os.path.abspath(cmt_filename)) RD = RunSimulation(cmt_dir, N=specfemspecs['nodes'], n=specfemspecs['tasks'], npn=specfemspecs['tasks_per_node'], memory_req=specfemspecs['memory_req'], modules=cm_dict['modulelist'], gpu_module=cm_dict['gpu_module'], GPU_MODE=specfemspecs["GPU_MODE"], walltime=specfemspecs['walltime_solver'], verbose=specfemspecs['verbose']) # Print Run specifications of verbose is True if specfemspecs['verbose']: print(RD) # Run Simulation by calling the class RD()
def main(cmt_filename): # Set directories of the parameter files param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") request_param_path = os.path.join(param_path, "RequestParams/RequestParams.yml") # Read the parameter file rCparams = smart_read_yaml(request_param_path, mpi_mode=is_mpi_env()) # Earthquake and Station parameters cmt_dir = os.path.dirname(cmt_filename) # Create Request Object Request = DataRequest.from_file(cmt_filename, duration=rCparams['duration'], channels=rCparams['channels'], locations=rCparams['locations'], starttime_offset=\ rCparams['starttime_offset'], outputdir=cmt_dir) # Print Earthquake Download Info print(Request) # Request download Request.download()
def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") # Load Database Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) # Get processing path from cmt_filename in database cmt_dir = os.path.dirname(os.path.abspath(cmt_filename)) # Processed data directory processed_dir = os.path.join(cmt_dir, "seismograms", "processed_seismograms") # Inversion dictionary directory inv_dict_dir = os.path.join(cmt_dir, "inversion", "inversion_dicts") # Get all files to be processed processed_files = glob.glob(os.path.join(processed_dir, "*observed*")) if DB_params["verbose"]: print("\n Creating inversion dictionaries ...\n") for _i, processed_file in enumerate(processed_files): # Get processing band bandstring = str(os.path.basename(processed_file)).split(".")[1] band = [float(x) for x in bandstring.split("_")] if DB_params["verbose"]: print("\nCreating inversion dictionary for period band:") print("Low: %d s || High: %d s \n" % tuple(band)) print("...\n") params = create_inversion_dict(processed_dir, bandstring) # Print Inversion parameters: if DB_params["verbose"]: print("Files") print("_______________________________________________________\n") for key, value in params.items(): print(key + ":", value) print("_______________________________________________________\n") # Outputfile: outfilename = os.path.join( inv_dict_dir, "inversion_file_dict." + bandstring + ".yml") # Write yaml file to inversion dictionary directory write_yaml_file(params, outfilename) if DB_params["verbose"]: print("\nDONE writing %s.\n" % outfilename) if DB_params["verbose"]: print("\nDONE writing all dictionaries!\n")
def data_request(cmt_filename, param_path): # Set directories of the parameter files request_param_path = os.path.join(param_path, "RequestParams/RequestParams.yml") # Read the parameter file rCparams = smart_read_yaml(request_param_path, mpi_mode=is_mpi_env()) # Earthquake and Station parameters cmt_dir = os.path.dirname(cmt_filename) station_dir = os.path.join(cmt_dir, "station_data") # Get STATIONS file from CMT directory stationsfile = os.path.join(station_dir, "STATIONS") # Create Request Object Request = DataRequest.from_file(cmt_filename, stationlistfname=stationsfile, sfstationlist=True, duration=rCparams['duration'], channels=rCparams['channels'], locations=rCparams['locations'], starttime_offset=rCparams[ 'starttime_offset'], outputdir=cmt_dir) # Print Earthquake Download Info for line in Request.__str__().splitlines(): logger.info(line) # Request download Request.download()
def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") inversionparam_path = os.path.join(param_path, "CMTInversion/InversionParams.yml") # Load Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) # Inversion Params INV_params = smart_read_yaml(inversionparam_path, mpi_mode=is_mpi_env()) # File and directory cmt_dir = os.path.dirname(cmt_filename) cmt = CMTSource.from_CMTSOLUTION_file(cmt_filename) outdir = os.path.join(cmt_dir, "CMT_SIMs") # Basic parameters dm = float(INV_params["config"]["dmoment"]) # 10**22 dyne*cm dz = float(INV_params["config"]["ddepth"]) # 1000 m ddeg = float(INV_params["config"]["dlocation"]) # 0.001 deg if DB_params["verbose"]: print("\n") print(" Perturbation parameters") print(" " + 50 * "*") print(" 𝚫M: %g" % dm) print(" 𝚫z: %g" % dz) print(" 𝚫deg: %g" % ddeg) print(" " + 50 * "*" + "\n") # Create source creation class sfsource = SpecfemSources(cmt, npar=DB_params['npar'], dm=dm, dx=dz, ddeg=ddeg, verbose=DB_params['verbose'], outdir=outdir) # Write sources sfsource.write_sources()
def main(cmt_filename): # Define parameter directory param_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath( __file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") # Load Database Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) # Get processing path from cmt_filename in database cmt_dir = os.path.dirname(os.path.abspath(cmt_filename)) window_path_dir = os.path.join(cmt_dir, "window_data", "window_paths") # Get all files to be processed window_pathfiles = glob.glob(os.path.join(window_path_dir, "*")) if DB_params["verbose"]: print("\nStart windowing all trace pairs ...\n") for _i, path_file in enumerate(window_pathfiles): if DB_params["verbose"]: print("\nWindowing path file:\n") print(path_file + "\n") print("Start windowing traces from path file ...\n") # Load process path file to get parameter file location params = smart_read_yaml(path_file, mpi_mode=is_mpi_env())\ ["window_param_file"] # Create Smart Process class proc = WindowASDF(path_file, params, verbose=DB_params["verbose"], debug=False) proc.smart_run() if DB_params["verbose"]: print("\nDONE windowing traces file.\n") if DB_params["verbose"]: print("\nDONE windowed all data!\n")
def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") comp_and_modules_path = os.path.join( param_path, "SpecfemParams/CompilersAndModules.yml") # Load Parameters specfemspecs = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) cm_dict = smart_read_yaml(comp_and_modules_path, mpi_mode=is_mpi_env()) cmt_dir = os.path.dirname(os.path.abspath(cmt_filename)) # Set up RunSimulation class with parameters from the files. RD = RunSimulation(cmt_dir, N=specfemspecs['nodes'], n=specfemspecs['tasks'], npn=specfemspecs['tasks_per_node'], memory_req=specfemspecs['memory_req'], modules=cm_dict['modulelist'], gpu_module=cm_dict['gpu_module'], GPU_MODE=specfemspecs["GPU_MODE"], walltime=specfemspecs['walltime_solver'], verbose=specfemspecs['verbose']) if specfemspecs["verbose"]: print("Deleting unnecessary stuff ...") # Clean up Simulation directory RD.clean_up() if specfemspecs["verbose"]: print("Deleting DONE.")
def main(cmt_filename): # Define parameter directory param_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath( __file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") # Load Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) # File and directory cmt_dir = os.path.dirname(cmt_filename) sim_dir = os.path.join(cmt_dir, "CMT_SIMs") attr = ["CMT", "CMT_rr", "CMT_tt", "CMT_pp", "CMT_rt", "CMT_rp", "CMT_tp", "CMT_depth", "CMT_lat", "CMT_lon"] ##### Converting the synthetic data if DB_params['verbose']: print("\nConverting synthetic traces to ASDF ... \n") for _i, at in enumerate(attr[:DB_params["npar"]+1]): # Path file syn_path_file = os.path.join(sim_dir, at, at + ".yml") converter = ConvertASDF(syn_path_file, verbose=DB_params["verbose"], status_bar=DB_params["verbose"]) converter.run() ##### Converting the observed data if DB_params['verbose']: print("\nConverting observed traces to ASDF ... \n") obs_path_file = os.path.join(cmt_dir, "seismograms", "obs", "observed.yml") converter = ConvertASDF(obs_path_file, verbose=DB_params["verbose"], status_bar=DB_params["verbose"]) converter.run() if DB_params['verbose']: print("\nConversion to ASDF DONE.\n")
def data_request(cmt_filename): # Set directories of the parameter files param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") request_param_path = os.path.join(param_path, "RequestParams/RequestParams.yml") # Read the parameter file rCparams = smart_read_yaml(request_param_path, mpi_mode=is_mpi_env()) # Earthquake and Station parameters cmt_dir = os.path.dirname(cmt_filename) station_dir = os.path.join(cmt_dir, "station_data") # Get STATIONS file from CMT directory stationsfile = os.path.join(station_dir, "STATIONS") # Observed output dir obsd_dir = os.path.join(cmt_dir, "seismograms", "obs") # CMT parameter input cmt = CMTSource.from_CMTSOLUTION_file(cmt_filename) duration = rCparams['duration'] starttime_offset = rCparams['starttime_offset'] starttime = cmt.origin_time + starttime_offset endtime = starttime + duration # Get station_list from station_file in database entry stations = read_station_file(stationsfile) station_ids = [station[0] + "_" + station[1] for station in stations] # Download Station Data _, _, filtered_station_ids = \ download_stationxml(station_ids, starttime, endtime, outputdir=station_dir, client=None, level="response") # Download waveform download_waveform(filtered_station_ids, starttime, endtime, outputdir=obsd_dir, client=None)
def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") # Load Parameters DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) if DB_params["verbose"]: print("Creating processing path files for the observed data...") # Create Processing path files observed process_obs_dir = os.path.join(param_path, "ProcessObserved") create_process_path_obs(cmt_filename, process_obs_dir, verbose=True) if DB_params["verbose"]: print("Creating processing path files for the synthetic data...") # Create Processing path files synthetics process_syn_dir = os.path.join(param_path, "ProcessSynthetic") create_process_path_syn(cmt_filename, process_syn_dir, DB_params["npar"], verbose=True) if DB_params["verbose"]: print("Creating processing path files for windowing the data...") # Create Window Path Files: window_dir = os.path.join(param_path, "CreateWindows") create_window_path(cmt_filename, window_dir, figure_mode=DB_params["figure_mode"], verbose=True)
def main(): """This script controlls the compilation and setting up of specfem3d_globe. Usage: In the command line ``00_Fix_Specfem_And_Recompile.py`` It uses the parameter files located in ``../params/SpecfemParams/SpecfemParams.yml`` and ``../params/SpecfemParams/CompAndModules.yaml`` to get all necessary parameters. """ # Define parameter directory param_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath( __file__))), "params") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") comp_and_modules_path = os.path.join(param_path, "SpecfemParams/CompilersAndModules.yml") # Load parameters sf_dict = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) cm_dict = smart_read_yaml(comp_and_modules_path, mpi_mode=is_mpi_env()) # Define the specfemdatafixer DF = DATAFixer(sf_dict["SPECFEM_DIR"], NEX_XI=sf_dict["NEX_XI"], NEX_ETA=sf_dict["NEX_ETA"], NPROC_XI=sf_dict["NPROC_XI"], NPROC_ETA=sf_dict["NPROC_ETA"], ROTATE_SEISMOGRAMS_RT=sf_dict["ROTATE_SEISMOGRAMS_RT"], RECORD_LENGTH=sf_dict["RECORD_LENGTH"], MODEL=sf_dict["MODEL"], WRITE_SEISMOGRAMS_BY_MASTER=sf_dict[ "WRITE_SEISMOGRAMS_BY_MASTER"], OUTPUT_SEISMOS_ASCII_TEXT=sf_dict[ "OUTPUT_SEISMOS_ASCII_TEXT"], OUTPUT_SEISMOS_SAC_ALPHANUM=sf_dict[ "OUTPUT_SEISMOS_SAC_ALPHANUM"], OUTPUT_SEISMOS_SAC_BINARY=sf_dict[ "OUTPUT_SEISMOS_SAC_BINARY"], OUTPUT_SEISMOS_ASDF=sf_dict["OUTPUT_SEISMOS_ASDF"], MOVIE_SURFACE=sf_dict["MOVIE_SURFACE"], MOVIE_VOLUME=sf_dict["MOVIE_VOLUME"], MOVIE_COARSE=sf_dict["MOVIE_COARSE"], GPU_MODE=sf_dict["GPU_MODE"], GPU_RUNTIME=sf_dict["GPU_RUNTIME"], GPU_PLATFORM=sf_dict["GPU_PLATFORM"], GPU_DEVICE=sf_dict["GPU_DEVICE"], ADIOS_ENABLED=sf_dict["ADIOS_ENABLED"], ADIOS_FOR_FORWARD_ARRAYS=sf_dict["ADIOS_FOR_FORWARD_ARRAYS"], ADIOS_FOR_MPI_ARRAYS=sf_dict["ADIOS_FOR_MPI_ARRAYS"], ADIOS_FOR_ARRAYS_SOLVER=sf_dict["ADIOS_FOR_ARRAYS_SOLVER"], ADIOS_FOR_SOLVER_MESHFILES=sf_dict[ "ADIOS_FOR_SOLVER_MESHFILES"], ADIOS_FOR_AVS_DX=sf_dict["ADIOS_FOR_AVS_DX"], ADIOS_FOR_KERNELS=sf_dict["ADIOS_FOR_KERNELS"], ADIOS_FOR_MODELS=sf_dict["ADIOS_FOR_MODELS"], ADIOS_FOR_UNDO_ATTENUATION=sf_dict[ "ADIOS_FOR_UNDO_ATTENUATION"], modules=cm_dict["modulelist"], gpu_module=cm_dict["gpu_module"], gpu_version=cm_dict["gpu_version"], cc=cm_dict["cc"], cpp=cm_dict["cpp"], mpicc=cm_dict["mpicc"], f90=cm_dict["f90"], mpif90=cm_dict["mpif90"], nodes=sf_dict["nodes"], tasks=sf_dict["tasks"], tasks_per_node=sf_dict["tasks_per_node"], walltime=sf_dict["walltime"], walltime_solver=sf_dict["walltime_solver"], memory_req=sf_dict["memory_req"], verbose=sf_dict["verbose"]) # Run `Par_file` fixer. DF.fix_parfiles() # Configure and compile DF.configure_and_make() # Run the mesher to a slurm scheduler. DF.run_mesher()
def main(cmt_filename): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") # Load Database Parameters databaseparam_path = os.path.join(param_path, "Database/DatabaseParameters.yml") DB_params = smart_read_yaml(databaseparam_path, mpi_mode=is_mpi_env()) # Inversion Params inversionparam_path = os.path.join(param_path, "CMTInversion/InversionParams.yml") INV_params = smart_read_yaml(inversionparam_path, mpi_mode=is_mpi_env()) # Get processing path from cmt_filename in database cmt_dir = os.path.dirname(os.path.abspath(cmt_filename)) # Create cmt source: cmtsource = CMTSource.from_CMTSOLUTION_file(cmt_filename) # Window directory window_dir = os.path.join(cmt_dir, "window_data") # Inversion dictionary directory inv_dict_dir = os.path.join(cmt_dir, "inversion", "inversion_dicts") # Inversion dictionaries inv_dicts = glob.glob(os.path.join(inv_dict_dir, "*")) # Inversion output directory inv_out_dir = os.path.join(cmt_dir, "inversion", "inversion_output") if DB_params["verbose"]: print("\n#######################################################") print("# #") print("# Starting inversion ... #") print("# #") print("#######################################################\n") # Creating Data container dcon = DataContainer(parlist=PARLIST[:DB_params["npar"]]) for _i, inv_dict in enumerate(inv_dicts): # Get processing band bandstring = str(os.path.basename(inv_dict)).split(".")[1] band = [float(x) for x in bandstring.split("_")] if DB_params["verbose"]: print("\n") print(" " + 54 * "*") print(" Getting data for inversion from period band:") print(" Low: %d s || High: %d s" % tuple(band)) print(" " + 54 * "*" + "\n") # Load inversion file dictionary asdf_dict = smart_read_yaml(inv_dict, mpi_mode=is_mpi_env()) window_files = glob.glob( os.path.join(window_dir, "windows." + bandstring + "*[!stats].json")) # Adding measurements for _j, window_file in enumerate(window_files): # Print Inversion parameters: if DB_params["verbose"]: print(" Adding measurements to data container:") print( " _____________________________________________________\n" ) # Add measurements from ASDF file and windowfile # if _j == 0: if DB_params["verbose"]: print(" Window file:\n", " ", window_file) print("\n ASDF files:") for key, value in asdf_dict.items(): print(" ", key + ":", value) dcon.add_measurements_from_asdf(window_file, asdf_dict) # else: # if DB_params["verbose"]: # print(" Window file:\n", " ", window_file) # dcon.add_measurements_from_sac(window_file) if DB_params["verbose"]: print( " _____________________________________________________\n" ) print(" ... \n\n") if DB_params["verbose"]: print(" Inverting for a new moment tensor .... ") print(" " + 54 * "*" + "\n\n") # Setting up weight config weight_config = DefaultWeightConfig(normalize_by_energy=False, normalize_by_category=False, comp_weight={ "Z": 1.0, "R": 1.0, "T": 1.0 }, love_dist_weight=1.0, pnl_dist_weight=1.0, rayleigh_dist_weight=1.0, azi_exp_idx=0.5) # Setting up general inversion config config = Config(DB_params["npar"], dlocation=float(INV_params["config"]["dlocation"]), ddepth=float(INV_params["config"]["ddepth"]), dmoment=float(INV_params["config"]["dmoment"]), weight_data=True, station_correction=True, zero_trace=True, double_couple=False, bootstrap=True, bootstrap_repeat=100, weight_config=weight_config) srcinv = Cmt3D(cmtsource, dcon, config) srcinv.source_inversion() # plot result srcinv.plot_summary(inv_out_dir, figure_format="pdf") if DB_params["verbose"]: print(" DONE inversion for period band: %d - %d s.\n" % tuple(band)) if DB_params["verbose"]: print("\n#######################################################") print("# #") print("# Inversion DONE. #") print("# #") print("#######################################################\n")
def Fix_Specfem(): """This Function uses the parameters found in :: GCMT3D/workflow/params/SpecfemParams/SpecfemParams.yml and :: GCMT3D/workflow/params/SpecfemParams/CompilersAndModules.yml to fix and recompile the software which is necessary for the simulation and inversion of the data. Since all data are taken from the parameter files. there are no in- and outputs. """ # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") comp_and_modules_path = os.path.\ join(param_path, "SpecfemParams/CompilersAndModules.yml") # Load parameters sf_dict = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) cm_dict = smart_read_yaml(comp_and_modules_path, mpi_mode=is_mpi_env()) # Define the specfemdatafixer df = DATAFixer( sf_dict["SPECFEM_DIR"], NEX_XI=sf_dict["NEX_XI"], NEX_ETA=sf_dict["NEX_ETA"], NPROC_XI=sf_dict["NPROC_XI"], NPROC_ETA=sf_dict["NPROC_ETA"], ROTATE_SEISMOGRAMS_RT=sf_dict["ROTATE_SEISMOGRAMS_RT"], RECORD_LENGTH=sf_dict["RECORD_LENGTH"], MODEL=sf_dict["MODEL"], WRITE_SEISMOGRAMS_BY_MASTER=sf_dict["WRITE_SEISMOGRAMS_BY_MASTER"], OUTPUT_SEISMOS_ASCII_TEXT=sf_dict["OUTPUT_SEISMOS_ASCII_TEXT"], OUTPUT_SEISMOS_SAC_ALPHANUM=sf_dict["OUTPUT_SEISMOS_SAC_ALPHANUM"], OUTPUT_SEISMOS_SAC_BINARY=sf_dict["OUTPUT_SEISMOS_SAC_BINARY"], OUTPUT_SEISMOS_ASDF=sf_dict["OUTPUT_SEISMOS_ASDF"], MOVIE_SURFACE=sf_dict["MOVIE_SURFACE"], MOVIE_VOLUME=sf_dict["MOVIE_VOLUME"], MOVIE_COARSE=sf_dict["MOVIE_COARSE"], GPU_MODE=sf_dict["GPU_MODE"], GPU_RUNTIME=sf_dict["GPU_RUNTIME"], GPU_PLATFORM=sf_dict["GPU_PLATFORM"], GPU_DEVICE=sf_dict["GPU_DEVICE"], ADIOS_ENABLED=sf_dict["ADIOS_ENABLED"], ADIOS_FOR_FORWARD_ARRAYS=sf_dict["ADIOS_FOR_FORWARD_ARRAYS"], ADIOS_FOR_MPI_ARRAYS=sf_dict["ADIOS_FOR_MPI_ARRAYS"], ADIOS_FOR_ARRAYS_SOLVER=sf_dict["ADIOS_FOR_ARRAYS_SOLVER"], ADIOS_FOR_SOLVER_MESHFILES=sf_dict["ADIOS_FOR_SOLVER_MESHFILES"], ADIOS_FOR_AVS_DX=sf_dict["ADIOS_FOR_AVS_DX"], ADIOS_FOR_KERNELS=sf_dict["ADIOS_FOR_KERNELS"], ADIOS_FOR_MODELS=sf_dict["ADIOS_FOR_MODELS"], ADIOS_FOR_UNDO_ATTENUATION=sf_dict["ADIOS_FOR_UNDO_ATTENUATION"], modules=cm_dict["modulelist"], gpu_module=cm_dict["gpu_module"], gpu_version=cm_dict["gpu_version"], cc=cm_dict["cc"], cpp=cm_dict["cpp"], mpicc=cm_dict["mpicc"], f90=cm_dict["f90"], mpif90=cm_dict["mpif90"], nodes=sf_dict["nodes"], tasks=sf_dict["tasks"], tasks_per_node=sf_dict["tasks_per_node"], walltime=sf_dict["walltime"], walltime_solver=sf_dict["walltime"], memory_req=sf_dict["memory_req"], verbose=sf_dict["verbose"]) # Run `Par_file` fixer. df.fix_parfiles() # Configure and compile df.configure_and_make() # Run the mesher to a slurm scheduler. df.run_mesher()
def data_request(cmt_filename, param_path): # Request config_file request_param_path = os.path.join(param_path, "RequestParams/RequestParams.yml") # Read the parameter file rCparams = smart_read_yaml(request_param_path, mpi_mode=is_mpi_env()) # Earthquake and Station parameters cmt_dir = os.path.dirname(cmt_filename) station_dir = os.path.join(cmt_dir, "station_data") # Get STATIONS file from CMT directory stationsfile = os.path.join(station_dir, "STATIONS") # Observed output dir obsd_dir = os.path.join(cmt_dir, "seismograms", "obs") # CMT parameter input cmt = CMTSource.from_CMTSOLUTION_file(cmt_filename) duration = rCparams['duration'] starttime_offset = rCparams['starttime_offset'] starttime = cmt.origin_time + starttime_offset endtime = starttime + duration # Get station_list from station_file in database entry stations = read_station_file(stationsfile) # Create list of networks to download from networks = list(set([station[0] for station in stations])) network_string = ",".join(networks) # Set domain containing all locations # Rectangular domain containing parts of southern Germany. domain = RectangularDomain(minlatitude=-90, maxlatitude=90, minlongitude=-180, maxlongitude=180) # Set download restrictions restrictions = Restrictions( starttime=starttime, endtime=endtime, reject_channels_with_gaps=False, minimum_length=float(rCparams['minimum_length']), # Trace needs to be almost full length network=network_string, # Only certain networks channel=",".join(rCparams['channels']), location=",".join(rCparams['locations'])) # No specified providers will result in all known ones being queried. providers = ["IRIS"] mdl = MassDownloader(providers=providers) # The data will be downloaded to the ``./waveforms/`` and ``./stations/`` # folders with automatically chosen file n stationxml_storage = os.path.join(station_dir) waveform_storage = os.path.join(obsd_dir) logger.info("MSEEDs: %s" % waveform_storage) logger.info("XMLs: %s" % stationxml_storage) mdl.download(domain, restrictions, mseed_storage=waveform_storage, stationxml_storage=stationxml_storage)
def main(): # Define parameter directory param_path = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "params") specfemspec_path = os.path.join(param_path, "SpecfemParams/SpecfemParams.yml") comp_and_modules_path = os.path.join( param_path, "SpecfemParams/CompilersAndModules.yml") # Load parameters sf_dict = smart_read_yaml(specfemspec_path, mpi_mode=is_mpi_env()) cm_dict = smart_read_yaml(comp_and_modules_path, mpi_mode=is_mpi_env()) # Define the specfemdatafixer DF = DATAFixer( sf_dict["SPECFEM_DIR"], NEX_XI=sf_dict["NEX_XI"], NEX_ETA=sf_dict["NEX_ETA"], NPROC_XI=sf_dict["NPROC_XI"], NPROC_ETA=sf_dict["NPROC_ETA"], ROTATE_SEISMOGRAMS_RT=sf_dict["ROTATE_SEISMOGRAMS_RT"], RECORD_LENGTH=sf_dict["RECORD_LENGTH"], MODEL=sf_dict["MODEL"], WRITE_SEISMOGRAMS_BY_MASTER=sf_dict["WRITE_SEISMOGRAMS_BY_MASTER"], OUTPUT_SEISMOS_ASCII_TEXT=sf_dict["OUTPUT_SEISMOS_ASCII_TEXT"], OUTPUT_SEISMOS_SAC_ALPHANUM=sf_dict["OUTPUT_SEISMOS_SAC_ALPHANUM"], OUTPUT_SEISMOS_SAC_BINARY=sf_dict["OUTPUT_SEISMOS_SAC_BINARY"], OUTPUT_SEISMOS_ASDF=sf_dict["OUTPUT_SEISMOS_ASDF"], MOVIE_SURFACE=sf_dict["MOVIE_SURFACE"], MOVIE_VOLUME=sf_dict["MOVIE_VOLUME"], MOVIE_COARSE=sf_dict["MOVIE_COARSE"], GPU_MODE=sf_dict["GPU_MODE"], GPU_RUNTIME=sf_dict["GPU_RUNTIME"], GPU_PLATFORM=sf_dict["GPU_PLATFORM"], GPU_DEVICE=sf_dict["GPU_DEVICE"], ADIOS_ENABLED=sf_dict["ADIOS_ENABLED"], ADIOS_FOR_FORWARD_ARRAYS=sf_dict["ADIOS_FOR_FORWARD_ARRAYS"], ADIOS_FOR_MPI_ARRAYS=sf_dict["ADIOS_FOR_MPI_ARRAYS"], ADIOS_FOR_ARRAYS_SOLVER=sf_dict["ADIOS_FOR_ARRAYS_SOLVER"], ADIOS_FOR_SOLVER_MESHFILES=sf_dict["ADIOS_FOR_SOLVER_MESHFILES"], ADIOS_FOR_AVS_DX=sf_dict["ADIOS_FOR_AVS_DX"], ADIOS_FOR_KERNELS=sf_dict["ADIOS_FOR_KERNELS"], ADIOS_FOR_MODELS=sf_dict["ADIOS_FOR_MODELS"], ADIOS_FOR_UNDO_ATTENUATION=sf_dict["ADIOS_FOR_UNDO_ATTENUATION"], modules=cm_dict["modulelist"], gpu_module=cm_dict["gpu_module"], gpu_version=cm_dict["gpu_version"], cc=cm_dict["cc"], cpp=cm_dict["cpp"], mpicc=cm_dict["mpicc"], f90=cm_dict["f90"], mpif90=cm_dict["mpif90"], nodes=sf_dict["nodes"], tasks=sf_dict["tasks"], tasks_per_node=sf_dict["tasks_per_node"], walltime=sf_dict["walltime"], walltime_solver=sf_dict["walltime_solver"], memory_req=sf_dict["memory_req"], verbose=sf_dict["verbose"]) # Run the mesher to a slurm scheduler. DF.run_mesher()