def test_eqlayer_polereduce():
"EQLTotalField can reduce data to the pole"
# Use remanent magnetization
sinc, sdec = -70, 30
model = [Prism(-100, 100, -500, 500, 0, 100,
{'magnetization': utils.ang2vec(5, sinc, sdec)})]
inc, dec = -60, -15
shape = (50, 50)
area = [-2000, 2000, -2000, 2000]
x, y, z = gridder.regular(area, shape, z=-100)
data = prism.tf(x, y, z, model, inc, dec)
true = prism.tf(x, y, z, model, -90, 0, pmag=utils.ang2vec(5, -90, 0))
layer = PointGrid(area, 200, shape)
eql = (EQLTotalField(x, y, z, data, inc, dec, layer, sinc, sdec)
+ 1e-24*Damping(layer.size))
eql.fit()
assert_allclose(eql[0].predicted(), data, rtol=0.01)
layer.addprop('magnetization',
utils.ang2vec(eql.estimate_, inc=-90, dec=0))
calc = sphere.tf(x, y, z, layer, inc=-90, dec=0)
assert_allclose(calc, true, atol=10, rtol=0.05)
def test_eqlgrav_prism_interp():
"EQLGravity can interpolate data from a prism"
model = [Prism(-300, 300, -500, 500, 100, 600, {'density': 400})]
shape = (30, 30)
n = shape[0]*shape[1]
area = [-2000, 2000, -2000, 2000]
x, y, z = gridder.scatter(area, n, z=-100, seed=42)
data = prism.gz(x, y, z, model)
layer = PointGrid(area, 200, shape)
eql = EQLGravity(x, y, z, data, layer) + 1e-23*Damping(layer.size)
eql.fit()
layer.addprop('density', eql.estimate_)
assert_allclose(eql[0].predicted(), data, rtol=0.01)
xp, yp, zp = gridder.regular(area, shape, z=-100)
true = prism.gz(xp, yp, zp, model)
calc = sphere.gz(xp, yp, zp, layer)
assert_allclose(calc, true, rtol=0.05)
# First thing to do is make some synthetic data to test the method. We'll use a
# single prism to keep it simple
props = {'density': 500}
model = [mesher.Prism(-5000, 5000, -200, 200, 100, 4000, props)]
# The synthetic data will be generated on a random scatter of points
area = [-8000, 8000, -5000, 5000]
x, y, z = gridder.scatter(area, 300, z=0, seed=42)
# Generate some noisy data from our model
gz = utils.contaminate(prism.gz(x, y, z, model), 0.2, seed=0)
# Now for the equivalent layer. We must setup a layer of point masses where
# we'll estimate a density distribution that fits our synthetic data
layer = mesher.PointGrid(area, 500, (20, 20))
# Estimate the density using enough damping so that won't try to fit the error
eql = EQLGravity(x, y, z, gz, layer) + 1e-22 * Damping(layer.size)
eql.fit()
# Now we add the estimated densities to our layer
layer.addprop('density', eql.estimate_)
# and print some statistics of how well the estimated layer fits the data
residuals = eql[0].residuals()
print("Residuals:")
print(" mean:", residuals.mean(), 'mGal')
print(" stddev:", residuals.std(), 'mGal')
# Now I can forward model gravity data anywhere we want. For interpolation, we
# calculate it on a grid. For upward continuation, at a greater height. We can
# even combine both into a single operation.
x2, y2, z2 = gridder.regular(area, (50, 50), z=-1000)
gz_up = sphere.gz(x2, y2, z2, layer)
model = [mesher.Prism(-2000, 2000, -200, 200, 100, 4000, props)]
# The synthetic data will be generated on a regular grid
area = [-8000, 8000, -5000, 5000]
shape = (40, 40)
x, y, z = gridder.regular(area, shape, z=-150)
# Generate some noisy data from our model
data = utils.contaminate(prism.tf(x, y, z, model, inc, dec), 5, seed=0)
# Now for the equivalent layer. We must setup a layer of dipoles where we'll
# estimate a magnetization intensity distribution that fits our synthetic data.
# Notice that we only estimate the intensity. We must provide the magnetization
# direction of the layer through the sinc and sdec parameters.
layer = mesher.PointGrid(area, 700, shape)
eql = (EQLTotalField(x, y, z, data, inc, dec, layer, sinc=inc, sdec=dec)
+ 1e-15*Damping(layer.size))
eql.fit()
# Print some statistics of how well the estimated layer fits the data
residuals = eql[0].residuals()
print("Residuals:")
print(" mean:", residuals.mean(), 'nT')
print(" stddev:", residuals.std(), 'nT')
# Now I can forward model data anywhere we want. To reduce to the pole, we must
# provide inc = 90 (or -90) for the Earth's field as well as to the layer's
# magnetization.
layer.addprop('magnetization', utils.ang2vec(eql.estimate_, inc=-90, dec=0))
atpole = sphere.tf(x, y, z, layer, inc=-90, dec=0)
fig, axes = plt.subplots(1, 2, figsize=(8, 6))
# Use 2% random noise to corrupt the data
tts = utils.contaminate(tts, 0.02, percent=True, seed=seed)
# Make a mesh for the inversion. The inversion will estimate the velocity in
# each square of the mesh. To make things simpler, we'll use a mesh that is the
# same as our original model.
mesh = SquareMesh(area, shape)
# Create solvers for each type of regularization and fit the synthetic data to
# obtain an estimated velocity model
solver = srtomo.SRTomo(tts, srcs, recs, mesh)
smooth = solver + 1e8 * Smoothness2D(mesh.shape)
smooth.fit()
damped = solver + 1e8 * Damping(mesh.size)
damped.fit()
sharp = solver + 30 * TotalVariation2D(1e-10, mesh.shape)
# Since Total Variation is a non-linear regularizing function, then the
# tomography becomes non-linear as well. We need to configure the inversion to
# use the Levemberg-Marquardt algorithm, a gradient descent method, that
# requires an initial estimate
sharp.config('levmarq', initial=0.00001 * np.ones(mesh.size)).fit()
# Plot the original model and the 3 estimates using the same color bar
fig, axes = plt.subplots(2, 2, figsize=(8, 7), sharex='all', sharey='all')
x = model.get_xs() / 1000
y = model.get_ys() / 1000
vmin, vmax = vel.min(), vel.max()
from fatiando import gridder, utils, mesher
from fatiando.vis import mpl
# Make synthetic data
inc, dec = -60, 23
props = {'magnetization': 10}
model = [mesher.Prism(-500, 500, -1000, 1000, 500, 4000, props)]
shape = (25, 25)
x, y, z = gridder.regular([-5000, 5000, -5000, 5000], shape, z=0)
tf = utils.contaminate(prism.tf(x, y, z, model, inc, dec), 5, seed=0)
# Setup the layer
layer = mesher.PointGrid([-7000, 7000, -7000, 7000], 700, (50, 50))
# Estimate the magnetization intensity
# Need to apply regularization so that won't try to fit the error as well
misfit = EQLTotalField(x, y, z, tf, inc, dec, layer)
regul = Damping(layer.size)
solver = (misfit + 1e-18 * regul).fit()
residuals = solver[0].residuals()
layer.addprop('magnetization', solver.estimate_)
print("Residuals:")
print("mean:", residuals.mean())
print("stddev:", residuals.std())
# Now I can forward model the layer at the south pole and check against the
# true solution of the prism
tfpole = prism.tf(x, y, z, model, -90, 0)
tfreduced = sphere.tf(x, y, z, layer, -90, 0)
mpl.figure(figsize=(14, 4))
mpl.subplot(1, 3, 1)
mpl.axis('scaled')
vel[5:25, 5:25] = 10000
model.addprop('vp', vel.ravel())
# Make some travel time data and add noise
seed = 0 # Set the random seed so that points are the same every time
src_loc = utils.random_points(area, 80, seed=seed)
rec_loc = utils.circular_points(area, 30, random=True, seed=seed)
srcs, recs = utils.connect_points(src_loc, rec_loc)
tts = ttime2d.straight(model, 'vp', srcs, recs)
tts, error = utils.contaminate(tts, 0.01, percent=True, return_stddev=True,
seed=seed)
# Make the mesh
mesh = SquareMesh(area, shape)
# and run the inversion
tomo = (srtomo.SRTomo(tts, srcs, recs, mesh) +
1e8*Damping(mesh.size))
tomo.fit()
mesh.addprop('vp', tomo.estimate_)
# Calculate and print the standard deviation of the residuals
# Should be close to the data error if the inversion was able to fit the data
residuals = tomo[0].residuals()
print "Assumed error: %g" % (error)
print "Standard deviation of residuals: %g" % (np.std(residuals))
mpl.figure(figsize=(14, 5))
mpl.subplot(1, 2, 1)
mpl.axis('scaled')
mpl.title('Vp model')
mpl.squaremesh(model, prop='vp', cmap=mpl.cm.seismic)
cb = mpl.colorbar()
30,
random=True,
seed=seed)
rec_loc = np.transpose([rec_loc_x, rec_loc_y])
srcs = [src for src in src_loc for _ in rec_loc]
recs = [rec for _ in src_loc for rec in rec_loc]
tts = ttime2d.straight(model, 'vp', srcs, recs)
tts, error = utils.contaminate(tts,
0.01,
percent=True,
return_stddev=True,
seed=seed)
# Make the mesh
mesh = SquareMesh(area, shape)
# and run the inversion
tomo = (srtomo.SRTomo(tts, srcs, recs, mesh) + 1e8 * Damping(mesh.size))
tomo.fit()
mesh.addprop('vp', tomo.estimate_)
# Calculate and print the standard deviation of the residuals
# Should be close to the data error if the inversion was able to fit the data
residuals = tomo[0].residuals()
print "Assumed error: %g" % (error)
print "Standard deviation of residuals: %g" % (np.std(residuals))
mpl.figure(figsize=(14, 5))
mpl.subplot(1, 2, 1)
mpl.axis('scaled')
mpl.title('Vp model')
mpl.squaremesh(model, prop='vp', cmap=mpl.cm.seismic)
cb = mpl.colorbar()