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)
