def test_laplace_from_potential():
"gravmag.transform 2nd derivatives of potential obey the Laplace equation"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': 200})]
shape = (300, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
potential = prism.potential(x, y, z, model)
gxx = utils.si2eotvos(transform.derivx(x, y, potential, shape, order=2,
method='fft'))
gyy = utils.si2eotvos(transform.derivy(x, y, potential, shape, order=2,
method='fft'))
gzz = utils.si2eotvos(transform.derivz(x, y, potential, shape, order=2))
laplace = _trim(gxx + gyy + gzz, shape)
assert np.all(np.abs(laplace) <= 1e-10), \
"Max: {} Mean: {} STD: {}".format(
laplace.max(), laplace.mean(), laplace.std())
def test_laplace_from_potential():
"gravmag.transform 2nd derivatives of potential obey the Laplace equation"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': 200})]
shape = (300, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
potential = prism.potential(x, y, z, model)
gxx = utils.si2eotvos(
transform.derivx(x, y, potential, shape, order=2, method='fft'))
gyy = utils.si2eotvos(
transform.derivy(x, y, potential, shape, order=2, method='fft'))
gzz = utils.si2eotvos(transform.derivz(x, y, potential, shape, order=2))
laplace = _trim(gxx + gyy + gzz, shape)
assert np.all(np.abs(laplace) <= 1e-10), \
"Max: {} Mean: {} STD: {}".format(
laplace.max(), laplace.mean(), laplace.std())
def test_second_horizontal_derivatives_fd():
"gravmag.transform 2nd xy derivatives by finite diff against analytical"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': 100})]
shape = (300, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-500)
derivatives = 'xx yy'.split()
grav = prism.potential(x, y, z, model)
for deriv in derivatives:
analytical = getattr(prism, 'g{}'.format(deriv))(x, y, z, model)
func = getattr(transform, 'deriv' + deriv[0])
calculated = utils.si2eotvos(
func(x, y, grav, shape, method='fd', order=2))
diff = np.abs(analytical - calculated)
assert np.all(diff/np.abs(analytical).max() <= 0.01), \
"Failed for g{}. Max: {} Mean: {} STD: {}".format(
deriv, diff.max(), diff.mean(), diff.std())
def test_second_horizontal_derivatives_fd():
"gravmag.transform 2nd xy derivatives by finite diff against analytical"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': 100})]
shape = (300, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-500)
derivatives = 'xx yy'.split()
grav = prism.potential(x, y, z, model)
for deriv in derivatives:
analytical = getattr(prism, 'g{}'.format(deriv))(x, y, z, model)
func = getattr(transform, 'deriv' + deriv[0])
calculated = utils.si2eotvos(func(x, y, grav, shape, method='fd',
order=2))
diff = np.abs(analytical - calculated)
assert np.all(diff/np.abs(analytical).max() <= 0.01), \
"Failed for g{}. Max: {} Mean: {} STD: {}".format(
deriv, diff.max(), diff.mean(), diff.std())
def test_second_derivatives():
"gravmag.transform FFT second derivatives against analytical solutions"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': -200})]
shape = (300, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
derivatives = 'xx yy zz'.split()
pot = prism.potential(x, y, z, model)
for deriv in derivatives:
analytical = getattr(prism, 'g{}'.format(deriv))(x, y, z, model)
calculated = utils.si2eotvos(
getattr(transform, 'deriv' + deriv[0])(x, y, pot, shape, order=2,
method='fft'))
diff = _trim(np.abs(analytical - calculated), shape)
assert np.all(diff <= 0.005*np.abs(analytical).max()), \
"Failed for g{}. Max: {} Mean: {} STD: {}".format(
deriv, diff.max(), diff.mean(), diff.std())
def test_second_derivatives():
"gravmag.transform FFT second derivatives against analytical solutions"
model = [Prism(-1000, 1000, -500, 500, 0, 2000, {'density': -200})]
shape = (300, 300)
x, y, z = gridder.regular([-10000, 10000, -10000, 10000], shape, z=-100)
derivatives = 'xx yy zz'.split()
pot = prism.potential(x, y, z, model)
for deriv in derivatives:
analytical = getattr(prism, 'g{}'.format(deriv))(x, y, z, model)
calculated = utils.si2eotvos(
getattr(transform, 'deriv' + deriv[0])(x,
y,
pot,
shape,
order=2,
method='fft'))
diff = _trim(np.abs(analytical - calculated), shape)
assert np.all(diff <= 0.005*np.abs(analytical).max()), \
"Failed for g{}. Max: {} Mean: {} STD: {}".format(
deriv, diff.max(), diff.mean(), diff.std())
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')
"""
GravMag: Forward modeling of the gravitational potential and its derivatives
using 3D model
"""
from fatiando import mesher, gridder
from fatiando.gravmag import prism
from fatiando.vis import mpl, myv
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')
def test_potential():
"gravmag.prism.potential python vs cython implementation"
py = _prism_numpy.potential(xp, yp, zp, model)
cy = prism.potential(xp, yp, zp, model)
diff = np.abs(py - cy)
assert np.all(diff <= precision), 'max diff: %g' % (max(diff))
GravMag: Forward modeling of the gravitational potential and its derivatives
using 3D model
"""
from fatiando import mesher, gridder
from fatiando.gravmag import prism
from fatiando.vis import mpl, myv
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)