def __init__(self, model, rec_positions, src_positions, t0, tn, **kwargs):
"""
In practice would be __init__(segyfile) and all below parameters
would come from a segy_read (at property call rather than at init)
"""
src_positions = np.reshape(src_positions, (-1, model.dim))
rec_positions = np.reshape(rec_positions, (-1, model.dim))
self.rec_positions = rec_positions
self._nrec = rec_positions.shape[0]
self.src_positions = src_positions
self._nsrc = src_positions.shape[0]
self._src_type = kwargs.get('src_type')
assert (self.src_type in sources or self.src_type is None)
self._f0 = kwargs.get('f0')
self._a = kwargs.get('a', None)
self._t0w = kwargs.get('t0w', None)
if self._src_type is not None and self._f0 is None:
error("Peak frequency must be provided in KH" +
" for source of type %s" % self._src_type)
self._grid = model.grid
self._model = model
self._dt = model.critical_dt
self._t0 = t0
self._tn = tn
def verify_parameters(self, parameters, expected):
"""
Utility function to verify a parameter set against expected
values.
"""
boilerplate = ['timers']
parameters = [p.name for p in parameters]
for exp in expected:
if exp not in parameters + boilerplate:
error("Missing parameter: %s" % exp)
assert exp in parameters + boilerplate
extra = [p for p in parameters if p not in expected and p not in boilerplate]
if len(extra) > 0:
error("Redundant parameters: %s" % str(extra))
assert len(extra) == 0
def verify_arguments(self, arguments, expected):
"""
Utility function to verify an argument dictionary against
expected values.
"""
for name, value in expected.items():
if isinstance(value, np.ndarray):
condition = (arguments[name] == value).all()
else:
condition = arguments[name] == value
if not condition:
error('Wrong argument %s: expected %s, got %s' %
(name, value, arguments[name]))
assert condition
def __init__(self, model, rec_positions, src_positions, t0, tn, **kwargs):
"""
In practice would be __init__(segyfile) and all below parameters
would come from a segy_read (at property call rather than at init)
"""
self.rec_positions = rec_positions
self._nrec = rec_positions.shape[0]
self.src_positions = src_positions
self._nsrc = src_positions.shape[0]
self._src_type = kwargs.get('src_type')
assert self.src_type in sources
self._f0 = kwargs.get('f0')
if self._src_type is not None and self._f0 is None:
error("Peak frequency must be provided in KH" +
" for source of type %s" % self._src_type)
self._model = model
self._dt = model.critical_dt
self._t0 = t0
self._tn = tn
def fwi_gradient_shot(vp_in, i, solver_params, source_location):
error("Initialising solver")
tn = solver_params['tn']
nbl = solver_params['nbl']
space_order = solver_params['space_order']
dtype = solver_params['dtype']
origin = solver_params['origin']
spacing = solver_params['spacing']
true_model_filename = "overthrust_3D_true_model_2D.h5"
# shots_container = solver_params['shots_container']
# true_d, source_location, old_dt = load_shot(i, container=shots_container)
true_solver_params = solver_params.copy()
true_solver_params['h5_file'] = true_model_filename
true_solver_params['datakey'] = "m"
solver_true = overthrust_solver_iso(**true_solver_params)
true_d, _, _ = solver_true.forward()
model = Model(vp=vp_in,
nbl=nbl,
space_order=space_order,
dtype=dtype,
shape=vp_in.shape,
origin=origin,
spacing=spacing,
bcs="damp")
geometry = create_geometry(model, tn, source_location)
error("tn: %d, nt: %d, dt: %f" % (geometry.tn, geometry.nt, geometry.dt))
# error("Reinterpolate shot from %d samples to %d samples" % (true_d.shape[0], geometry.nt))
# true_d = reinterpolate(true_d, geometry.nt, old_dt)
solver = AcousticWaveSolver(model,
geometry,
kernel='OT2',
nbl=nbl,
space_order=space_order,
dtype=dtype)
grad = Function(name="grad", grid=model.grid)
residual = Receiver(name='rec',
grid=model.grid,
time_range=geometry.time_axis,
coordinates=geometry.rec_positions)
u0 = TimeFunction(name='u',
grid=model.grid,
time_order=2,
space_order=solver.space_order,
save=geometry.nt)
error("Forward prop")
smooth_d, _, _ = solver.forward(save=True, u=u0)
error("Misfit")
residual.data[:] = smooth_d.data[:] - true_d.data[:]
objective = .5 * np.linalg.norm(residual.data.ravel())**2
error("Gradient")
solver.gradient(rec=residual, u=u0, grad=grad)
grad = clip_boundary_and_numpy(grad.data, model.nbl)
return objective, -grad
