def main(model_folder, draw_pics): nlayers, params_all_dict, params_to_optimize, bounds_to_optimize, \ observation_params = read_input_fp_file(model_folder) dx = float(observation_params['dx']) nrec = observation_params['nrec'] x_rec = [i * dx for i in range(1, nrec + 1)] forward_input_params = { 'x_rec': x_rec, 'display_stat': True, 'visualize_seismograms': False, 'use_p_waves': observation_params['use_p_waves'], 'use_s_waves': observation_params['use_s_waves'], 'dt': observation_params['dt'], 'trace_len': observation_params['trace_len'], } forward_input_params.update(params_all_dict) observe, model, res_seismic = forward_with_trace_calcing( **forward_input_params) write_segy(seismogram_p, os.path.join(model_folder, 'input', 'pwaves.sgy')) if draw_pics: picks_folder = os.path.join(model_folder, 'pics') draw_seismogram(seismogram_p, 'p-waves', os.path.join(picks_folder, 'p-observed.png'))
def main(): # Km, Gm, rho_m, Ks, Gs, rho_s, Kf, rho_f, phi, phi_s, h = get_model_1() layer_1_dict, layer_2_dict = get_model_2layered() h = 500 layer_1 = Layer1D(h, rp_attribute=RockPhysicsAttribute( layer_1_dict["components"], layer_1_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) layer_2 = Layer1D(-1, rp_attribute=RockPhysicsAttribute( layer_2_dict["components"], layer_2_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) model = SeismicModel1D([layer_1, layer_2]) nlayers = 2 dx = 50 nx = 200 x_rec = [i * dx for i in range(1, nx)] time_mark_1 = time.time() # DEM(nlayers, Km, Gm, Ks, Gs, Kf, phi, phi_s, rho_s, rho_f, rho_m, h, x_rec, # display_stat=True, visualize_res=True, # calc_rays_p=True, calc_rays_s=True, # calc_reflection_p=True, calc_reflection_s=False # ) wavetypes = [ OWT.PdPu # OWT.PdSVu ] forward_with_trace_calcing(model, x_rec, dt=3e-03, trace_len=1500, wavetypes=wavetypes, display_stat=True, visualize_res=False, visualize_seismograms=True) time_mark_2 = time.time() print(f'Calculation time: {time_mark_2 - time_mark_1}')
def main(): Km, Gm, rho_m, Ks, Gs, rho_s, Kf, rho_f, phi, phi_s, h = get_model_1() nlayers = 8 dx = 50 nx = 20 x_rec = [i * dx for i in range(1, nx)] dt = 3e-03 observe, model, rays_p, rays_s, seismogram_p, seismogram_s = forward_with_trace_calcing( nlayers, Km, Gm, Ks, Gs, Kf, phi, phi_s, rho_s, rho_f, rho_m, h, x_rec, dt=dt, trace_len=1500, display_stat=True, visualize_res=False, use_p_waves=True, use_s_waves=False, visualize_seismograms=False) indexes_params = { "type": "from_model", "values": { "start": { "v": 2600, "h": 500 }, "stop": { "v": 2000, "h": 1000 } } } start_indexes, stop_indexes = create_start_stop_indexes( indexes_params, np.array(x_rec), dt) fig, axes = plt.subplots(nrows=1, ncols=1) axes.plot(x_rec, start_indexes * dt) axes.plot(x_rec, stop_indexes * dt) visualize_seismogram(axes, seismogram_p, normalize=True, wiggles=False) axes.set_title('p-waves seismogram') plt.show()
def func_to_optimize_seismogram_universal(model_opt, params_all, params_to_optimize, seismogram_observed_p, seismogram_observed_s, use_p_waves, use_s_waves, helper): params_all_ = {} for key in list(params_all.keys()): if type(params_all[key]) == type([]): params_all_[key] = params_all[key].copy() else: params_all_[key] = params_all[key] for m, p in zip(model_opt, params_to_optimize): params_all_[list(p.keys())[0]][list(p.values())[0]] = m seismogram_p, seismogram_s = forward_with_trace_calcing(**params_all_) errs = [] if use_p_waves: p1 = seismogram_p.get_values_matrix() p2 = seismogram_observed_p.get_values_matrix() diff_p = p1 - p2 np.nan_to_num(diff_p, False) # diff_p = (seismogram_p.get_values_matrix() - seismogram_observed_p.get_values_matrix()) errs.append(linalg.norm(diff_p)) if use_s_waves: s1 = seismogram_s.get_values_matrix() s2 = seismogram_observed_s.get_values_matrix() diff_s = s1 - s2 np.nan_to_num(diff_s, False) # diff_s = np.abs(seismogram_s.get_values_matrix() - seismogram_observed_s.get_values_matrix()) errs.append(linalg.norm(diff_s)) error_start_time = time.time() error = np.average(errs) print(np.average(errs)) helper.add_error(error) if helper.need_to_stop(): raise ErrorAchievedException(model_opt) return error
def func_to_optimize(model_opt, placeholders, forward_params, helper=None, show_tol=True): try: forward_params['model'].set_optimization_option(model_opt) observe, seismic = forward_with_trace_calcing(**forward_params) errors = [] for key in seismic.keys(): ph = placeholders[key] errors.append( get_matrices_diff(ph.seismogram, seismic[key]["seismogram"], ph.start_indexes, ph.stop_indexes, ph.trace_weights)) error = np.mean(errors) # Добавляем минимизацию к-тов оражения aip_1 = forward_params['model'].get_single_param('aip', index_finish=-1) aip_2 = forward_params['model'].get_single_param('aip', index_start=1) rp = (aip_2 - aip_1) / (aip_2 + aip_1) error = 1 * error + 0 * np.sum(abs(rp)) if np.isnan(error): error = 99999 except OverflowError as e: error = 99999 except BadCalcBaseException as e: error = 99999 # except Warning: # error = 99999 if show_tol: print(error) if helper is not None: helper.add_error(error) if helper.need_to_stop(): raise ErrorAchievedException(model_opt) return error
def water_case_test(): h = [ 67.5, 22.5, 40, ] layer_1_seism = {'vp': 1500, 'vs': 0, 'rho': 1000} layer_2_seism = {'vp': 1600, 'vs': 200, 'rho': 1300} layer_3_seism = {'vp': 2600, 'vs': 1000, 'rho': 2000} layer_4_seism = {'vp': 3000, 'vs': 1200, 'rho': 2200} layer_1 = Layer1D(h[0], rp_attribute=None, seism_attribute=SeismicAttribute(**layer_1_seism), opt=LayerOPT.NO) layer_2 = Layer1D(h[1], seism_attribute=SeismicAttribute(**layer_2_seism), rp_attribute=None, opt=LayerOPT.NO) layer_3 = Layer1D(h[2], rp_attribute=None, seism_attribute=SeismicAttribute(**layer_3_seism), opt=LayerOPT.NO) layer_4 = Layer1D(-1, rp_attribute=None, seism_attribute=SeismicAttribute(**layer_4_seism), opt=LayerOPT.NO) model = SeismicModel1D([layer_1, layer_2, layer_3, layer_4]) dx = 2 nx = 100 x_rec = [i * dx for i in range(1, nx + 1)] wave_types = [OWT.PdPu_water] start_time = time.time() observe, test_seismic = \ forward_with_trace_calcing(model, x_rec, dt=1e-04, trace_len=2000, wavetypes=wave_types, display_stat=True, visualize_res=False, visualize_seismograms=True) end_time = time.time() print(end_time - start_time)
def process_3_layer(): layer_1_dict, layer_2_dict, layer_3_dict = get_model_3layered() h = 500 layer_1 = Layer1D(h, rp_attribute=RockPhysicsAttribute(layer_1_dict["components"], layer_1_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) layer_2 = Layer1D(h, rp_attribute=RockPhysicsAttribute(layer_2_dict["components"], layer_2_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) layer_3 = Layer1D(-1, rp_attribute=RockPhysicsAttribute(layer_3_dict["components"], layer_2_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) model = SeismicModel1D([layer_1, layer_2, layer_3]) # model.layers[0]["Km"] = model.layers[1].opt = LayerOPT.NO model.layers[2].opt = LayerOPT.NO dx = 300 nx = 5 x_rec = [i*dx for i in range(1, nx+1)] wave_types = [OWT.PdPu] observe, test_seismic = \ forward_with_trace_calcing(model, x_rec, dt=3e-03, trace_len=1500, wavetypes=wave_types, display_stat=True, visualize_res=False) placeholders = {} for wt in wave_types: placeholders[wt] = WaveDataPlaceholder( wt, test_seismic[wt]["rays"], test_seismic[wt]["seismogram"] ) forward_params = { "model": model, "x_rec": x_rec, "dt": 3e-03, "trace_len": 1500, "wavetypes": wave_types, "display_stat": False, "visualize_res": False } experiment_val_Km1 = 5.89 optimizers = [ LBFGSBOptimization( maxiter=15000, maxfun=15000, factr=10000, maxls=50, epsilon=0.000001 ) ] inversed_model, stats = inverse(optimizers, error=0.01, placeholders=placeholders, forward_params=forward_params, scale="minmax") err = func_to_optimize([experiment_val_Km1], placeholders, forward_params, helper=None, show_tol=False) print(1)
def main(model_folder, draw_pics): inversion_start_time = time.time() nlayers, params_all_dict, params_to_optimize, bounds_to_optimize, \ observation_params = read_input_fp_file(model_folder) dx = float(observation_params['dx']) nrec = observation_params['nrec'] x_rec = [i * dx for i in range(1, nrec + 1)] dt = observation_params['dt'] forward_base_params = { 'x_rec': x_rec, 'display_stat': False, 'visualize_seismograms': False, 'use_p_waves': observation_params['use_p_waves'], 'use_s_waves': observation_params['use_s_waves'], 'dt': dt, 'trace_len': observation_params['trace_len'], } forward_input_params = dict(forward_base_params) forward_input_params.update(params_all_dict) seismogram_observed, err, optimizers, start_indexes, stop_indexes = read_input_ip_file( model_folder, np.array(x_rec), observation_params['dt']) result_number = create_res_folder(model_folder) result_folder = os.path.join(model_folder, 'output', f'result_{result_number}') logpath = os.path.join(result_folder, 'opt.log') inversed_model = inverse(optimizers, err, forward_input_params, params_to_optimize, bounds_to_optimize, seismogram_observed, None, start_indexes, stop_indexes, logpath=logpath) # inversed_model = inverse_per_layer(optimizers, err, forward_input_params, params_to_optimize, bounds_to_optimize, # seismogram_observed, None, start_indexes, stop_indexes, logpath=logpath) inversion_end_time = time.time() inversion_duration = (inversion_end_time - inversion_start_time) / 60 write_output_file(model_folder, params_all_dict, inversed_model, params_to_optimize, inversion_duration, result_number) if draw_pics: # calculate true model's params observe_true, model_true, rays_p_true, rays_s_true, seismogram_p_true, seismogram_s_true = \ forward_with_trace_calcing(**forward_input_params) # changing start model to result model params_all_ = {} for key in list(params_all_dict.keys()): if type(params_all_dict[key]) == type([]): params_all_[key] = params_all_dict[key].copy() else: params_all_[key] = params_all_dict[key] for m, p in zip(inversed_model, params_to_optimize): params_all_[list(p.keys())[0]][list(p.values())[0]] = m forward_input_params = dict(forward_base_params) forward_input_params.update(params_all_) # calculate forward from inverse model observe, model, rays_p, rays_s, seismogram_p, seismogram_s = forward_with_trace_calcing( **forward_input_params) picks_folder = os.path.join(model_folder, 'output', f'result_{result_number}') # draw wellogs visualize_model(model_true, model, picks_folder) draw_seismogram(seismogram_observed, 'p-waves observed', os.path.join(picks_folder, 'p-observed.png'), additional_lines=[ [x_rec, start_indexes * dt, {}], [x_rec, stop_indexes * dt, {}], ]) draw_seismogram(seismogram_p, 'p-waves inverted', os.path.join(picks_folder, 'p-inverted.png')) draw_dos_seismograms(seismogram_observed, seismogram_p, 'p-waves compare', os.path.join(picks_folder, 'p-compare.png'), normalize=False) draw_seismogram(seismogram_observed, 'p-waves observed', os.path.join(picks_folder, 'p-observed-wig.png'), wiggles=True, normalize=False) draw_seismogram(seismogram_p, 'p-waves inverted', os.path.join(picks_folder, 'p-inverted-wig.png'), wiggles=True, normalize=False) write_segy(seismogram_p, os.path.join(result_folder, 'pwaves_inv.sgy')) draw_seismogram(seismogram_observed - seismogram_p, 'p-waves difference', os.path.join(picks_folder, 'p-difference.png'), colorbar=True) write_segy(seismogram_observed - seismogram_p, os.path.join(result_folder, 'pwaves_diff.sgy')) write_averaged_result(model_folder) plot_histogram_by_all_results(model_folder)
def main(): # Km, Gm, rho_m, Ks, Gs, rho_s, Kf, rho_f, phi, phi_s, h = get_model_1() layer_1_dict, layer_2_dict = get_model_2layered() h = 500 layer_1 = Layer1D(h, rp_attribute=RockPhysicsAttribute(layer_1_dict["components"], layer_1_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) layer_2 = Layer1D(-1, rp_attribute=RockPhysicsAttribute(layer_2_dict["components"], layer_2_dict["name"]), seism_attribute=None, opt=LayerOPT.RP) dx = 100 nx = 2 x_rec = [i * dx for i in range(1, nx)] wave_types = [OWT.PdPu] model = SeismicModel1D([layer_1, layer_2]) print('Calculating DEM modeling...') observe, test_seismic = \ forward_with_trace_calcing(model, x_rec, dt=3e-03, trace_len=1500, wavetypes=wave_types, display_stat=True, visualize_res=False) print('Forward calculated!') print('Calculating inversion...') inversion_start_time = time.time() forward_params = { "model": model, "x_rec": x_rec, "dt": 3e-03, "trace_len": 1500, "wavetypes": wave_types, "display_stat": False, "visualize_res": False } placeholders = {} for wt in wave_types: placeholders[wt] = WaveDataPlaceholder( wt, test_seismic[wt]["rays"], test_seismic[wt]["seismogram"] ) optimizers = [ LBFGSBOptimization( maxiter=15000, maxfun=15000, factr=10000, maxls=50, epsilon=0.0001 ) ] optimizers_de = [ DifferentialEvolution( popsize=5, maxiter=50000, init="latinhypercube", strategy="best1bin", disp=True, polish=False, tol=0.00001, mutation=1.5, recombination=0.6, workers=8 ) ] # optimizers = [ # AxOptimizer(num_evals=20) # ] model.layers[0]['Km'] = 5 model.layers[1]['Km'] = 20 # true values: 7.3 and 21.5 # from inversion.Strategies.SeismDiffInversion1D import func_to_optimize # assert func_to_optimize(forward_params['model'].get_optimization_option('val', vectorize=True), placeholders, # forward_params, helper=None, show_tol=False) < 0.01 inversed_model, stats = inverse(optimizers_de, error=0.0001, placeholders=placeholders, forward_params=forward_params) print('inversion calculated!') inversion_end_time = time.time() print('inversion duration: {} seconds'.format((inversion_end_time - inversion_start_time))) print(inversed_model) func_to_opt_start_time = time.time() func_to_optimize(forward_params['model'].get_optimization_option('val', vectorize=True), placeholders, forward_params, helper=None, show_tol=False) print(f'Func to optimize evaluation time: {time.time() - func_to_opt_start_time} seconds')
def main(input_folder, dx, nx, use_rays_p, use_rays_s, noise=False, result_number=None): input_file_name = input_folder + '/input_fp.json' result_file_name = input_folder + '/result_{}'.format(result_number) nlayers, params_all_dict, params_to_optimize, bounds_to_optimize = read_input_file( input_file_name) if result_number: pictures_folder = os.path.join(input_folder, 'pictures_{}'.format(result_number)) params_optimized, values_optimized = read_inversion_result_file( result_file_name) else: pictures_folder = os.path.join(input_folder, 'pictures') params_optimized, values_optimized = get_averaged_model(input_folder) # params_optimized, values_optimized = read_inversion_result_file(result_file_name) if not os.path.exists(pictures_folder): os.makedirs(pictures_folder) # without seismograms forwarding x_rec = [i * dx for i in range(1, nx)] forward_input_params = { 'x_rec': x_rec, 'display_stat': False, 'visualize_res': False, 'calc_reflection_p': use_rays_p, 'calc_reflection_s': use_rays_s, 'noise': noise } forward_input_params.update(params_all_dict) params_all_ = {} for key in list(forward_input_params.keys()): if type(forward_input_params[key]) == type([]): params_all_[key] = forward_input_params[key].copy() else: params_all_[key] = forward_input_params[key] for m, p in zip(values_optimized, params_to_optimize): params_all_[list(p.keys())[0]][list(p.values())[0]] = m params_all_['noise'] = False observe_1, model_1, rays_p_1, rays_s_1 = forward(**forward_input_params) observe_2, model_2, rays_p_2, rays_s_2 = forward(**params_all_) max_depth = model_1.get_max_boundary_depth() * 1.2 dz = 100 visualize_model_wellogs(plt, model_1, 'vp', legend_label='истиная модель') visualize_model_wellogs(plt, model_2, 'vp', legend_label='результат подбора', linestyle='--') plt.gca().invert_yaxis() plt.title('vp', fontsize=18) plt.ylabel('глубина, м') plt.xlabel('скорость, м/с') plt.tight_layout() plt.savefig(os.path.join(pictures_folder, 'vp_average.png')) plt.close() visualize_model_wellogs(plt, model_1, 'vs', legend_label='истиная модель') visualize_model_wellogs(plt, model_2, 'vs', legend_label='результат подбора', linestyle='--') plt.gca().invert_yaxis() plt.title('vs', fontsize=18) plt.ylabel('глубина, м') plt.xlabel('скорость, м/с') plt.tight_layout() plt.savefig(os.path.join(pictures_folder, 'vs_average.png')) plt.close() visualize_model_wellogs(plt, model_1, 'rho', legend_label='истиная модель') visualize_model_wellogs(plt, model_2, 'rho', legend_label='результат подбора', linestyle='--') plt.gca().invert_yaxis() plt.title('rho', fontsize=18) plt.ylabel('глубина, м') plt.xlabel('плотность, кг/м3') plt.tight_layout() plt.savefig(os.path.join(pictures_folder, 'rho_average.png')) plt.close() visualize_model_wellogs(plt, model_1, 'phi', legend_label='истиная модель') visualize_model_wellogs(plt, model_2, 'phi', legend_label='результат подбора', linestyle='--') plt.gca().invert_yaxis() plt.title('phi', fontsize=18) plt.ylabel('глубина, м') plt.xlabel('пористость') plt.tight_layout() plt.savefig(os.path.join(pictures_folder, 'phi_average.png')) plt.close() # visualize_model_wellogs(plt, model_2, 'vs', legend_label='vs, m/s') # visualize_model_wellogs(plt, model_2, 'rho', legend_label='dens, kg/m3') # # plt.gca().invert_yaxis() # # plt.title('Vp welllogs') # plt.legend() # plt.show() # visualize_model1D(plt, model_1, observe_1, max_depth, dz, 'vp', only_boundaries=True) # visualize_rays_model_1D(plt, rays_p_1) # plt.gca().invert_yaxis() # # plt.legend() # plt.show() for i in range(nlayers - 1): visualize_reflection_amplitudes(plt, rays_p_1, reflection_index=i, absc='angle') visualize_reflection_amplitudes(plt, rays_p_2, reflection_index=i, absc='angle', linestyle='--') plt.title('отражение от подошвы {} слоя для p-волн'.format(i + 1), fontsize=18) plt.ylabel('к-т отражения') plt.xlabel('угол падения, рад') plt.tight_layout() plt.savefig( os.path.join(pictures_folder, 'amplitudes_vp_{}.png'.format(i))) plt.close() visualize_time_curves(plt, model_1, rays_p_1, observe_1, depth_index=i) visualize_time_curves(plt, model_2, rays_p_2, observe_2, depth_index=i, linestyle='--') plt.title('отражение от подошвы {} слоя для p-волн'.format(i + 1), fontsize=18) plt.ylabel('время, сек') plt.xlabel('удаление, м') plt.tight_layout() plt.savefig(os.path.join(pictures_folder, 'times_vp_{}.png'.format(i))) plt.close() visualize_reflection_amplitudes(plt, rays_s_1, reflection_index=i, absc='angle') visualize_reflection_amplitudes(plt, rays_s_2, reflection_index=i, absc='angle', linestyle='--') plt.title('отражение от подошвы {} слоя для s-волн'.format(i + 1), fontsize=18) plt.ylabel('амплитуда') plt.xlabel('угол падения, рад') plt.tight_layout() plt.savefig( os.path.join(pictures_folder, 'amplitudes_vs_{}.png'.format(i))) plt.close() visualize_time_curves(plt, model_1, rays_s_1, observe_1, depth_index=i) visualize_time_curves(plt, model_2, rays_s_2, observe_2, depth_index=i, linestyle='--') plt.title('отражение от подошвы {} слоя для s-волн'.format(i + 1), fontsize=18) plt.ylabel('время, сек') plt.xlabel('удаление, м') plt.tight_layout() plt.savefig(os.path.join(pictures_folder, 'times_vs_{}.png'.format(i))) plt.close() # # plt.legend() # plt.show() # visualize_time_curves(plt, model_1, rays_p_1, observe_1) # plt.show() # with seismogram forwarding forward_input_params_shots = { 'x_rec': x_rec, 'display_stat': False, 'visualize_res': False, 'use_p_waves': True, 'use_s_waves': True, 'dt': 3e-03, 'trace_len': 800, } forward_input_params_shots.update(params_all_dict) seismogram_p_1, seismogram_s_1 = forward_with_trace_calcing( **forward_input_params_shots)