def execute_plot(tensor_info, data_type, segments_data, default_dirs, velmodel=None, plot_input=False): """We plot modelling results :param tensor_info: dictionary with moment tensor properties :param data_type: set with data types to be used in modelling :param plot_input: choose whether to plot initial kinematic model as well :param default_dirs: dictionary with default directories to be used :param velmodel: dictionary with velocity model :type velmodel: dict, optional :type default_dirs: dict :type tensor_info: dict :type data_type: set :type plot_input: bool, optional """ print('Plot results') segments = segments_data['segments'] rise_time = segments_data['rise_time'] solution = get_outputs.read_solution_static_format(segments) if not velmodel: velmodel = mv.select_velmodel(tensor_info, default_dirs) point_sources = pf.point_sources_param(segments, tensor_info, rise_time) shear = pf.shear_modulous(point_sources, velmodel=velmodel) plot.plot_ffm_sol(tensor_info, segments_data, point_sources, shear, solution, velmodel, default_dirs) plot.plot_misfit(data_type) # plot.plot_beachballs(tensor_info, segments, data_type) traces_info, stations_gps = [None, None] if 'strong_motion' in data_type: traces_info = json.load(open('strong_motion_waves.json')) if 'gps' in data_type: names, lats, lons, observed, synthetic, error = get_outputs.retrieve_gps( ) stations_gps = zip(names, lats, lons, observed, synthetic, error) if 'strong_motion' in data_type or 'gps' in data_type: plot._PlotMap(tensor_info, segments, point_sources, solution, default_dirs, files_str=traces_info, stations_gps=stations_gps) if plot_input: input_model = load_ffm_model(segments_data, option='Fault.time') plot._PlotSlipDist_Compare(segments, point_sources, input_model, solution) plot._PlotComparisonMap(tensor_info, segments, point_sources, input_model, solution)
def plane_for_chen(tensor_info, segments_data, min_vel, max_vel, velmodel): """Code to create files Fault.time, Fault.pos and Niu_model :param tensor_info: dictionary with moment tensor information :param segments: dictionary with information of the fault segments :param rise_time: dictionary with rise time function information :param min_vel: minimum rupture velocity to be used :param max_vel: maximum rupture velocity to be used :param velmodel: dictionary with velocity model information :type tensor_info: dict :type segments: dict :type rise_time: dict :type velmodel: dict :type min_vel: float :type max_vel: float """ segments = segments_data['segments'] rise_time = segments_data['rise_time'] delta_strike = segments[0]['delta_strike'] delta_dip = segments[0]['delta_dip'] rupture_vel = segments[0]['rupture_vel'] subfaults = {'delta_strike': delta_strike, 'delta_dip': delta_dip} subfaults2 = pf._point_sources_def(rise_time, rupture_vel, subfaults) strike_ps = subfaults2['strike_ps'] dip_ps = subfaults2['dip_ps'] t1 = rise_time['min_rise'] t2 = rise_time['delta_rise'] windows = rise_time['windows'] hyp_stk = segments[0]['hyp_stk'] hyp_dip = segments[0]['hyp_dip'] delta_strike = segments[0]['delta_strike'] delta_dip = segments[0]['delta_dip'] depth = tensor_info['depth'] point_sources = pf.point_sources_param(segments, tensor_info, rise_time) shear = pf.shear_modulous(point_sources, velmodel=velmodel) disp_or_vel = 0 string = '{} {} {} {} {}\n' with open('Fault.time', 'w') as outfile: outfile.write('{} {} {} 10\n'.format(hyp_stk, hyp_dip, depth)) outfile.write('{} {} {} {} {} {} {} {} {}\n'.format( len(segments), delta_strike, delta_dip, strike_ps, dip_ps, min_vel, max_vel, -100, 100)) outfile.write('{} {} {} {} {}\n'.format(t1, t2, windows, rupture_vel, disp_or_vel)) for i_segment, segment in enumerate(segments): dip = segment['dip'] strike = segment['strike'] rake = segment['rake'] n_stk = segment['stk_subfaults'] n_dip = segment['dip_subfaults'] outfile.write('{} {} {}\n'.format(i_segment + 1, dip, strike)) outfile.write('{} {} 0\n'.format(n_stk, n_dip)) for i in range(n_dip): for j in range(n_stk): slip = 300 if j == hyp_stk - 1 and i == hyp_dip - 1 else 0 outfile.write(string.format(slip, rake, 0, t1, t1)) with open('Fault.pos', 'w') as outfile: for i_segment, (ps_seg, segment)\ in enumerate(zip(point_sources, segments)): dip = segment['dip'] strike = segment['strike'] n_stk = segment['stk_subfaults'] n_dip = segment['dip_subfaults'] outfile.write('{} {} {}\n'.format(i_segment + 1, dip, strike)) for j1 in range(n_dip): for i1 in range(n_stk): for j2 in range(dip_ps): for i2 in range(strike_ps): outfile.write( '{} {} {} {} {} {} {}\n'.format(*ps_seg[j1, i1, j2, i2])) with open('Niu_model', 'w') as outfile: outfile.write('{}\n'.format(len(shear))) for i_segment, (shear_seg, segment) in enumerate(zip(shear, segments)): n_stk = segment['stk_subfaults'] n_dip = segment['dip_subfaults'] outfile.write('{} {} {}\n'.format(i_segment + 1, n_stk, n_dip)) ratio = len(shear_seg[0, :]) // 5 format_str = ('{} ' * 5 + '\n') * ratio remain = len(shear_seg[0, :]) % 5 format_str = format_str if remain == 0\ else format_str + ('{} ' * remain + '\n') for i in range(n_dip): outfile.write(format_str.format(*shear_seg[i, :])) return
def forward_model(tensor_info, segments_data, model, vel0, vel1): """Rewrite input file Fault.time with input model :param tensor_info: dictionary with moment tensor information :param segments: dictionary with information of the fault segments :param rise_time: dictionary with rise time function information :param model: dictionary with properties of the input kinematic model :param vel0: minimum rupture velocity to be used :param vel1: maximum rupture velocity to be used :type tensor_info: dict :type segments: dict :type rise_time: dict :type model: dict :type vel0: float :type vel1: float """ slip_segs = model['slip'] rake_segs = model['rake'] trup_segs = model['trup'] tris_segs = model['trise'] tfall_segs = model['tfall'] segments = segments_data['segments'] rise_time = segments_data['rise_time'] hyp_stk = segments[0]['hyp_stk'] hyp_dip = segments[0]['hyp_dip'] delta_strike = segments[0]['delta_strike'] delta_dip = segments[0]['delta_dip'] rupture_vel = segments[0]['rupture_vel'] subfaults = {'delta_strike': delta_strike, 'delta_dip': delta_dip} subfaults2 = pf._point_sources_def(rise_time, rupture_vel, subfaults) strike_ps = subfaults2['strike_ps'] dip_ps = subfaults2['dip_ps'] t1 = rise_time['min_rise'] t2 = rise_time['delta_rise'] windows = rise_time['windows'] depth = tensor_info['depth'] disp_or_vel = 0 string = '{} {} {} {} {}\n' point_sources0 = pf.point_sources_param(segments, tensor_info, rise_time) ny = int(dip_ps / 2) nx = int(strike_ps / 2) times = [ point_sources[:, :, ny, nx, 4] for point_sources in point_sources0 ] trup_segs2 = [rupt_seg - time for time, rupt_seg in zip(times, trup_segs)] zipped = zip(segments, slip_segs, rake_segs, trup_segs2, tris_segs, tfall_segs) with open('Fault.time', 'w') as outfile: outfile.write('{} {} {} 10\n'.format(hyp_stk, hyp_dip, depth)) outfile.write('{} {} {} {} {} {} {} {} {}\n'.format( len(segments), delta_strike, delta_dip, strike_ps, dip_ps, vel0, vel1, -100, 100)) outfile.write('{} {} {} {} {}\n'.format(t1, t2, windows, rupture_vel, disp_or_vel)) for i_segment, (segment, slip_seg, rake_seg, trup_seg, tris_seg, tfall_seg)\ in enumerate(zipped): dip = segment['dip'] strike = segment['strike'] n_stk = segment['stk_subfaults'] n_dip = segment['dip_subfaults'] outfile.write('{} {} {}\n'.format(i_segment + 1, dip, strike)) outfile.write('{} {} 0\n'.format(n_stk, n_dip)) for i in range(n_dip): for j in range(n_stk): outfile.write( string.format(slip_seg[i, j], rake_seg[i, j], trup_seg[i, j], tris_seg[i, j], tfall_seg[i, j])) return
def static_to_fsp(tensor_info, segments_data, used_data, vel_model, solution): """Write FSP file with the solution of FFM modelling from file Solucion.txt :param tensor_info: dictionary with moment tensor information :param segments_data: list of dictionaries with properties of fault segments :param rise_time: dictionary with rise time information :param point_sources: properties of point sources of the fault plane :param used_data: list with data types to be used in modelling :param solution: dictionary with output kinematic model properties :param vel_model: dictionary with velocity model properties :type tensor_info: dict :type segments_data: list :type rise_time: dict :type point_sources: array :type used_data: list :type solution: dict :type vel_model: dict """ locator = flinnengdahl.FlinnEngdahl() segments = segments_data['segments'] rise_time = segments_data['rise_time'] point_sources = pf.point_sources_param(segments, tensor_info, rise_time) slips = solution['slip'] rakes = solution['rake'] trup = solution['rupture_time'] trise = solution['trise'] tfall = solution['tfall'] latitudes = solution['lat'] longitudes = solution['lon'] depths = solution['depth'] moment = solution['moment'] total_moment = np.sum(np.array(moment).flatten()) string = ' ---------------------------------- ' event_lat = tensor_info['lat'] event_lon = tensor_info['lon'] depth = tensor_info['depth'] moment_mag = 2 * np.log10(total_moment) / 3 - 10.7 location = locator.get_region(event_lon, event_lat) date = tensor_info['datetime'] tag = date now = datetime.datetime.now() plane_info = segments[0] stk_subfaults, dip_subfaults, delta_strike, delta_dip, hyp_stk, hyp_dip\ = pl_mng.__unpack_plane_data(plane_info) hyp_stk = (hyp_stk + 0.5) * delta_strike length = delta_strike * stk_subfaults hyp_dip = (hyp_dip + 0.5) * delta_dip width = delta_dip * dip_subfaults strike = plane_info['strike'] dip = plane_info['dip'] rake = plane_info['rake'] ps_depths = [ps_segment[:, :, :, :, 2] for ps_segment in point_sources] min_depth = min([np.min(ps_depth.flatten()) for ps_depth in ps_depths]) ps_distances = [ps_segment[:, :, 0, 0, 3] for ps_segment in point_sources] ps_times = [ps_segment[:, :, 0, 0, 4] for ps_segment in point_sources] delta_time = [rupt_seg - ps_time for ps_time, rupt_seg\ in zip(ps_times, trup)] total_subfaults = [segment['stk_subfaults'] * segment['dip_subfaults']\ for segment in segments] total_subfaults = np.sum(np.array(total_subfaults)) avg_time = [np.sum(dt_seg.flatten()) for dt_seg in delta_time] avg_time = np.sum(np.array(avg_time).flatten()) / total_subfaults avg_vel = [ps_dist / rupt_seg for ps_dist, rupt_seg\ in zip(ps_distances, trup)] avg_vel = [np.sum(avg_vel_seg.flatten()) for avg_vel_seg in avg_vel] avg_vel = np.sum(np.array(avg_vel).flatten()) / total_subfaults min_rise = rise_time['min_rise'] delta_rise = rise_time['delta_rise'] windows = rise_time['windows'] quantity_strong = 0 if 'strong_motion' in used_data: strong_data = json.load(open('strong_motion_waves.json')) quantity_strong = len(strong_data) quantity_gps = 0 if 'gps' in used_data: gps_data = json.load(open('static_data.json')) quantity_gps = len(gps_data) quantity_tele = 0 if 'tele_body' in used_data: tele_data = json.load(open('tele_waves.json')) quantity_tele = len(tele_data) quantity_surf = 0 if 'surf_tele' in used_data: surf_data = json.load(open('surf_waves.json')) quantity_surf = len(surf_data) n_layers = len(vel_model['dens']) p_vel = [float(v) for v in vel_model['p_vel']] s_vel = [float(v) for v in vel_model['s_vel']] dens = [float(v) for v in vel_model['dens']] thick = [float(v) for v in vel_model['thick']] qp = [float(v) for v in vel_model['qa']] qs = [float(v) for v in vel_model['qb']] depth2 = np.cumsum(np.array(thick)) depth2 = depth2 - depth2[0] zipped = zip(depth2, p_vel, s_vel, dens, qp, qs) zipped2 = zip(segments, point_sources, latitudes, longitudes, depths, slips, rakes, trup, trise, tfall, moment) string2 = '{0:9.4f} {1:9.4f} {2:9.4f} {3:9.4f} {4:9.4f} '\ '{5:8.4f} {6:9.4f} {7:8.4f} {8:9.4f} {9:8.2e}\n' string_fun = lambda a, b, c, d, e, f, g, h, i, j:\ string2.format(a, b, c, d, e, f, g, h, i, j) with open('fsp_sol_file', 'w') as outfile: outfile.write('%{}FINITE-SOURCE RUPTURE '\ 'MODEL{}\n%\n'.format(string, string)) outfile.write('% Event : {} {} CSN\n'.format(location, date)) outfile.write('% EventTAG: {}\n%\n'.format(tag)) outfile.write('% Loc : LAT = {} LON = {} DEP = {}\n'.format( event_lat, event_lon, depth)) outfile.write( '% Size : LEN = {} km WID = {} km Mw = {} Mo = {} Nm\n'.format( length, width, moment_mag, total_moment * 10**-7)) outfile.write( '% Mech : STRK = {} DIP = {} RAKE = {} Htop = {} '\ 'km\n'.format(strike, dip, rake, min_depth)) outfile.write( '% Rupt : HypX = {} km Hypz = {} km avTr = {:5.2f} s avVr = {:5.2f} '\ 'km/s\n%\n'.format(hyp_stk, hyp_dip, avg_time, avg_vel)) outfile.write('% {} inversion-related '\ 'parameters{}\n'.format(string, string)) outfile.write('%\n% Invs : Nx = {} Nz = {} Fmin = {} Hz '\ 'Fmax = {} Hz\n'.format(stk_subfaults, dip_subfaults, 0.01, 0.125)) outfile.write('% Invs : Dx = {} km Dz = {} '\ 'km\n'.format(delta_strike, delta_dip)) outfile.write('% Invs : Ntw = {} Nsg = {} '\ '(# of time-windows,# of fault segments)'\ '\n'.format(windows, len(segments))) outfile.write('% Invs : LEN = {} s SHF = {} s '\ '(time-window length and time-shift)\n'.format( min_rise + delta_rise, delta_rise)) outfile.write('% SVF : Asymetriccosine '\ '(type of slip-velocity function used)\n') outfile.write('%\n% Data : SGM TELE TRIL LEVEL GPS INSAR SURF OTHER\n') outfile.write('% Data : {} {} 0 0 {} 0 {} '\ '0\n'.format(quantity_strong, quantity_tele, quantity_gps, quantity_surf)) outfile.write('% Data : {} {} 0 0 {} 0 {} '\ '0\n'.format(quantity_strong, quantity_tele, quantity_gps, quantity_surf)) outfile.write('% Data : {} {} 0 0 {} 0 {} '\ '0\n'.format(quantity_strong, quantity_tele, quantity_gps, quantity_surf)) outfile.write('%\n%{}{}\n'.format(string, string)) outfile.write('%\n% VELOCITY-DENSITY STRUCTURE\n') outfile.write('% No. of layers = {}\n'.format(n_layers)) outfile.write('%\n% DEPTH P_VEL S_VEL DENS QP QS\n') outfile.write('% [km] [km/s] [km/s] [g/cm^3]\n') for dep, pv, sv, den, qpp, qss in zipped: outfile.write('% {} {} {} {} {} '\ '{}\n'.format(dep, pv, sv, den, qpp, qss)) outfile.write('%\n%{}{}\n'.format(string, string)) outfile.write('% {}/{}/{} created by [email protected].'\ 'cl\n'.format(now.day, now.month, now.year)) outfile.write('%\n% SOURCE MODEL PARAMETERS\n') if len(segments) == 1: outfile.write('% Nsbfs = {} subfaults\n'.format( stk_subfaults, dip_subfaults)) outfile.write('% X,Y,Z coordinates in km; SLIP in m\n') outfile.write('% if applicable: RAKE in deg, RISE in s, TRUP in s, '\ 'slip in each TW in m\n') outfile.write('%\n% Coordinates are given for center of each '\ 'subfault or segment: |\'|\n') outfile.write('% Origin of local coordinate system at epicenter: '\ 'X (EW) = 0, Y (NS) = 0\n') if len(segments) == 1: outfile.write('% LAT LON X==EW Y==NS Z SLIP RAKE TRUP RISE ') outfile.write('SF_MOMENT\n%{}{}\n'.format(string, string)) lat_fault = latitudes[0].flatten() lon_fault = longitudes[0].flatten() depth_fault = depths[0].flatten() slip_fault = slips[0].flatten() rake_fault = rakes[0].flatten() trup_fault = trup[0].flatten() trise_fault = trise[0].flatten() tfall_fault = tfall[0].flatten() moment_fault = moment[0].flatten() zipped3 = zip(lat_fault, lon_fault, depth_fault, slip_fault, rake_fault, trup_fault, trise_fault, tfall_fault, moment_fault) for line in zipped3: lat, lon, dep, slip, rake, t_rup, t_ris, t_fal, moment = line north_south = (float(lat) - event_lat) * 111.11 east_west = (float(lon) - event_lon) * 111.11 moment = moment * 10**-7 slip = slip * 10**-2 outfile.write( string_fun(lat, lon, east_west, north_south, dep, slip, rake, t_rup, t_ris + t_fal, moment)) else: outfile.write('%{}{}\n'.format(string, string)) outfile.write('%{} MULTISEGMENT MODEL {}\n'.format(string, string)) outfile.write('%{}{}\n'.format(string, string)) start_line = 10 for i_segment, fault_segment_data in enumerate(zipped2): segment = fault_segment_data[0].flatten() ps_seg = fault_segment_data[1].flatten() lat_fault = fault_segment_data[2].flatten() lon_fault = fault_segment_data[3].flatten() depth_fault = fault_segment_data[4].flatten() slip_fault = fault_segment_data[5].flatten() rake_fault = fault_segment_data[6].flatten() trup_fault = fault_segment_data[7].flatten() trise_fault = fault_segment_data[8].flatten() tfall_fault = fault_segment_data[9].flatten() moment_fault = fault_segment_data[10].flatten() strike = segment['strike'] dip = segment['dip'] stk_subfaults, dip_subfaults, delta_strike, delta_dip, hyp_stk, hyp_dip\ = pl_mng.__unpack_plane_data(plane_info) length = stk_subfaults * delta_strike width = dip_subfaults * delta_dip min_dep = np.min(ps_seg[:, :, :, :, 2].flatten()) lat0 = ps_seg[-1, -1, -1, -1, 0] lon0 = ps_seg[-1, -1, -1, -1, 1] hyp_stk = (hyp_stk + 0.5) * delta_strike hyp_dip = (hyp_dip + 0.5) * delta_dip n_subfaults = stk_subfaults * dip_subfaults outfile.write('% SEGMENT # {}: STRIKE = {} deg DIP = {} '\ 'deg\n'.format(i_segment + 1, strike, dip)) outfile.write('% LEN = {} km WID = {} km\n'.format( length, width)) outfile.write( '% depth to top: Z2top = {:6.2f} km\n'.format(min_dep)) outfile.write('% coordinates of top-center\n') outfile.write('% LAT = {}, LON = {}\n'.format(lat0, lon0)) outfile.write('% hypocenter on SEG # {} : along-strike (X) '\ '= {}, down-dip (Z) = {}\n'.format( i_segment + 1, hyp_stk, hyp_dip)) outfile.write('% Nsbfs = {} subfaults\n'.format(n_subfaults)) outfile.write('% LAT LON X==EW Y==NS Z SLIP RAKE TRUP RISE ') outfile.write('SF_MOMENT\n%{}{}\n'.format(string, string)) zipped3 = zip(lat_fault, lon_fault, depth_fault, slip_fault, rake_fault, trup_fault, trise_fault, tfall_fault, moment_fault) for line in zipped: lat, lon, dep, slip, rake, t_rup, t_ris, t_fal,\ moment = line north_south = (float(lat) - event_lat) * 111.11 east_west = (float(lon) - event_lon) * 111.11 moment = moment * 10**-7 slip = slip * 10**-2 outfile.write( string_fun(lat, lon, east_west, north_south, dep, slip, rake, t_rup, t_ris + t_fal, moment)) start_line = start_line + 1 start_line = start_line + 9