def test_derivatives_uneven_shape():
"gravmag.transform FFT derivatives work if grid spacing is uneven"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': 100})]
shape = (150, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
grav = utils.mgal2si(prism.gz(x, y, z, model))
analytical = prism.gzz(x, y, z, model)
calculated = utils.si2eotvos(transform.derivz(x, y, grav, shape,
method='fft'))
diff = _trim(np.abs(analytical - calculated), shape)
assert np.all(diff <= 0.005*np.abs(analytical).max()), \
"Failed for gzz"
def test_tilt_analytical_derivatives():
"gravmag.transform tilt returns same values given analytical derivatives"
model = [Prism(-100, 100, -100, 100, 0, 100, {'density': 1000})]
shape = (400, 400)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
data = utils.mgal2si(prism.gz(x, y, z, model))
dx = utils.eotvos2si(prism.gxz(x, y, z, model))
dy = utils.eotvos2si(prism.gyz(x, y, z, model))
dz = utils.eotvos2si(prism.gzz(x, y, z, model))
tilt_analytical = transform.tilt(x, y, data, shape, dx, dy, dz)
tilt_numerical = transform.tilt(x, y, data, shape)
npt.assert_allclose(tilt_numerical, tilt_analytical, rtol=0.10)
def test_derivatives_uneven_shape():
"gravmag.transform FFT derivatives work if grid spacing is uneven"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': 100})]
shape = (150, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
grav = utils.mgal2si(prism.gz(x, y, z, model))
analytical = prism.gzz(x, y, z, model)
calculated = utils.si2eotvos(
transform.derivz(x, y, grav, shape, method='fft'))
diff = _trim(np.abs(analytical - calculated), shape)
assert np.all(diff <= 0.005*np.abs(analytical).max()), \
"Failed for gzz"
def test_tilt_analytical_derivatives():
"gravmag.transform tilt returns same values given analytical derivatives"
model = [Prism(-100, 100, -100, 100, 0, 100, {'density': 1000})]
shape = (400, 400)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
data = utils.mgal2si(prism.gz(x, y, z, model))
dx = utils.eotvos2si(prism.gxz(x, y, z, model))
dy = utils.eotvos2si(prism.gyz(x, y, z, model))
dz = utils.eotvos2si(prism.gzz(x, y, z, model))
tilt_analytical = transform.tilt(x, y, data, shape, dx, dy, dz)
tilt_numerical = transform.tilt(x, y, data, shape)
npt.assert_allclose(tilt_numerical, tilt_analytical, rtol=0.10)
def test_around():
"gravmag.prism gravitational results are consistent around the prism"
funcs = ['potential', 'gx', 'gy', 'gz',
'gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz']
model = [Prism(-300, 300, -300, 300, -300, 300, {'density': 1000})]
# Make the computation points surround the prism
shape = (101, 101)
area = [-600, 600, -600, 600]
distance = 310
grids = [gridder.regular(area, shape, z=-distance),
gridder.regular(area, shape, z=distance),
gridder.regular(area, shape, z=distance)[::-1],
gridder.regular(area, shape, z=-distance)[::-1],
np.array(gridder.regular(area, shape, z=distance))[[0, 2, 1]],
np.array(gridder.regular(area, shape, z=-distance))[[0, 2, 1]]]
xp, yp, zp = grids[0]
# Test if each component is consistent
# POTENTIAL
face = [prism.potential(x, y, z, model) for x, y, z in grids]
for i in range(6):
for j in range(i + 1, 6):
assert_almost(face[i], face[j], 10,
'Failed potential, faces %d and %d' % (i, j))
# GX
top, bottom, north, south, east, west = [prism.gx(x, y, z, model)
for x, y, z in grids]
assert_almost(top, bottom, 10, 'Failed gx, top and bottom')
assert_almost(north, -south, 10, 'Failed gx, north and south')
assert_almost(east, west, 10, 'Failed gx, east and west')
assert_almost(east, top, 10, 'Failed gx, east and top')
assert_almost(north, -prism.gz(xp, yp, zp, model), 10,
'Failed gx, north and gz')
assert_almost(south, prism.gz(xp, yp, zp, model), 10,
'Failed gx, south and gz')
# GY
top, bottom, north, south, east, west = [prism.gy(x, y, z, model)
for x, y, z in grids]
assert_almost(top, bottom, 10, 'Failed gy, top and bottom')
assert_almost(north, south, 10, 'Failed gy, north and south')
assert_almost(east, -west, 10, 'Failed gy, east and west')
assert_almost(north, top, 10, 'Failed gy, north and top')
assert_almost(east, -prism.gz(xp, yp, zp, model), 10,
'Failed gy, east and gz')
assert_almost(west, prism.gz(xp, yp, zp, model), 10,
'Failed gy, west and gz')
# GZ
top, bottom, north, south, east, west = [prism.gz(x, y, z, model)
for x, y, z in grids]
assert_almost(top, -bottom, 10, 'Failed gz, top and bottom')
assert_almost(north, south, 10, 'Failed gz, north and south')
assert_almost(east, west, 10, 'Failed gz, east and west')
assert_almost(north, prism.gx(xp, yp, zp, model), 10,
'Failed gz, north and gx')
assert_almost(south, prism.gx(xp, yp, zp, model), 10,
'Failed gz, south and gx')
assert_almost(east, prism.gy(xp, yp, zp, model), 10,
'Failed gz, east and gy')
assert_almost(west, prism.gy(xp, yp, zp, model), 10,
'Failed gz, west and gy')
# GXX
top, bottom, north, south, east, west = [prism.gxx(x, y, z, model)
for x, y, z in grids]
assert_almost(top, bottom, 10, 'Failed gxx, top and bottom')
assert_almost(north, south, 10, 'Failed gxx, north and south')
assert_almost(east, west, 10, 'Failed gxx, east and west')
assert_almost(east, top, 10, 'Failed gxx, east and top')
assert_almost(north, prism.gzz(xp, yp, zp, model), 10,
'Failed gxx, north and gzz')
assert_almost(south, prism.gzz(xp, yp, zp, model), 10,
'Failed gxx, south and gzz')
# GXY
top, bottom, north, south, east, west = [prism.gxy(x, y, z, model)
for x, y, z in grids]
assert_almost(top, bottom, 4, 'Failed gxy, top and bottom')
assert_almost(north, -south, 10, 'Failed gxy, north and south')
assert_almost(east, -west, 10, 'Failed gxy, east and west')
assert_almost(north, -prism.gyz(xp, yp, zp, model), 10,
'Failed gxy, north and gyz')
assert_almost(south, prism.gyz(xp, yp, zp, model), 10,
'Failed gxy, south and gyz')
# GXZ
top, bottom, north, south, east, west = [prism.gxz(x, y, z, model)
for x, y, z in grids]
assert_almost(top, -bottom, 10, 'Failed gxz, top and bottom')
assert_almost(north, -south, 10, 'Failed gxz, north and south')
assert_almost(east, west, 4, 'Failed gxz, east and west')
assert_almost(bottom, north, 10, 'Failed gxz, bottom and north')
assert_almost(top, south, 10, 'Failed gxz, top and south')
assert_almost(east, prism.gxy(xp, yp, zp, model), 4,
'Failed gxz, east and gxy')
assert_almost(west, prism.gxy(xp, yp, zp, model), 10,
'Failed gxz, west and gxy')
# GYY
top, bottom, north, south, east, west = [prism.gyy(x, y, z, model)
for x, y, z in grids]
assert_almost(top, bottom, 10, 'Failed gyy, top and bottom')
assert_almost(north, south, 10, 'Failed gyy, north and south')
assert_almost(east, west, 10, 'Failed gyy, east and west')
assert_almost(top, north, 10, 'Failed gyy, top and north')
assert_almost(east, prism.gzz(xp, yp, zp, model), 10,
'Failed gyy, east and gzz')
assert_almost(west, prism.gzz(xp, yp, zp, model), 10,
'Failed gyy, west and gzz')
# GYZ
top, bottom, north, south, east, west = [prism.gyz(x, y, z, model)
for x, y, z in grids]
assert_almost(top, -bottom, 10, 'Failed gyz, top and bottom')
assert_almost(north, south, 4, 'Failed gyz, north and south')
assert_almost(east, -west, 10, 'Failed gyz, east and west')
assert_almost(top, west, 10, 'Failed gyz, top and west')
assert_almost(bottom, east, 10, 'Failed gyz, bottom and east')
assert_almost(north, prism.gxy(xp, yp, zp, model), 4,
'Failed gyz, north and gxy')
assert_almost(south, prism.gxy(xp, yp, zp, model), 10,
'Failed gyz, south and gxy')
# GZZ
top, bottom, north, south, east, west = [prism.gzz(x, y, z, model)
for x, y, z in grids]
assert_almost(top, bottom, 10, 'Failed gzz, top and bottom')
assert_almost(north, south, 10, 'Failed gzz, north and south')
assert_almost(east, west, 10, 'Failed gzz, east and west')
assert_almost(north, prism.gxx(xp, yp, zp, model), 10,
'Failed gzz, north and gxx')
assert_almost(south, prism.gxx(xp, yp, zp, model), 10,
'Failed gzz, south and gxx')
assert_almost(east, prism.gyy(xp, yp, zp, model), 10,
'Failed gzz, east and gyy')
assert_almost(west, prism.gyy(xp, yp, zp, model), 10,
'Failed gzz, west and gyy')
model = [mesher.Prism(-4000,-3000,-4000,-3000,0,2000,{'density':1000}),
mesher.Prism(-1000,1000,-1000,1000,0,2000,{'density':-900}),
mesher.Prism(2000,4000,3000,4000,0,2000,{'density':1300})]
shape = (100,100)
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=-150)
fields = [prism.potential(xp, yp, zp, model),
prism.gx(xp, yp, zp, model),
prism.gy(xp, yp, zp, model),
prism.gz(xp, yp, zp, model),
prism.gxx(xp, yp, zp, model),
prism.gxy(xp, yp, zp, model),
prism.gxz(xp, yp, zp, model),
prism.gyy(xp, yp, zp, model),
prism.gyz(xp, yp, zp, model),
prism.gzz(xp, yp, zp, model)]
titles = ['potential', 'gx', 'gy', 'gz',
'gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz']
mpl.figure(figsize=(8, 9))
mpl.subplots_adjust(left=0.03, right=0.95, bottom=0.05, top=0.92, hspace=0.3)
mpl.suptitle("Potential fields produced by a 3 prism model")
for i, field in enumerate(fields):
mpl.subplot(4, 3, i + 3)
mpl.axis('scaled')
mpl.title(titles[i])
levels = mpl.contourf(yp*0.001, xp*0.001, field, shape, 15)
cb = mpl.colorbar()
mpl.contour(yp*0.001, xp*0.001, field, shape, levels, clabel=False, linewidth=0.1)
mpl.show()
myv.figure()
props = {'density':1000}
model = [Prism(400, 600, 300, 500, 200, 400, props),
Prism(400, 600, 400, 600, 400, 600, props),
Prism(400, 600, 500, 700, 600, 800, props)]
# and generate synthetic data from it
shape = (51, 51)
bounds = [0, 1000, 0, 1000, 0, 1000]
area = bounds[0:4]
xp, yp, zp = gridder.regular(area, shape, z=-150)
noise = 0.5
gxx = utils.contaminate(prism.gxx(xp, yp, zp, model), noise)
gxy = utils.contaminate(prism.gxy(xp, yp, zp, model), noise)
gxz = utils.contaminate(prism.gxz(xp, yp, zp, model), noise)
gyy = utils.contaminate(prism.gyy(xp, yp, zp, model), noise)
gyz = utils.contaminate(prism.gyz(xp, yp, zp, model), noise)
gzz = utils.contaminate(prism.gzz(xp, yp, zp, model), noise)
tensor = [gxx, gxy, gxz, gyy, gyz, gzz]
titles = ['gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz']
# plot the data
mpl.figure()
for i in xrange(len(tensor)):
mpl.subplot(2, 3, i + 1)
mpl.title(titles[i])
mpl.axis('scaled')
levels = mpl.contourf(yp, xp, tensor[i], shape, 30)
mpl.colorbar()
mpl.xlabel('y (km)')
mpl.ylabel('x (km)')
mpl.m2km()
mpl.show()
def test_gzz():
"gravmag.prism.gzz python vs cython implementation"
py = _prism_numpy.gzz(xp, yp, zp, model)
cy = prism.gzz(xp, yp, zp, model)
diff = np.abs(py - cy)
assert np.all(diff <= precision), 'max diff: %g' % (max(diff))
def test_gzz():
"polyprism.gzz against prism"
resprism = prism.gzz(xp, yp, zp, prismmodel)
respoly = polyprism.gzz(xp, yp, zp, model)
diff = np.abs(resprism - respoly)
assert np.all(diff <= precision), 'max diff: %g' % (max(diff))
"""
import numpy as np
from fatiando.gravmag import prism, sphere
from fatiando.gravmag.eqlayer import EQLGravity
from fatiando.inversion.regularization import Smoothness2D, LCurve
from fatiando import gridder, utils, mesher
from fatiando.vis import mpl
# Make synthetic data
props = {'density': 1000}
model = [mesher.Prism(-500, 500, -1000, 1000, 500, 4000, props)]
area = [-5000, 5000, -5000, 5000]
x1, y1, z1 = gridder.scatter(area, 80, z=0, seed=0)
gz = utils.contaminate(prism.gz(x1, y1, z1, model), 0.1, seed=0)
x2, y2, z2 = gridder.regular(area, (10, 50), z=-200)
gzz = utils.contaminate(prism.gzz(x2, y2, z2, model), 5, seed=0)
# Setup the layer
layer = mesher.PointGrid([-6000, 6000, -6000, 6000], 500, (50, 50))
# and the inversion
# Apply a scaling factor to make both portions of the misfit the same order of
# magnitude
scale = np.linalg.norm(gz)**2 / np.linalg.norm(gzz)**2
misfit = (EQLGravity(x1, y1, z1, gz, layer) +
scale * EQLGravity(x2, y2, z2, gzz, layer, field='gzz'))
regul = Smoothness2D(layer.shape)
# Use an L-curve analysis to find the best regularization parameter
solver = LCurve(misfit, regul, [10**i for i in range(-30, -20)]).fit()
layer.addprop('density', solver.estimate_)
# Now I can forward model gz using my layer to produce an integrated map in a
# much denser region
# show it
myv.figure()
myv.prisms(model, 'density')
myv.axes(myv.outline(bounds), ranges=[i * 0.001 for i in bounds],
fmt='%.1f', nlabels=6)
myv.wall_bottom(bounds)
myv.wall_north(bounds)
myv.show()
# and use it to generate some tensor data
shape = (51, 51)
area = bounds[0:4]
noise = 2
x, y, z = gridder.regular(area, shape, z=-150)
gyy = utils.contaminate(prism.gyy(x, y, z, model), noise)
gyz = utils.contaminate(prism.gyz(x, y, z, model), noise)
gzz = utils.contaminate(prism.gzz(x, y, z, model), noise)
# Set up the inversion:
# Create a prism mesh
mesh = PrismMesh(bounds, (15, 50, 50))
# Wrap the data so that harvester can use it
data = [harvester.Gyy(x, y, z, gyy),
harvester.Gyz(x, y, z, gyz),
harvester.Gzz(x, y, z, gzz)]
# and the seeds
seeds = harvester.sow(
[(800, 3250, 600, {'density': 1200}),
(1200, 3250, 600, {'density': 1200}),
(1700, 3250, 600, {'density': 1200}),
(2100, 3250, 600, {'density': 1200}),
(2500, 3250, 600, {'density': 1200}),
"""
import numpy as np
from fatiando.gravmag import prism, sphere
from fatiando.gravmag.eqlayer import EQLGravity
from fatiando.inversion.regularization import Smoothness2D, LCurve
from fatiando import gridder, utils, mesher
from fatiando.vis import mpl
# Make synthetic data
props = {'density': 1000}
model = [mesher.Prism(-500, 500, -1000, 1000, 500, 4000, props)]
area = [-5000, 5000, -5000, 5000]
x1, y1, z1 = gridder.scatter(area, 80, z=0, seed=0)
gz = utils.contaminate(prism.gz(x1, y1, z1, model), 0.1, seed=0)
x2, y2, z2 = gridder.regular(area, (10, 50), z=-200)
gzz = utils.contaminate(prism.gzz(x2, y2, z2, model), 5, seed=0)
# Setup the layer
layer = mesher.PointGrid([-6000, 6000, -6000, 6000], 500, (50, 50))
# and the inversion
# Apply a scaling factor to make both portions of the misfit the same order of
# magnitude
scale = np.linalg.norm(gz) ** 2 / np.linalg.norm(gzz) ** 2
misfit = (EQLGravity(x1, y1, z1, gz, layer)
+ scale * EQLGravity(x2, y2, z2, gzz, layer, field='gzz'))
regul = Smoothness2D(layer.shape)
# Use an L-curve analysis to find the best regularization parameter
solver = LCurve(misfit, regul, [10 ** i for i in range(-30, -20)]).fit()
layer.addprop('density', solver.estimate_)
# Now I can forward model gz using my layer to produce an integrated map in a
# much denser region
model = [mesher.Prism(-1000, 1000, -1000, 1000, 0, 2000, {'density': 100})]
area = (-5000, 5000, -5000, 5000)
shape = (51, 51)
z0 = -500
xp, yp, zp = gridder.regular(area, shape, z=z0)
gz = utils.contaminate(prism.gz(xp, yp, zp, model), 0.001)
# Need to convert gz to SI units so that the result can be converted to Eotvos
gxz = utils.si2eotvos(transform.derivx(xp, yp, utils.mgal2si(gz), shape))
gyz = utils.si2eotvos(transform.derivy(xp, yp, utils.mgal2si(gz), shape))
gzz = utils.si2eotvos(transform.derivz(xp, yp, utils.mgal2si(gz), shape))
gxz_true = prism.gxz(xp, yp, zp, model)
gyz_true = prism.gyz(xp, yp, zp, model)
gzz_true = prism.gzz(xp, yp, zp, model)
mpl.figure()
mpl.title("Original gravity anomaly")
mpl.axis('scaled')
mpl.contourf(xp, yp, gz, shape, 15)
mpl.colorbar(shrink=0.7)
mpl.m2km()
mpl.figure(figsize=(14, 10))
mpl.subplots_adjust(top=0.95, left=0.05, right=0.95)
mpl.subplot(2, 3, 1)
mpl.title("x deriv (contour) + true (color map)")
mpl.axis('scaled')
levels = mpl.contourf(yp, xp, gxz_true, shape, 12)
mpl.colorbar(shrink=0.7)
def test_gzz():
"polyprism.gzz against prism"
resprism = prism.gzz(xp, yp, zp, prismmodel)
respoly = polyprism.gzz(xp, yp, zp, model)
diff = np.abs(resprism - respoly)
assert np.all(diff <= precision), 'max diff: %g' % (max(diff))
from fatiando.vis import mpl, myv
from fatiando import mesher, gridder, utils
from fatiando.gravmag import prism, tensor
# Generate some synthetic data
model = [mesher.Prism(-1000, 1000, -1000, 1000, 1000, 3000, {'density': 1000})]
shape = (100, 100)
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=-150)
noise = 2
data = [
utils.contaminate(prism.gxx(xp, yp, zp, model), noise),
utils.contaminate(prism.gxy(xp, yp, zp, model), noise),
utils.contaminate(prism.gxz(xp, yp, zp, model), noise),
utils.contaminate(prism.gyy(xp, yp, zp, model), noise),
utils.contaminate(prism.gyz(xp, yp, zp, model), noise),
utils.contaminate(prism.gzz(xp, yp, zp, model), noise)
]
# Plot the data
titles = ['gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz']
mpl.figure()
for i, title in enumerate(titles):
mpl.subplot(3, 2, i + 1)
mpl.title(title)
mpl.axis('scaled')
levels = mpl.contourf(yp, xp, data[i], shape, 10)
mpl.contour(yp, xp, data[i], shape, levels)
mpl.m2km()
mpl.show()
# Get the eigenvectors from the tensor data
eigenvals, eigenvecs = tensor.eigen(data)
# Use the first eigenvector to estimate the center of mass
# show it
myv.figure()
myv.prisms(model, 'density')
myv.axes(myv.outline(bounds), ranges=[i*0.001 for i in bounds],
fmt='%.1f', nlabels=6)
myv.wall_bottom(bounds)
myv.wall_north(bounds)
myv.show()
# and use it to generate some tensor data
shape = (51, 51)
area = bounds[0:4]
noise = 2
x, y, z = gridder.regular(area, shape, z=-150)
gyy = utils.contaminate(prism.gyy(x, y, z, model), noise)
gyz = utils.contaminate(prism.gyz(x, y, z, model), noise)
gzz = utils.contaminate(prism.gzz(x, y, z, model), noise)
# Set up the inversion:
# Create a prism mesh
mesh = PrismMesh(bounds, (15, 50, 50))
# Wrap the data so that harvester can use it
data = [harvester.Gyy(x, y, z, gyy),
harvester.Gyz(x, y, z, gyz),
harvester.Gzz(x, y, z, gzz)]
# and the seeds
seeds = harvester.sow(
[( 800, 3250, 600, {'density':1200}),
(1200, 3250, 600, {'density':1200}),
(1700, 3250, 600, {'density':1200}),
(2100, 3250, 600, {'density':1200}),
(2500, 3250, 600, {'density':1200}),
mesher.Prism(-1000, 1000, -1000, 1000, 0, 2000, {'density': -900}),
mesher.Prism(2000, 4000, 3000, 4000, 0, 2000, {'density': 1300})
]
shape = (100, 100)
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=-150)
fields = [
prism.potential(xp, yp, zp, model),
prism.gx(xp, yp, zp, model),
prism.gy(xp, yp, zp, model),
prism.gz(xp, yp, zp, model),
prism.gxx(xp, yp, zp, model),
prism.gxy(xp, yp, zp, model),
prism.gxz(xp, yp, zp, model),
prism.gyy(xp, yp, zp, model),
prism.gyz(xp, yp, zp, model),
prism.gzz(xp, yp, zp, model)
]
titles = [
'potential', 'gx', 'gy', 'gz', 'gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz'
]
mpl.figure(figsize=(8, 9))
mpl.subplots_adjust(left=0.03, right=0.95, bottom=0.05, top=0.92, hspace=0.3)
mpl.suptitle("Potential fields produced by a 3 prism model")
for i, field in enumerate(fields):
mpl.subplot(4, 3, i + 3)
mpl.axis('scaled')
mpl.title(titles[i])
levels = mpl.contourf(yp * 0.001, xp * 0.001, field, shape, 15)
cb = mpl.colorbar()
mpl.contour(yp * 0.001,
xp * 0.001,